Lessons

Nobody announces what an asset is worth, yet prices move toward it. The mechanism is order flow: trading is how private information becomes public price. This lesson builds Kyle's model of that process, separates the part of your impact that is permanent from the part that reverts, and explains why size costs more than depth alone predicts.

Competition should compress the bid-ask spread to nothing, and it does not. The reason is not fees or greed: a spread survives even when trading is free and the quoting participant expects zero profit. This lesson builds the adverse selection argument, then shows how to measure which part of a spread is information and which part is rent.

A market price is not published by anyone. It is the residue of a queue of resting orders and the orders that consume them. This lesson builds the limit order book and its matching rules, shows what a fill actually costs, and takes apart the assumption that an instrument has one price at all.

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.