State & Data
Where state lives, and how data reaches the UI without waterfalls.
18 topics
State Taxonomy
The five kinds of state in a frontend app, and why treating server data like client state is the root of most state-management pain.
core20 minColocation & Lifting State
Keeping state as close to where it is used as possible, and the disciplined exceptions when it has to move up.
core20 minThe URL as State
Which state belongs in the address bar, why it is the cheapest persistence you will ever get, and how to keep it from thrashing.
core20 minUnidirectional Data Flow & Flux
Why the one-way loop won, what Flux was actually solving, and how the idea survives in every modern store.
core20 minClient State Libraries
Redux Toolkit, Zustand, Jotai and the rest — what actually distinguishes them, and when the answer is none of them.
core25 minDerived State & Selectors
Why computed values should not be stored, and how selectors keep derivation cheap without duplicating truth.
core20 minUI State Machines
Modelling a screen as explicit states and legal transitions so the impossible combinations cannot be represented at all.
core25 minServer State & Cache Semantics
Why a copy of server data is a cache and not state, and what stale-while-revalidate actually buys you.
core25 minData Fetching Patterns
Waterfalls, parallel loading, prefetching and dependent queries — the shapes that decide how fast a screen actually loads.
core25 minCache Normalisation & Entity Shape
When the same record appears in three places and one of them updates — the problem normalisation solves, and its real cost.
deep25 minOptimistic Updates & Rollback
Showing the result before the server confirms it, and the discipline that keeps a failed request from leaving the UI lying.
core25 minPagination & Infinite Lists
Offset versus cursor, why the classic paged list drops rows, and what infinite scroll costs you beyond the code.
core25 minRealtime State Sync
Keeping the UI current when the server pushes — transport choice, reconciliation with the cache, and what happens on reconnect.
deep25 minOffline & Local-First
What it takes for an app to work without a network, and why conflict resolution is the part that decides whether it is feasible.
deep25 minForms & Validation
Controlled versus uncontrolled, where validation actually belongs, and the accessibility requirements that make an error message useful.
core25 minGraphQL, REST & RPC from the Client
What each style costs the frontend in requests, caching, and types — judged from the consumer's side rather than the server's.
core25 minAPI Contracts & End-to-End Types
Getting a type from the server to the client without lying, and why a hand-written interface is a comment that compiles.
core20 minAPI Contracts
The agreement between a producer and its consumers about shape, meaning, and change — and the mechanisms that stop it drifting.
core25 minshared