Kotlin from Zero to Production: Concise, Safe, Modern

You'll work with Kotlin's core types — Int, Long, Double, Float, Boolean, and Char — and see common operations like integer division versus floating-point division. You'll pick up the suffix conventions (L for Long, F for Float) and learn that these types behave as real objects with methods, building your intuition for how numeric types resolve.

You'll interpolate variables and expressions straight into strings using template syntax — both the dollar-sign placeholder and the dollar-brace form — and see why it reads so much better than Java-style concatenation. You'll also use triple-quoted multiline strings to write raw text without escape clutter, and assemble a personalized character sheet using both template forms.

You'll get a wide, orienting tour of where Kotlin actually lives: the JVM as its home base, Android as its flagship, Kotlin/JS for the browser, Kotlin/Native for iOS and embedded targets, and Kotlin Multiplatform tying it all together. You'll map the key frameworks and tools that orbit the language so you have a feel for the terrain before you go deep.

You'll exercise the full set of everyday operators — arithmetic, comparison, and logical and/or/not — and read each result in the console output. You'll learn that operators are really function calls under the hood (which is what makes overloading possible later), then combine arithmetic and logical operators into a single expression that decides whether a gate can be entered.

You'll discover that if in Kotlin returns a value, so you can assign the result of an if/else straight to a val. You'll compare statement-style and expression-style if side by side, see why Kotlin doesn't need a ternary operator, and refactor a multi-line if into a single clean expression-style assignment.

You'll use when to dispatch on an integer, a range, and a type check — all in one expression — and watch the matched result for each case. You'll see how when replaces long if/else-if chains with something far more readable, and learn what happens when the compiler requires a when to be exhaustive but a case is missing.

You'll meet Kotlin's flagship feature head-on: declaring a nullable String?, seeing why calling length on it directly won't compile, then handling nullability cleanly with the safe call operator and the Elvis operator. You'll write a one-liner that returns a value or a sensible default when it's null, and chain safe calls through nested objects.

You'll check a value of type Any with the is operator and watch the compiler smart-cast it to a more specific type inside the branch — letting you call type-specific methods with no explicit cast. You'll work through several branches, including a smart cast inside a when expression, and see where smart casts refuse to help.

You'll learn the core values behind every Kotlin decision: pragmatism over purity, non-negotiable Java interoperability, conciseness without losing clarity, null safety in the type system, and a preference for immutability and expressions. You'll see how each pillar shows up in real code and how Kotlin's philosophy contrasts with other modern languages, giving you a mental compass for predicting why features exist.

You'll loop over ranges with the dot-dot operator, count downward with downTo, and skip values with step — watching each iteration print as it runs. You'll learn that ranges are first-class objects you can name and reuse, then put a named range to work in a loop.

You'll write both a while loop that counts up to a condition and a do-while loop that's guaranteed to run at least once, watching each iteration print. You'll learn when each form is the right choice, then combine both loops in a single scenario and reason about the output.

You'll loop over a collection with access to the index two idiomatic ways — destructuring with withIndex, and iterating positions directly with the indices property — and see how the same result reads differently in code. You'll then combine position and value to compute a running total.

You'll work with nested loops where an inner break or continue is targeted at an outer loop using a label, watching each step so you can follow exactly which iteration was skipped or stopped. You'll learn why labelled control flow is rare but indispensable, then use a label to break out of a doubly-nested loop on a condition.

You'll get a candid, honest look at where Kotlin falls short rather than another sales pitch: slower compile times than Java, the relative immaturity of Kotlin/Native, the complexity coroutines add for newcomers, occasional leaky Java interop, a heavier Android runtime footprint, and how the language's flexibility can hurt readability across teams. You'll leave trusting the course's neutrality and knowing the rough edges that separate a fluent practitioner from a fan.

You'll declare your first function with fun — defining parameters, a return type, and a body — then call it from main and print the result. You'll learn about the Unit type for functions that return nothing, then combine a couple of small functions so one feeds into another.

You'll call a function several ways — all positional, all named, and a mix that relies on defaults — and see how named arguments make call sites self-documenting while default values cut down on overloads. You'll then add a new default parameter to an existing function without breaking any of the calls that already use it.

You'll learn the equals-sign form of function declaration, where a single-expression body lets the return type be inferred, by rewriting a block-body function into its terse single-expression version. You'll see when this concise form aids readability and when it hides too much, then convert a small function yourself.

You'll define a function inside another function, watch it capture variables from the enclosing scope, and call it several times to see the closure behavior. You'll learn how local functions organize complex logic without cluttering the top-level namespace, then use a pair of local helpers to orchestrate a small piece of logic inside main.

You'll write a function that accepts a vararg parameter, call it with several individual arguments, then call it again by spreading an array with the asterisk operator. You'll learn when vararg beats accepting a List, then build a function that takes a vararg of strings and joins them with a separator you choose.

You'll get a quick technical fact sheet on the language itself: the current stable version, supported JVM bytecode targets, the standard library, the K2 compiler transition, and JetBrains' compatibility guarantees. You'll understand how Kotlin compiles to JVM bytecode, JavaScript, or native binaries, and what that means for performance and binary size — a reference worth bookmarking.

You'll create a read-only list with listOf, see why mutating it won't compile, then build a mutableListOf and add and remove elements, printing the state after each step. You'll learn why the read-only/mutable split is more honest than Java's pseudo-immutable collections, then reason about what compiles when a mutable list is promoted to read-only.

You'll use setOf and mutableSetOf, add duplicate elements, and watch the set silently deduplicate them. You'll learn the difference between a LinkedHashSet that preserves insertion order and a HashSet that doesn't, then compute the unique elements of a list with duplicates and print the size before and after.

You'll build a map with mapOf using the to infix function, look up values by key, iterate over entries to print them, and handle a missing key safely with the Elvis operator — then create a mutableMapOf and add to it. You'll see how maps work with destructuring in for loops, then filter a map down to only the entries above a threshold.

You'll chain the three essential functional operations on a list — filter to keep matching elements, map to transform each one, and forEach to print the results — and watch the intermediate result at each step. You'll then build a full pipeline that filters a list of numbers by a threshold, transforms what's left, and prints each result.

You'll destructure a Pair returned from a function, destructure map entries inside a for loop, and pull a data class instance apart into its components — printing each destructured value. You'll learn how componentN functions power this, then write your own function that returns a Pair and call it using destructuring.

You'll look at Kotlin's real-world footprint through dashboards and charts: the share of Android apps written in Kotlin, language rankings, survey results, and growth over recent years. You'll see which companies run Kotlin in production and across which domains, while learning to read benchmarks and adoption numbers critically rather than taking them at face value.

You'll write a function that takes another function as a parameter and returns a function as its result, then call it with lambda expressions and print each outcome. You'll learn the function-type syntax and the trailing-lambda convention, then build a higher-order function that takes a predicate, applies it to a list, and returns the count of matches.

You'll add a brand-new method to the built-in String type with an extension function and call it as if it were a real member, then add an extension property too. You'll learn that extensions are resolved statically and what that means for polymorphism, then build your own toolkit of String extensions firsthand.

You'll declare a data class, create an instance, use copy to make a modified version, print it with the generated toString, compare instances with the generated equals, and destructure one into its components — seeing every generated feature in action. You'll come away ready to lean on data classes anywhere you model plain values.

You'll build a sealed class hierarchy modelling a quest-result type with victory, defeat, and in-progress variants, then dispatch on it with a when expression the compiler verifies is exhaustive. You'll see how sealed classes give you algebraic data types that fit Kotlin's type system, then watch the compiler strike if you skip a variant, forcing you to handle every case.

You'll define a generic function and a generic class, instantiate each with different type arguments, and print the results. You'll meet variance through the in and out modifiers and see how the compiler treats covariance and contravariance, then build your own small generic container class that learns and stores items of any type.

You'll compare an eager list pipeline against a lazy sequence pipeline by chaining filter and map on each with print statements inside, making it obvious that a sequence runs one element through the whole chain before the next while a list materializes every intermediate. You'll learn when sequences pay off and when they don't, including how a sequence handles an effectively endless range.

You'll follow what happens when you compile Kotlin: source passing through the K2 frontend, lowering through intermediate representations, and emerging as JVM bytecode the verifier and JIT can run. You'll see where data classes, properties, and extension functions become synthetic accessors and static helpers — giving you a mental model for why Kotlin and Java interoperate so seamlessly and where the abstraction occasionally leaks.

You'll work inside a runBlocking scope to launch coroutines concurrently with launch and run others with async, awaiting their results and printing them as they complete. You'll learn the difference between fire-and-forget launch and async returning a Deferred, then bring launch and async together in a single scenario.

You'll write a suspend function that simulates work with the delay primitive, call it from multiple coroutines inside a scope, and print timestamps that show delay never blocks a thread. You'll learn how structured concurrency guarantees no coroutine outlives its scope, then write a suspend function that returns a result after a delay and call it concurrently from several coroutines.

You'll build a Flow that emits values over time, collect it from a runBlocking scope with a print on each emission, then transform it lazily with map and filter operators. You'll learn how Flow differs from a sequence (it can suspend between emissions) and from a hot stream, then build a flow that streams values with a delay between each.

You'll open a Closeable resource inside a use block and confirm its close method still runs even when an exception is thrown — with print statements before, during, and after to make the lifecycle visible. You'll see how this compares to Java's try-with-resources and why the Kotlin form is just a standard-library function, then trigger an exception in your own use block and handle nested resources to verify cleanup.

You'll contrast a traditional try/catch with the Result type wrapping a runCatching block, using onSuccess and onFailure to handle each outcome. You'll learn when Result is cleaner than throwing and when classical exceptions still make sense, then use getOrElse for a fallback value and chain results through a small pipeline.

You'll see three delegation idioms in one place: a val initialized with by lazy that computes only on first access, a property delegated to a map, and a class delegated to an interface implementation with by. You'll watch each pattern at work, then bring all three delegates together on a single class.

You'll learn what coroutines actually are at the bytecode level: suspending functions transformed into state machines that pass a Continuation object around, letting a function pause and resume without blocking a thread. You'll understand why this differs fundamentally from threads and how it supports thousands of concurrent operations on a small thread pool — replacing the magic with a real mental model you can rely on.

You'll compare the five scope functions — let, run, with, apply, and also — across their context object (this versus it), their return value, and their idiomatic use case. You'll walk through real scenarios where each is the right pick: apply for configuration, let for null-safe transforms, run for grouping a computation, with for clean access, and also for mid-chain side effects — the nuance that separates beginner Kotlin from idiomatic Kotlin.

You'll see how classic design patterns get reshaped by Kotlin's features: the Singleton becomes a one-line object declaration, the Builder is largely absorbed by named and default arguments, and the Decorator collapses into class delegation with by. You'll learn what survives, what fades away, and why this matters most for developers coming from Java where the Gang of Four patterns are a daily habit.

You'll see how Kotlin Multiplatform organizes shared code: a common module for platform-agnostic logic, platform-specific modules for JVM, iOS, JS, and native, and the expect/actual declarations that bridge them. You'll learn the real maturity of each target today, the friction teams hit adopting KMP, and where it genuinely shines (shared business logic) versus where it stays rough (shared UI everywhere).

You'll get a one-page map of the Kotlin standard library by category — collections, sequences, ranges, strings, IO, reflection, coroutines support, scope functions, and math utilities — so you know what you get for free before reaching for third-party dependencies. You'll spot non-obvious gems like the Result type and the use function, and avoid the common beginner mistake of importing a library for something the stdlib already handles.