Chapter 1. Introducing Kotlin

Kotlin is a relatively new programming language, developed by JetBrains, the company that stands behind some of the most popular developer IDEs and tools, such as IntelliJ IDEA and ReSharper. JetBrains didn't create Kotlin so that they could make money on it; instead, they started the project because they wanted to solve their own development problems. In 2010, when the project started, Java was the dominant language in their code base. However, the development team wasn't happy with Java and some of its old-fashioned features. They looked for more modern alternatives to Java, but couldn't find one that satisfied their requirements in the existing JVM languages. Scala was popular at the time and was considered, but it had issues such as slow compile times.

So, they decided to create a completely new language by themselves. Since they already had a huge code base written in Java, rewriting everything in this new language wouldn't have been practical. So, Java interoperability was one of the top priorities.

Preview of the language was released in 2011 and the developer community reacted positively to it. Since then, the popularity of the language has grown rapidly. The language is open source and JetBrains' developers are not the only ones working on it. The project (language, compiler, standard library, tools, and so on) is hosted on GitHub and developers all around the world are contributing to it. Currently, there around 200 contributors to the Kotlin repository. Developers are also adopting it and more and more companies are using it in their production code. Even big companies, such as Atlassian, Square, Uber, and Pinterest, use Kotlin in production. Google also supports Kotlin development. It made Kotlin an officially supported language for building Android apps.

Now that we know how Kotlin started – and that its main goals are great Java interoperability and, at the same time, better productivity than Java – we can say that Kotlin is a general purpose, statically typed, object-oriented and functional programming language, that (primarily) targets JVM. The name Kotlin comes from an island near St.Petersburg, just as Java was named after an island in Indonesia.

In this chapter we will focus on:

Compiling and running Kotlin
Kotlin's uses
Java interoperability
Build tools
Setting up the development environment

Compiling and running Kotlin

Kotlin started as a JVM language, so the first compiler for Kotlin was targeting Java bytecode. But now, there are also compilers that can turn Kotlin into JavaScript and one that is still experimental, that produces native code.

Thanks to this compiler and the native code output, soon it will be possible to write apps with Kotlin that don't require additional runtimes.

This book will focus on Kotlin running on JVM, as this is the most popular usage of Kotlin today. But most of the things learned here can also be applied to other Kotlin platforms (both JavaScript and Native).

Kotlin source code is stored in files with a .kt extension, similar to the way that Java's are stored with a .java extension. Compiling Kotlin .kt files produces .class files that contain Java bytecode.

These are the same .class files that a Java compiler produces.

From there, .class files are bundled inside .jar files to form a module (a library or an app).

Since JVM only knows about Java bytecode, running apps written in Kotlin is no different from how they are written in Java.

One additional step is needed to run Kotlin modules or apps. Kotlin has its own standard library, which builds upon Java's Standard Library, and it has to be distributed with your module or app. Luckily, the Kotlin compiler does this step for us (if you are using the compiler from the command-line, just add the -include-runtime argument to a kotlinc command). Also, with the size of around 800 KB, we can say that the Kotlin standard library is relatively small and you shouldn't be worried about it.

The following diagram shows how Kotlin source code is compiled and run on the JVM:

Kotlin's uses

Now that we know that Kotlin apps run on the JVM, we also know that it basically means that Kotlin can be used for anything that Java could be used for.

Today, Java is really popular for backend (server) development and Kotlin can be used for any kind of server development. Whether it is web apps that serve HTML content, a backend for REST APIs or Microservices, Kotlin can do the job. Not only that, thanks to the Kotlin JavaScript compiler, it can also be used for building frontend web Apps. So it is entirely possible to create a web App (both backend and frontend) using only one language.

Another area where Java used to be dominant was in native Android development (other JVM languages could also be used, but none has really gained popularity on Android). This is where Kotlin has probably gained the most popularity. In one part, due to Google officially supporting it for Android development, and, secondly, because Android is still stuck on Java 6. Kotlin, with its modern features, spread rapidly among the Android developers' community.

Kotlin can also be used for developing desktop apps since both JavaFX and Swing UI libraries can be called from Kotlin.

Java interoperability

As mentioned before, Java interoperability was one of the main goals during the development of Kotlin and it is implemented seamlessly. You can call from Kotlin existing libraries compiled with Java; you can also extend a class written in Java or implement an interface written in Java and use all its types from the Java Standard Library.

But the best part is that you can have Kotlin side-by-side with the existing Java code. There's nothing preventing you from writing half of your project in Java and the other half in Kotlin.

IDEs (IntelliJ or Eclipse with a Kotlin plugin) support navigating in both Kotlin and Java files in the same project. Also, debugging and stepping through code from a project with both languages is not a problem at all. Refactoring Kotlin or Java code will also correctly update the references in another language as well.

This interoperability is also visible in the Kotlin Standard Library. Standard Library relies heavily on Java Standard Library and extends a lot of types from it. For example, Kotlin doesn't have it's own collections classes, it uses ones from Java. Java library has been battle tested and so it wouldn't make sense to reinvent the wheel.

Java-Kotlin interoperability also works in another direction. You can call functions written in Kotlin from Java, extend types and implement interfaces declared in Kotlin.

Build tools

For anything more than a simple app, you will probably use some kind of build automation tools like Maven, Ant or Gradle. The good news is that Kotlin is supported by all three of them.

In this section, will see how to set up Maven and Gradle tools for development with Kotlin.

If you are starting a new project with Gradle or Maven, your IDE probably can generate the required files for you. Here you will learn how to add Kotlin manually because you might have an existing Java project and want to start using Kotlin with it or in case you don't want to use an IDE.

Gradle

In your Gradle project, you have the build.gradle file located somewhere in the root of your project. Make sure that you have this buildScript section in that file.

buildscript {
   ext.kotlin_version = '1.2.40'

   repositories {
       mavenCentral()
   }
   dependencies {
       classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
}

This tells Gradle to use a Kotlin plugin and adds Maven central to the list of repositories. With the plugin added, we still need the Kotlin standard library to be able to compile a Kotlin source code. If you have multiple Gradle modules, make sure that the module's build.gradle file in which you plan to use Kotlin has the following:

apply plugin: "kotlin"

repositories {
   mavenCentral()
}

dependencies {
   compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}

compileKotlin {
   kotlinOptions.jvmTarget = "1.8"
}

If you don't have multiple build.gradle files, then put this to the root build.gradle file. The same one in which you added the Kotlin plugin.

You can also set various compiler options under the compile Kotlin section. For example, with the kotlinOptions.jvmTarget = "1.8" option we told the Kotlin compiler to produce Java 1.8 compatible bytecode.

Now, if you sync your Gradle project, you should be able to add Kotlin files to it and compile them with Gradle.

Maven

If Maven is your build tool of choice, then setting up Kotlin will be just as easy.

In the same way as with Gradle, we first need to add a Kotlin plugin to a pom.xml file. You can do this by adding these lines to the plugins section:

<plugin>
   <artifactId>kotlin-maven-plugin</artifactId>
   <groupId>org.jetbrains.kotlin</groupId>
   <version>${kotlin.version}</version>
<executions>
<execution>
<id>compile</id>
          <goals><goal>compile</goal></goals>
      </execution>
    </executions>
</plugin>

We can define a Kotlin version at one place, inside the properties section:

<properties>
   <kotlin.version>1.2.40</kotlin.version>
</properties>

In the same way as with Gradle, the Kotlin standard library needs to be added to dependencies.

<dependencies>
   <dependency>
       <groupId>org.jetbrains.kotlin</groupId>
       <artifactId>kotlin-stdlib</artifactId>
       <version>${kotlin.version}</version>
   </dependency>
</dependencies>

If you are targeting JDK 8, you can replace kotlin-stdlib with kotlin-stdlib-jdk8 so you can have Kotlin extension functions that cover the latest APIs from JDK 8.

This should be enough if you plan on only writing Kotlin. If you are mixing Kotlin and Java inside a Maven project, a Kotlin compiler needs to run before a Java compiler. To instruct Maven to compile Kotlin first, the Kotlin plugin needs to be before the Maven compiler plugin.

Here's what the complete build section looks like:

<build>
   <plugins>
       <plugin>
           <artifactId>kotlin-maven-plugin</artifactId>
           <groupId>org.jetbrains.kotlin</groupId>
           <version>${kotlin.version}</version>
           <executions>
               <execution>
                   <id>compile</id>
                   <goals> <goal>compile</goal> </goals>
                   <configuration>
                       <sourceDirs>
                           <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
                           <sourceDir>${project.basedir}/src/main/java</sourceDir>
                       </sourceDirs>
                   </configuration>
               </execution>
           </executions>
       </plugin>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.5.1</version>
           <executions>
               <execution>
                   <id>default-compile</id>
                   <phase>none</phase>
               </execution>
               <execution>
                   <id>java-compile</id>
                   <phase>compile</phase>
                   <goals> <goal>compile</goal> </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>
</build>

Finally, there are various Kotlin compiler options that can be set under the configuration section of a Kotlin plugin. Here's an example of how to instruct the compiler to produce a Java 1.8 compatible bytecode.

<plugin>
   <artifactId>kotlin-maven-plugin</artifactId>
   <groupId>org.jetbrains.kotlin</groupId>
   <version>${kotlin.version}</version>
   <configuration>
      <jvmTarget>1.8</jvmTarget>
   </configuration>
</plugin>

Setting up the development environment

Although you could use a basic text editor for writing Kotlin source code and compile it using the command-line tools, you will make your life easier if you use an IDE for coding. IDE can provide code completion, syntax highlighting, stepping through code while debugging, refactoring, and more.

IntelliJ IDEA is probably the most popular IDE for Java today. The IDE comes from the same company that created Kotlin and, of course, Kotlin is a first class citizen inside IntelliJ. This book uses IntelliJ, and it is recommended that you use it as well. But other popular IDEs for Java could also work, such as Eclipse or NetBeans (a Kotlin plugin would be needed). The great thing about IntelliJ is that the latest versions already come with a Kotlin plugin pre-installed, so the IDE is ready for Kotin development out of the box. This plugin already has a Kotlin compiler and also enables Kotlin syntax highlighting inside the code editor.

Another benefit of using IntelliJ is that it comes with a Java to Kotlin converter. If you have some Java code, or you are working in a mixed (both Java and Kotlin) project, you can convert Java code to Kotlin with the click of a button. Some minor changes might be needed in the resulting Kotlin code but in general, this converter works reasonably well.

IntelliJ has a paid for Ultimate version and a free Community version. The Express version has everything needed for Kotlin development and can be downloaded from the JetBrains website https://www.jetbrains.com/idea/download/. It's available for all platforms (Mac, Linux, and Windows).

Finally, if you are just trying out the syntax or just getting a feel for the language, there is a free online compiler and IDE available at https://try.kotlinlang.org/.

What's great about this online IDE is that it has plenty of examples of Kotlin features. There is also a section called Koans which has smaller code problems with the goal of teaching Kotlin. So, it might be worth checking it out.

Now that we have an IDE installed, let's get the first taste of Kotlin. Inside Intellij, start a new project and select Kotlin from the bar on the left and then select the Kotlin/JVM option, as seen in the following screenshot:

On the next screen, enter your project name and select KotlinJavaRuntime in the Use library section.

This will be enough to compile and run Kotlin code from the IDE. For smaller examples, setting up Maven or Gradle would be an overkill.

Now that we have a Kotlin project, let's add some Kotlin code: the standard Hello World printed to the console. Add a file named Main.kt inside the src folder.

Inside that file add the following code:

fun main(args: Array<String>) {
   println("Hello World!")
}

Now, there should be a little green icon in the gutter of the text editor and if you click it you should see "Hello World!" in the output.

Summary

In this chapter, we took a look at the history of Kotlin and explained how it compiles to Java bytecode. Thanks to Kotlin's great interoperability with Java, we've seen that it has wide use cases, from Backend apps to Mobile and Desktop apps. We'll be using IntelliJ IDEA as our IDE in this book, as Kotlin is supported out of the box. Finally, we discussed build tools that support Kotlin.

In the next chapter, we'll start with exploring the language and learning the basics.