CodeDojo | Aprende a fondo. Construye con confianza.

I · La máquina5 lecciones

En qué compila realmente `suspend`, por qué una corrutina suspendida no retiene ningún hilo, y qué te da cada uno de los tres builders.

Paso 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…
Empezar lección
Paso 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…
Empezar lección
Paso 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…
Empezar lección
Paso 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…
Empezar lección
Paso 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…
Empezar lección

II · Estructura7 lecciones

Scopes, el árbol de Jobs y sus estados, la cancelación como protocolo cooperativo, los modos de arranque, y la limpieza que nunca corre en silencio.

III · Composición6 lecciones

Correr cosas a la vez a propósito: async/await, deadlines, carreras con select, acotar el fan-out, y dónde aparece realmente una falla.

IV · Contexto y dispatchers5 lecciones

El CoroutineContext como mapa tipado, qué dispatcher elegir y por qué, limitedParallelism, y cómo se muere de hambre un pool de hilos.

V · Sincronización5 lecciones

Estado mutable compartido y las cuatro formas de sobrevivirlo: confinamiento, atómicos, Mutex y Semaphore — y los deadlocks que cada una invita.

VI · Canales6 lecciones

La cola entre corrutinas: capacidad, política de desborde, worker pools, pipelines, actores y estado con un único dueño.

VII · Flow7 lecciones

Streams asíncronos fríos: el set de operadores, operadores terminales, flowOn y preservación de contexto, contrapresión, y escribir tu propio operador.

VIII · Estado y streams calientes6 lecciones

StateFlow vs SharedFlow, ciclos de vida de shareIn, combinación de streams, debounce y sample — y cómo elegir entre Channel, Flow y StateFlow.

IX · Testing6 lecciones

runTest y el reloj virtual — la parte que convierte la temporización de fuente de inestabilidad en una aserción confiable.

X · Depuración y rendimiento5 lecciones

Nombrar corrutinas para que un stack trace signifique algo, encontrar la que se colgó, y medir lo que realmente cuesta suspender.

XI · Código bloqueante e interoperación5 lecciones

La otra mitad de todo código real: JDBC, archivos, callbacks y futures — envueltos para que no bloqueen el pool equivocado ni se filtren al cancelar.

XII · Interoperación reactiva5 lecciones

Reactive Streams desde los primeros principios — demanda y contrapresión — y luego Mono/Flux a suspend/Flow y de vuelta, sin mezclar los dos estilos.

XIII · Spring Boot con corrutinas5 lecciones

Controllers suspend, servicios y repositorios con corrutinas, cancelación por request, y llamadas paralelas aguas abajo que respetan un deadline.

XIV · Datos y mensajería5 lecciones

Persistencia reactiva y brokers vistos con corrutinas: límites del pool de conexiones, fronteras transaccionales, concurrencia de consumidores e idempotencia.

XV · Resiliencia5 lecciones

Reintentos con backoff y jitter, circuit breakers, bulkheads, fallbacks y propagación de deadlines — escritos como funciones suspend, no como anotaciones.

XVI · Arquitectura de throughput5 lecciones

Diseñar para carga: worker pools, batching y chunking, pipelines paralelos, y elegir dónde se permite que se acumule la contrapresión.

XVII · Internals de corrutinas5 lecciones

Continuation, COROUTINE_SUSPENDED y las etiquetas de estado que emite el compilador — y después el scheduler debajo: workers, colas locales y work stealing.

XVIII · Fundamentos de concurrencia en la JVM5 lecciones

La capa sobre la que se construyen las corrutinas: hilos, executors, ForkJoinPool, atómicos y compare-and-set, y las reglas happens-before que hacen visible el estado.

XIX · Arquitectura y anti-patrones5 lecciones

Dónde viven los scopes en un código, qué capas pueden tener uno, los leaks que aparecen cuando no — y la checklist de revisión para todo eso.

XX · Operación en producción5 lecciones

Logging con correlation ids a través de puntos de suspensión, métricas con significado, y apagar sin perder trabajo en vuelo.

XXI · Decisiones de diseño de concurrencia4 lecciones

Cuándo no paralelizar, dónde está el techo real, y cómo elegir un número de concurrencia que puedas defender con una medición.

XXII · Labs de maestría6 lecciones

Seis sistemas para construir que combinan todo: un agregador, un scraper acotado, una cola de trabajo, un event bus, un pipeline de streaming y una revisión final.

Práctica extra (drills)

¿Quieres más repeticiones? Estos bancos de retos en Arena profundizan los operadores y patrones de este curso.

Drills de operadores Reactor →Drills de Coroutines →Drills de Spring Boot →

Corrutinas de Kotlin: de la máquina a producción

Aprendamos juntos.

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