CodeDojo | Learn deeply. Build confidently.

I · The machine5 lessons

What `suspend` actually compiles to, why a suspended coroutine holds no thread, and what the three builders each give you.

Step 1
What `suspend` really is
Every asynchronous story starts with the same problem: a thread that waits is a thread you cannot use. A JVM thread cost…
Start lesson
Step 2
Continuations: what the compiler actually generates
Coroutines feel like magic until you see the transform, and then they stop being magic forever. The compiler rewrites ev…
Start lesson
Step 3
The cost model: why 50,000 coroutines is unremarkable
Concurrency arguments usually stall on vibes, so put numbers on it. A JVM thread reserves roughly 1 MB of stack by defau…
Start lesson
Step 4
launch, async, runBlocking — and withContext
You cannot call a suspend function from ordinary code — lesson 1's rule — so something has to create the first coroutine…
Start lesson
Step 5
Capstone: sequential by default, concurrent on purpose
Part I ends where most real slowdowns begin. A handler calls three services, each takes 100 ms, and the endpoint takes 3…
Start lesson

II · Structure7 lessons

Scopes, the Job tree and its lifecycle states, cancellation as a cooperative protocol, start modes, and the cleanup that silently never runs.

III · Composition6 lessons

Running things at the same time on purpose: async/await, deadlines, racing with select, capping the fan-out, and where a failure actually surfaces.

IV · Context and dispatchers5 lessons

The CoroutineContext as a typed map, which dispatcher to pick and why, limitedParallelism, and how a thread pool actually starves.

V · Synchronization5 lessons

Shared mutable state and the four ways to survive it: confinement, atomics, Mutex and Semaphore — plus the deadlocks each one invites.

VI · Channels6 lessons

The queue between coroutines: capacity, overflow policy, worker pools, pipelines, actors, and state owned by exactly one coroutine.

VII · Flow7 lessons

Cold asynchronous streams: the operator set, terminal operators, flowOn and context preservation, back-pressure, and writing your own operator.

VIII · State and hot streams6 lessons

StateFlow vs SharedFlow, shareIn lifecycles, combining streams, debounce and sample — and how to choose between Channel, Flow and StateFlow.

IX · Testing6 lessons

runTest and the virtual clock — the part that turns timing from a source of flakiness into an assertion you can rely on.

X · Debugging and performance5 lessons

Naming coroutines so a stack trace means something, finding the one that hung, and measuring what suspension actually costs.

XI · Blocking code and interop5 lessons

The other half of every real codebase: JDBC, files, callbacks and futures — wrapped so they neither block the wrong pool nor leak on cancellation.

XII · Reactive interop5 lessons

Reactive Streams from first principles — demand and back-pressure — then Mono/Flux to suspend/Flow and back, without mixing the two styles.

XIII · Spring Boot with coroutines5 lessons

Suspend controllers, coroutine services and repositories, request-scoped cancellation, and parallel downstream calls that respect a deadline.

XIV · Data and messaging5 lessons

Reactive persistence and brokers through a coroutine lens: connection-pool limits, transactional boundaries, consumer concurrency and idempotency.

XV · Resilience5 lessons

Retry with backoff and jitter, circuit breakers, bulkheads, fallbacks and deadline propagation — written as suspending functions, not annotations.

XVI · Throughput architecture5 lessons

Designing for load: worker pools, batching and chunking, parallel pipelines, and choosing where the back-pressure is allowed to build up.

XVII · Coroutine internals5 lessons

Continuation, COROUTINE_SUSPENDED and the state labels the compiler emits — then the scheduler underneath: workers, local queues and work stealing.

XVIII · JVM concurrency foundations5 lessons

The layer coroutines are built on: threads, executors, ForkJoinPool, atomics and compare-and-set, and the happens-before rules that make state visible.

XIX · Architecture and anti-patterns5 lessons

Where scopes belong in a codebase, which layers may own one, the leaks that follow when they do not — and the review checklist for all of it.

XX · Production operations5 lessons

Logging with correlation ids across suspension points, metrics that mean something, and shutting down without dropping work in flight.

XXI · Concurrency design decisions4 lessons

When not to parallelize at all, where the real ceiling is, and how to pick a concurrency number you can defend with a measurement.

XXII · Mastery labs6 lessons

Six build-it-yourself systems that combine everything: an aggregator, a bounded scraper, a work queue, an event bus, a streaming pipeline, and a final review.

Extra practice (drills)

Want more reps? These Arena challenge banks drill the operators and patterns from this course.

Reactor operator drills →Coroutines drills →Spring Boot drills →

Kotlin Coroutines: from the machine to production

Let’s figure it out.

What `suspend` really is

Continuations: what the compiler actually generates

The cost model: why 50,000 coroutines is unremarkable

launch, async, runBlocking — and withContext

Capstone: sequential by default, concurrent on purpose

Scopes and the Job tree

The Job lifecycle

coroutineScope vs supervisorScope

Cancellation is cooperative

Cleanup that survives cancellation

Start modes: DEFAULT, LAZY, ATOMIC, UNDISPATCHED

Capstone: a job you can actually stop

async and Deferred, in depth

Timeouts and deadlines

select — waiting on several things at once

Bounded fan-out

Where an exception actually goes

Capstone: a call that is bounded, timed and retried

CoroutineContext: the typed set every coroutine carries

Dispatchers in production

limitedParallelism and custom dispatchers

CPU-bound, blocking, and the starvation in between

CoroutineContext, names and correlation ids

Shared mutable state

The four races, and how to make one reproduce

Mutex: a lock that suspends instead of blocking

Semaphore: a quota that travels with the coroutine

Deadlock, livelock, starvation

Channels: the queue between coroutines

Capacity and overflow policy

Fan-out and fan-in

Pipelines and produce

Actors: state with an inbox

Capstone: confinement — state with exactly one owner

Flow: the cold asynchronous stream

Operators: transforming a stream

Terminal operators: the only things that make a flow run

flowOn and the context preservation rule

Sequential by default: buffer, conflate, collectLatest

The Flow contract and declarative error handling

Capstone: write your own operator

StateFlow and SharedFlow

shareIn and stateIn: cold to hot

Channel, Flow, SharedFlow, StateFlow: choosing

Combining flows: combine, zip, flatMapLatest

debounce, sample and throttle

Capstone: state, events and one shared upstream

runTest and the virtual clock

Testing flows

Injecting dispatchers

Testing cancellation, timeouts and failures

Testing channels and hot flows

Capstone: pin a timing-sensitive component

Making a coroutine identifiable

Finding the coroutine that stopped

What a coroutine actually costs

Paying for concurrency you are not using

Measuring coroutine code honestly

Spotting blocking code

Wrapping blocking code correctly

Turning a callback into a suspend function

Futures in, futures out, and streams of callbacks

Transactions, connections and coroutine affinity

Reactive Streams: four methods and one number

Mono and Flux, coming in

Suspend functions, going out

Back-pressure across the boundary

One style per layer

Suspending controllers

Layering: where the framework stops

When the client hangs up

Parallel downstream calls with a deadline

Scopes, dispatchers and shutdown as configuration

Streaming a result set instead of holding it

Batching writes, and where to stop

Consuming a broker: the poll loop as a Flow

Ordering and consumer concurrency

Idempotency, retries and dead letters