Last year, Google announced that Android was becoming a Kotlin-first OS. Such a statement had a two-fold purpose. On the one hand, boost Kotlin’s adoption among Android developers as the first step towards a more ambitious project: a common language for all platforms. On the other hand, it was Google’s way to say to Java developers that they should start learning Kotlin.
More than a year after that announcement, Kotlin’s adoption is on the rise, and the language is popping up in developer surveys as one of the most popular languages out there. Does that mean that this is the end of Java as an alternative for Android development? Not quite. One of the most popular languages in history still has some things to offer to Android developers, which can still rely on it for their applications.
So, which one should you choose? Should you follow Google’s advice and pick Kotlin? Or should you go with a tried-and-proven language like Java? Let’s compare both of them to see which one is best.
Kotlin – The Beautiful New Kid in the Neighborhood
When Google introduced Kotlin in 2017, its intentions were clear – they wanted to provide developers with a more practical and efficient programming language for Android development. Though Java was the right choice for developing applications, Google felt it needed some more modern features and better performance – hence the creation of Kotlin.
Google’s push for Kotlin surely affected the mobile development community. Since the Kotlin-first announcement, Google works on all of its Android apps with it. Big companies like Twitter, Netflix, Airbnb, and Pinterest have all switched to Kotlin. And many other developers are looking into it to make a move, charmed by the possibilities brought by the newest kid in the neighborhood.
What are those possibilities? Kotlin brings solutions to common issues and improvements to the Java programming experience as a whole. Some of them include:
- Interoperability. Kotlin was born out of a clear goal: to become a dominant language that would eventually sip into all platforms. That focus led its creators to provide Kotlin with high interoperability that allows you to use a vast amount of libraries and write modules that will work seamlessly with Java code.
- Code Economy. Java isn’t precisely known for being concise, something that Kotlin addresses full-on by offering a concise and readable syntax. It allows you to develop your Android projects faster while also reducing the likelihood of errors, especially in applications with a broad scope, an increased number of features, or high complexity.
- Modern Programming Capabilities. Since Kotlin is so new, it was built on top of more modern approaches to programming. That means you can use fresh programming concepts for your development, including extension functions, high-order functions, delegates, and other options to build APIs.
- No Raw Types: there was a time when everybody was using raw types but, as generics started to pop up, they were kept around to ensure backward compatibility. However, developers know that raw types can cause issues during execution. To cut that problem from the root, Kotlin doesn’t allow raw types, which leads to a more type-safe code.
- No Checked Exceptions. Certain Java developers might point out that checked exceptions are useful to perform error handling. However, these exceptions often cause empty catch blocks, which leads to developers losing time identifying the exception that caused it in the first place. Kotlin deals with this problem by removing checked exceptions altogether.
- Non-nullable Variables. One of the most well-known problems during Android development is NullPointerException. Kotlin deals with it by building null safety that prevents variables from taking a null value. Naturally, there’s a workaround for cases when a variable needs to have a null value, but, on a general level, the language doesn’t allow it.
All of those benefits might have you believe that Kotlin is better for Java, and that’s that. Yet, it’s better to outline Kotlin’s limitations and cons to provide you with a full picture. Some of the language drawbacks include:
- Steep Learning Curve. This might seem contradictory. How can a language that’s concise and highly readable be hard to learn? Yet, that brevity can be hard to grasp for developers used to other languages. Learning Kotlin needs a change of mind about what a language can be.
- Slow Compilation Speed. When compared to Java, Kotlin’s compilation is slower in most cases. You might find some projects where Kotlin beats Java speed, but that’s more like an exception than a rule.
- Boilerplate Code. Since Kotlin is a highly declarative language, it often tends to create boilerplate code in the corresponding JVM bytecode, leading to a verbose code that doesn’t need to be that way.
- Small Community. Finally, given how young it is, Kotlin still has to develop a strong developer community. Kotlin’s community pales when compared to Java’s, simply because the latter has been around for a long time and has plenty of resources to offer to its users.
The Old Reliable Java
On the other corner is Java, a developer favorite, especially in Android app development. That has a simple reason: Android used to be written in Java, so creating apps in it was sort of a no brainer. However, since Kotlin’s appearance, many developers are questioning how useful it can genuinely be to stick to it when building Android apps.
The answer, again, might seem simple: just ditch Java and adopt Kotlin. Yet, there’s plenty of reasons why Java has passed the test of time. Being one of the most popular programming languages around, it’s only natural that some want to stick with it without even considering an alternative. Here’s a list of reasons why that may be:
- Easy to learn. Java is straightforward to learn, write, and understand. There are many resources available online to help you with training, but the syntax also presents ease of use and comprehension that makes any Java project simple.
- Portability. Thanks to the Java Virtual Machine, Java is platform-independent, which means it can run virtually anywhere. This means that anything you develop with it might be ported easily to other platforms.
- Android’s reliance. Android might be choosing Kotlin as its go-to language, but that doesn’t mean it has cut its ties with Java. The Android SDK still contains many standard Java libraries, making it easier for Java developers to work on Android.
- More compact apps. Java apps tend to be more compact and far more optimizable. That’s a great thing when you want to create a new version of an app that’s desperately calling for better performance. What’s more – you can achieve that with lighter apps, thanks to Java’s imperative nature.
- Large community. You’ll find issues when programming with any language. That’s a fact. So, it’s great for Java development teams to have a large community of experts supporting them. If you use Java and run into an issue, chances are you can find help online to solve it.
As you can see, there are plenty of benefits of working with Java in Android, even if Kotlin feels more tailor-made. Naturally, there are some drawbacks to Java, which you should consider before making a decision. Those cons include:
- Verbose. Java is a verbose language, which means you’ll have to write more code to power the same functionality Kotlin would have with far less code. For one, there’s an increased risk of incurring errors and bugs. Then, there’s the possibility of bloating the application. Finally, there’s also an increased development time to get to the final product.
- Slow performance. Anyone that has used Java knows that it’s unfortunately slow, especially if you compare it to more modern languages – like Kotlin. That’s not all, as Java requires a lot of memory to perform correctly, which might be a dealbreaker to some.
- Absence of modern functions. Just as Kotlin is capable of using newer concepts and approaches to app development, the opposite is true for Java. Though we’re now seeing more and more updates for it, Java still feels like an old language in certain aspects, which can be challenging for new developers with a different approach to development.
Which One Should You Choose?
All of the above might feel like you’ll be forced to make the switch to Kotlin sooner or later. But, where we stand today, it isn’t necessary. Java can do a great job in Android development and can be a perfect choice, especially in the hands of seasoned developers. When the time comes to make that language switch, Java development companies won’t have that much difficulty, as Kotlin is intertwined with Java in some sense.
Time will tell if Kotlin will become the dominant force it appears to be. In the meantime, it’s already setting new standards and methodologies for Android development, which, for good or better, will require developers to learn to stay current and up-to-date.