Episode Details

1. Jules May on Extreme Reliability and Writing Software That Never Fails

In this episode of the Leanpub Podcast, Len Epp interviews Jules May, freelance consultant and author of Extreme Reliability: Programming like your life depends on it. Jules specialises in safety-critical systems, mathematical software, and compilers, and has spent nearly fifty years in the industry. The conversation ranges from the early days of aviation software to the philosophical underpinnings of reliable code, and wraps up with a candid discussion of Jules’s writing process and his decision to publish on Leanpub.

1.1 From Aviation to a Career in Reliability

Jules began his career in the early 1980s working on software systems for aircraft, at a time when the industry was attempting to apply formal mathematical proofs to both hardware and software. He explains that although full proof of correctness turned out to be impractical for the complexity of real systems, the discipline instilled in him a deep commitment to reliability — one he has since carried into medical instrumentation, automotive systems, and enterprise software.

1.2 Why Planes Don’t Crash Because of Software

One of the most striking claims in Jules’s book is that no passenger has ever been killed by a software fault in aviation. He addresses the widely misunderstood Boeing 737 MAX disasters in detail, explaining that the MCAS stall-prevention software was doing exactly what it was designed to do. The crashes resulted from a combination of deferred maintenance on faulty angle-of-attack sensors, inadequate pilot training, a failure by Boeing to inform crews that the new system existed, and — in at least one case — cockpit communication culture that prevented a co-pilot from overriding a captain’s incorrect response. The software, Jules argues, was not the culprit.

1.3 Why Software Is So Brittle

Jules argues that mainstream software development actively engineers fragility into systems. Error-handling patterns — from legacy error codes to modern exception throwing — cause programs to abandon their execution context the moment something goes wrong, amplifying small failures into catastrophic ones. He contrasts this with well-designed physical systems such as aircraft and boats, which are built to be intrinsically stable: they can absorb disturbances and return to safe behaviour without human intervention. The goal, he says, is not perfection but stability — software that keeps working even when the environment misbehaves.

1.4 Reliability Techniques in Practice

As a concrete example of a reliability technique, Jules explains the Null Object pattern. Rather than scattering null checks throughout a codebase — which programmers routinely forget — a null object exposes the full interface of its type but delivers no information. Programs can be prototyped entirely with null objects, and when real values are substituted, correct behaviour follows naturally. This is one of many techniques Jules covers in the book for eliminating, rather than merely reducing, bugs.

1.5 The Dark Ages of Software

In a chapter on what good code looks like, Jules draws an extended analogy between the post-Roman “Dark Ages” and the current state of software culture. Just as the early medieval period is obscure to us not because it was unpleasant but because its artefacts were not preserved, software lacks a transmitted canon. NASA has had to appeal for working 8-inch floppy disk drives to recover old data; a BBC millennium project produced optical disks that no device could read before the project was even finished. Jules argues that the industry reinvents its values every generation because it has no heroes, no canon, and no culture of reading code for pleasure the way musicians listen to music or architects study buildings.

1.6 Writing the Book

Jules credits a decade writing a monthly column for the British programming magazine .exe as the foundation of his writing craft. When it came time to write Extreme Reliability, a weekly train commute between Scotland and London gave him six uninterrupted hours each week to write without distraction. He composed in LaTeX, which he found indispensable for taking a bird’s-eye view and rearranging arguments — eventually cutting the manuscript roughly in half when he realised he had been writing two books simultaneously. He used Claude to generate a first-pass index, which he then refined, describing it as a good example of appropriate AI assistance.

1.7 Why Leanpub

After exploring traditional publishing, Jules found that every meaningful conversation with a publisher came only through personal introduction, and that publishers offered uniform style constraints, no promotional support, and royalties amounting to roughly 50 pence per copy on an expected lifetime sale of 3,000 copies. Within five years on Leanpub he had already earned more than the projected lifetime return from a traditional deal. He notes that the primary trade-off is that the author must do all production work independently — “it only takes five months to make a baby” — but considers the creative freedom and financial return well worth it.

Visit Jules’s website at julesmay.co.uk and find the book at leanpub.com/extremereliability.

This interview was recorded on [interview-date].

The full audio for the interview is here: https://s3.amazonaws.com/leanpub_podcasts/video1488727298-edited.mp3. The Leanpub Podcast is available on our YouTube channel at https://www.youtube.com/leanpub, in Apple Podcasts here https://podcasts.apple.com/ca/podcast/Leanpub/id517117137, and almost everywhere else people listen to podcasts.

About the Book

Amid the chaos of real-world software development, programmers often express regret for the mess they’ve made, and hope for a better world. After half a century of developing software, we all agree about the principles that good development practice should follow. And yet our code is still a mess. Surely, software can be developed better than this?

We just accept that software is inherently flawed, that all software contains bugs like original sin, and we design our processes around that. But what if it were possible to write software correctly? What if we could create bug-free, maintainable code? And what if it were cheaper, faster and easier to write correct code than to write the buggy variety? What then?

It turns out that it is possible to write code that behaves perfectly, all the time. In fact, perfectly-behaving code is not uncommon – we have been entrusting our lives to it for decades. What do they do, these perfect programmers, that the rest of us don’t? What research backs up their practices? Can we all do what they do?

The message in this book is: yes, there really are techniques and methodologies which will deliver perfectly-functioning software at industrial scale. Tucked away in unregarded corners of our industry, there are developers turning out high-quality software in a scalable fashion. Presented here is: this is how other great programmers have understood (and solved) their reliability problems, and this is what we can learn from them.

This book is for developers and technical leads who want to eliminate not just 95% of their bugs, but all of them. For developers who want to delver flawless software, faster.

About the Author

Jules is a freelance consultant specialising in safety-critical systems, mathematical software, and compilers and languages. He has been writing, teaching and speaking for 25 years, and conducts frequent lectures and workshops. He is the author of Extreme Reliability: Programming like your life depends on it, and is the originator of Problem Space Analysis.

Author website at julesmay.co.uk

Follow the author here!

Leanpub Book LAUNCH 🚀 Extreme Reliability: Programming like your life depends on it by Jules May

Watch Clips From The Video