Read-only is not immutable

`List` hides the mutators; the object underneath can still change through another reference.

fun main() {
    val readOnly: List<Int> = listOf(3, 1, 2)
    val mutable = readOnly.toMutableList()      // a copy you may change
    mutable += 4
    println("$readOnly $mutable")

    val view: List<Int> = mutable               // a read-only VIEW of the same list
    mutable.clear()
    println(view.size)
}

[3, 1, 2] [3, 1, 2, 4]
0

Sources: List, Set and Map — Kotlin docs

Maps and sets

`getValue` throws on a missing key; `[]` returns null; set algebra reads as infix words.

fun main() {
    val counts = mutableMapOf<String, Int>()
    for (word in "the cat and the hat".split(" ")) {
        counts[word] = counts.getOrDefault(word, 0) + 1
    }
    println(counts)
    println(counts.getValue("the") to ("dog" in counts))

    val a = setOf(1, 2, 3)
    val b = setOf(2, 3, 4)
    println("${a union b} ${a intersect b} ${a subtract b}")
}

{the=2, cat=1, and=1, hat=1}
(2, false)
[1, 2, 3, 4] [2, 3] [1]

Keys need value equality

A `data class` generates `equals` and `hashCode`; a plain class compares by identity.

data class Point(val x: Int, val y: Int)
class Cell(val x: Int, val y: Int)

fun main() {
    println(setOf(Point(1, 1), Point(1, 1)).size)
    println(setOf(Cell(1, 1), Cell(1, 1)).size)
}

1
2

Sources: Data classes — Kotlin docs

ArrayDeque and primitive arrays

`ArrayDeque` is the queue and the stack; `IntArray` is `int[]` with no boxing.

fun main() {
    val queue = ArrayDeque<String>()
    queue.addLast("a")
    queue.addLast("b")
    queue.addFirst("urgent")
    println("${queue.removeFirst()} ${queue.removeLast()} $queue")

    val primes = intArrayOf(2, 3, 5, 7)
    println(primes.sum())
}

urgent b [a]
17

Pitfalls

Where Kotlin differs from Swift's value-type collections.

• Collections are references: val ys = xs aliases a MutableList. Copy with toList() / toMutableList().
• list.removeAt(0) in a loop is O(n²) — use ArrayDeque.
• Mutating a collection while iterating it throws ConcurrentModificationException; use removeAll { } or iterate a copy.
• Expose List, Set, Map from APIs; keep the Mutable* type private.
• List<Int> boxes every element; IntArray does not — it matters for large numeric data.

Transform and fold

`sumOf` says the intent; `fold` is the general form.

data class Order(val id: Int, val customer: String, val total: Int)

fun main() {
    val orders = listOf(Order(1, "ana", 30), Order(2, "bo", 12), Order(3, "ana", 8))
    println(orders.filter { it.total >= 10 }.map { it.id })
    println(orders.sumOf { it.total })
    println(orders.fold(0) { acc, o -> acc + o.total })
}

[1, 2]
50
50

Group, index, count, partition

Groups keep the order in which keys first appear.

data class Person(val name: String, val team: String)

fun main() {
    val people = listOf(Person("Ana", "web"), Person("Bo", "data"), Person("Cy", "web"))
    println(people.groupBy({ it.team }, { it.name }))
    println(people.associateBy { it.name }.getValue("Bo").team)
    println(people.groupingBy { it.team }.eachCount())
    val (web, others) = people.partition { it.team == "web" }
    println("${web.size} ${others.size}")
}

{web=[Ana, Cy], data=[Bo]}
data
{web=2, data=1}
2 1

Sources: Grouping — Kotlin docs

Sort by several keys

Comparators compose: `compareByDescending { }.thenBy { }`. Sorting is stable.

data class Player(val name: String, val score: Int)

fun main() {
    val players = listOf(Player("cy", 7), Player("ana", 9), Player("bo", 7))
    val ranked = players.sortedWith(compareByDescending<Player> { it.score }.thenBy { it.name })
    println(ranked.joinToString(" ") { "${it.name}:${it.score}" })
    println("${players.maxBy { it.score }.name} ${players.minByOrNull { it.score }?.name}")
}

ana:9 bo:7 cy:7
ana cy

Sources: Ordering — Kotlin docs

Chunk, window, dedupe, zip

All built in.

fun main() {
    println((1..5).chunked(2))
    println((1..4).windowed(3))
    println(listOf("b", "a", "b", "c", "a").distinct())
    println(listOf("a", "b", "c").zip(listOf(1, 2)))     // stops at the shorter
    println(listOf(1, 2, 4, 7).zipWithNext { a, b -> b - a })
}

[[1, 2], [3, 4], [5]]
[[1, 2, 3], [2, 3, 4]]
[b, a, c]
[(a, 1), (b, 2)]
[1, 2, 3]

Search and test

`first { }` throws when nothing matches; the `OrNull` variants return null.

fun main() {
    val xs = listOf(3, 8, 12, 5, 20)
    println("${xs.first { it > 10 }} ${xs.lastOrNull { it > 10 }} ${xs.indexOfFirst { it > 100 }} ${xs.firstOrNull { it > 100 }}")
    println("${xs.any { it % 2 == 0 }} ${xs.all { it > 0 }} ${5 in xs} ${xs.none { it < 0 }}")
}

12 20 -1 null
true true true true

Lazy pipelines with sequences

A sequence runs each element through the whole chain and stops as soon as `take` is satisfied.

fun main() {
    var squared = 0
    val firstOddSquares = generateSequence(1) { it + 1 }
        .map { squared++; it * it }
        .filter { it % 2 == 1 }
        .take(3)
        .toList()
    println("$firstOddSquares after $squared squares")
}

[1, 9, 25] after 5 squares

Sources: Sequences — Kotlin docs

Sequential vs concurrent

Calls are sequential by default; `async` makes concurrency explicit.

import kotlinx.coroutines.*
import kotlin.time.measureTime

suspend fun load(name: String): String {
    delay(100)                             // suspends; the thread is free meanwhile
    return name
}

fun main() = runBlocking {
    val sequential = measureTime { load("user"); load("posts") }
    val concurrent = measureTime {
        val user = async { load("user") }
        val posts = async { load("posts") }
        println("${user.await()} ${posts.await()}")
    }
    // about 200 ms against about 100 ms; compared, not printed, so a busy machine cannot change the output
    println("concurrent took well under the sequential time: ${concurrent < sequential * 0.75}")
}

user posts
concurrent took well under the sequential time: true

Structured fan-out

`coroutineScope` waits for every child and fails if one fails — the TaskGroup of Kotlin.

import kotlinx.coroutines.*

suspend fun thumbnail(id: Int): String {
    delay(10L * (4 - id))                  // later ids finish first
    return "thumb-$id"
}

suspend fun thumbnails(ids: List<Int>): Map<Int, String> = coroutineScope {
    ids.map { id -> async { id to thumbnail(id) } }   // all start now
        .awaitAll()                                   // results in INPUT order
        .toMap()
}

fun main() = runBlocking {
    println(thumbnails(listOf(1, 2, 3)))
}

{1=thumb-1, 2=thumb-2, 3=thumb-3}

Sources: Composing suspending functions — Kotlin docs

Failure propagation and supervision

A failing child cancels its siblings in `coroutineScope`; in `supervisorScope` each child fails alone.

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        coroutineScope {
            launch { delay(1_000); println("never printed: cancelled by its sibling") }
            launch { delay(10); error("boom") }
        }
    } catch (e: IllegalStateException) {
        println("caught ${e.message}")
    }

    val results = supervisorScope {
        val a = async { delay(10); 1 }
        val b = async<Int> { throw IllegalArgumentException("bad input") }
        listOf(runCatching { a.await() }, runCatching { b.await() })
    }
    println(results.map { r -> r.getOrElse { it.message } })
}

caught boom
[1, bad input]

Sources: Coroutine exceptions handling — Kotlin docs

Cancellation and timeouts

Cancellation is cooperative: every suspension point checks it, and `finally` runs like Swift's `defer`.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel

fun main() = runBlocking {
    val ticks = Channel<Int>()
    val job = launch {
        try {
            repeat(10) { i ->
                ticks.send(i)
                delay(100)                     // a suspension point: where cancellation lands
            }
        } finally {
            println("cleanup")
        }
    }
    repeat(3) { println("tick ${ticks.receive()}") }
    job.cancelAndJoin()                        // e.g. the screen went away after three ticks

    val result = withTimeoutOrNull(150) { delay(1_000); "done" }
    println("timeout -> $result")
}

tick 0
tick 1
tick 2
cleanup
timeout -> null

CPU work off the caller's thread

`withContext(Dispatchers.Default)` moves the work; a loop without suspension must call `ensureActive()` to stay cancellable.

import kotlinx.coroutines.*

suspend fun countPrimes(limit: Int): Int = withContext(Dispatchers.Default) {
    var count = 0
    for (n in 2..limit) {
        ensureActive()
        if ((2..Math.sqrt(n.toDouble()).toInt()).none { n % it == 0 }) count++
    }
    count
}

fun main() = runBlocking {
    println(countPrimes(10_000))
}

1229

Bridging callbacks and futures

`suspendCancellableCoroutine` is `withCheckedContinuation`; `CompletableFuture.await()` ships in coroutines-core.

import kotlinx.coroutines.*
import kotlinx.coroutines.future.await
import java.util.concurrent.CompletableFuture
import kotlin.coroutines.resume

fun fetchTheme(callback: (String) -> Unit) {          // a callback API you do not own
    Thread { Thread.sleep(20); callback("dark") }.start()
}

suspend fun fetchTheme(): String = suspendCancellableCoroutine { cont ->
    fetchTheme { value -> cont.resume(value) }
}

fun main() = runBlocking {
    println(fetchTheme())
    println(CompletableFuture.supplyAsync { 6 * 7 }.await())
}

dark
42

Rules

What reviewers flag first.

• runBlocking inside a coroutine or on the Android main thread blocks the thread it runs on.
• catch (e: Exception) around a suspend call swallows CancellationException — rethrow it, or catch narrower types.
• Launch in a scope with a lifetime (viewModelScope, lifecycleScope, your own CoroutineScope), never GlobalScope.
• Make suspend functions main-safe: they switch dispatcher themselves with withContext.

Two pointers

On sorted input, move the pointer that brings the sum closer. O(n), O(1) space.

fun pairWithSum(sorted: List<Int>, target: Int): Pair<Int, Int>? {
    var lo = 0
    var hi = sorted.lastIndex
    while (lo < hi) {
        val sum = sorted[lo] + sorted[hi]
        when {
            sum == target -> return lo to hi
            sum < target -> lo++
            else -> hi--
        }
    }
    return null
}

fun main() = println("${pairWithSum(listOf(1, 3, 4, 6, 9), 10)} ${pairWithSum(listOf(1, 2), 7)}")

(0, 4) null

Sliding window

Longest substring without repeats — grow the right edge, jump the left past the last repeat. O(n).

fun longestUnique(s: String): Int {
    val lastSeen = HashMap<Char, Int>()
    var start = 0
    var best = 0
    for ((i, ch) in s.withIndex()) {
        val prev = lastSeen[ch]
        if (prev != null && prev >= start) start = prev + 1
        lastSeen[ch] = i
        best = maxOf(best, i - start + 1)
    }
    return best
}

fun main() = println("${longestUnique("abcabcbb")} ${longestUnique("pwwkew")}")

3 3

Binary search — built in and lower bound

The built-in finds some match; the lower bound finds the first index not less than the target.

fun lowerBound(xs: List<Int>, target: Int): Int {
    var lo = 0
    var hi = xs.size
    while (lo < hi) {
        val mid = (lo + hi) ushr 1
        if (xs[mid] < target) lo = mid + 1 else hi = mid
    }
    return lo
}

fun main() {
    val xs = listOf(1, 3, 3, 5, 8)
    println("${xs.binarySearch(5)} ${xs.binarySearch(4)}")    // 4 is missing: -(3) - 1
    println("${lowerBound(xs, 3)} ${lowerBound(xs, 4)} ${lowerBound(xs, 9)}")
}

3 -4
1 3 5

Heap — top k

A min-heap of size k keeps the k largest; its root is the smallest of them. O(n log k).

import java.util.PriorityQueue

fun topK(xs: List<Int>, k: Int): List<Int> {
    val heap = PriorityQueue<Int>()
    for (x in xs) {
        heap.offer(x)
        if (heap.size > k) heap.poll()
    }
    return heap.sortedDescending()
}

fun main() = println(topK(listOf(5, 1, 9, 3, 7, 9, 2), 3))

[9, 9, 7]

Breadth-first search on a grid

BFS finds shortest paths in unweighted graphs; `ArrayDeque` makes each dequeue O(1).

fun shortestPath(grid: List<String>, from: Pair<Int, Int>, to: Pair<Int, Int>): Int {
    val dist = hashMapOf(from to 0)
    val queue = ArrayDeque(listOf(from))
    while (queue.isNotEmpty()) {
        val cell = queue.removeFirst()
        val here = dist.getValue(cell)
        if (cell == to) return here
        val (r, c) = cell
        for ((dr, dc) in listOf(1 to 0, -1 to 0, 0 to 1, 0 to -1)) {
            val next = r + dr to c + dc
            val (nr, nc) = next
            if (nr !in grid.indices || nc !in grid[nr].indices || grid[nr][nc] == '#' || next in dist) continue
            dist[next] = here + 1
            queue.addLast(next)
        }
    }
    return -1
}

fun main() = println(shortestPath(listOf("..#.", ".##.", "...."), 0 to 0, 0 to 3))

7

Working a problem out loud

The habits that matter more than the language.

• State the brute force and its cost first, then the bottleneck the better pattern removes.
• Name the edge cases before coding: empty input, one element, duplicates, Int overflow.
• (lo + hi) / 2 can overflow on huge indices — ushr 1 or lo + (hi - lo) / 2.
• List<Int> boxes; for tight numeric loops prefer IntArray.

Virtual time with runTest

Inside `runTest`, `delay` advances a virtual clock — a 300 ms debounce is tested instantly.

import kotlinx.coroutines.*
import kotlinx.coroutines.test.*

class Debouncer(private val scope: CoroutineScope, private val waitMs: Long, private val action: (String) -> Unit) {
    private var pending: Job? = null
    fun submit(value: String) {
        pending?.cancel()
        pending = scope.launch { delay(waitMs); action(value) }
    }
}

fun main() = runTest {
    val saved = mutableListOf<String>()
    val debouncer = Debouncer(this, 300, saved::add)
    debouncer.submit("h")
    debouncer.submit("he")
    debouncer.submit("hey")
    advanceTimeBy(299); runCurrent()
    check(saved.isEmpty())
    advanceTimeBy(1); runCurrent()
    check(saved == listOf("hey"))
    println("saved $saved at virtual $currentTime ms")
}

saved [hey] at virtual 300 ms

• kotlinx-coroutines-core
• kotlinx-coroutines-test
• kotlin >=2.0
• kotlinx-coroutines >=1.10
• jvm >=17

Design for testability — inject the clock

A `fun interface` makes the seam a lambda in tests.

fun interface Clock { fun nowMs(): Long }

class Session(private val clock: Clock, private val ttlMs: Long) {
    private val started = clock.nowMs()
    fun expired() = clock.nowMs() - started >= ttlMs
}

fun main() {
    var now = 1_000L
    val session = Session({ now }, ttlMs = 500)
    check(!session.expired())
    now += 500                             // the test owns time: no sleeping
    check(session.expired())
    println("expired after ${now - 1_000} ms of fake time")
}

expired after 500 ms of fake time

A JUnit 5 test class

Backtick names read as sentences; `assertThrows<T>` is JUnit's Kotlin extension.

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

fun slugify(title: String): String {
    require(title.isNotBlank()) { "blank title" }
    return title.trim().lowercase().replace(Regex("[^a-z0-9]+"), "-").trim('-')
}

class SlugTest {
    @Test
    fun `joins words with single hyphens`() = assertEquals("hello-world", slugify("  Hello, World!  "))

    @Test
    fun `rejects blank titles`() {
        assertThrows<IllegalArgumentException> { slugify("   ") }
    }
}

• JUnit 5
• kotlin >=2.0
• junit-jupiter >=5.10
• jvm >=17

Sources: JUnit 5 User Guide

Principles worth stating

The same in every language.

• Fakes you own (an in-memory repository, a Clock) over mocks of code you do not.
• Inject dispatchers and scopes; in tests pass StandardTestDispatcher or the TestScope itself.
• Thread.sleep or real delay in tests: slow and flaky — use virtual time.
• runTest fails a test that leaves coroutines running — a free leak check.

Null safety

Nullability is part of the type. `?.` short-circuits, `?:` supplies a default — or returns early.

data class Address(val city: String?)
data class User(val name: String, val address: Address?)

fun cityOf(user: User): String {
    val city = user.address?.city ?: return "no city for ${user.name}"   // like guard let … else
    return city.uppercase()                                              // smart cast: String here
}

fun main() {
    val user = User("Ana", address = null)
    println(user.address?.city ?: "unknown city")
    println(cityOf(user))
    println(cityOf(User("Bo", Address("lima"))))
}

unknown city
no city for Ana
LIMA

Sources: Null safety — Kotlin docs

Sealed hierarchies and when

A new case breaks compilation at every `when` that does not handle it.

sealed interface Shape
data class Circle(val radius: Double) : Shape
data class Rect(val width: Double, val height: Double) : Shape

fun area(s: Shape): Double = when (s) {
    is Circle -> Math.PI * s.radius * s.radius
    is Rect -> s.width * s.height               // smart cast: s is a Rect here
}

fun main() {
    println(area(Rect(2.0, 3.0)))
    println(Math.round(area(Circle(1.0)) * 100) / 100.0)
}

6.0
3.14

Sources: Sealed classes and interfaces — Kotlin docs

Generics, bounds and variance

`out T` marks a producer, so a `Source<Int>` is a `Source<Number>` — Swift has no user-declared variance.

fun <T : Comparable<T>> clamp(value: T, low: T, high: T): T = maxOf(low, minOf(value, high))

interface Source<out T> { fun next(): T }

fun sumAll(sources: List<Source<Number>>): Double = sources.sumOf { it.next().toDouble() }

fun main() {
    println("${clamp(15, 0, 10)} ${clamp("m", "a", "f")}")
    val ints = object : Source<Int> { override fun next() = 2 }
    val doubles = object : Source<Double> { override fun next() = 0.5 }
    println(sumAll(listOf(ints, doubles)))
}

10 f
2.5

Sources: Generics — Kotlin docs

Exceptions, require and runCatching

`throw` is an expression; `require` throws `IllegalArgumentException`; `runCatching` turns a throw into a `Result`.

class InvalidPort(text: String) : Exception("not a port: $text")

fun parsePort(text: String): Int {
    val n = text.toIntOrNull() ?: throw InvalidPort(text)
    require(n in 1..65535) { "out of range: $n" }
    return n
}

fun main() {
    for (input in listOf("8080", "http", "70000")) {
        val result = runCatching { parsePort(input) }
        println(result.fold({ "port $it" }, { "${it::class.simpleName}: ${it.message}" }))
    }
}

port 8080
InvalidPort: not a port: http
IllegalArgumentException: out of range: 70000

Sources: Exceptions — Kotlin docs

Data classes and copies

`==` compares values, `===` identity; `copy()` is shallow, like a struct copy of a reference field.

data class Settings(val theme: String, val tags: List<String>)

fun main() {
    val a = Settings("dark", listOf("x"))
    val b = a.copy(theme = "light")
    println("$a $b")
    println("${a == a.copy()} ${a === a.copy()} ${a.tags === b.tags}")
}

Settings(theme=dark, tags=[x]) Settings(theme=light, tags=[x])
true false true

Extensions and scope functions

`apply` configures and returns the receiver; `let` transforms and returns the lambda's result.

fun String.initials(): String =
    split(" ").filter { it.isNotEmpty() }.joinToString("") { it.first().uppercase() }

data class Request(var url: String = "", var retries: Int = 0)

fun main() {
    println("ada lovelace".initials())
    val request = Request().apply { url = "https://example.com"; retries = 3 }
    println(request.let { "${it.url} x${it.retries}" })
}

AL
https://example.com x3

Sources: Scope functions — Kotlin docs

Cold flows

A `flow { }` does nothing until collected, and runs again for each collector.

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun numbers(): Flow<Int> = flow {
    println("start")
    for (i in 1..3) emit(i)
}

fun main() = runBlocking {
    numbers().map { it * 10 }.collect { println(it) }
    println(numbers().toList())
}

start
10
20
30
start
[1, 2, 3]

StateFlow and SharedFlow

`StateFlow` holds the latest value and skips equal ones; `SharedFlow` broadcasts events.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val count = MutableStateFlow(0)
    val events = MutableSharedFlow<String>()

    val watcher = launch { count.collect { println("count = $it") } }
    val listener = launch { events.collect { println("event: $it") } }
    yield()                                    // let both collectors subscribe
    count.value = 1
    yield()
    count.value = 1                            // equal: not re-emitted
    events.emit("saved")
    yield()
    watcher.cancel()
    listener.cancel()
}

count = 0
count = 1
event: saved

Operators that matter

`flatMapLatest` cancels stale work — the search-as-you-type operator.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

@OptIn(ExperimentalCoroutinesApi::class)
fun main() = runBlocking {
    flowOf("a", "ab", "abc")
        .onEach { delay(50) }                  // a keystroke every 50 ms
        .flatMapLatest { q -> flow { delay(500); emit("results for $q") } }   // a slow search
        .collect { println(it) }

    println(flowOf("ana", "bo").zip(flowOf(31, 27, 99)) { n, a -> "$n:$a" }.toList())
    println(flowOf(1, 1, 2, 2, 3).distinctUntilChanged().scan(0) { acc, x -> acc + x }.toList())
}

results for abc
[ana:31, bo:27]
[0, 1, 3, 6]

Lifetime belongs to a scope

`launchIn(scope)` ties the collection to the scope; cancelling the scope ends it (the role of `AnyCancellable`).

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun ticker(periodMs: Long): Flow<Int> = flow {
    var n = 0
    while (true) {
        emit(n++)
        delay(periodMs)
    }
}

fun main() = runBlocking {
    val screen = CoroutineScope(coroutineContext + Job())   // stand-in for viewModelScope
    val thirdTick = CompletableDeferred<Unit>()
    ticker(100).onEach { println("tick $it"); if (it == 2) thirdTick.complete(Unit) }.launchIn(screen)
    thirdTick.await()                                        // e.g. the screen goes away after three ticks
    screen.cancel()
    delay(200)
    println("after cancel: quiet")
}

tick 0
tick 1
tick 2
after cancel: quiet

Bridging a listener API

`callbackFlow` registers on collect and unregisters in `awaitClose` when the collector stops.

import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun interface Listener { fun onReading(value: Int) }

class Sensor {                                 // a listener API you do not own
    fun register(listener: Listener) {
        Thread { for (v in listOf(10, 20, 30, 40)) listener.onReading(v) }.start()
    }
    fun unregister() = println("unregistered")
}

fun Sensor.readings(): Flow<Int> = callbackFlow {
    register { value -> trySend(value) }
    awaitClose { unregister() }
}

fun main() = runBlocking {
    println(Sensor().readings().take(3).toList())
}

unregistered
[10, 20, 30]

Sources: callbackFlow — kotlinx.coroutines API

Gotchas

The ones that cost a day.

• collect suspends until the flow completes — a StateFlow never does, so the next line never runs.
• Updating a StateFlow with a mutated list: equal by equals, so nothing is emitted. Emit a new list.
• stateIn(scope, SharingStarted.WhileSubscribed(5_000), initial) for UI state: stops upstream work when nobody watches.
• flowOn(Dispatchers.IO) for blocking upstream work; the collector keeps its own context.
• catch { } handles upstream exceptions only — a throw in collect { } is not caught by it.

Mutex and atomics

100,000 increments from many threads. A plain `count++` would lose updates; both of these do not.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import java.util.concurrent.atomic.AtomicInteger

fun main() = runBlocking {
    val mutex = Mutex()
    var guarded = 0
    val atomic = AtomicInteger()
    withContext(Dispatchers.Default) {         // a pool of threads
        repeat(1_000) {
            launch {
                repeat(100) {
                    mutex.withLock { guarded++ }
                    atomic.incrementAndGet()
                }
            }
        }
    }
    println("guarded=$guarded atomic=${atomic.get()}")
}

guarded=100000 atomic=100000

Confinement to one-at-a-time

`limitedParallelism(1)` gives a serial view of a shared pool — the closest thing to a serial executor.

import kotlinx.coroutines.*

val counterContext = Dispatchers.Default.limitedParallelism(1)

fun main() = runBlocking {
    var count = 0                               // only ever touched on counterContext
    withContext(Dispatchers.Default) {
        repeat(1_000) { launch { withContext(counterContext) { count++ } } }
    }
    println(count)
}

1000

An actor from a channel

One coroutine owns the state and handles one message at a time; replies come back through `CompletableDeferred`.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel

sealed interface AccountMsg {
    data class Deposit(val amount: Int) : AccountMsg
    data class Balance(val reply: CompletableDeferred<Int>) : AccountMsg
}

fun CoroutineScope.account(): Channel<AccountMsg> {
    val inbox = Channel<AccountMsg>(Channel.UNLIMITED)
    launch {
        var balance = 0
        for (msg in inbox) when (msg) {
            is AccountMsg.Deposit -> balance += msg.amount
            is AccountMsg.Balance -> msg.reply.complete(balance)
        }
    }
    return inbox
}

fun main() = runBlocking {
    val account = account()
    coroutineScope {
        repeat(100) { launch(Dispatchers.Default) { account.send(AccountMsg.Deposit(10)) } }
    }
    val reply = CompletableDeferred<Int>()
    account.send(AccountMsg.Balance(reply))
    account.close()                             // the actor drains its inbox, then stops
    println(reply.await())
}

1000

Sources: Channels — Kotlin docs

Rules

Without a compiler check, the design has to make races impossible.

• Prefer immutable data passed between coroutines: val properties, read-only collections, data class copies.
• Expose state as StateFlow and mutate it only with update { } — an atomic compare-and-set.
• synchronized or ReentrantLock around a suspension point: the lock is held while the coroutine is parked.
• @Volatile makes writes visible, not compound updates atomic: x++ still races.

Read and write a small text file

Whole-file helpers are right for small files; they default to UTF-8.

import kotlin.io.path.*

fun main() {
    val dir = createTempDirectory("demo")
    val file = dir / "notes.txt"
    file.writeText("first line\nsecond line\n")
    println("${file.readLines().size} lines, ${file.fileSize()} bytes")
    dir.toFile().deleteRecursively()
}

2 lines, 23 bytes

Writing atomically

Write a temporary sibling, `force(true)` it to the device, then `ATOMIC_MOVE` over the target.

import java.nio.ByteBuffer
import java.nio.channels.FileChannel
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardCopyOption
import java.nio.file.StandardOpenOption
import kotlin.io.path.*

fun writeAtomically(target: Path, text: String) {
    val temp = Files.createTempFile(target.parent, ".${target.name}", ".tmp")   // same file system
    FileChannel.open(temp, StandardOpenOption.WRITE).use { channel ->
        val buffer = ByteBuffer.wrap(text.toByteArray())
        while (buffer.hasRemaining()) channel.write(buffer)
        channel.force(true)                    // on the device before the move publishes it
    }
    Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE)
}

fun main() {
    val dir = createTempDirectory("atomic")
    val settings = dir / "settings.json"
    writeAtomically(settings, """{"theme":"dark"}""")
    writeAtomically(settings, """{"theme":"light"}""")
    println(settings.readText())
    dir.toFile().deleteRecursively()
}

{"theme":"light"}

Sources: Files.move — Java SE 17 API

Streaming a large file line by line

`useLines` hands a lazy sequence and closes the file afterwards; one line is in memory at a time.

import kotlin.io.path.*

fun main() {
    val log = createTempFile("app", ".log")
    log.bufferedWriter().use { out ->
        for (i in 0 until 10_000) out.appendLine("${if (i % 10 == 0) "ERROR" else "INFO"} event $i")
    }
    val errors = log.useLines { lines -> lines.count { it.startsWith("ERROR") } }
    println("$errors errors")
    log.deleteExisting()
}

1000 errors

An append-only journal

One JSON object per line — appending never rewrites what is already there.

import kotlin.io.path.*

fun main() {
    val journal = createTempFile("journal", ".jsonl")
    for (event in listOf("start", "save", "stop")) journal.appendText("{\"event\":\"$event\"}\n")
    println(journal.readLines().map { it.substringAfter(":\"").removeSuffix("\"}") })
    journal.deleteExisting()
}

[start, save, stop]

Walking a directory tree

`walk()` is lazy and depth-first; it is still marked experimental, hence the opt-in.

import kotlin.io.path.*

@OptIn(ExperimentalPathApi::class)
fun main() {
    val root = createTempDirectory("tree")
    (root / "src/main").createDirectories()
    (root / "src/main/App.kt").writeText("fun main() {}")
    (root / "README.md").writeText("# demo")
    val sources = root.walk().filter { it.extension == "kt" }.map { it.relativeTo(root).invariantSeparatorsPathString }
    println(sources.toList())
    root.deleteRecursively()
}

[src/main/App.kt]

Rules that prevent data loss

The JVM adds a few of its own.

• Close every stream with use { } — it is defer for Closeable.
• Replace a file with a temporary sibling + ATOMIC_MOVE; never truncate the original first.
• Java's FileReader / InputStreamReader without a charset used the platform default before JDK 18; Kotlin's readText() / readLines() default to UTF-8 already.
• ATOMIC_MOVE over an existing target is implementation-specific: POSIX rename replaces, other file systems may throw.
• On Android, app-private files go under context.filesDir; shared storage goes through the Storage Access Framework.

remember, rememberSaveable and hoisting

A stateless composable takes the value and an event; the caller owns the state.

@Composable
fun Counter(count: Int, onIncrement: () -> Unit) {        // stateless: easy to preview and test
    Button(onClick = onIncrement) { Text("Clicked $count times") }
}

@Composable
fun CounterScreen() {
    var count by rememberSaveable { mutableIntStateOf(0) }   // survives recomposition and rotation
    Counter(count = count, onIncrement = { count++ })
}

ViewModel + StateFlow, collected with the lifecycle

One immutable UI state, updated atomically; the screen collects it only while it is at least STARTED.

data class SearchUiState(val query: String = "", val results: List<String> = emptyList(), val loading: Boolean = false)

class SearchViewModel(private val repo: SearchRepository) : ViewModel() {
    private val _state = MutableStateFlow(SearchUiState())
    val state: StateFlow<SearchUiState> = _state.asStateFlow()
    private var searchJob: Job? = null

    fun onQueryChange(query: String) {
        _state.update { it.copy(query = query, loading = true) }
        searchJob?.cancel()                                  // a newer query supersedes the old one
        searchJob = viewModelScope.launch {                  // cancelled when the ViewModel is cleared
            val results = repo.search(query)
            _state.update { it.copy(results = results, loading = false) }
        }
    }
}

@Composable
fun SearchScreen(vm: SearchViewModel) {
    val state by vm.state.collectAsStateWithLifecycle()
    Column {
        TextField(value = state.query, onValueChange = vm::onQueryChange)
        if (state.loading) CircularProgressIndicator()
        state.results.forEach { Text(it) }
    }
}

Sources: StateFlow and SharedFlow — Android Developers · collectAsStateWithLifecycle — Android Developers

Async work tied to the screen

`LaunchedEffect(key)` starts when the composable enters, restarts when the key changes and is cancelled when it leaves — `.task(id:)`.

@Composable
fun Profile(userId: String, load: suspend (String) -> String) {
    var name by remember(userId) { mutableStateOf<String?>(null) }   // reset for a new user
    LaunchedEffect(userId) {
        name = load(userId)
    }
    Text(name ?: "Loading…")
}

Sources: Side-effects in Compose — Android Developers

Identity and lifetime rules

Most Compose state bugs are one of these.

• Mutating a list inside mutableStateOf(list) — Compose sees the same object and does not recompose. Assign a new list, or use mutableStateListOf.
• Side effects (network, logging, writes) directly in a composable body: it runs on every recomposition.
• Give items(…, key = { it.id }) stable keys so state follows the item, not the position.
• derivedStateOf { } for values computed from state that changes more often than the result.
• Configuration changes recreate the activity: remember resets, rememberSaveable and the ViewModel survive.

How to read the matrix

Nothing here is a translation made to fill a gap.

• equivalent — a sheet here covers the same concept and shares its concept id, so the language selector lands on it from the Swift sheet.
• partial — a sheet here covers part of it under its own concept id, so the selector does not land on it: the Here column names it and the reason says what is missing.
• no counterpart — nothing here; the reason says whether the topic does not exist in this language or is simply not written yet.