By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.
The Pragmatic EngineerSoftware correctness and programming languages with Sean Allen
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 howCHAPTERS
Jump to publisher timestampsChapter summaries
Shared “SenseNet” origin story and setting up the themes
The conversation opens with a surprising coincidence: both speakers’ first professional software jobs were at different companies with the same name. This leads into a welcoming setup for a wide-ranging discussion touching testing, correctness, programming languages, and engineering tradeoffs.
- •Both speakers independently started at different companies named SenseNet
- •The host frames two provocative quotes that recur later: tests as a means to an end, and technical debt only hurting if you must repay it
- •The episode context is established as a conversation about how to build software that works reliably
From music to programming: early career moves and learning by doing
Sean Allen describes initially being more focused on music, then drifting into tech after graduating college and moving to New York City. He recounts early jobs and how learning Perl became a gateway into software work, plus a formative (and intimidating) first exposure to programming through Commodore 64 machine language.
- •Sean Allen didn’t set out to enter tech; music was his main interest at first
- •He moved to New York City, struggled to find work, and got a job fixing computers
- •A friend suggested learning Perl; Sean learned it over several months, but the startup opportunity collapsed
- •As a teenager, he tried to learn programming from a Commodore 64 machine language book, which made programming feel extremely hard
- •He realized programming was something people would pay well for and decided to get good at it
Getting good at programming via community mentorship (BeOS and C++)
Sean explains how he improved by spending substantial free time learning and engaging with developer communities. He highlights BeOS as a major interest and recalls receiving guidance from experienced people on mailing lists, including a memorable exchange with someone he later learned was Neal Stephenson.
- •Sean Allen invested a lot of free time into improving his programming skills
- •He got deeply interested in BeOS and learned from people in that community
- •The head of a compiler group (at Metrowerks) helped him learn C++ via a mailing list
- •He also received advice from a helpful mailing-list participant who turned out to be Neal Stephenson
- •These interactions stood out as formative mentorship moments
Joining Antithesis and the “Red Team” as an internal customer
Sean describes joining Antithesis after being contacted by the CEO and being intrigued by the work described. He explains his role on the Red Team, which uses the product the same way customers do—sometimes intentionally avoiding internal tooling—to reflect real customer constraints and teach both customers and colleagues how to reason about software that works.
- •Sean joined after being messaged by the CEO with a link to a hiring post and a prompt about doing Jepsen-style work
- •He works on a team called the Red Team, whose mission is interpreted differently across the company
- •He frames the team as using the product like customers would, including avoiding internal-only tools
- •He’s been involved in helping agents work better with the product and in educating customers and coworkers
- •He emphasizes that “being sure software works” starts far below what most people call testing
OCaml, the ML family, and compiler-enforced correctness via exhaustive matching
The host asks about OCaml and why it’s attractive, and Sean explains its academic origins and the ML family’s focus on strong static type systems. The discussion centers on how sum types, pattern matching, and exhaustive checking allow compilers to point out every place a codebase needs updating when you expand a set of cases—shifting correctness work earlier than runtime.
- •OCaml emerged from academic work and attempts to combine functional and object-oriented features
- •Sean notes many OCaml users don’t rely much on OCaml’s object-oriented features
- •He distinguishes ML-family languages from “Algo” languages like Python, Perl, Ruby, C, and C++
- •He explains sum types and pattern matching, emphasizing exhaustive matching as the big win
- •A compiler can identify every location that doesn’t handle a newly added case, making change safer
- •Sean frames ML-like languages as pushing as much correctness checking as possible into the compiler
Ada vs C: strict guarantees, early frustration, and later appreciation for compilers
Sean recounts committing early to C (pragmatically) and Ada (as an experiment), and how Ada’s strictness prevented his programs from compiling. With hindsight, he views Ada’s refusal as a correctness feature that would have saved him from crashes, memory corruption, and data races—problems he instead learned to avoid through personal discipline in C/C++.
- •Sean settled on C and Ada early, mostly using C due to platform needs at the time
- •Ada is described as extremely strict, aimed at mission-critical domains like NASA and defense
- •He couldn’t get Ada programs to compile and found that frustrating as a beginner
- •He later recognized C programs compiling didn’t mean they were correct; they often segfaulted
- •He developed personal rules to avoid crashes but would prefer compiler-enforced correctness
- •He connects Ada-like guarantees to motivations behind languages like OCaml, F#, and Rust
F# on .NET: OCaml-like semantics with unusually seamless platform integration
Sean explains F#’s roots in Microsoft Research and its early framing as “OCaml for .NET.” He emphasizes that F#’s standout quality is how smoothly it integrates into the .NET ecosystem, and how its evolution intentionally paced itself alongside runtime capabilities; he also notes that C# has adopted many ideas over time, with sum types and exhaustive matching still a key missing semantic piece.
- •F# came from Microsoft Research and is strongly associated with Don Syme’s work
- •It began as an attempt to bring OCaml-style semantics to the .NET platform
- •The host and Sean compare .NET to Microsoft’s version of the JVM
- •Sean argues F#’s most impressive aspect is seamless interoperability with .NET, unlike rough JVM polyglot edges
- •He describes a deliberate “push and wait” evolution: F# advances, then the runtime catches up
- •Many features pioneered or popularized in F# later influenced and appeared in C#
Pony: actor-model concurrency, “illegal states” prevention, and building fast systems
Sean introduces Pony as an open-source language he works on, created by a longtime friend. He explains the context that motivated it: needing high performance and strong guarantees (especially around concurrency and not corrupting data) without requiring rare expert-level C/C++ discipline, leading to a language design that enforces many safety rules in the compiler and pairs them with an actor-model concurrency approach.
- •Pony is an open-source language Sean works on, originally created by his friend Sylvan
- •The motivation came from building high-speed data processing systems where latency and correctness mattered deeply
- •Stop-the-world garbage collection and latency spikes were a major concern for JVM-based approaches at the time
- •Sylvan evolved from building a C-based actor runtime to pursuing type-system work and creating a full language
- •Pony is described as ML-descended in some ways and sharing goals with Rust (preventing many illegal states)
- •Pony’s concurrency approach is actor-model-based and presented as a built-in, opinionated “fearless concurrency” package
Rethinking garbage collection: latency, heaps per actor, and throughput tradeoffs
Sean reframes garbage collection as “freeing memory the program no longer needs” and argues the usual “GC is slow” claim confuses symptoms with causes. He contrasts stop-the-world designs (common in earlier JVM defaults) with approaches like Pony’s, where memory management work is distributed so individual actors can reclaim memory without pausing the whole system—flattening tail latencies at some cost to peak throughput.
- •Sean defines garbage collection broadly as a mechanism for freeing unneeded memory
- •He notes performance-minded systems often avoid frequent malloc/free and instead use allocators (slabs, arenas), which already resemble GC concerns
- •He explains why JVM-style reachability across threads makes non-pausing GC hard and why concurrent collectors are impressive engineering
- •He describes Pony’s model as each actor having its own heap (a simplifying mental model) and reclaiming memory independently
- •This avoids stop-the-world pauses by doing small memory work between application operations
- •The tradeoff is flatter latency profiles with slightly reduced maximum throughput
Software correctness and why “tests are a means to an end”
Asked to define software correctness, Sean describes it as software doing what is expected, often expressed through invariants, and ideally not waking people up at night. He then argues his provocative stance: tests matter only as a mechanism when you lack earlier guarantees; he frames Antithesis less as a testing company and more as a software verification and correctness company.
- •Sean defines correctness as software doing what is expected, often framed as maintaining invariants
- •He notes teams often know when software is wrong more easily than when it’s right
- •He emphasizes correctness as an approach and mindset, not just a collection of tests
- •He explains he wrote “tests are a means to an end” because he sees the goal as verification/correctness, not tests themselves
- •Testing is positioned as a late-stage method used when earlier guarantees aren’t available
- •He contrasts C (little correctness help) with Ada and ML-like languages that can prevent whole classes of incorrectness by construction
TDD, property-based testing, and why randomness changes the game
Sean says he loves TDD for shaping good APIs, then illustrates a limitation of example-based tests using a kata format: he can “beat” tests by hardcoding outputs for the given examples. He argues that to defeat this, tests must generalize—often via randomized inputs—which naturally pushes you toward property-based testing, while also noting that stronger compilers can eliminate the need to test some categories of behavior.
- •Sean praises TDD as a strong mechanism for designing usable APIs
- •He describes a kata where one person writes tests and the other implements the simplest thing to pass them
- •He intentionally hardcodes behaviors to demonstrate how example-based tests can be gamed
- •The only reliable way to prevent this is to randomize inputs and broaden coverage
- •He connects this shift directly to property-based testing practices
- •He reiterates that some things people test could be avoided with stronger compile-time guarantees
Workloads: making property-based ideas practical for databases and distributed systems
Sean explains workloads as the combination of validation logic and the input generation that drives the system into meaningful behavior. Using a key-value store, he shows how naive random operation selection can become a “drunken walk” that fails to reach interesting states, while thoughtful workload design can push systems into edge cases like disk swapping, garbage collection, or resharding. He also describes the “bank test” workload for validating database isolation through an invariant about total money remaining constant.
- •A workload combines how you’ll validate behavior with the inputs you generate to drive the system
- •For distributed systems and databases, workloads generalize property-based testing beyond simple list-reversal examples
- •Naive random selection (equal probability of get/put/delete) may never reach deep system states
- •He describes this as a “drunken walk” that stays near the starting point
- •Good workloads deliberately push systems into interesting behaviors (e.g., reaching limits that trigger internal mechanisms)
- •He presents the bank test: transfer money between accounts while concurrently checking the total remains constant
- •He notes simple workloads can reveal serious bugs under fault injection (network faults, node failures), similar to what happens in production
Why “quality isn’t a gate”: correctness up front, and the inevitability of testing in production
Sean challenges the idea that a release process can ever truly “gate” quality, arguing that no matter how many layers you add, unknowns and holes remain. He contrasts low-functioning teams that rely on late-stage CI/staging gates with teams that design for correctness from the outset—using early modeling, early fault-driven verification, and clear definitions of what “working” means. He also disputes the claim that business logic can’t be statically enforced, though the conversation doesn’t pursue that thread deeply.
- •Sean distinguishes preferring “correctness” language over “testing” language
- •He argues an ideal would be provable specs and model checking, but most teams aren’t there
- •He lists earlier foundations for correctness: static checking in type systems and constraints from models like actor/message-passing
- •He says the belief that “after these gates, it’s quality” is misleading; everyone ends up testing in production
- •Even sophisticated tools can’t cover every real-world state (e.g., corrupted production data that generators won’t produce)
- •He contrasts slow, fragile teams relying on late gates with confident teams focusing on correctness from the start
- •He gives examples of testable invariants for complex systems (requests get responses; results correspond to the query; no cross-user leakage)
Supply chain security and the limits of today’s dependency ecosystems
The discussion shifts to supply chain security: compromising software by attacking the weakest link, including both software dependencies and hardware/firmware paths. Sean highlights the difficulty of vetting dependencies because most ecosystems grant third-party code the same power as first-party code, and he argues there’s no broadly good solution within today’s common language and package-management designs. He points to object-capability models as an interesting direction, while noting practical obstacles like escaping through FFIs.
- •Supply chain security is framed as attacking the weakest link in a widely used system
- •Sean notes it applies to both software and hardware (e.g., malicious firmware in a trusted stack)
- •He describes how compromising CI/CD or dependency pipelines can expose secrets and enable malware insertion
- •He emphasizes most language ecosystems allow downloaded packages to do “anything” (network, compute, etc.), making vetting hard
- •He argues there is no good general solution in most widely used languages today
- •He introduces object-capability ideas: actions require explicit capabilities (e.g., network access)
- •He notes practical challenges: foreign function interfaces can bypass capability constraints unless fully controlled
Side-channel attacks and confidential computing: security “modulo side channels”
Sean argues that even strong security measures can be undermined by hardware realities, especially speculative execution enabling side-channel attacks. Drawing on his work in a confidential computing group, he describes confidential computing as running software in environments where operators aren’t trusted, reducing the number of parties you must trust. However, he underscores that side-channel attacks can violate the guarantees, and fully eliminating the risk would require giving up speculative execution—at major performance cost.
- •Sean explains speculative execution as a major source of CPU speedups over decades
- •He describes side-channel attacks as exploiting speculative branches and memory effects to infer secrets
- •He says security guarantees can be violated via side channels, including extracting keys from memory
- •He references working in a confidential computing group and caveating guarantees as “modulo side-channel attacks”
- •Confidential computing aims to let software run where operators of the environment aren’t trusted
- •He explains the trust-reduction principle: trusting more parties reduces security
- •He notes mitigating speculative-execution risks can cause steep performance drops, leading to a “Whac-A-Mole” patch cycle
Technical debt: when it matters, how it’s sidestepped, and “go slow to go fast”
In the closing arc, Sean reiterates his long-held stance that technical debt only hurts if you must repay it, noting many debts are avoided through business changes, replacement systems, or strategic workarounds. He distinguishes reckless hacks from building quick, removable solutions that preserve malleability. He finishes with a philosophy of sustainable speed: aligning on meaning early, planning before coding, knowing how you’ll validate behavior, and building observability so you can move fast without constant emergencies.
- •Sean strongly reaffirms: technical debt only hurts if you have to pay it back
- •He argues many teams sidestep debt via new technology, throwing money at a workaround, or abandoning systems when needs change
- •He notes debt repayment often happens because a company was successful enough to keep scaling the system
- •He warns you can still debt yourself into a corner before product-market fit
- •He emphasizes malleable software that can adapt as context changes, sometimes by being easy to remove or replace
- •He explains “go slow to go fast” as planning, agreeing on definitions, spiking unknowns, and stopping when production incidents demand it
- •He highlights a major time-waster: teams using the same words but meaning different things (e.g., debates over “exactly once”)
- •He stresses designing from the start for knowing whether a system is working, including observability and handling gray failures
Publisher timestamps
- 0:00Intro
- 1:11Sean’s path into techRead this chapter
- 4:45Joining Antithesis
- 6:49OCaml and type systemsRead this chapter
- 12:25Ada and compiler guaranteesRead this chapter
- 14:28F# and .NETRead this chapter
- 18:26Pony and safe concurrencyRead this chapter
- 27:16Rethinking garbage collection
- 31:48Software correctnessRead this chapter
- 32:51Testing as a means to an endRead this chapter
- 35:41TDD and property-based testingRead this chapter
- 40:52Designing testing workloads
- 49:30Why quality isn’t a gate
- 57:44Testing complex systems
- 1:00:50Supply chain securityRead this chapter
- 1:09:57Side-channel attacks
- 1:11:54Confidential computingRead this chapter
- 1:14:38Rethinking technical debtRead this chapter from 1:14:39
- 1:20:14Going slow to go fastRead this chapter