Skip to content

By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.

The Pragmatic EngineerThe Pragmatic Engineer

Software correctness and programming languages with Sean Allen

We do not mention "AI" a single time - even though this happens to be a deep conversation on the biggest challenges of developing with AI.

Gergely OroszhostSean Allenguest
Nov 10, 20261h 25mWatch on YouTube

Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.

Great conversations run long. Their best ideas don't have to.

uListen is free on iPhone, iPad, Android, Chrome, and Claude.

See how

At a glance

WHAT IT’S REALLY ABOUT

Correctness over testing: languages, workloads, and limits of assurance

  1. Sean Allen frames software correctness as upholding expected behavior and invariants, while noting teams often know failure states better than success criteria.
  2. He argues that testing is a means to verify what static techniques can’t enforce, and that stronger type systems and modeling can prevent many bugs before tests exist.
  3. He explains how ML-family language features like sum types and exhaustive pattern matching let compilers surface missing cases across a codebase, changing how refactors and correctness feel.
  4. He describes workloads as a critical missing piece in many testing strategies, using examples like key-value store operation distributions and the “bank test” for transactional isolation under faults.
  5. He discusses supply chain security and side-channel attacks, claiming today’s dependency and CPU performance trade-offs make fully reliable defenses difficult, and that “quality gates” can increase assurance but never guarantee quality.

IDEAS WORTH REMEMBERING

5 ideas

Correctness should be built in before “testing” starts.

He argues that most testing happens late in the lifecycle and can’t fully guarantee correctness, so teams should instead try to prevent whole classes of bugs through language choice, static checks, and design that encodes invariants.

ML-style type systems can turn many runtime failures into compile-time guidance.

He highlights sum types plus pattern matching and exhaustive matching as enabling a workflow where adding a new case forces the compiler to point out every place that needs updating, which he describes as a "gloriously wonderful" experience.

Strict compilers can be frustrating early but pay off by preventing memory-unsafe mistakes.

He describes Ada as extremely strict and designed to avoid incorrect programs, contrasting it with C compiling easily while enabling frequent crashes; he regrets not appreciating Ada’s compiler help earlier.

Pony aims for “fearless concurrency” by combining a built-in concurrency model with compiler-enforced safety.

He describes Pony as an actor-model language designed to make fast concurrent programming easier while having the compiler enforce safety rules, reducing reliance on humans remembering concurrency “rules” and still getting them wrong.

GC “slowness” is often a symptom of heap sharing and stop-the-world design, not GC itself.

He reframes garbage collection as any mechanism for reclaiming memory and explains that JVM-style shared heaps make stop-the-world pauses hard to avoid, while Pony’s approach lets actors reclaim memory independently, trading peak throughput for flatter tail latencies.

WORDS WORTH SAVING

5 quotes

I would define software correctness as my program does what I expected it to do at, at a really loose level.

— Sean Allen

None of the tools that we have are good enough to guarantee whatever it is.

— Sean Allen

It didn't really dawn on me, the fact that my C programs were segfaulting all the time and didn't really run for very long, but it was like, thank you for the cookie that it compiled, you know?

— Sean Allen

One of the worst time-wasters that I've, I've seen in my career is people not spending time to make sure that when they're talking to each other and using words, that they actually mean the same thing.

— Sean Allen

You can very much get yourself into a position where, unfortunately, before you've even found product market fit, you might have debted yourself into a corner.

— Sean Allen

Read the available transcript
Software correctness and invariantsTesting vs verification mindsetML-family type systems and exhaustive matchingAda vs C compiler strictnessF# on .NET integration and feature transfer to C#Pony, actor model, and safe concurrencyGarbage collection, tail latency, and per-actor memory management approaches

Ask ChatGPT about this episode

Get its key ideas, plus a summary of each chapter linked to that point in the video, right in your chat.

  1. Add uListen AI to ChatGPT.

  2. Paste this prompt into a new chat.

    Use uListen AI to give me this episode's key ideas and a chapter-by-chapter summary, with timestamps: https://www.youtube.com/watch?v=OrXKvOjR-vI

SPEAKERS

  • Gergely Orosz

    host

    Software engineer and author who hosts The Pragmatic Engineer podcast/newsletter, interviewing engineering leaders and experts.

  • Sean Allen

    guest

    Software correctness and programming-languages expert who has worked on reliability/security topics (e.g., Antithesis and Microsoft Research confidential computing).

High quality AI-generated summary created from speaker-labeled transcript.

Get more out of YouTube videos.

Read along on your phone, search it beside the video, or ask your favorite AI app what was said.