Advanced Kotlin (Marcin Moskała)（Z-Library）

【One-Line Pitch】 A practical deep-dive into the Kotlin features you already use but may not fully understand—variance, delegation, contracts, Java interop, multiplatform, reflection, and the processor/compiler-plugin toolchain. Best for experienced Kotlin developers who want to reason about consequences and build tooling, not just write app code. 【Book Arc】 - **Opening (~0%–10%)**: Sets scope and prerequisites, then moves into generic variance—why `in`/`out` exist, what they forbid, and how `UnsafeVariance` and star projections work around those limits. - **Early (~10%–32%)**: Delegation as a design tool: interface and property delegation, how delegates compile to accessor code, and the standard `lazy`, `Lateinit`, and `vetoable` delegates with their trade-offs. - **Early–Middle (~32%–42%)**: Kotlin Contracts as compiler hints (`returns`, `implies`, `callsInPlace`), followed by Kotlin–Java interop: nullability annotations, annotation targets, `@JvmName`/`@JvmOverloads`, and `fun interface`. - **Middle (~42%–48%)**: Multiplatform structure—shared modules, source sets, expect/actual, and using shared code from Java, JS, and native targets. - **Late (~48%–65%)**: Reflection and metaprogramming: breaking encapsulation, then building annotation processors and KSP processors, including testing, dependencies, incremental and multi-round processing. - **Ending (~65%–100%)**: Compiler plugins (frontend/backend, extensions, examples like making classes open or generating wrappers) and static analysis with custom detekt rules, closing with exercises and solutions. 【Key Takeaways】 - **Variance modifiers carry real consequences** (Opening): `in`/`out` are not decoration—they restrict where type parameters may appear, and the book shows the workarounds (`UnsafeVariance`, star projections, `Nothing`) and when they are legitimate. - **Delegation beats inheritance for composition** (Early): you can delegate to many objects but inherit from one; inheritance is a strong, encapsulation-breaking relationship, so delegation is often the safer default. - **Property delegates are just generated accessors** (Early): understanding the compiled `getValue`/`setValue` shape explains receiver types, `KProperty` access, and why `ReadWriteProperty<Any?, T>` is the usual contract. - **Standard delegates have hidden knobs** (Early): `lazy` thread-safety modes trade speed for safety; `vetoable` validates state changes; `Lateinit` shows how to build your own delegate. - **Contracts make the compiler smarter** (Early): `returns(false) implies (...)` and `callsInPlace` enable smart casts and non-local returns that would otherwise be impossible—worth knowing when writing inline APIs. - **Interop friction is structural, not accidental** (Middle): nullability annotations, platform types, annotation targets, and default arguments all need explicit handling; `fun interface` fixes Java call-site ergonomics. - **Multiplatform is about source-set layout** (Middle): shared modules and correctly named source sets let one library serve JVM, JS, and native consumers. - **Tooling is a ladder** (Late–Ending): reflection → annotation processing → KSP → compiler plugins → static analysis; each step trades simplicity for power and build complexity. 【Reading Tips】 - Deep-read the variance and delegation chapters; they underpin later material and repay re-reading with the exercises. - Skim the interop chapter if you work purely in Kotlin, but keep the annotation-target and `@JvmOverloads` sections as reference. - Treat the processor/KSP/compiler-plugin chapters as hands-on: build the smallest working example before reading the advanced sections on rounds and incremental processing. - Do the end-of-chapter exercises—solutions are included—especially the serialization and DI-library ones, which consolidate reflection and DSL skills. - Use the detekt chapter as a practical entry point to static analysis even if you never write a compiler plugin. 【Coverage Limits】 The excerpts cover the table of contents and sampled sections on variance, delegation, contracts, interop, multiplatform, reflection, processors, compiler plugins, and detekt; Kotlin/JS specifics and several exercise details are only partially represented, so this guide does not assess their depth.