Optimus Agency | Professional Web Development

Chapter 1 — Kotlin for Reactive Code10 lessons

Null safety & Elvis → data class + copy → default/named args → extension functions → scope functions → lambdas & higher-order functions → collection pipelines → when & smart casts → sealed types → the row→Vehicle converter capstone.

Step 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…
Start lesson
Step 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…
Start lesson
Step 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…
Start lesson
Step 4
Extension functions
Prices live in the database as **cents** (an `Int`) but the API speaks **dollars** (a `Double`). Rather than scatter `ce…
Start lesson
Step 5
Scope functions — with / let / apply / also / run
The converter builds a `Vehicle` inside `with(tsvCar) { ... }` so it can read `vin`, `drivewayPrice`, `inventoryId` dire…
Start lesson
Step 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 **…
Start lesson
Step 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…
Start lesson
Step 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 `…
Start lesson
Step 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 …
Start lesson
Step 10
Capstone — the row → Vehicle converter
Time to assemble Chapter 1. The real `ExtractedRowToVehicleConverter` takes a raw feed row and produces a clean `Vehicle…
Start lesson

Chapter 2 — Project Reactor: Mono & Flux10 lessons

Cold vs hot & subscription → building Flux → building Mono → map vs flatMap → transform → then/thenReturn → switchIfEmpty → doOnNext/doOnError/doFinally → onErrorResume/retry → the upsert-merge pipeline capstone.

Chapter 3 — Coroutines & Reactor Interop10 lessons

suspend & suspend main → a stdlib coroutine runner → the mono{}/flux{} bridge → awaitSingle/awaitFirst → structured concurrency → Semaphore-bounded parallelism → chunked batches → withTimeout → cancellation → the coDoVehicleImport capstone.

Chapter 4 — Spring Boot 3 + WebFlux + DI10 lessons

Dependency injection → @Component/@Service/@Configuration → constructor injection → @ConfigurationProperties ↔ application.yml → @Scheduled crons → WebFlux vs MVC → reactive DAOs → end-to-end wiring → observability & checkpoints → the full EDS reader job capstone.

Chapter 5 — Advanced Reactor & Production Pipelines10 lessons

collectList → buffer batches → zipWith & Tuple2 record pairing → combineRecords nested-copy merge → limitRate & backpressure → retryWhen → distinctUntilChanged → set-based delta calculation → Schedulers (publishOn/subscribeOn) → the record-pair merge job capstone.

Chapter 6 — Modern Kotlin & Coroutine Flow10 lessons

Cold Flow built from the stdlib → Flow operators (map, take) → StateFlow/SharedFlow → Flow vs Flux & interop → @JvmInline value classes → sealed interface → Result & runCatching → fun interface (SAM) → a modern Flow-based import capstone.

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 →

Reactive Kotlin: Reactor, Coroutines & 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