Kotlin's basic types in full: val/var and inference, the number types and how they map to JVM primitives, boxing and the identity trap, no implicit conversions, silent overflow, unsigned types, Char that isn't a number, strings and templates, and Any/Unit/Nothing.
Functions as first-class declarations: fun and single-expression bodies, the = { } trap, default and named arguments that retire overloads, vararg and spread, infix and tailrec, local functions and closures, and how defaults reach Java.
Control flow in full: if and when as expressions, ranges and the modern ..< operator, progressions and how for-loops compile, in/!in membership, while, labelled break/continue, and why loops aren't expressions.
when replaces switch, long if/else ladders, and instanceof-with-cast in one construct: subject and subjectless forms, range and type matching, exhaustiveness on sealed types, inline subject capture, and the new guard conditions.
How smart casts remove the check-then-cast tax, the control-flow analysis behind them, and the exact stability rules — local val vs var, the mutable-property refusal, and the open-or-custom-getter error — that decide when they kick in.
The full null-safety toolkit: safe calls and chaining, the Elvis operator, !!, safe casts, ?.let, nullable-receiver extensions, lateinit and isInitialized, Delegates.notNull, nullable generics, and the platform types that leak in from Java.
Lists, sets, and maps: the read-only versus mutable split and why it isn't runtime-enforced, the factory and builder functions, set algebra, map operations like getOrPut, primitive arrays, and how the split shapes your signatures.
Code as a value: defining versus calling, parameters and results, function types and what they compile to, invoke, nullable function types, type aliases, the implicit it, and multi-line bodies. Part 1 of five.
Where lambdas earn their keep: higher-order functions, the trailing-lambda convention, map/filter and the grouping toolkit, fold and reduce, chaining, and lazy sequences that turn a million-element pipeline into a handful of evaluations. Part 2 of five.
A lambda can capture variables from the scope where it was written — and in Kotlin it can even change them. The mental model, the boxing that makes it work, the Java contrast, the this-capture leak, and the concurrency caveat. Part 3 of five.
Function references and the difference between bound and unbound, property references and the reflection behind them, the surprising rules for return inside a lambda and the labels that tame them, and anonymous functions. Part 4 of five.
The performance model behind lambdas — inline functions, reified type parameters, and when NOT to inline — plus lambdas with a receiver, the trick behind apply, buildString, and Kotlin's DSLs. Part 5 of five.
Declaring classes, primary and secondary constructors, property promotion, construction order, backing fields and custom accessors, private constructors, and why Kotlin classes are final by default. Part 1 of a two-part tour.
Beyond the plain class — data classes and why they're final, sealed hierarchies, objects and companions with const and @JvmStatic, nested vs inner, and value classes with the boxing that undoes their savings. Part 2 of two.
Kotlin enums coming from Java: constants that carry data and per-value behavior, exhaustive when, entries vs values(), the ordinal trap, Comparable ordering, interface implementation, and the reified enumValues/enumValueOf helpers.
Interfaces with default method bodies and property contracts, generic interfaces, implementing several and resolving the clashes with super<T>, functional (SAM) interfaces, Java default-method interop, and choosing between an interface and an abstract class.
Declaring extension functions and properties, what the receiver and this mean, why extensions resolve statically rather than virtually, the member-wins rule, generic and nullable receivers, and how scoping keeps them from becoming a global Utils bucket.
Structural equality with == versus referential with ===, the equals/hashCode contract data classes solve, how Comparable wires the comparison operators, and two traps that survive: floating-point equals and array ==
Pulling several values out of an object with destructuring declarations, the componentN convention behind it, use in loops and lambdas, and the positional footgun that makes it wrong for wide objects.
The four visibility modifiers, why public is the default, what internal means at the module level and how it gets name-mangled in bytecode, per-accessor visibility, and how Kotlin's file structure frees you from one-class-per-file.
Class delegation that makes composition as cheap as inheritance, delegated properties like lazy and observable, lazy's three thread-safety modes, and writing your own delegate with getValue/setValue.
Generic functions and classes, invariance by default, declaration-site variance with out and in versus use-site projections, type bounds and where clauses, star projections, and reified type parameters on inline functions.
Kotlin drops checked exceptions entirely — why, what changes day to day, try/catch as an expression, use and the precondition helpers, runCatching and Result, and the @Throws you need at the Java boundary.
Java getters seen as properties, platform types and nullability annotations, SAM conversion, arrays across the boundary, and the @Jvm annotations that make Kotlin code pleasant to call from Java.
The five scope functions decided by two questions — how the object is referenced (this or it) and what the block returns — plus takeIf/takeUnless and the nesting gotcha where this and it stop being obvious.
Kotlin allows operator overloading but only through a fixed set of conventionally-named functions: plus, get, invoke, contains, compareTo, iterator, rangeTo — plus the plusAssign ambiguity and how in reverses its operands.
An introduction to Kotlin coroutines — suspend functions and the state machine behind them, launch and async, structured concurrency with measured concurrency, dispatchers, and cooperative cancellation.