Software Stability: An Introduction
The life of a piece of software always starts full of optimism, hope, and vigor. Like the naive optimism of a fresh college graduate, new software suddenly face the harsh realities of the world outside controlled environments and situations. Things just don’t happen in these planned tests and experiments like they do in the real world because these tests are created by people who know what to expect. In the real world, many people will be using software in so many different ways and as such, tests shouldn’t be designed to have answers as often times they set up software to fail. In Michael Nygard’s Release It!, Nygard introduces the concept of stability and its importance in the software world.
What is software stability? Often times when we use the term stability, we refer to a system that is consistently up and running. Ideally we’d all like our systems to always be running; however, in the real world where anything can happen, that’s never the case. Knowing this, how do we define stability? According to Nygard, software stability refers not to a system’s ability to be up and running, but its ability to withstand sudden spikes in activity, stresses on the system or component failures to perform its normal processing.
Sudden impulses and persistent stress are expected throughout the life of a system, but sometimes these events can lead to disastrous failures. In either case, a component in the system will fail before everything else does. Nygard refers to these component failures as cracks, as cracks tend to spread throughout a system in various ways. The original cause of these cracks, the way the system breaks down, and the resulting damage is what Nygard calls failure mode.
No matter how hard you try to failure-proof your system, it will fail one way or another. Fooling yourself into thinking otherwise will only impede your ability and control to identify when a failure occurs and contain it as soon as possible. As developers, we must expect the unexpected accept that failures will happen. Only when we accept this harsh reality, are we able to design our system’s reactions to specific failures - safe failure modes that contain the damage and prevent this crack from propagating throughout the system. The implementations of these safe failure modes determines the resilience and stability of the system. Without these self-protecting failure modes, there is nothing keeping a crack from spreading into indispensable features of a system that are crucial and at times, even life saving. It is our responsibility to do everything we can to identify these vital components of our systems and protect them to ensure that cracks don't find these parts and cause potentially life threatening situations. In the upcoming chapters, we'll be discussing stability anti-patterns that help contain damage and preserve partial functionality of the system as opposed to taking the entire thing down.