14 lectures · free to all

Lectures

The halls show what was built. These are about the arguments underneath: what the two great traditions of programming actually claim, what a type can prove, what an abstraction costs, and why a program that worked perfectly well last year has become so much harder to change.

Each one is given in the theatre, one slide at a time, and printed in full underneath — so it can be sat through or simply read. None of them tells you which side to take. Where a question is genuinely unsettled, they say so.

  1. Compiled, interpreted, and the space between7 slides

    A distinction that stopped describing anything decades ago, why it persists, and what is actually different about the machinery underneath.

  2. What a compiler actually does8 slides

    Four jobs in a row, each mechanical, none magic: text to tokens, tokens to a tree, a tree to a judgement, and a judgement to instructions.

  3. Functional programming and object orientation8 slides

    Two ways of arranging a program, what each one genuinely makes easy, and the trade-off underneath the argument that neither side can escape.

  4. The principles of object orientation7 slides

    Encapsulation, inheritance, polymorphism and SOLID, one at a time: what each actually claims, which held up, and which its own community abandoned.

  5. Types: what they can and cannot prove7 slides

    A type checker proves one thing about every possible run of your program. Knowing which proposition explains both the enthusiasm and the disappointment.

  6. Null, and the mistake its inventor apologised for8 slides

    Tony Hoare called it his billion-dollar mistake. What was actually wrong with it, what the alternatives cost, and why the fix took forty years to arrive.

  7. What abstraction costs7 slides

    Abstraction is sold as free and is not. What you buy, what you pay, and how to tell before writing it which of the two is larger.

  8. Immutability, and what it is not free of7 slides

    Values that never change buy sharing, comparison and time travel. They are not free, and it is worth knowing where they are expensive before you commit.

  9. Recursion, and why it feels like cheating8 slides

    A function that calls itself looks like an unpaid debt. What makes it terminate, what it costs on the stack, and why some problems resist any other shape.

  10. Big-O, and what it deliberately ignores8 slides

    Complexity notation throws away constants, hardware and every input you will actually see. Knowing what it discards is what makes the number useful.

  11. What regular expressions cannot match6 slides

    There is a precise boundary around what a regex can recognise. It explains the famous refusal to parse HTML, and why some patterns run forever.

  12. Concurrency is not parallelism8 slides

    One is a way of structuring a program, the other a way of executing it. Keeping them apart explains why async helps a web server and threads often do not.

  13. Errors: exceptions, values, and what each hides7 slides

    Throwing makes the happy path readable and the failure paths invisible. Returning errors as values does the opposite. Neither side has won.

  14. Why programs are hard to change7 slides

    Software is called soft because it can be edited. Why editing gets harder every year, what the mechanism is, and which of the usual remedies work.