Lessons

The two renderer architectures are not competing implementations of the same idea. One sorts fragments for a single viewpoint, the other searches for a hit along an arbitrary ray. Reading them that way explains which effects are cheap in each, why production renderers combine them, and what a hybrid actually buys.

Ray tracing takes the opposite loop: for each pixel, find the geometry it hits. That buys visibility queries from any point in any direction, which is what shadows and reflections need. It also costs a scene-wide data structure, and the quality of that structure decides whether the renderer is usable.

Rasterisation walks the geometry and asks which pixels each triangle covers. Two ideas make that fast enough for real time: a coverage test that is three linear functions, and a depth buffer that resolves visibility without sorting anything. This lesson builds both and shows why the design maps onto parallel hardware.

Every renderer answers one question first: at this pixel, which surface is visible? Getting there means moving geometry through five coordinate spaces. This lesson builds that chain, explains why a fourth coordinate is not a trick, and shows where depth precision quietly goes wrong.

Rice's theorem closes every interesting question a type checker, linter or verifier wants to answer, yet those tools exist and work. They work by choosing which way to be wrong. This lesson covers the sound and unsound bargains, the provable approximation in pointer analysis, and the option of leaving Turing completeness behind on purpose.

Once memory stops being the constraint, a different kind of limit appears. No program can decide whether an arbitrary program halts, and the proof fits in eight lines. This lesson builds that argument, separates deciding from merely recognising, and shows how one impossibility result propagates to every other question worth asking.

Finite memory fails on anything that must be counted, so add memory and watch what each purchase buys. A stack buys nesting and nothing more. An unbounded tape buys everything, and two entirely different formalisms invented in the same year turn out to buy exactly the same thing.

A machine with a fixed number of states can recognise a surprising amount, and then hits a wall that no amount of cleverness moves. This lesson builds the finite automaton, shows that regular expressions are the same thing in different notation, and proves by counting that balanced parentheses are out of reach.

A procedure for deciding between greedy, dynamic programming, and neither. Write the recurrence, count the states, attempt the greedy proof, and read the failure. Includes the instance where greedy is optimal and off by a third depending on one word in the problem statement.

A greedy algorithm is three lines of code and a proof. This lesson covers the proof techniques that make it an algorithm rather than a heuristic: the exchange argument, greedy-stays-ahead, Huffman's merge, and the matroid theorem that says exactly when greedy is guaranteed.

Writing a dynamic program is three decisions, not a recurrence to memorise. This lesson works through choosing the state, deriving the running time from it, fixing the evaluation order, recovering the answer rather than its value, and why an O(nW) knapsack is not polynomial.

Dynamic programming and greedy algorithms both rest on a structural property the problem either has or does not have. This lesson establishes it precisely, shows a problem that lacks it, and separates the three properties that decide which technique applies.

The edge that survives statistics still has to survive trading. Spread, market impact and the square-root law, why every strategy has a capital ceiling, and the research protocol that makes a backtest worth believing.

The statistical core of backtest overfitting: why the best of many trials is inflated even when nothing works, how much to discount it, and why finance needs a far higher significance bar than the usual one.

Look-ahead bias, survivorship bias, and point-in-time data. The errors that make a backtest wrong as a simulation, independent of any statistical question about whether the edge is real.

A backtest is not a measurement of the past, it is a counterfactual about a world that never happened. Getting precise about that claim explains every way backtests mislead.

Why prediction systems fail when deployed, how invariance across environments becomes a training signal, and where causal reasoning enters bandits, reinforcement learning, and language models.

If the graph is an assumption, can you learn it from data instead? Conditional independence testing, the equivalence classes that limit what is knowable, and what changes when unmeasured confounders are allowed.

The central question of causal inference has a precise answer. The backdoor criterion, the front-door criterion, instrumental variables, and what to do when no identification strategy exists.

The formal machinery that makes causal questions answerable: structural causal models, graphs as assumptions you can inspect, the three ways variables become associated, and why prediction and intervention are different problems.

Where the pure feedforward story breaks: sensory entrainment, dynamic movement primitives for non-rhythmic motion, how CPGs combine with reinforcement learning in current legged robots, and the exoskeleton applications.

The experiment that put a spinal cord model in an amphibious machine: how one drive signal switches a robot from swimming to walking, and what that says about how vertebrate locomotion evolved.

How a handful of phase oscillators produce coordinated gaits: limit cycles and why they resist disturbance, phase coupling that locks oscillators into fixed relationships, and the travelling waves that swim a robot.

Walking is rhythmic, fast, and must survive disturbances no planner anticipated. The biological answer is a spinal circuit that generates rhythm without the brain, and it suggests a fundamentally different control architecture.