Courses
Ordered reading paths over existing articles. A course owns no content.
- React·6 lessons·115 min read
React foundations
Six articles that introduce the React mental model and the building blocks every later concept depends on. Pairs with `react-render-cycle`, which picks up where this leaves off and walks the full render and commit model with its symptom-first recipes.
The corpus separates concept articles from symptom-first recipes. The foundations path is the concept-only entry point: the model first, then the primitives (JSX, props, composition), then the patterns the primitives compose into (branching and events), and finally the constraints that prevent the patterns from being misused. Order is bottom-up on purpose. `thinking-in-react` opens with the bet the whole API is built on — UI as a function of state — because every later rule only makes sense once that bet is on the table. `jsx-and-rendering` comes next because the rules about when output is recomputed assume the reader already knows what the output is. Props precede composition because composition is built on prop typing and slot discipline. Branching and events come after composition because the conditional-render machinery is easier to read once the host-versus-children distinction is in place. The Rules of React close the path, placed last so the constraints read as consequences of the preceding five articles rather than as prerequisites. Nothing here asserts how React behaves. Every claim lives in an article under the corpus gates.
- React·12 lessons·234 min read
The React render cycle
Twelve articles from react-concepts in reading order, covering JSX compilation, the render and commit phases, state and context as the things that schedule work, memoization, and where effects sit relative to render. Concept articles are interleaved with the symptom-first recipes that exercise them.
The corpus holds concept articles and symptom-first recipes in separate trees, and read separately each half is weaker than it should be. A concept article explains a mechanism with no bug in front of it; a recipe diagnoses a bug and points back at a mechanism the reader has not met yet. This sequence alternates them. The order is bottom-up. It starts with what JSX becomes, because everything after it is about when that output is recomputed. Rendering and keys come before state, so that when state arrives there is already a render to talk about. The Rules of React sit after the render model rather than before it, because the constraints only make sense once you know what they protect. Three positions pay off the ones before them. Context re-rendering follows Context. The typing-lag recipe follows Memoization and the Compiler. The Escape Hatches audit closes the sequence by asking which of the previous eleven mechanisms the reader has been stepping around. Nothing here asserts how React behaves. Every claim in this course lives in an article under the corpus gates.