Kotlin Coroutines Under the Hood with Sivavishnu R

This is not another "here's what launch and async do" tutorial. It's a 25-chapter deep dive into what actually happens underneath Kotlin coroutines — from the Continuation-Passing Style transform the compiler applies to every suspend function, to the state machine that lets your local variables survive a suspension point, to why a suspended coroutine costs a few dozen bytes while a blocked thread costs a megabyte of stack.

You'll go past syntax and build back up through the full structured-concurrency model — CoroutineContext, Job hierarchies, cancellation propagation, exception aggregation — into Flow, StateFlow, SharedFlow, channels, mutexes, and the bridging APIs (callbackFlow, suspendCancellableCoroutine) that connect coroutines to callback-based and Java code.

What's inside:

• Compiler internals: CPS transform, generated state machines, bytecode-level mechanics
• Dispatchers deep dive: IO, Default, Main, Unconfined, and limitedParallelism()
• Structured concurrency & cancellation done right — supervisorScope, SupervisorJob, cooperative cancellation
• Flow, StateFlow, SharedFlow, channels, and low-level primitives
• A 100,000-coroutines-vs-100,000-threads benchmark lab
• A full Android case study: retrofitting a legacy callback-driven app onto coroutines and Flow
• Common mistakes, best practices, and interview prep

Every concept ships with a fully worked, runnable example — not abstract snippets.

Who it's for: Kotlin/Android engineers who already use coroutines and want to reason about concurrent code with the precision of the compiler — not another crash course to stop the crashing.