Lectures

We break down Channel in Kotlin Coroutines as a typed message queue between coroutines: why send() and receive() are suspend, how capacity (buffer) affects sender behavior, how to correctly finish a message stream via close() and reading with for ( x in ch), and why closing the channel in finally saves you from the consumer’s “infinite wait.”

We break down the Producer–Consumer pattern in Kotlin Coroutines: why to use a Channel instead of a shared MutableList, how the roles are arranged ( producer, worker, collector), how to close channels correctly ( tasks and results) according to a protocol and the “closure owner” rule, why result order is not guaranteed, how capacity affects things, and which mistakes most often lead to hangs and crashes.

We break down Flow in Kotlin Coroutines as a cold stream: how to create a source via flow { emit }, why without collect “nothing happens,” what completion looks like without close(), and how the Flow model fundamentally differs from Channel (communication vs. describing how values are obtained). At the end—common beginner mistakes and how to avoid them.

We break down how to build a readable and testable pipeline on Flow: transformations via map, selection via filter, side effects via onEach, error handling with the catch operator, and the basic idea of backpressure (how a stream naturally “adapts” to the consumer speed via suspend). We will assemble a neat “strings → events → alerts” pipeline and discuss common pitfalls.

We break down the “completion protocol” of coroutine data sources: how to correctly finish working with Channel via close(), why reading via for (x in ch) is safer than receive(), and how to guarantee cleanup via try/finally. For Flow, we discuss where exceptions are actually caught (upstream via catch, downstream—around collect), and also why you must not “accidentally swallow” CancellationException, so you don’t break cancellation.