Introduction to Kotlin

import Citations from ‘@components/Citations.astro’

Kotlin is a statically typed language targeting the JVM, Android, JavaScript, and native platforms via LLVM. Developed by JetBrains, it was designed to address Java’s verbosity, null safety issues, And lack of modern language features while maintaining full interoperability.

Key design goals:

• Null safety at the type level — nullable and non-nullable types are distinct; NullPointerException is largely eliminated at compile time.
• Concise syntax — type inference, data classes, default parameters, extension functions reduce boilerplate significantly versus Java.
• Full Java interoperability — Kotlin compiles to JVM bytecode and can call any Java library without wrappers or adapters.
• Coroutines for async — first-class language support for suspending functions replaces callback hell and reactive boilerplate.

All three targets share the same language syntax and standard library. Platform-specific APIs are Accessed through expect/actual declarations.

// Common code (shared across all targets)
expect fun platformName(): String

fun greet() = "Hello from ${platformName()}"

// JVM actual
actual fun platformName(): String = "JVM ${System.getProperty("java.version")}"

// Native actual
actual fun platformName(): String = "Kotlin/Native"

• JVM: Default choice. Leverages the mature JVM ecosystem, garbage collector, and existing Java libraries. Android uses the JVM target (with ART/Dalvik as the runtime).
• Kotlin/Native: Required for iOS targets. No garbage collector — uses reference counting with an automated cycle collector. Interop with C/Objective-C/Swift via cinterop.
• Kotlin/JS: Use Kotlin Multiplatform with Compose Multiplatform or when sharing logic between backend and browser. IR compiler produces optimizable JavaScript.

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install kotlin

brew install kotlin

kotlin -version
## Kotlin version 2.1.0-release (JRE 21.0.2+13)
kotlinc -version
## info: kotlinc-jvm 2.1.0 (JRE 21.0.2+13)

The Kotlin Playground provides an in-browser editor with JVM, JavaScript, and Kotlin/Native targets. Useful for quick experimentation without a local setup.

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

Compile and run:

kotlinc hello.kt -include-runtime -d hello.jar
java -jar hello.jar

Or run directly:

kotlin hello.kt

The Kotlin Koans are a series of interactive exercises Covering syntax features from basic to advanced. Each koan is a failing test that you fix by Implementing the correct Kotlin code.

plugins {
    kotlin("jvm") version "2.1.0"
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation(kotlin("test"))
}

tasks.test {
    useJUnitPlatform()
}

<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib</artifactId>
    <version>2.1.0</version>
</dependency>

Kotlin uses a stable backward compatibility policy. Code compiled with Kotlin 1.x will run on Future 1.x releases without recompilation. Major version bumps (rare) may break compatibility.

kotlin {
    compilerOptions {
        languageVersion.set(org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0)
        apiVersion.set(org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0)
    }
}

• languageVersion: Language features available to the compiler.
• apiVersion: API surface available at runtime (must be <= languageVersion).

Kotlin is a modern JVM language that fixes Java’s pain points: Null safety, data classes, extension functions, and coroutines address common Java complaints while maintaining full Java interoperability. Kotlin is now the preferred language for Android development.

Why it matters: Kotlin’s conciseness and safety features reduce boilerplate and prevent common bugs, making development faster and code more reliable.

The key insight: Kotlin’s null safety system (nullable vs non-nullable types) eliminates the billion-dollar mistake of null pointer exceptions at compile time.

• ** Mixing JVM and Native targets in the same module without Kotlin Multiplatform. Use KMP explicitly or keep targets in separate modules.
• *_ Assuming Kotlin/JS has the same runtime characteristics as JVM. No java._ packages, different concurrency model, different performance profile.
• ** Using kotlinc directly for production builds. Always use Gradle or Maven for dependency management, incremental compilation, and reproducible builds.

<Citations sources={[ {title=“Kotlin in Action”, author=“Jemerov and Isakova”, year=“2017”, type=“book”}, {title=“Kotlin Programming: The Big Nerd Ranch Guide”, author=“Acido and Phillips”, year=“2018”, type=“book”}, ]} />

• Site Home: Main landing page for kotlin notes.
• Practice: Practice problems for revision.

• About This Site
• Before You Begin: What Kotlin Assumes You Know
• Complete Kotlin Programming Study Guide
• Kotlin Glossary, Key Terms and Definitions