Kotlin Quick Start Guide

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:

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.

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.

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.

buildscript {
   ext.kotlin_version = '1.2.40'

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

apply plugin: "kotlin"

repositories {
   mavenCentral()
}

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

compileKotlin {
   kotlinOptions.jvmTarget = "1.8"
}

<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>

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

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

<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>

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

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.

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.