Kotlin at a Glance — A Language a Day, Advent Calendar Day 4/24

About this ‘A Language a Day’ Advent Calendar

This article became a part of my book ‘A Language a Day’, which you can get in both electronic and paper format. Languages covered in the book: C++, Clojure, Crystal, D, Dart, Elixir, Factor, Go, Hack, Hy, Io, Julia, Kotlin, Lua, Mercury, Nim, OCaml, Raku, Rust, Scala, and TypeScript.

Learn more where to get the book

Welcome to Day 4 of this year’s A Language a Day Advent Calendar. Today’s topic is introduction to the Kotlin programming language.

Facts about the language

Some facts about the Kotlin programming language:

• It targets JVM (but the syntax is not of Java)
• Can be compiled to JavaScript or LLVM
• Directly suitable for Android development
• Appeared in 2011
• Designed by JetBrains
• Website: kotlinlang.org

Installing and running Kotlin

There are multiple options of installing Kotlin on your machine, here is the simplest way to get it on a Mac:

 $ brew install kotlin

To compile a program, use the following command-line call:

$ kotlinc helloworld.kt -include-runtime -d helloworld.jar

To run the generated jar file, pass it to Java:

$ java -jar helloworld.jar 

Alternatively, use the online playground.

fun main() {
    println("Hello, World!")
}

Variables

There are two keywords to create a variable: var and val. The first of them creates a mutable, the second one — an immutable variable.

fun main() {
    val greeting = "Hello"
    var name = "John"
    println("$greeting, $name!") // Hello, John!

    // greeting = "Hi" // error: "val cannot be reassigned"
    name = "Karla"
    println("$greeting, $name!") // Hello, Karla!
}

In this example, you can also see how Kotlin is interpolating variables in a string. Similarly to Perl, the variable is prefixed with a dollar to be interpolated, but unlike Perl, you use a regular name with no prefix everywhere else.

The type of the variable can be deduced by the compiler, but you can also help it by specifying the type explicitly:

var name: String = "John"

Functions

The main function, which we met in the Hello, World! program, is an example of a minimalistic function that takes nothing and returns nothing. But that is, of course, not the general rule, and even the main function can look differently.

fun main(args: Array) {
    for (arg in args) {
        println(arg)
    }
}

This program prints the arguments passed via command line:

$ java -jar out.jar alpha beta gamma
alpha
beta
gamma

The same idea is for announcing the return type, for example:

fun make_greeting(name: String): String {
    return "Hello, $name!"
}

An interesting feature of Kotlin is the way you can express short functions. The above example can be rewritten like this, using the = sign instead of curly braces:

fun make_greeting(name: String) = "Hello, $name!"

You can provide a function with the default value of a parameter:

fun make_greeting(name: String = "buddy") = "Hey, $name!"

fun factorial(n: Int): Int = when {
    n < 2 -> 1
    else -> n * factorial(n - 1)
}

fun main() {
    println(factorial(4)) // 24
    println(factorial(5)) // 120
    println(factorial(6)) // 720
}

Lambdas

There are a few ways of defining a lambda function, one of them is shown below. Here, an anonymous function is saved in an immutable variable:

val greeter = {s: String -> "Hi, $s!"}

fun main() {
    println(greeter("John"))
}

Classes

In Kotlin, the object-oriented system is quite diverse. First, here is an example that can be more or less understood by anybody with an OOP experience in other languages.

class Person(name: String, age: Int) {
    val name = name
    var age = age

    fun info() {
        println("My name is $name, I am $age years old.")
    }
}

fun main() {
    var p = Person("John", 42)
    p.info()
}

Note that the name and the age data members are declared with different keywords: val and var. A part in parentheses after the name of the class is actually a shortened form of a constructor. You can do the same more verbosely:

class Person constructor(name: String, age: Int) { ... }

You don’t need a constructor if you don’t need one. To set the initial values of data members (if you have them), use the init method.

class Person {    
    var name: String
    var age: Int

    init {
        name = ""
        age = 0
    }
    
    fun info() {
        println("My name is $name, my age is $age.")
    }
 }

fun main() {
    var p = Person()
    p.name = "Linda"
    p.age = 24
    p.info()
}

Objects

There is another keyword, object, which can work in place of class, but in this case you will create a single object (singleton). Take the following simple class and create two instances of it:

class X {
    init {
        println("Class init")
    }

    fun info() {
        println(this)
    }
}

fun main() {
    var x = X()
    x.info()

    var y = X()
    y.info()
}

This program creates two different objects:

Class init
X@4ca8195f
Class init
X@65e579dc

Now, change class to object (and remove parentheses when creating variables).

object X {
    init {
        println("Object init")
    }

    fun info() {
        println(this)
    }
}

fun main() {
    var x = X
    x.info()

    var y = X
    y.info()
}

Having this change, you will have a single object in your code: it is created only once, and both x and y refer to the same object:

Object init
X@4ca8195f
X@4ca8195f

Getters and setters

For data members to behave more like properties, you can define your own getters and setters. Here is an example of both a setter and a getter methods that do some additional work when the value of age is read or changed.

class Person(name: String, age: Int) {    
    val name = name
    var age = age
        set(new_age) {
            println("Happy birthday, $name!")
            field = new_age
        }
        get() {
            println("Somebody asked for $name's age")
            return field
        }
}

fun main() {
    var p = Person("John", 42)
    p.age++ // both getter and setter are triggered here
}

Inheritance

By default, classes are final. To derive a child class, make the class explicitly open.

open class Animal

class Dog: Animal()
class Cat: Animal()

(This is a correct Kotlin program, by the way. All three classes are empty.)

The same consideration counts for redefining methods. You have to both specify them as open in the base class, and as override in the derived class.

abstract class Animal {
    abstract fun speak(): String
}

class Dog: Animal() {
    override fun speak() = "Dog"
}

class Cat: Animal() {
    override fun speak() = "Cat"
}

fun main() {
    var zoo = arrayOf(Dog(), Cat(), Dog(), Cat())
    for (animal in zoo) {
        println(animal.speak())
    }
}

Coroutines

Instead of looking at working with threads, or using the async/await pair, let us touch another interesting feature of Kotlin, coroutines. We’ll implement the Sleep Sort algorithm using them.

import kotlinx.coroutines.*

fun main() = runBlocking<Unit> {
    val data = arrayOf(10, 4, 2, 6, 2, 7, 1, 3)

    var jobs = emptyArray<Job>();
    for (n in data) {
        jobs += GlobalScope.launch {
            delay(n * 50L)
            println(n)
        }
    }
    
    jobs.forEach {
        it.join()
    }
} 

Get more

I hope that you got an impression that Kotlin is a very rich language. I would advise you to continue exploring it. As a starting point, use the following resources:

• Learn Kotlin by Example
• Kotlin Tutorials
• Language reference
• Online Playground

Please get the source code of Kotlin examples you’ve seen in this article on GitHub.

Next: Day 5. Modern C++