Learn
From your first line of code to an evidence-based explanation of a real system.
0 of 28 completed
Where to start
Nothing is locked. Pick the closest fit.
How it works
- 23 lessons, 4 checkpoints and a capstone, about 8 hours in all. You need only a browser.
- Each lesson has a worked example, practice and an exit check. You select answers; nothing runs code.
- A correct exit check completes a lesson. Showing the answer doesn't, but you can still check afterwards.

Group 1: Read a small program
Values, branches, loops, calls, collections and failure paths, traced by hand.
0 of 7 completed
Module 1: Values and control flow
Follow a value through assignments, branches and loops.
- L01 Values and assignmentsStart hereRead literals, names, expressions and assignments, and say what a variable holds after a given line.12 min
- L02 Branches and comparisonsEvaluate a comparison and say which branch of an
ifruns, including exactly at the cutoff.14 min - L03 Loops and running stateBuild a small trace table that follows an accumulator through every iteration of a loop.16 min
Module 2: Functions and data
Calls and returns, shared collections, and the difference between a type and a check.
- L04 Calls and returnsName the caller, callee, argument, parameter and return value in a nested call.15 min
- L05 Collections and mutationRead an array index or object key, and predict whether a change shows through two names.16 min
- L06 Types and failure pathsTell a TypeScript annotation from a runtime check, and a returned failure from a thrown error.19 min

Group 2: Navigate a repository
Find the right file, follow a name to its definition, and trace calls across files.
0 of 7 completed
Module 3: Evidence and navigation
Repository maps, pinned snapshots, symbol navigation, tests and defaults.
- L07 Repository maps and snapshotsPick the right starting files in an unfamiliar repository, and say why the exact commit matters.15 min
- L08 Search and symbol navigationTell a definition from a use and a re-export, and follow a public name to its implementation.17 min
- L09 Tests and configurationRead a test's setup, action and assertion, and tell an explicit option from its default.17 min
Module 4: Tracing across files
Call chains with a stop rule, callbacks and async order, and dispatch.
- L10 Call chains and trace boundariesProduce an ordered trace between a given start and stop, following the branch the input takes.18 min
- L11 Callbacks and async orderTell registering a callback from calling it, and predict the order of events around an
await.20 min - L12 Interfaces and dispatchFind the declared contract, the selection rule and the concrete implementation for one configuration.19 min

Group 3: Follow a web request
Routing, middleware, validation, clients, retries and the line between identity and permission.
0 of 7 completed
Module 5: Inside the server
How a request reaches a handler, what wraps it, and where input is checked.
- L13 HTTP and routingRead a request's method, path and query, and pick the handler a router chooses under stated rules.18 min
- L14 Middleware and error pathsTrace the way in and back out through a middleware chain, and what a short circuit skips.20 min
- L15 Input validation and dependenciesSeparate parsing, validation, dependency resolution and the handler's own work.21 min
Module 6: Across a network boundary
Redirects, timeouts, retries, and the checks that guard a resource.
- L16 Clients and redirectsSeparate preparing a request from sending it, and trace a redirect under a stated policy.19 min
- L17 Timeouts and retriesWork out a bounded retry schedule, and decide when it's unsafe to retry an operation.21 min
- L18 Authentication and authorizationFind the evidence for who is asking, and separately the evidence that they're allowed.21 min

Group 4: Reason about systems
State, reactivity, streams, caches and compilers, ending in an investigation of your own.
0 of 7 completed
Module 7: State and events
Reducers, reactive dependencies, and streams with subscriptions.
- L19 Actions and reducersPredict a state transition from an action, and know where to look for side effects.20 min
- L20 Reactive dependenciesPredict which changes make an effect run again under a stated tracking model.22 min
- L21 Streams and subscriptionsFollow values through stream operators, and say what completion and unsubscribing stop.22 min
Module 8: Mechanisms and trade-offs
Caches, parsers and code generators, then the capstone investigation.
- L22 Caches and storageTell a cache's key, freshness, invalidation and eviction apart, and reason about a mechanism's cost.24 min
- L23 Parsing and code generationName the parser, transform and generator by what each stage takes in and gives out.24 min
- C4 State and freshnessCheckpointCompare a state transition, a reactive dependency and a cache expiry, and why each can matter.12 min
- L24 Codebase investigation capstoneCapstoneInvestigate an unfamiliar code path, and back a design claim with an input, a call sequence and a line.30 min