KOTLIN COROUTINE SERVICE PATTERN

FOUNDATION: STRUCTURED CONCURRENCY
• Use CoroutineScope for lifecycle management. Never GlobalScope — it has no cancellation.
• Pair scope with Job for clean shutdown. Example: val scope = CoroutineScope(Job() + Dispatchers.Default)
• On service shutdown, call scope.cancel() to propagate cancellation to all children.

CONCURRENCY MODEL: LAUNCH VS ASYNC
• launch() → fire-and-forget work (no return value). Use for logging, metrics, side effects.
• async() → suspendable work with Result. Use when you need .await() and exception handling.
• Never mix — launching an async that you forget to await() is a memory leak.

FLOW FOR STREAMS
• Flow<T> replaces callback hell. Build with flow { emit(data) }
• Collect safely: catch { e -> log.error() } then emit a fallback or rethrow.
• Use .buffer() if downstream is slow — otherwise backpressure stalls.

EXCEPTION HANDLING
• launch { try/catch } wraps each coroutine — unhandled exceptions crash the scope.
• Use CoroutineExceptionHandler on the scope dispatcher, not inside try/catch.
• async().await() surfaces exceptions to the caller (don't swallow with try/catch at launch).

TYPE-SAFE EXAMPLE: KTOR SERVER
embedApplication {
  install(StatusPages) { exception<Exception> { e -> respond(...) } }
  routing { get("/data") { val data = repository.fetchAsync().await(); respond(data) } }
}