Kotlin Blueprints

4.5 (2 reviews total)
By Ashish Belagali , Hardik Trivedi , Akshay Chordiya
    Advance your knowledge in tech with a Packt subscription

  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies

About this book

Kotlin is a powerful language that has applications in a wide variety of fields. It is a concise, safe, interoperable, and tool-friendly language. The Android team has also announced first-class support for Kotlin, which is an added boost to the language. Kotlin’s growth is fueled through carefully designed business and technology benefits.

The collection of projects demonstrates the versatility of the language and enables you to build standalone applications on your own. You’ll build comprehensive applications using the various features of Kotlin. Scale, performance, and high availability lie at the heart of the projects, and the lessons learned throughout this book.

You’ll learn how to build a social media aggregator app that will help you efficiently track various feeds, develop a geospatial webservice with Kotlin and Spring Boot, build responsive web applications with Kotlin, build a REST API for a news feed reader, and build a server-side chat application with Kotlin.

It also covers the various libraries and frameworks used in the projects. Through the course of building applications, you’ll not only get to grips with the various features of Kotlin, but you’ll also discover how to design and prototype professional-grade applications.

Publication date:
December 2017
Publisher
Packt
Pages
227
ISBN
9781788390804

 

Chapter 1. The Power of Kotlin

Our interest in the Kotlin programming language should be there because it is fast moving towards becoming the universal programming language. What is a universal programming language? From a simplistic view, the expectation could be that one language is used for all types of programming. While that may be far-fetched in today's complex world, the expectation could be adjusted to one language becoming the dominant programming language. Most certainly, it is the single, most important language to master. This book is written to help with that objective.

In this introductory chapter, we will see how Kotlin is poised to become the next universal programming language. In particular, we will look into the following topics:

  • Why can Kotlin be described as a better Java than any other language?
  • How does Kotlin address areas beyond the Java world?
  • What is Kotlin's winning strategy?
  • What does this all mean for a smart developer?

Historically, different languages have used strategies appropriate for those times to become the universal programming languages:

  • In the 1970s, C became the universal programming language. Prior to C, the programming languages of the world were divided between low-level and high-level languages, the former being the languages that were close to machine code and the latter being ones that were more concise and worked better for human understanding. The C programming language was developed as a single language that could work as a low-level and a high-level language. The Unix operating system was showcased as one that was built ground-up entirely in C, without needing another low-level language.
  • In the 1990s, Java became the universal programming language with the Write Once Run Anywhere strategy. Prior to Java, developers needed to create different programs to run on different platforms (different operating systems running on different hardware needed different programs to run). However, with Java, programs could be written targeting a single platform, namely the Java Virtual Machine (JVM). The JVM is available across all the popular platforms and takes care of all platform-specific nuances. The Java language became the universal language by being the language in which to write programs for the JVM.

Another two decades have passed, and the stage is all set to welcome the next universal language. Let's examine Kotlin's strategy to become that.

 

Kotlin – a better Java


Why is being a better Java important for a language? For over a decade, Java has consistently been the world's most widely used programming language. Therefore, a language that gets crowned as being a better Java should automatically attract the attention of the world's single largest community of programmers: the Java programmers.

The TIOBE index is widely referred to as a gauge of the popularity of programming languages. Updated to August 2017, the index graph is reproduced in the following illustration:

The interesting point is that while Java has been the #1 programming language in the world for the last 15 years or so, it has been in a steady state of decline for many years now. Many new languages have kept coming, and existing ones have kept improving, chipping steadily into Java's developer base; however, none of them have managed to take the #1 position from Java so far.

Today, Kotlin is poised to become the most serious challenger for the better Java crown, and subsequently, to take the first place, for reasons that we will see shortly. Presently at 41st place, Kotlin is marching ahead at a fast pace. In May 2017, Google announced Kotlin to be the officially supported language for Android development in league with Java. This has turned out to be a major boost for Kotlin, and the rate of its adoption has accelerated ever since.

Why not other languages?

Many languages prior to Kotlin have tried to become a better Java. Let's see why they could never become one.

Every language attracts the programmer community by giving them an ability to do something that was cumbersome before. Their adoption is directly driven by how much value the promise has for them and how much faith the community can put into that promise.

All languages that claimed to be a better Java and offered something worthwhile beyond what Java offers, also took something back in turn. Here are a few examples:

  • .NET has been the longtime rival of Java and has supported multiple languages from day one. Based on the lessons learnt from Java, the .NET designers came up with better language constructs. However, the biggest hurdle for .NET was that it was a proprietary technology, and that created an impediment to its adoption. Also, .NET was more aggressive in adding newer language constructs. While the language evolved quickly as a result of that, it broke its backwards compatibility many times.
  • Ruby (and Python) offered shortened code, enticing programming constructs, and greater expressiveness as opposed to the boring Java; however, they took away static typing support (which helps to make robust programs) and made the programs slower.
  • Scala offered shortened code and advanced programming constructs, without sacrificing typing safety. However, Scala is complex and has a substantially high learning curve. It supports multiple coding styles. So, there is a danger that Scala code written by one developer may not be understood easily by another. These are risk factors for any project that includes a team of developers and when the application is expected to be supported over a long period, which is true about most applications anyway.

Why Kotlin?

Unlike other languages, Kotlin offers a lot of power over Java, while not taking anything away. Let's take a look at the following screenshot to see how:

Kotlin is interoperable with Java. It is possible to write applications containing both Java and Kotlin code, calling one from the other. Calling Java code from Kotlin is simpler, as opposed to the other way around, but the former will be the case most of the times anyway, where new Kotlin code is added on top of legacy Java code. Kotlin is interoperable and can use all the Java libraries and legacy coding without having to do any code conversion. It is possible to inject Kotlin into a Java project without boiling the ocean.

Concise yet expressive code

While being interoperable, Kotlin code is far superior to Java code. Like Scala, Kotlin uses type inference to cut down on a lot of boilerplate code and makes it concise. (Type inference is a better feature than dynamic typing as it reduces the code without sacrificing the robustness of the end product). However, unlike Scala, Kotlin code is easy to read and understand, even for someone who may not know Kotlin.

Kotlin's data class construct is the most prominent example of being concise as shown in the following:

    data class Employee (val id: Long, var name: String) 

Compared to its Java counterpart, the preceding line has packed into it the class definition, member variables, constructor, getter-setter methods, and also the utility methods, such as equals() and hashCode(). This will easily take 15-20 lines of Java code.

 

The data classes construct is not an isolated example. There are many others where the syntax is concise and expressive. Consider the following as additional examples:

  • Kotlin's default values to function parameters save the need to overload the functions
  • Kotlin's extension functions can be used to add domain-specific functionality to existing classes, making it easy for someone from the domain to understand
Enhanced robustness

Statically typed languages have a built-in safety net because of the assurance that the compiler will catch any incorrect type cast. Both Java and Kotlin support static typing.

With Java Generics introduced in Java 1.5, they both fare better over the Java releases prior to 1.5.

However, Kotlin takes a big step further in addressing the Null pointer error. This Null pointer error causes a lot of checks in Java programs:

    String s = someOperation(); 
    if (s != null) { 
      ... 
    } 

One can see that the null check is not needed if someOperation() never returns null. On the other hand, it is possible for a programmer to omit the null check while someOperation() returning null is a valid case.

With Kotlin, the definition of someOperation() itself will return either String or String? and then there are implications on the subsequent code, so the developer just cannot go wrong. Refer the  following table:  

fun someOperation() : String // not nullable
fun someOperation() : String? // nullable
val s = someOperation()
if (s != null) {  // null check not needed – editor warning
…
}
val s = someOperation()
n = s.length() // error, null check imposed
n = s?.length() ?: 0 // handling null condition

 

One may point out that Java developers can use the @Nullable and @NotNull annotations or the Optional class; however, these were added quite late, most developers are not aware of them, and they can always get away with not using them, as the code does not break. Finally, they are not as elegant as putting a question mark.

There is also a subtle point here. If a Kotlin developer is careless, he would write just the type name, which would automatically become a non-nullable declaration. If he wanted to make it nullable, he would have to  key in that extra question mark deliberately. Thus, you are on the side of caution, and that is as far as keeping the code robust is concerned.

Another example of this robustness is found in the var/val declarations. Seasoned programmers know that most variables get a value assigned to them only once. In Kotlin, while declaring the variable, you choose val for such a variable. At the time of variable declaration, the programmer has to select between val and var, and so he puts some thought into it. On the other hand, in Java, you can get away with just declaring the type with its name, and you will rarely find any Java code that defines a variable with the final keyword, which is Java's way of declaring that the variable can be assigned a value only once.

Basically, with the same maturity level of programmers, you expect a relatively more robust code in Kotlin as opposed to Java, and that's a big win from the business perspective.

Excellent IDE support from day one

Kotlin comes from JetBrains, who also develop a well-known Java integrated development environment (IDE): IntelliJ IDEA. JetBrains developers made sure that Kotlin has first-class support in IDEA. Not only that, they also developed a Kotlin plugin for Eclipse, which is the #1 most widely used Java IDE.

Contrast this with the situation when Java appeared on the scene roughly two decades ago. There was no good IDE support. Programmers were asked to use simple text editors. Coding Java was hard, with no safety net provided by an IDE, until the Eclipse editor was open-sourced.

In the case of Kotlin, the editor's suggestions being available from day one means that they can learn the language faster, make fewer mistakes, and write good quality compilable code with relative ease. Clearly, Kotlin does not want to waste any time in climbing up the ladder of popularity.

Beyond being a better Java

We saw that on the JVM platform, Kotlin is neat and quite superior. However, Kotlin has set its eyes beyond the JVM. Its strategy is to win based on its superior and modern feature set.

Before we go ahead, let's list the top five appeals of Kotlin:

  • Static typing (like in C or Java) means that there is built-in type safety. The compiler catches any incorrect type assignments. This makes programs robust.
  • Kotlin is concise and expressive. Being concise implies that there is less to read and maintain. Being expressive implies better maintainability.
  • Being a JVM language, the Kotlin programs can take advantage of the features built into the JVM, such as its cross-platform nature, memory management, high performance and sandbox security.
  • Kotlin has inbuilt null-safety. Null references are famous as the billion-dollar mistake, as admitted by its inventor Tony Hoare and cost a great deal of unnecessary null-checks in programs. Kotlin eliminates those and makes the programs more robust.

Kotlin is easy to learn, especially for Java developers. Its syntax is clean and therefore easy to understand, because of which, Kotlin programs are fun for developers to code and easy to understand, and enhancing for their peers. From a business angle, they are more robust and easy to maintain for businesses.

Kotlin is in the winning camp

The features of Kotlin have a good validation when one considers that other languages, which have similar features, are also growing in popularity:

  • The Crystal language attracts Ruby programmers by adding static typing support. Similarly, TypeScript adds static typing support to JavaScript and has become the preferred language for some JavaScript frameworks.
  • Scala and F# add functional programming support to traditional non-functional paradigms without sacrificing type safety and, hence, are more attractive. Kotlin uses functional programming, just enough to ease out the programming in a lot of cases, but not too much to make it complex.
  • Like Kotlin, Swift, and Rust also have inbuilt null-safety. Kotlin and Swift are often compared, as their syntaxes resemble one another a lot.
  • Server-side languages, which were getting designed after the emergence of the parallel computing phenomena, became one of the chief requirements for providing inbuilt constructs for easing the programmer's work. One can find this in both Kotlin (coroutines) and Rust.

Go native strategy

The Kotlin developers figured that the same strategy that is used on the JVM platform could be used on other platforms too. Consider the following illustration:

On no platform does Kotlin disrupt the platform's existing technology:

  • The JVM works with the Java bytecode and Kotlin gives an alternative to Java to generate the same bytecode (By no means is Kotlin the first alternative as there are already 200+ languages that work with JVM, but it is the most elegant one for all the reasons that we have seen previously).
  • On modern browsers where JavaScript is the de facto standard, Kotlin can work by transpiling to JavaScript. Again, this means that Kotlin is friendly with existing browsers without making any special effort.
  • On the Node.js platform where JavaScript is used on the server side, your Kotlin code transpiles into JavaScript, and hence there are no changes needed in the Node.js framework for Kotlin to run.
  • In a similar way, Kotlin/Native plans to work with other technologies in a native way. As we will see in Chapter 7, CSV Reader in Kotlin Native, Kotlin/Native will be used to generate Native code.

Since the platform's technology is not disrupted, there are zero changes needed at the platform level to adopt Kotlin. Kotlin's compatibility with a given platform can be taken for granted from day one. This eliminates a big business risk.

 

Kotlin's winning strategy


Kotlin's winning strategy is the sum of the various factors that we have seen previously. It has a two-pronged strategy to win over the developers with the coolness of the language, and the ease of working with it, to win over business users with its business benefits. The following illustration shows us the different benefits of using Kotlin:

The other benefits also include:

  • The growing popularity of the language
  • Endorsement from Google to make Kotlin an officially supported language in May 2017
  • Kotlin-specific development frameworks emerging
  • Leading Java frameworks, such as Spring, offering Kotlin-specific improvements
  • The growing number of applications being tried out with Kotlin
  • The user groups spread across Kotlin developer hubs
  • The growing number of technology companies using Kotlin

With this in mind, the winning strategy for smart programmers is to master Kotlin and learn to work with Kotlin on various platforms. Being ahead of the curve as opposed to following the world after Kotlin is already big but it will be a quick path to being recognized as a leader. Further chapters of this book will help you in exactly this mission.

Apart from going through this book, we strongly suggest you join the community.

Note

Join the Kotlin weekly mailing list at http://kotlinweekly.net. Join the nearest Kotlin user group at http://kotlinlang.org/community/user-groups.html.Kotlin's community on Slack is at https://kotlinlang.slack.com/.

 

Summary


In this chapter, we mainly saw how Kotlin is well positioned to take off as the universal programming language. It offers an opportunity for smart programmers to establish themselves at the forefront of this rising tide.

For you to see what makes Kotlin a worthy candidate as a better Java, we saw in detail the strategies that Kotlin is employing to get there, such as wooing the largest chunk of developers (namely, the Java developers) by being a better Java and a compatible one too. In other territories, where other languages are well-established, giving code generation options to get compatible source codes/binaries. Doing everything that developers and managers love to make coding, or migrating from another language easy.

About the Authors

  • Ashish Belagali

    Ashish Belagali is an IIT Bombay alumnus with 24 years of experience in software technology, management, consulting, and client handling. He has successfully executed offshore engagements in both onsite and offshore roles. He is known as a turnaround specialist, having turned many IT projects from red to green in a short time.

    In spite of the senior positions he has handled, Ashish loves coding and has managed to stay hands-on with it. He often speaks about technology, entrepreneurship, and work effectiveness. He is a Kotlin enthusiast and has worked on several Kotlin projects. He is also the founder of the Kotlin Pune User Group.

    Browse publications by this author
  • Hardik Trivedi

    Hardik Trivedi is a self-taught computer programmer. He has worked on Android and Java since 2010 and has immersed himself in Kotlin and JavaScript. Apart from client projects, he loves contributing back to the development community by spending time on Stack Overflow and writing tech blogs. Hardik also mentors college students, professionals, and companies are interested in mobile app development. He is also an active community speaker.

    Browse publications by this author
  • Akshay Chordiya

    Akshay Chordiya is the co-founder of BitFurther, an Android Developer by heart, and a Kotlin enthusiast. He has been working with Android for over 4 years. He is an active community speaker who is mostly found talking about Android and Kotlin.

    Akshay is an avid blogger and instructor. He has a love for anything with the word "technology" in it! The vision of bringing about a change in the world through his knowledge is what makes him get out of bed every day and work on his apps and his start-up. "Doing what you love" can be said to sum up his life until now and in the exciting years to come ahead!

    Browse publications by this author

Latest Reviews

(2 reviews total)
Good starting point for Kotlin
Brilliant book, step by step, project oriented book.
Kotlin Blueprints
Unlock this book and the full library for $5 a month*
Start now