Today, almost everything works because of the software inside it. And yet, software contains bugs. No matter how carefully we write our code, no matter how thoroughly we test it, sooner or later it will break. If our software doesn't perform reliably, neither can anything else.

Why is it so difficult to create reliable programs? In contrast to nearly every other engineering discipline (which routinely use techniques such as self-stability, fail-safety, and feedback to build robust and resilient systems) software amplifies disturbances, and so builds systems which are inherently brittle. It doesn’t matter how thoroughly we error-check results or how carefully we catch exceptions, sooner or later a disturbance will start a crack in the code, which can spread to the whole system. That’s why we have to switch it off and switch it on again.

it doesn't have to be this way. We can write intrinsically stable software which uses the lessons from 5000 years of engineering practice. We can make code that consistently and provably behaves perfectly, even when it is impacted by stressors from outside and defects from within. The people who build the software to which we entrust our lives: this is how they do it. And it turns out, once you know the secret, it costs much less money and takes far less time to build code that works perfectly than it does to wrestle with the buggy variety.

In this talk, Jules explains the fundamental difference between software and other kinds of engineering. He explores some of the anti-patterns that we believe will strengthen our code but which (in fact) make matters worse, and introduces a paradigm for creating code which is robust and reliable even in the presence of errors.

This is the key to flawless software, delivered faster.