Optimus Agency | Desarrollo Web Profesional

Capítulo 1 — Kotlin para código reactivo10 lecciones

Null safety y Elvis → data class + copy → argumentos por defecto/nombrados → funciones de extensión → scope functions → lambdas y funciones de orden superior → pipelines de colecciones → when y smart casts → tipos sealed → capstone del converter fila→Vehicle.

Paso 1
Null safety & the Elvis operator
Reactive inventory code is drowning in *maybe-present* values. A feed row might carry a driveway price, or only an askin…
Empezar lección
Paso 2
data class & .copy() — immutable merges
A `data class` is Kotlin's value-holder: declare the properties in the primary constructor and you get `equals`/`hashCod…
Empezar lección
Paso 3
Default & named arguments
Why does the `Vehicle` model have `= null` on almost every property? Because a feed row rarely fills them all, and **def…
Empezar lección
Paso 4
Extension functions
Prices live in the database as **cents** (an `Int`) but the API speaks **dollars** (a `Double`). Rather than scatter `ce…
Empezar lección
Paso 5
Scope functions — with / let / apply / also / run
The converter builds a `Vehicle` inside `with(tsvCar) { ... }` so it can read `vin`, `drivewayPrice`, `inventoryId` dire…
Empezar lección
Paso 6
Lambdas & higher-order functions
The converter doesn't know how to look up a dealer's free-shipping zip codes — and it shouldn't. Instead it accepts a **…
Empezar lección
Paso 7
Collections pipeline — map / filter / chunked / mapNotNull
The import reads thousands of rows and runs them through a *pipeline*: `rows.map { convert(it) }.chunked(500).map { batc…
Empezar lección
Paso 8
when & smart casts
Deriving a vehicle's condition is a textbook `when`: a `New` listing is `NEW`; a `Used` one is `CPO` if certified else `…
Empezar lección
Paso 9
Sealed types & exhaustive when
An inventory diff produces one of exactly three outcomes per VIN: an **ADD** (new to the feed), a **DELETE** (gone from …
Empezar lección
Paso 10
Capstone — the row → Vehicle converter
Time to assemble Chapter 1. The real `ExtractedRowToVehicleConverter` takes a raw feed row and produces a clean `Vehicle…
Empezar lección

Capítulo 2 — Project Reactor: Mono y Flux10 lecciones

Cold vs hot y suscripción → construir Flux → construir Mono → map vs flatMap → transform → then/thenReturn → switchIfEmpty → doOnNext/doOnError/doFinally → onErrorResume/retry → capstone del pipeline upsert-merge.

Capítulo 3 — Corrutinas e interop con Reactor10 lecciones

suspend y suspend main → un runner de corrutinas stdlib → el puente mono{}/flux{} → awaitSingle/awaitFirst → concurrencia estructurada → paralelismo acotado con Semaphore → batches con chunked → withTimeout → cancelación → capstone coDoVehicleImport.

Capítulo 4 — Spring Boot 3 + WebFlux + DI10 lecciones

Inyección de dependencias → @Component/@Service/@Configuration → inyección por constructor → @ConfigurationProperties ↔ application.yml → crons @Scheduled → WebFlux vs MVC → DAOs reactivos → wiring de extremo a extremo → observabilidad y checkpoints → capstone del job lector EDS completo.

Capítulo 5 — Reactor avanzado y pipelines de producción10 lecciones

collectList → batches con buffer → emparejado con zipWith & Tuple2 → merge combineRecords con copy anidado → limitRate y backpressure → retryWhen → distinctUntilChanged → cálculo de deltas con conjuntos → Schedulers (publishOn/subscribeOn) → capstone del job de merge por pares.

Capítulo 6 — Kotlin moderno y Coroutine Flow10 lecciones

Flow frío construido desde la stdlib → operadores de Flow (map, take) → StateFlow/SharedFlow → Flow vs Flux e interop → value classes @JvmInline → sealed interface → Result y runCatching → fun interface (SAM) → capstone de importación moderna basada en Flow.

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 →

Kotlin reactivo: Reactor, corrutinas y WebFlux

Null safety & the Elvis operator

data class & .copy() — immutable merges

Default & named arguments

Extension functions

Scope functions — with / let / apply / also / run

Lambdas & higher-order functions

Collections pipeline — map / filter / chunked / mapNotNull

when & smart casts

Sealed types & exhaustive when

Capstone — the row → Vehicle converter

Why reactive? Cold streams & subscription

Flux<T> — the 0..N stream & map

Mono<T> — the 0..1 value

map vs flatMap

transform — reusable pipeline segments

then — sequencing stages

switchIfEmpty — fallback when nothing emits

doOnNext / doFinally — lifecycle side-effects

onErrorResume — fallback on failure

Capstone — the upsert-merge pipeline

suspend functions & suspend fun main

Building a coroutine runner from the stdlib

The mono { } bridge — coroutine → reactive

awaitSingle — reactive → coroutine

Structured concurrency — awaitAll

Bounded parallelism — Semaphore & chunked batches

withTimeout — bounding a stage

Cooperative cancellation

coroutineScope vs supervisorScope

Capstone — the coDoVehicleImport orchestration

Dependency injection — why classes just get their deps

@Component / @Service & the container

Constructor injection — wiring a component

@ConfigurationProperties ↔ application.yml

@Scheduled crons

WebFlux — the reactive web stack

Reactive DAOs — Mono & Flux at the data layer

End-to-end wiring — DAO → Service → Controller

Observability — checkpoints & metrics

Capstone — the full EDS reader job

collectList — Flux → Mono<List>

buffer — fixed-size batches

zipWith & Tuple2 — pairing incoming with existing

combineRecords — the nested-copy merge

limitRate & backpressure

retryWhen — bounded retries

distinctUntilChanged — suppress consecutive duplicates

Set-based delta calculation

Schedulers — publishOn / subscribeOn

Capstone — the record-pair merge job

Flow<T> — the coroutine-native cold stream

Flow operators — map via flow { collect { emit } }

Flow.take — bounding a stream

StateFlow & SharedFlow — hot state

Flow vs Flux — terminal operators & interop

value classes — type-safe ids, zero cost

sealed interface — modern result hierarchies

Result & runCatching — functional error handling

fun interface — SAM conversions

Capstone — a modern Flow-based import