React
The model, the internals, and the parts that go wrong at scale.
24 topics
The React Mental Model
React as a function from state to a description of UI, and why every other React question falls out of that one idea.
core25 minElements, Components & JSX
What JSX compiles to, why an element is a plain object, and where the boundary between a component and its output actually sits.
core20 minReconciliation & Keys
How React decides which element in the new tree corresponds to which in the old one, and why the key you pick decides whether state survives.
core25 minWhen Components Re-render
The actual triggers for a re-render, why "the props changed" is not one of them, and why most re-renders are harmless.
core20 minFiber Architecture
The linked-list rewrite of React's reconciler that made rendering interruptible, and the vocabulary it gave the rest of React.
deep30 minThe Rules of Hooks & Why They Exist
Why hooks depend on call order, what that implies for conditionals and loops, and what actually breaks when the order changes.
core20 minState Updates & Batching
Why state looks stale inside the function that set it, when updates are batched, and when to reach for the updater form.
core20 minThe useEffect Mental Model
Effects as synchronisation with an external system rather than lifecycle callbacks, and why the dependency array is a consequence, not a configuration.
core30 minYou Might Not Need an Effect
The four things effects are actually for, and the much longer list of things people use them for that belong in render, an event handler, or a data library.
core25 minRefs & Imperative Escape Hatches
When to hold a value that is not state, how to reach a DOM node safely, and why an imperative handle is usually the wrong first answer.
core20 minMemoisation — useMemo, useCallback & memo
What each of the three actually caches, when memoising pays for itself, and why it so often does nothing.
core25 minContext & Its Limits
What context is actually for, why every consumer re-renders when the value changes, and the patterns that keep it usable at scale.
core25 minuseReducer & UI State Machines
When to trade several useState calls for one reducer, and when to go further and model the UI as explicit states and transitions.
core25 minCustom Hook Design
What belongs in a custom hook, what to return, and why most bad hooks are bad because they hide too much or too little.
core20 minConcurrent Rendering
What "interruptible rendering" actually buys you, and the two hooks — useTransition and useDeferredValue — that let you use it.
core25 minSuspense & Streaming
How a component suspends, what the boundary is actually for, and why streaming SSR changed what a loading state costs.
core25 minError Boundaries
What a boundary catches, the four things it does not, and how to design fallbacks that leave the app usable.
core20 minPortals & Rendering Outside the Tree
Rendering a child into a different DOM node while keeping it in the React tree, and the accessibility work a portal does not do for you.
core20 minLists & Virtualisation
Why long lists get slow, when windowing is the right answer, and the accessibility and UX costs it brings with it.
core25 minProfiling React Performance
How to find the component that is actually costing you time, using the Profiler and the browser's performance panel rather than guesswork.
core25 minReact Server Components
Components that run only on the server and ship their output instead of their code, and the boundary rules that follow from that.
core30 minThe use Hook
Reading a promise or a context conditionally during render, and why this one hook does not follow the rules of hooks.
deep20 minReact 19 Actions
The built-in pattern for pending state, errors, and optimistic updates around an async mutation — and how forms became the unit of submission again.
core25 minReact Compiler
A build-time optimiser that inserts memoisation for you, what it requires of your code, and what it does not fix.
deep20 min