Why you should totally switch to Kotlin

It’s time to start using a modern programming language

I want to tell you about a new programming language called Kotlin and why you should consider it for your next project. I used to prefer Java but the last year I’ve found myself coding Kotlin whenever I could, and at this point, I really can’t think of a situation where Java would be a better choice.

It’s developed by JetBrains, and the fact that these are the people behind a suite of IDEs, such as IntelliJ and ReSharper, really shines through in Kotlin. It’s pragmatic and concise and makes coding a satisfying and efficient experience.

Although Kotlin compiles to both JavaScript and soon machine code, I’ll focus on its prime environment, the JVM.

So here’s a couple of reasons why you should totally switch to Kotlin (in no particular order):

0# Java Interoperability

1# Familiar Syntax

class Foo {

val b: String = "b" // val means unmodifiable
var i: Int = 0 // var means modifiable

fun hello() {
val str = "Hello"
print("$str World")

fun sum(x: Int, y: Int): Int {
return x + y

fun maxOf(a: Float, b: Float) = if (a > b) a else b


2# String Interpolation

val x = 4
val y = 7
print("sum of $x and $y is ${x + y}") // sum of 4 and 7 is 11

3# Type Inference

val a = "abc"                         // type inferred to String
val b = 4 // type inferred to Int

val c: Double = 0.7 // type declared explicitly
val d: List<String> = ArrayList() // type declared explicitly

4# Smart Casts

if (obj is String) {
print(obj.toUpperCase()) // obj is now known to be a String

5# Intuitive Equals

val john1 = Person("John")
val john2 = Person("John")
john1 == john2 // true (structural equality)
john1 === john2 // false (referential equality)

6# Default Arguments

fun build(title: String, width: Int = 800, height: Int = 600) {
Frame(title, width, height)

7# Named Arguments

build("PacMan", 400, 300)                           // equivalent
build(title = "PacMan", width = 400, height = 300) // equivalent
build(width = 400, height = 300, title = "PacMan") // equivalent

8# The When Expression

when (x) {
1 -> print("x is 1")
2 -> print("x is 2")
3, 4 -> print("x is 3 or 4")
in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
else -> print("x is out of range")

It works both as an expression or a statement, and with or without an argument:

val res: Boolean = when {
obj == null -> false
obj is String -> true
else -> throw IllegalStateException()

9# Properties

class Frame {
var width: Int = 800
var height: Int = 600

val pixels: Int
get() = width * height

10# The Data Class

data class Person(val name: String,
var email: String,
var age: Int)

val john = Person("John", "john@gmail.com", 112)

11# Operator Overloading

data class Vec(val x: Float, val y: Float) {
operator fun plus(v: Vec) = Vec(x + v.x, y + v.y)

val v = Vec(2f, 3f) + Vec(4f, 1f)

12# Destructuring Declarations

for ((key, value) in map) {
print("Key: $key")
print("Value: $value")

13# Ranges

for (i in 1..100) { ... } 
for (i in 0 until 100) { ... }
for (i in 2..10 step 2) { ... }
for (i in 10 downTo 1) { ... }
if (x in 1..10) { ... }

14# Extension Functions

If only there was a way to add new functions to old classes; that way your IDE could help you find the right function in code-completion. In Kotlin you can do exactly that:

fun String.replaceSpaces(): String {
return this.replace(' ', '_')

val formatted = str.replaceSpaces()

The standard library extends the functionality of Java’s original types, which was especially needed for String:

str.replaceAfter(":", "classified")

15# Null Safety

Kotlin resolves this by distinguishing between non-null types and nullable types. Types are non-null by default, and can be made nullable by adding a ?like so:

var a: String = "abc"
a = null // compile error

var b: String? = "xyz"
b = null // no problem

Kotlin forces you to guard against NPEs whenever you access a nullable type:

val x = b.length        // compile error: b might be null

And while this might seem cumbersome, it’s really a breeze thanks to a few of its features. We still have smart casts, which casts nullable types to non-null wherever possible:

if (b == null) return
val x = b.length // no problem

We could also use a safe call ?., which evaluates to null instead of throwing a NPE:

val x = b?.length       // type of x is nullable Int

Safe calls can be chained together to avoid those nested if-not-null checks we sometimes write in other languages, and if we want a default value other than null we can use the elvis operator ?::

val name = ship?.captain?.name ?: "unknown"

If none of that works for you, and you absolutely need an NPE, you will have to ask for it explicitly:

val x = b?.length ?: throw NullPointerException()  // same as below
val x = b!!.length // same as above

16# Better Lambdas

val sum = { x: Int, y: Int -> x + y }   // type: (Int, Int) -> Int
val res = sum(4,7) // res == 11

And here come the clever bits:

  1. Method parentheses can be moved or omitted if the lambda is the last or the only argument of a method.
  2. If we choose not to declare the argument of a single-argument-lambda it’ll be implicitly declared under the name it.

These facts combined make the following three lines equivalent:

numbers.filter({ x -> x.isPrime() })
numbers.filter { x -> x.isPrime() }
numbers.filter { it.isPrime() }

And this allows us to write concise functional code — just look at this beauty:

.filter { it.age >= 18 }
.sortedBy { it.name }
.map { it.email }
.forEach { print(it) }

Kotlin’s lambda system combined with extension functions makes it ideal for DSL creation. Check out Anko for an example of a DSL that aims to enhance Android development:

verticalLayout {
padding = dip(30)
editText {
hint = “Name”
textSize = 24f
editText {
hint = “Password”
textSize = 24f
button(“Login”) {
textSize = 26f

17# IDE Support

Just to give you a minor but clever example, this thing popped up when I first tried to copy-paste some Java code from Stack Overflow:

IntelliJ will notice if you paste Java code into a Kotlin file

And that’s all for now. Thank you for reading! This is my first ever medium post.

EDIT: I finally finished my second medium post in which I’ve mapped all events since the Big Bang onto a one year Calendar. It’s called Everything So Far Summarized.