CharlieKey takeaways from your favorite podcasts
← 10 November 2026The Pragmatic Engineer

Software correctness and programming languages with Sean Allen

Sean argues that software correctness should be built in from the start through strong type systems, models and workload-driven testing, not checked at late quality gates, and that pragmatism about debt and speed matters.

Watch on YouTube ↗

Charlie's summary

  1. Exhaustive matching in ML-style languages lets the compiler find every place a change breaks

    Sean explains that ML-family languages (OCaml, F#, and much of Rust) are built around sum types, pattern matching and exhaustive matching. Add a sixth variant to a type that had five, and the compiler lists every place that doesn't handle it. He calls this gloriously wonderful. It moves validation from runtime to compile time. Sean says F# fits .NET so seamlessly because it advanced slowly while the runtime caught up.

    ▶ 7:10
  2. Garbage collection isn't inherently slow; stop-the-world collection is what wrecks tail latency

    Sean says people confuse the symptom with the cause. Fast programs already slab- or arena-allocate and track when memory is free, so they are halfway to garbage collection. The JVM's shared memory forces stop-the-world pauses. Pony gives each actor its own heap, so an actor frees memory after some operations, with no global pause. You get flat latencies and give up a little peak throughput.

    ▶ 27:18
  3. Tests are a means to an end; correctness should be built in before testing starts

    Sean thinks of Antithesis as a correctness company, not a testing company. He says C gave him almost nothing for correctness, while Ada refused to compile programs that were memory unsafe. He wants as much as possible enforced before testing: type systems that encode allowed states and transitions, or model checkers like TLA+. Testing should cover only what static means can't enforce.

    ▶ 32:55
  4. Defeat literal-minded implementations with randomized inputs, which leads to property-based testing

    In a TDD kata, Sean played the implementer who does the simplest thing possible, hardcoding return values for each example. The only way to beat him was to randomize inputs, which is property-based testing. Partners who paired with him said they would write better tests afterward. Sean loves TDD for shaping APIs, but notes that many such tests wouldn't be needed with a stronger compiler.

    ▶ 35:59

Give your email to unlock the rest of the key points — for every episode.

Do more with Charlie

Free — sign in with your email, no password.