Is Kotlin the New Java?

Kotlin is an object-oriented and functional programming language primarily developed by JetBrains. Designed to be compiled for the Java virtual machine, among other things, it has multiple uses. However, since Google declared Kotlin a supported language for developing native Android applications, it has replaced Java as the official recommended language. That is the main reason we will be discussing Kotlin in this post.

Pros of Kotlin

Kotlin is a programming language that has a lot of fans among developers. Its numerous benefits make it a particularly useful and practical tool for saving time and increasing effectiveness.

An Explicit Language

Kotlin is an explicit language. This means that anything not explicitly written into the code is forbidden (type inference, inheritance, nullability, etc.). Using this language ensures that the code used will only go in the direction you specify. This is especially true for classes. Classes in Kotlin are final by default (non-inheritable), which means you must explicitly mark a class open for another class to inherit it. The same applies to types. Overall, Kotlin’s explicitness provides more control over the supplied code, whether for the developer or when sharing with a team of multiple developers.

A Secure Language

Among its many advantages, Kotlin lets you avoid the most common Java error: the NullPointerException. All properties must be defined as “nullable” or “non-nullable” and are managed by monitoring the code. However, this is optional and not required. By avoiding the NullPointerException, Kotlin can reduce the risk of persistent errors in Java at runtime or during compilation, significantly increasing developer productivity and product code resilience.

Static Typing

Kotlin’s typing is static to ensure clean code that is monitored by the language rather than the developer. This means that the type of each variable is known at compilation. The language will deduce its own types during the compilation process, not when the application is executed. This means that no runtime errors will be generated indicating that the variable being treated as this or that type is incorrect.

Note that the developer is not required to specify the desired type: the language will determine the appropriate type during compilation.

A Concise Language Similar to Recent Syntax

Compared to Java, Kotlin is a less “verbose” language: it requires fewer lines of code to achieve the same result. The reduced number of lines means the write time is reduced, saving the developer time and improving their effectiveness. In addition, because this language is similar to other recent languages (Swift, for example), switching from one to another is simple.

100% Java-Compatible

Because the two languages are fully compatible, Kotlin and Java can easily coexist in the same project. This enables the use of Kotlin within existing Java projects, especially for Android. As a result, in the case of a Java-based application, new features can be developed in Kotlin. The two languages are fully compatible, so you won’t have to recreate applications from scratch if you switch to Kotlin.

Available Kotlin Libraries

There is a wealth of documentation available for Kotlin. There is a huge set of Kotlin libraries designed to reduce code lines and make working in this language easier and faster for developers. On mobile, Kotlin is a language championed by Google for native applications: using these assets makes creating new native Android applications in Kotlin easier and more enjoyable.

An Open and Free Language

Kotlin is not a proprietary language. The language, libraries, and tools are all completely free and accessible to everyone on GitHub. As a result, it has all the benefits of open source: accessibility, adaptability to requirements, price, scalability, tools, etc.

For More Than Mobile

Cellenza recommends using Kotlin in all Android native applications. But keep in mind that Kotlin’s primary purpose is to replace Java: therefore, this language can also be used for backend applications other than mobile. This language is becoming increasingly popular because Kotlin developers are creating more and more interoperability.

Cons of Kotlin

Kotlin was created to address some of Java’s shortcomings: much thought has gone into correcting what could be corrected in comparison to Java. As a result, the flaws in this solution are few and far between. However, we can highlight two of them:

• A less clean compilation: Despite being faster throughout the application development cycle, Kotlin’s executable is slightly chunkier than Java’s. From an optimization standpoint, an Android project written in Java will be lighter than one written in Kotlin (in particular due to the residual code), but this weight difference is minor.
• No namespace: in pure code terms, Kotlin has no namespace. As a result, organizing classes into sub-groups is impossible: all classes have the same level and thus cannot be sorted. It is also impossible to have two classes with the same name. However, this missing feature is not a problem in a clean architecture.

Cellenza’s Recommendations for Using Kotlin

As mobile solution experts, we recommend using Kotlin first and foremost for any new native Android project. This language’s many advantages make it an ideal solution for web developers’ needs: easier, faster, and more secure development, the assurance that the application will remain supported over time due to the latest updates, reduced debugging time, etc. We, therefore, recommend Kotlin over Java for new projects, both technically and functionally.

We also recommend using Kotlin for developing new modules and features. Its 100% compatibility with Java with no performance loss means that nothing is stopping you from switching to Kotlin for these new features in an application originally developed in Java. There is one minor caveat: some settings, such as the project team or application size (including libraries), must be considered before switching to Kotlin.

Case Study

Let’s look at an example of how Kotlin was used to create a native Android mobile application.

I had to design an Android Proof of Concept (POC) application to manage board games played among friends as part of an internal project here at Cellenza. Since I already had experience with Android development in Java, I took the opportunity to work with Kotlin this time to get to grips with the language’s capabilities.

The following features were implemented:

• Viewing latest games played
• Viewing game details and results
• Taking photos during a game
• Game over notifications for the user’s active games

The application was developed using the Model, View, ViewModel (MVVM) pattern, and the features presented allow management of the following aspects:

• Data retrieval via REST API (using the Retrofit library
  and Coroutines)
• Management of the cache for offline data access (use of the Room library)
• Navigation between multiple views (use of Jetpack Navigation)
• Activity life cycle management (use of LiveData)
• Interface development
• Management of the camera, associated permissions, and photo storage
• Use of the push notification service

As you can see, Android provides a variety of tools to assist you in creating applications quickly and efficiently while adhering to quality criteria. Here are some of the elements that particularly caught my attention:

• Coroutines: a Kotlin language feature that allows you to respond seamlessly and securely by simplifying the management of asynchronous calls and their results.
• LiveData: an Android feature that is fully exploitable in Kotlin. Google’s AndroidX libraries make this extremely simple to use. To summarize, this involves objects that monitor changes in our application’s life cycle status and respond to them to ensure the validity of their data: this can prevent a slew of errors when returning to a screen, rotating it, or even putting the application in the background and then returning to it.
• Ease of integration: coming from native Java development, I was curious about how we could use all of these Android components in Kotlin. I was pleasantly surprised by how quick, easy, and effective the implementation was in Kotlin.

All of these factors, and the benefits of the language set out above, have reinforced our belief in the use of Kotlin for developing native Android applications.

Would you like to learn more about the various technologies available for developing mobile apps? Read through the rest of the posts in this series:

bout mobile app:

• Swift/SwiftUI: Apple’s Native Language
• Why Create a Mobile Application in Unity?
• Progressive Web App: Web Pages Turned Mobile
• Meet Flutter the Tool for Creating iOS and Android Applications
• Meet .NET MAUI, the Technology Replacing Xamarin.Forms