Kotlin in Action, 2nd Edition (Roman Elizarov, Svetlana Isakova etc.)（Z-Library）

【One-Line Pitch】 A thorough, authoritative tour of Kotlin written by members of the language team, taking you from syntax basics to idiomatic APIs and modern coroutine-based concurrency. Best for developers who already know Java or another OO language and want to write production-quality Kotlin rather than just translate Java. 【Book Arc】 - **Opening (~0%–10%)**: Frames what Kotlin is and why it exists—its pragmatic, concise, safe, interoperable philosophy, its main use cases (Android, server-side, multiplatform), and how to set up and compile code. Solves the "should I care, and how do I start" question. - **Early (~10%–30%)**: Core language fundamentals in reading order—functions and variables, classes and properties, enums and `when`, extension functions, data classes and companion objects, lambdas, collections and sequences, nullability, and the type system. This is the foundation everything else builds on. - **Early–Middle (~30%–40%)**: Deeper language features for building your own abstractions—operator overloading and conventions, delegated properties, higher-order and inline functions, generics (reified parameters, variance), annotations and reflection, and DSL construction. Moves you from using Kotlin to shaping it. - **Middle (~40%–55%)**: The book's structural pivot into Part 3, introducing Kotlin's concurrency model: suspending functions, coroutines versus threads, and the basics of writing concurrent code. This is where the second edition's major new material begins. - **Late (~55%–85%)**: Structured concurrency in depth—cancellation and error handling, flows as a coroutine-based stream abstraction, and the full operator toolkit (transform, buffer, conflate, debounce, flowOn, and more). Turns concurrency from intimidating into structured and predictable. - **Ending (~85%–100%)**: Error handling and testing for coroutines and flows, including exception propagation, supervisors, `CoroutineExceptionHandler`, virtual-time testing, and Turbine, plus appendices on building projects, documentation, and the ecosystem. Closes the loop on production readiness. 【Key Takeaways】 - **Kotlin is deliberately pragmatic, not novel for its own sake** (Opening): its design values conciseness, safety, and Java interoperability, which explains most of its syntax and library choices. - **Null safety is a type-system feature, not a coding convention** (Early): nullable types, safe calls, the Elvis operator, and platform types make the absence of values explicit and compiler-checked. - **Functions are first-class and lambdas are everywhere** (Early): collection operations, `with`/`apply`/`also`, and higher-order functions are the idiomatic backbone of everyday Kotlin. - **Inline functions remove lambda overhead and enable control flow** (Early–Middle): understanding inlining, non-local returns, and resource-management helpers like `use` and `withLock` is key to writing efficient abstractions. - **Generics go beyond Java's model** (Middle): reified type parameters and declaration-site variance let you express things Java cannot, though with their own restrictions. - **DSLs are built from ordinary language features** (Middle): lambdas with receivers, the `invoke` convention, and infix calls combine into expressive internal DSLs—no special syntax required. - **Coroutines make concurrency structured and sequential-looking** (Middle–Late): suspending functions let asynchronous code read like straight-line code, while structured concurrency ties task lifetimes to scopes. - **Flows model streams, and their operators are composable** (Late): intermediate and terminal operators, buffering, conflation, and context switching give fine control over asynchronous data pipelines. - **Error handling and testing are first-class concerns** (Ending): exception propagation rules, supervisors, and virtual-time testing with Turbine are essential for reliable concurrent code. 【Reading Tips】 - **Read Part 1 linearly if you're new to Kotlin**; if you're an experienced Java developer, skim chapters 2–3 and slow down at nullability (ch. 7) and the type system (ch. 8). - **Treat Part 2 as a reference for API design**: chapters 10–13 (inline functions, generics, reflection, DSLs) reward careful reading but are less urgent for everyday coding. - **Deep-read Part 3 (coroutines and flows)**—it's the second edition's headline addition and the hardest material; work the examples rather than just reading them. - **Use the appendices as practical bookmarks** for build tooling (Gradle/Maven), documentation, and ecosystem discovery. - **Take away the "why," not just the syntax**: the authors are language designers, so pay attention to the rationale behind features—it's what makes the idioms stick. 【Coverage Limits】 This guide is synthesized from stratified excerpts (front matter, table of contents, and chapter overviews); specific code examples, worked exercises, and detailed chapter content are not covered here.