The Kotlin Toolchain

Before writing real Kotlin, get comfortable with the tooling around it - how you build, run, and structure a Kotlin project, and the standard library that comes along. The good news for a Java developer: it's almost entirely tools you already know (JVM, Gradle, IntelliJ) with a Kotlin flavor. This short lesson maps the toolchain so nothing surprises you when the real language work starts.

Building: Gradle's Kotlin DSL

Kotlin projects usually build with Gradle - and there's a pleasant twist: Gradle's build script can itself be written in Kotlin, the Kotlin DSL (build.gradle.kts), instead of Groovy (build.gradle). For a Kotlin project this means your build script is in the same language as your code, with full IDE autocompletion and type-checking on the build itself:

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.0.0"
    application
}
dependencies {
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")   // a Java library, used from Kotlin
    testImplementation(kotlin("test"))
}

Everything you learned about Gradle in the build tooling context applies; the Kotlin DSL just gives you a type-safe, autocompleted script. (Maven works too via the Kotlin Maven plugin, but Gradle + Kotlin DSL is the idiomatic pairing - and a natural cross-link to the Build & Delivery path.)

Running Kotlin: apps, scripts, and the REPL

Kotlin's entry point is a top-level main function - no class required:

fun main() {
    println("Hello from Kotlin")
}

Three quick ways to run code while learning:

• A compiled application - the normal path: build with Gradle, run the main function (the application plugin wires this up).
• The REPL - kotlinc with no file drops you into an interactive shell to try expressions instantly (great for experimenting with a feature).
• Kotlin scripts (.kts files) - runnable scripts without a full project, handy for small automation.

For pure learning and experimentation, the online Kotlin Playground (play.kotlinlang.org) runs snippets in the browser with zero setup - the fastest way to test a language feature you just read about.

The standard library: batteries you used to import

Kotlin ships a rich standard library (kotlin-stdlib) that replaces a lot of what Java developers reach to Guava or Apache Commons for. Much of it lives as extension functions on the Java types you already use:

val name = "  Kotlin  ".trim().uppercase()        // String helpers built in
val nums = listOf(1, 2, 3, 4)                      // concise collection factories
val evens = nums.filter { it % 2 == 0 }            // functional collection ops, no streams import
val text = listOf("a", "b", "c").joinToString("-") // "a-b-c", no StringJoiner ceremony

Collections, sequences, string utilities, scope functions, ranges (1..10), and null-handling helpers are all in the stdlib - no extra dependency. It sits on top of the Java collections you know (a Kotlin List is a java.util.List at runtime), so interop is seamless while the API is far more ergonomic. You'll meet these properly in the collections module; for now, know they're built in.

Project layout and the IDE

A Kotlin project looks like a Java one: sources under src/main/kotlin (and src/test/kotlin), the same JAR output, the same JDK. IntelliJ IDEA has the deepest Kotlin support (same vendor), including the invaluable "convert Java file to Kotlin" action - paste Java code and it becomes Kotlin, a great learning aid and migration tool (review the result; it's a starting point, not always idiomatic).