Kotlin coroutines and Flows are the foundation of modern Android and server-side Kotlin development. These exercises cover structured concurrency, the Flow abstraction, hot vs cold flows, lifecycle-aware coroutine scopes, and key Flow operators.
0 / 5 completed
1 / 5
At standup, a colleague asks what structured concurrency means in Kotlin coroutines. What is the correct answer?
Structured concurrency in Kotlin means coroutines are launched within a CoroutineScope that defines their lifetime. A parent scope waits for all its child coroutines before completing. If the parent is cancelled, all children are cancelled automatically. If a child fails, the exception propagates to the parent (with SupervisorJob as the exception). This prevents coroutine leaks and makes reasoning about concurrency lifetimes much easier.
2 / 5
During a PR review, a teammate asks what a Flow in Kotlin is. Which answer is correct?
A Kotlin Flow<T> is a cold asynchronous stream. It does not execute until a consumer calls .collect { } (or another terminal operator). Each collection triggers a fresh execution of the flow builder. Flows support a rich operator library (map, filter, flatMapLatest, debounce, etc.) and are fully integrated with coroutine cancellation. They are the primary abstraction for reactive-style programming in Kotlin.
3 / 5
In a design review, the team discusses StateFlow vs SharedFlow. A junior engineer asks what the key differences are. What is correct?
StateFlow is a hot flow designed for state: it always holds a current value, new collectors immediately receive the latest value (replay = 1), and it uses structural equality to skip emitting when the new value equals the current value. SharedFlow is more flexible: configurable replay cache (0+), no mandatory initial value, and it emits every value regardless of equality. Use StateFlow for UI state; use SharedFlow for events and one-time signals.
4 / 5
An incident report shows an Android app crashing with CancellationException when the ViewModel is cleared. A senior engineer asks how viewModelScope relates to coroutine lifecycle. What is correct?
viewModelScope is a CoroutineScope bound to the ViewModel's lifecycle. When the ViewModel is cleared (e.g., the user navigates away), onCleared() is called and the scope is cancelled — all running coroutines receive a CancellationException. This is intentional and correct behaviour, preventing work from continuing after the UI is gone. CancellationException should be caught carefully — it should generally not be swallowed, as catching it can prevent coroutine cancellation from propagating.
5 / 5
During a code review, a senior engineer asks what flatMapLatest does on a Kotlin Flow. What is accurate?
flatMapLatest is the key operator for cancelling stale work. When a new value arrives from the upstream flow, flatMapLatest cancels the currently running inner flow and starts a new one for the latest value. This is perfect for search-as-you-type: each character triggers a new search flow, and the previous in-flight search is cancelled automatically. Use flatMapMerge when you want all inner flows to run concurrently, or flatMapConcat to run them sequentially.