Getting Started

🚀 Getting Started with Kotlin

☕ What Is Kotlin, and Why Learn It?

Kotlin is:

• Statically typed — every value has a type, checked at compile time (like TypeScript, unlike plain JavaScript)
• JVM-based — Kotlin source compiles to the same bytecode Java does, and runs on the same virtual machine
• 100% Java-interoperable — Kotlin code can call Java libraries directly, and vice versa
• Android's preferred language — Google made Kotlin the recommended language for Android development in 2019, ahead of Java
• Designed to fix Java's pain points — null safety, less boilerplate, and expression-oriented syntax are all direct responses to common Java frustrations

▶️ Your First Kotlin Program

Copy// hello.kt
fun main() {
    println("Hello, Kotlin!")
}

Copy$ kotlinc hello.kt -include-runtime -d hello.jar
$ java -jar hello.jar
Hello, Kotlin!

Notice there's no class wrapping main, and no semicolon at the end of the println line — both required in Java, both optional in Kotlin. fun declares a function (short for function), and top-level functions — ones that live outside any class — are completely normal in Kotlin, unlike Java where every method must belong to a class.

📦 val vs var

Kotlin has exactly two ways to declare a value, and the choice is deliberate every time:

Copyval name = "Philip"      // read-only reference — cannot be reassigned
var score = 0            // mutable — can be reassigned

score = 10                 // fine, score is a var
name = "Someone else"     // compile error — val cannot be reassigned

Java's default is mutable — you have to opt in to immutability with final, and most Java code doesn't bother. Kotlin flips that: val is the natural first choice, which pushes code toward fewer accidental mutations without any extra ceremony.

🔢 Basic Types & Type Inference

Kotlin's built-in types cover the same ground as Java's primitives, but without the primitive/object split:

Copyval age: Int = 33
val price: Double = 19.99
val isReady: Boolean = true
val initial: Char = 'P'
val title: String = "Learning Blog"

// The type annotations above are optional — Kotlin infers them:
val inferredAge = 33       // inferred as Int
val inferredPrice = 19.99 // inferred as Double

Type inference means you rarely write the type annotation explicitly — Kotlin figures out Int, String, etc. from the value on the right-hand side, the same way TypeScript's let x = 5 infers number. The annotation is still useful (and sometimes required) when the type isn't obvious from context, such as an empty collection or a function parameter.

📝 String Templates

Kotlin builds strings with string templates — the direct equivalent of JavaScript's template literals, but with a different symbol:

Copyval name = "Philip"
val age = 33

// Simple variable — just $name
println("Hello, $name!")                    // Hello, Philip!

// Expression — needs ${ } braces
println("Next year you'll be ${age + 1}")  // Next year you'll be 34

The key difference: Kotlin string templates live inside ordinary double-quoted strings, not a special delimiter — so every String in Kotlin is automatically template-capable. For a single variable, the braces are optional ($name works fine); for anything more than a bare variable — a property access, a function call, an expression — the ${ } braces are required.

💻 Coding Challenges

🎯 What's Next

Next chapter: Functions & Lambdas — default parameters, named arguments, single-expression functions, and Kotlin's lambda syntax.