The blog

Android, from the source up.

Deep dives into Kotlin, Jetpack Compose, coroutines and the architecture decisions that hold real production apps together.

Read as a series Android, Line by Line 3 parts Compose Design System 1 parts Kotlin Problem Solving 1 parts DogWalk Devlog 1 parts System Design 2 parts
All Android Architecture (3) Kotlin & Core Concepts (3) System Design (2) Design System (1) Kotlin Multiplatform (1) Problem Solving (1)
Kotlin & Core Concepts Latest

Let's Make a Callback Suspend: suspendCancellableCoroutine, Line by Line

Wrapping a callback API in a suspend function is four lines. The fifth line — invokeOnCancellation — is the one that decides whether cancelling actually stops anything, and it's the one people leave out.

·4 min read
Kotlin & Core Concepts

Let's Make SupervisorJob Work: Independent Failure Without Breaking the Tree

One child throws and the whole scope dies. SupervisorJob fixes that — but you probably already have one and didn't know, and the way most people reach for it does nothing except break structured concurrency.

· 4 min read
Android Architecture

Let's Make WorkManager Work: Constraints, Unique Work, and a Retry That Stops

Forty lines that run a job surviving the app being killed. Three decisions inside are worth stealing, and one line is a bug you can ship without noticing — because CancellationException is an Exception.

· 4 min read
Design System

Let's Make an Avatar System Work: Layering, Negative Spacing, and Constrained APIs

Two composables, three decisions. An image drawn on top of initials replaces an if/else. A negative number replaces a custom layout. And an enum stops the call site inventing its own sizes.

· 4 min read
Problem Solving

Let's Make the Kangaroo Problem Work: Algebra Instead of a Loop

Two kangaroos, different starting points, different jump distances. Do they ever land on the same spot at the same time? The instinct is to simulate. Four lines of algebra answer it in O(1).

· 3 min read
Kotlin Multiplatform

Let's Make a Game Engine Work Inside Compose Multiplatform

No SurfaceView. No OpenGL. No Godot. A 2D game loop running on withFrameNanos, a fixed timestep simulation, and a redraw path that never recomposes — shipping to Android and Desktop from one commonMain.

· 4 min read
System Design

Let's Make Three-Tier Architecture Work: Layers, Sync vs Async, and Statelessness

Presentation, domain, data. The oldest diagram in system design, and still the first one you should draw — because it decides what you can scale, what you can swap, and where your state is allowed to live.

· 5 min read
System Design

Let's Make System Design Work: What It Actually Is

System design is drawing how a system is — architecture, components, modules, interfaces and flows. Here's what you're really being assessed on, and why half the scorecard has nothing to do with the diagram.

· 5 min read
Android Architecture

Let's Make SOLID Work: The Principles and Patterns Behind Android Architecture

AsyncTask died, Fragments were rewritten twice, XML gave way to Compose. What survived every migration was the shape of the code underneath. Here are the five principles and nine patterns that decide it.

· 6 min read
Android Architecture

Let's Make ViewModels Work: A Look Inside ViewModel.kt

Let's break down the actual source of ViewModel.kt — why it's abstract, how it survives rotation, and how viewModelScope quietly saves you from leaking network calls.

· 3 min read
Kotlin & Core Concepts

Let's Make Coroutines Work: What is a Coroutine?

Threads block, and blocked threads freeze apps. Here's what a coroutine actually is, what a suspension point does, and why you can run 100,000 of them on a single thread.

· 2 min read