Lessons

Most catastrophic structural failures happen far below yield strength, because a crack was already there. This lesson builds the fracture mechanics that predicts the largest crack a part can carry, shows why raising strength shrinks that number, and works through the two disasters that turned fatigue from a curiosity into a design discipline.

A dislocation is a line of atomic misfit that lets a crystal slip a few bonds at a time, and its mobility decides whether a material bends or breaks. This lesson explains how it moves, why some crystal structures permit it and others do not, and the four standard ways engineers obstruct it to buy strength at the price of ductility.

A perfect copper crystal should yield at about 7 GPa. Real annealed copper gives way at 10 MPa, hundreds of times lower, and the gap took thirty years to explain. This lesson separates stiffness from strength from toughness, works the theoretical calculation, and shows why the answer turned out to be defects rather than arithmetic.

Quadratics, cubics and quartics all have formulas in radicals. The general fifth-degree equation has none, and not because nobody clever enough has tried. This lesson explains how permuting the roots turns an algebra question into a group question, and why the answer changes at degree five when a group of order 60 refuses to break down.

Group theory earns its keep when a symmetry argument settles a physical question no calculation was going to answer. This lesson covers group actions and counting up to symmetry, why crystals cannot have five-fold rotation and what happened when one did, Noether's link between symmetry and conservation, and how the same idea is built into modern networks.

Cosets cut a group into equal-sized blocks, and one counting argument then forces every subgroup's size to divide the group's. This lesson proves that, derives Fermat's little theorem from it as a corollary, and introduces the maps that let you compare two groups and say precisely when they are the same object.

A group is a set with one operation obeying four rules, and that deliberate poverty is the point: anything proved about groups holds for rotations, permutations, integers, XOR and Rubik's cube at once. This lesson builds the definition from symmetry, works through the symmetries of a square, and shows where groups already sit in code.

Wrap the number line into a circle and addition and multiplication survive intact while division mostly does not. This lesson builds congruences, shows why you can reduce early to avoid overflow, works through Euclid's algorithm and modular inverses, and explains how a million-digit exponent becomes twenty multiplications.

A graph is two sets and an incidence relation, and that austerity is why the same object models build dependencies, social networks, register allocation and road maps. This lesson covers the structural properties worth knowing, the special families that make hard problems easy, and the line where a small change to a question makes it intractable.

Testing checks the cases you thought of; a proof covers all of them at once, including the ones nobody will ever run. This lesson builds direct proof, contradiction and induction as working tools, shows the two ways induction fails, and connects it to the loop invariants that make a program correct rather than merely untested.

Combinatorics answers how many arrangements exist without producing any of them, which is what makes password strength, hash collisions and search-space size computable at all. This lesson builds the product rule, permutations, combinations, inclusion-exclusion and the pigeonhole principle, then applies them to problems where intuition is reliably wrong.

A spectrum shows you artefacts of the analysis alongside the signal, and telling them apart is a learnable skill. This lesson covers spectral leakage, what windows buy and what they cost, why zero-padding does not add resolution, and the hard trade a spectrogram forces between knowing when and knowing what.

A filter is fully described by what it does to a single impulse, and applying it is a convolution. This lesson builds that idea, shows why the frequency domain turns convolution into plain multiplication, and works through the trade-offs that make real filters ring, lag, or cost more than they need to.

Turning a continuous signal into numbers is safe only above a specific rate, and below it the damage is silent and permanent. This lesson derives the Nyquist limit, shows exactly where a too-high frequency reappears, and explains why the fix has to be analogue and has to happen before the converter.

The same signal can be written as a function of time or as a recipe of frequencies. This lesson explains why sinusoids in particular get that job, builds the discrete Fourier transform, and shows how the FFT turned a quadratic computation into one you can run on a million samples in a fraction of a second.

Frameworks do not differentiate formulas symbolically or estimate derivatives numerically. They differentiate the program. This lesson builds forward mode from dual numbers and reverse mode from the backward sweep, shows why a full gradient costs about four function evaluations at any size, and where the answer is not what you meant.

A deep network is a composition, so its derivative is a product of Jacobians. This lesson builds the chain rule from one variable up to matrix form, shows that the order you multiply that product in changes the cost tenfold, and explains vanishing gradients as an arithmetic consequence rather than a mystery.

One derivative becomes three objects once a function has many inputs and many outputs. This lesson builds the gradient, the Jacobian and the Hessian, shows what each one actually tells you, and explains why curvature decides how many steps an optimiser needs and why nobody ever writes the Hessian down.

Machine learning uses the derivative as a search strategy, not a symbolic exercise. This lesson builds it as the best local linear approximation, derives the gradient descent update from it, and shows why estimating derivatives numerically loses half your digits and costs one function evaluation per parameter.

A benchmark is an experiment, and most are badly designed enough to produce confident wrong answers. This lesson covers what a measurement must control to mean anything, the ways microbenchmarks lie including code the compiler deletes, how to catch regressions in continuous integration despite noisy machines, and how to recognise the point where optimising stops paying.

Slow software is slow for a short list of reasons, and each one has a signature you can recognise before you find the code. This lesson covers the six recurring bottleneck classes, waiting on I/O, chatty queries, allocation pressure, lock contention, memory access patterns and serialisation, with the symptom that identifies each and the fix that actually works.

A profiler is not a neutral observer: sampling and instrumentation see different things, distort the program in different ways, and answer different questions. This lesson covers how each works, why CPU time and wall-clock time give opposite answers, and how to read a flame graph correctly, including the axis that means nothing and is misread constantly.

Most optimisation effort is spent on code that was never the problem, and the reason is that intuition about where time goes is reliably wrong. This lesson covers why guessing fails, the arithmetic that caps what any optimisation can buy, the difference between latency and throughput, and how to set a target that tells you when to stop.

A canary release sends a slice of real traffic to a new version and asks whether it is healthy. This lesson covers what to measure, why comparing the canary against the current version beats comparing against history, the statistics problem that makes small canaries weak evidence, and how automated promotion and rollback turn a judgement call into a rule.