Kotlin

Sealed classes and exhaustive when

A sealed class restricts which classes can inherit from it — all subclasses must be in the same package/file. Combined with when, this creates exhaustive pattern matching: the compiler verifies every subclass is handled, eliminating the need for an else branch and catching missing cases at compile time. This is Kotlin's equivalent of Rust's enums or Haskell's algebraic data types.

sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String, val code: Int) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

fun handleResult(result: Result<String>) {
    // Compiler verifies all cases are handled — no else needed
    when (result) {
        is Result.Success -> println("Got: ${result.data}")
        is Result.Error   -> println("Error ${result.code}: ${result.message}")
        Result.Loading    -> println("Loading...")
    }
}

fun main() {
    handleResult(Result.Success("Hello"))
    handleResult(Result.Error("Not found", 404))
    handleResult(Result.Loading)
}

Coroutines — structured concurrency

Kotlin coroutines are the standard way to write asynchronous code in Kotlin. A coroutine is a suspendable computation — it can be suspended (paused) without blocking a thread, and resumed later. Coroutines are not threads: millions of coroutines can coexist on a handful of threads. The suspend keyword marks a function that can be suspended. Coroutines use structured concurrency: a coroutine is always launched in a CoroutineScope, and if the scope is cancelled, all child coroutines are cancelled too — preventing coroutine leaks.

import kotlinx.coroutines.*

suspend fun fetchUser(id: Int): String {
    delay(100)   // non-blocking delay — suspends coroutine, not thread
    return "User$id"
}

fun main() = runBlocking {   // creates coroutine scope for main
    // Launch concurrent coroutines
    val job1 = async { fetchUser(1) }
    val job2 = async { fetchUser(2) }

    // Await both results — runs in parallel
    println("${job1.await()} and ${job2.await()}")

    // Structured: launch N coroutines and wait for all
    val results = (1..5).map { id ->
        async { fetchUser(id) }
    }.awaitAll()
    println(results)

    // Flow — cold asynchronous stream (like Rx)
    // flow { emit(1); emit(2); emit(3) }
    //     .filter { it > 1 }
    //     .collect { println(it) }
}

Kotlin vs Java: key differences

Kotlin Multiplatform

Kotlin Multiplatform (KMP) allows sharing business logic code across platforms — Android, iOS, web (via Kotlin/JS), desktop, and server — while using native UI frameworks on each platform. KMP compiles Kotlin to JVM bytecode (Android/JVM), JavaScript (web), and LLVM-based native code (iOS, macOS, Linux). This is distinct from Flutter/React Native which render UI uniformly; KMP shares only logic, not UI. JetBrains declared KMP stable in November 2023.

Kotlin's type system: nullability and generics

Kotlin's type system distinguishes nullable (T?) and non-nullable (T) types at the type level. The compiler tracks nullability through the control flow graph — after a null check, the type is narrowed (smart cast). Kotlin's generics are similar to Java's but add explicit variance annotations: out T (covariant — producer), in T (contravariant — consumer). This resolves the use-site variance verbosity of Java (? extends T, ? super T) by declaring variance at the declaration site. Nothing is Kotlin's bottom type — a value of type Nothing never exists; functions that always throw or loop forever return Nothing.

Coroutines implementation: continuation-passing style

Kotlin coroutines are implemented via continuation-passing style (CPS) transformation at compile time. A suspend fun is transformed by the compiler into a state machine with a hidden Continuation<T> parameter. Each suspension point becomes a state in the machine. When suspended, the current state is saved in the Continuation object (heap-allocated) and the thread is released. When resumed, the state machine continues from where it left off. This is why millions of coroutines can exist with minimal overhead — each coroutine stores only its current state, not an entire OS thread stack.

Inline functions and reified generics

Kotlin inline functions have their body inlined at call sites — eliminating the overhead of lambda object creation and function call. This is critical for higher-order functions used in hot loops: filter, map, forEach are all inline. reified type parameters (only available with inline) allow accessing the actual runtime type of a generic parameter — solving the type erasure problem. inline fun <reified T> instanceOf(value: Any) = value is T works because the compiler inlines the function and substitutes the actual type for T.