Text is the most expensive composable you use without thinking
Layout measures text to resolve constraints, and a changing style invalidates the cache.
performance
24 posts
derivedStateOf exists because you were recomposing on every keystroke
A computed value read in composition invalidates on every change of its source. derivedStateOf narrows it to the result.
Four bytes a pixel is the number that decides whether your app gets killed
A bitmap costs width × height × 4 bytes in memory regardless of its file size. Decoding at display size, choosing the right config and budgeting the cache are what keep an image-heavy app from being reclaimed.
remember is not a cache, and the key is the whole contract
It is scoped to a composition and keyed by its arguments. A missing key gives stale state; a wrong one recomputes every frame.
Recomposition is not re-rendering, and that is why your list stutters
Compose re-executes functions whose inputs changed. An unstable parameter means all of them.
Compose is doing what you told it; the instruction was wrong
Recomposition scope is set by where a value is read, not where it is declared. Most Compose performance problems are a read placed higher than it needed to be.
What a local model does to your battery
Battery cost is attributed at app level and spent at feature level. Measure the delta against a control run, and treat thermal state as part of the result.
The first inference is the one users judge you on
Cold start is a different system from steady state, not the same one measured twice. Treat warmth as a resource with a lifecycle, and measure both numbers.
Streaming tokens into Compose without recomposing the world
Streaming output updates state far faster than a normal screen. Narrow what reads the changing value, and let the smallest possible scope recompose.
The latency maths that decides on-device versus an API call
Comparing a local model to an API is not a race between two averages — it is tail latency, failure rates, and how often one task crosses the boundary.
Composition, layout, drawing — and why reading a value in the wrong one costs frames
Compose renders in three phases. Where you read state decides which phase invalidates, and moving a read from composition into layout or draw is the single highest-leverage performance change available.
Recomposition doesn't re-run your screen. It re-runs the scopes that read what changed.
Compose does not re-run your whole screen when state changes. It re-runs the smallest restartable scopes that read the changed value. Once you can see those scopes, recomposition stops being mysterious.