Sources & further reading
The literature review behind this course — what we took from the best React guides, why the days are in this order, and what to read next.
Before writing any lessons, we reviewed the most respected React learning resources. Every item below was read first-hand in November 2026, against React 19.3 (released 9 September 2026). This page sums up what each resource does best, what this course borrowed from it, and where to go next.
The short version
react.dev / Learn
The official docs. The order of this course follows its four chapters.
The Joy of React
Josh W. Comeau. Mental models first, taught with interactive widgets.
Epic React
Kent C. Dodds. Exercise, solution, extra credit. All React 19 and TypeScript.
Full Stack Open
University of Helsinki. Free, project-driven, with testing and server state.
TkDodo's blog
Dominik Dorfmeister. Server state vs client state, and TanStack Query.
patterns.dev
Design and rendering patterns, each with pros and cons.
What each source taught us
react.dev / Learn: the spine
The official docs move through Describing the UI → Adding Interactivity → Managing State → Escape Hatches. Days 2–4 of this course follow that order closely. The docs also set the lesson format we copied: "You will learn", live sandboxes, a recap, and challenges with hidden solutions. Two decisions shaped this course in particular:
- Purity comes early. Purity is taught in chapter one, long before effects (Keeping Components Pure).
- Effects are an escape hatch, not a default. You Might Not Need an Effect gets a whole lesson on Day 4.
Its five-step Thinking in React method ties Day 4 together.
The Joy of React: mental models
Josh Comeau's course is built around misconceptions. It gives you a correct mental model first, then the API. We borrowed:
- the idea that "every re-render starts with a state change" (Why React Re-Renders);
- his checklist of common beginner mistakes, which appear here as
Pitfallboxes; - his "client boundary" explanation of Server Components for Day 7.
Its FAQ says the course does not cover the React 19 Actions APIs. Day 6 here covers them.
Epic React: learning by doing
Kent C. Dodds' workshops are a strict loop: short exercise, then solution, then extra credit. That's why every lesson here has a Try it challenge with a hidden solution. His React Suspense workshop goes data fetching → cached promises → optimistic UI. Day 6 follows the same order.
Full Stack Open: one app that keeps growing
Helsinki's free course builds one app in many small steps, keeps the console open, and treats testing and server state as core topics. Our Reading List project follows the same model. Its 2026 update teaches TanStack Query + Context for server and client state, and Vitest + Testing Library for tests. This course uses the same stack.
TkDodo: server state is not client state
React Query's maintainer argues that data from a server is a snapshot you borrow, not state you own. It belongs in a cache, so you shouldn't copy it into useState (React Query as a State Manager). That idea is why Day 4 teaches useEffect fetching mainly so you understand how it works, and Day 5 switches to TanStack Query for real apps.
patterns.dev and roadmap.sh: the map
patterns.dev gives a 2026 reference stack: Vite or Next.js, React Router, TanStack Query, Vitest with Testing Library, and Playwright. It also explains how the rendering strategies relate, which sets up Day 7. roadmap.sh/react served as a coverage checklist. Its many alternatives (MobX, Formik, Relay and others) are left out on purpose, because one good tool per job is easier to learn.
Why the days are in this order
Every source agrees on this sequence:
JavaScript first. Full Stack Open and Epic React both start with plain JS, so Day 1 starts there too.
Components → JSX → props → lists & conditionals, all before state (Day 2).
Events → state → forms → lifting state, tied together by Thinking in React (Days 3–4).
Effects and refs after state, framed as escape hatches. Custom hooks come after effects (Day 4).
Context and reducers as the fix for prop drilling, and a library for server data instead of hand-written effects (Day 5).
Suspense, Actions and the newest APIs, then testing (Day 6), and finally Server Components and full-stack (Day 7).
The sources disagree on a few points. Here is how this course handles each one:
- JSX directly, or
createElementfirst? We start with JSX, as react.dev does. A short Deep Dive on Day 1 shows that JSX compiles to function calls, which is the point Epic React makes withcreateElement. - When to start fetching data? We wait until Day 4, after state and effects, and keep it brief. Then Day 5 switches to TanStack Query.
- React 19 Actions: no single non-official source covers 19.0–19.3 from start to finish. Day 6 is built from the react.dev reference pages and the 19.3 release post.
Facts we verified
- React 19.3 (released 2026-09-09) made
<ViewTransition>and Fragment refs stable and addedaddTransitionTypeanduse(browser())(release post). - React 19.2 (released 2025-10-01) added
<Activity>anduseEffectEvent(release post). - React 19.0 (released 2024-12-05) added Actions,
useActionState,useOptimistic,use,refas a prop, and<Context>as a provider (release post). - React Compiler 1.0 is stable (released 2025-10-07), and Next.js 16 moved
reactCompilerout of experimental (compiler post, Next.js docs). - React still has no function-component error boundary; the docs point to
react-error-boundary. - Server Components had security advisories in December 2025. Always build on current, patched versions.