Kotlin Coroutines by Tutorials (1st Edition) - 2018 (Babic F., Srivastava N.)（Z-Library）

# Kotlin Coroutines by Tutorials (1st Edition) — Reading Guide ## 【One-Line Pitch】 A hands-on, project-based introduction to Kotlin coroutines for Android and JVM developers who want to replace callback hell and complex threading with lightweight, readable asynchronous code. If you're comfortable with basic Kotlin and want to write concurrent programs that are actually maintainable, this book walks you from first principles to advanced patterns like channels and actors. ## 【Book Arc】 - **Opening (~0%–13%)**: Sets up the problem — blocking calls, thread communication, and the pain of callback nesting ("indentation hell"). Establishes why asynchronous programming matters and why traditional approaches fall short. - **Early (~13%–32%)**: Introduces coroutines conceptually — suspension points, continuations, and how coroutines differ from threads and callbacks. Compares Kotlin's approach with Python and C# coroutine support, then covers environment setup (IntelliJ IDEA, Android Studio, JDK). - **Middle (~32%–48%)**: Hands-on fundamentals — launching your first coroutines with `GlobalScope.launch`, understanding `CoroutineScope` vs. `GlobalScope`, and the importance of cooperative cancellation. Explains why coroutines are lightweight enough to launch thousands at once. - **Middle (~48%–60%)**: Deepens into suspending functions, async/await patterns, and building sequences with `yield`. Covers coroutine contexts and dispatchers for controlling which threads execute your code. - **Late (~60%–80%)**: Advanced topics — exception handling, cancellation, coroutines as state machines, channels for communication, and producers/actors for structured concurrency patterns. - **Ending (~80%–100%)**: Broadcast channels, coroutine operators, and a practical comparison between coroutines and RxKotlin to help you choose the right tool for your projects. ## 【Key Takeaways】 - **Blocking calls are the root problem** (Early): When a function like `showLoadingSpinner()` blocks, nothing else can run — animations freeze, UIs stall. Understanding this fundamental limitation motivates everything that follows. - **Callbacks solve blocking but create "indentation hell"** (Early): Nested callbacks for sequential operations (load → resize → upload) produce deeply nested, hard-to-maintain code. This is the pain point coroutines directly address. - **Coroutines are "part-thread, part-callback"** (Early): They use suspension points to pause and resume work without blocking threads, letting you write sequential-looking code that runs asynchronously. The "taco" analogy — code is wrapped up but doesn't execute until needed — captures the lazy execution model. - **Coroutines are extremely lightweight** (Middle): Launching 10,000 coroutines is feasible where 10,000 threads would crash with `OutOfMemoryException`. This makes them ideal for high-concurrency scenarios. - **Scope selection matters** (Middle): `GlobalScope` is fine when you don't care about results or lifecycle, but implementing `CoroutineScope` with a custom `CoroutineContext` is essential for UI-bound work and tying jobs to object lifecycles (like Android Activities). - **Cancellation requires cooperation** (Middle): You can't just cancel a coroutine — your code must check whether its wrapping `Job` is still active. Writing cooperative code is a discipline, not an automatic feature. - **Kotlin's coroutines are extensible by design** (Early): Built as global functions with receivers, they let you build custom APIs on top of existing coroutine functions — a design choice that enables the advanced patterns in later chapters. ## 【Reading Tips】 - **Skim Chapter 1 if you're already async-savvy**: The first chapter is a thorough motivation for asynchronous programming, but if you already know why callbacks are painful, jump to Chapter 3 for the actual coroutine syntax. - **Do the hands-on exercises in Chapters 2–3**: The book is tutorial-based — actually importing the Gradle projects and running the coroutine examples is where the concepts click. Don't just read the code samples. - **Pay special attention to Chapter 3's scope discussion**: The difference between `GlobalScope` and custom `CoroutineScope` implementations is subtle but critical for real Android development. This is where beginners often get confused. - **Treat Chapters 7–8 (contexts, dispatchers, exceptions) as reference material**: These are dense but become more relevant as you build real apps. Consider skimming first, then returning when you hit related problems. - **Use the RxKotlin comparison chapter as a decision guide**: If you're coming from RxJava/RxKotlin, the final comparison chapter helps map your existing knowledge to coroutine concepts and decide which approach fits your project. ## 【Coverage Limits】 This guide covers the book's opening through the middle chapters (~48% of the book), where the foundational concepts and first hands-on exercises are presented. The later chapters on channels, actors, broadcast channels, and coroutine operators are listed in the table of contents but not covered in the available excerpts. ##