Lectures

We break down reflection in Kotlin “without fanaticism”: what changes when moving from static code to runtime inspection, why KClass is the entry point, how to get a class via :: class (both from a type and from an object), how to safely use simpleName, how checks with is differ from comparing KClass, when you need kotlin-reflect, and how to convert KClass to a Java Class via .java.

We break down practical reflection in Kotlin on the JVM: why you should add kotlin-reflect, how to get properties via memberProperties and read their values via get(receiver), how to find and invoke methods via memberFunctions and call(...), and how to build safe wrappers with firstOrNull, try/ catch, and clear fallback results. At the end: a CLI command example inspect, a mermaid pipeline, and common mistakes.

We break down a practical alternative to runtime reflection in Kotlin: how an annotation (for example, @CliCommand) becomes input data for KSP, how .kt files are generated at compile time, and why the end result is a fast, predictable runtime without “magic” lookups. Using a CLI example, we show the pipeline “annotation → generation → regular code”, discuss pros/cons, selection criteria, and common generation design mistakes.

We break down what “version layers” a Kotlin project is really made of: Kotlin Gradle Plugin, the compiler ( K2), languageVersion/ apiVersion, stdlib, plugins like KSP, and even the IDE. We will understand why updating to Kotlin 2 . x often pulls a “train” of dependencies, how to temporarily pin the language rules to 1.9, and how to build a predictable update process without “everything is on fire”. At the end: hands-on practice of gentle API migration via @Deprecated and a list of common mistakes.

A practical JVM memory model for Kotlin: what’s the difference between the stack and the heap, why the garbage collector ( GC) sometimes introduces pauses, where Kotlin most often creates unnecessary allocations (strings in a loop, intermediate collections, Pair/ Triple), how boxing affects things ( List<Int> vs IntArray), and why exceptions with stack traces and reflection in “hot spots” can sharply degrade performance.