Kotlin Coroutines by Tutorials (Nishant Srivastava Filip Babić)（Z-Library）

【One-Line Pitch】 A hands-on, tutorial-driven introduction to Kotlin coroutines that takes Android and JVM developers from callback and Rx pain to writing, structuring, and debugging asynchronous code with coroutines. Best for developers who already know Kotlin basics and want practical patterns rather than theory. 【Book Arc】 - **Opening (~0%–15%)**: Frames the problem — responsive UIs, long-running work, callbacks, "indentation hell," and reactive extensions — then explains why coroutines exist and how they work internally. Solves the "why should I care?" question before any syntax. - **Early (~15%–35%)**: Environment setup (IntelliJ IDEA, JDK 8, Android Studio) followed by first coroutines: launching, building, jobs, cancellation, and posting back to the UI thread. Gets you running code quickly. - **Middle (~35%–55%)**: The conceptual core — suspending functions, async/await, sequences and yield, contexts and dispatchers, exception propagation and cancellation. This is where the mental model solidifies. - **Late (~55%–75%)**: Advanced machinery — coroutines as state machines, channels, producers and actors, broadcast channels, and coroutine operators. Moves from single coroutines to communicating, concurrent systems. - **Ending (~75%–100%)**: Bridges to practice — a coroutines-vs-RxKotlin comparison, then a three-part Android section covering whether Android needs coroutines, integration patterns, and Anko. Excerpts do not detail the final Android chapters' contents. 【Key Takeaways】 - **Asynchrony is motivated by UX, not elegance** (Opening): the book opens with spinners, uploads, and unresponsive UIs, grounding every later abstraction in a real user-facing problem. - **Callbacks and Rx carry real costs** (Opening): callback nesting and reactive-extension complexity are presented as the pain coroutines are meant to relieve, giving you a comparison baseline. - **Jobs are the handle for lifecycle control** (Early): launching, building, and canceling jobs are treated as the first practical skill, so you learn to stop work as well as start it. - **Suspension is the central concept** (Middle): suspending functions, async/await, and yield are grouped as the mechanism that makes non-blocking code read sequentially — the book's pivotal idea. - **Contexts and dispatchers decide where code runs** (Middle): thread selection is framed as explicit configuration rather than an afterthought, which matters for UI safety. - **Errors and cancellation are first-class** (Middle): exception propagation, handling, callback wrapping, and cancellation get their own chapter — treat this as required, not optional, reading. - **Channels turn coroutines into communicating systems** (Late): producers, actors, and broadcast channels extend the model from single tasks to pipelines and message passing. - **Coroutines are compared, not isolated** (Ending): the RxKotlin comparison and Android chapters position coroutines against existing tools, helping you decide when to migrate. 【Reading Tips】 - Skim Chapter 2 setup if your environment is ready; spend the saved time on suspension, contexts, and exception handling. - Deep-read the exception handling and cancellation chapter — it is the most common source of production bugs and the densest part of the book. - Type and run the sample code rather than reading it; coroutine behavior (threading, ordering) is hard to absorb passively. - Treat the RxKotlin comparison and Android chapters as decision guides for migrating existing codebases, not as new theory. - Note that this is an early access edition; check for updated chapters before relying on any API details. 【Coverage Limits】 The excerpts cover front matter, the table of contents, setup, and the early-to-middle chapters in detail, but the later chapters (state machines, channels, operators, Rx comparison, Android parts) are represented mainly by titles and brief section names. Specific code, exercises, and conclusions from those chapters are not covered here.