Source control systems make it easy to reverse changes, whereas hundreds of lines of commented code create distractions and confusion (especially as the source files continue to evolve), and code that is never executed, gated by a flag that is always disabled, is a metaphorical time bomb waiting to explode, as painfully experienced by Knight Capital, for example (see "Order In the Matter of Knight Capital Americas LLC" ).Īt the risk of sounding extreme, when you consider a web service that’s expected to be available 24/7, to some extent, every new line of code written is a liability. Some might protest, "What if we need that code later?" "Why don’t we just comment the code out so we can easily add it again later?" or "Why don’t we gate the code with a flag instead of deleting it?" These are all terrible suggestions. Constantly strive to eliminate complexity in systems they onboard and for which they assume operational responsibilityīecause engineers are human beings who often form an emotional attachment to their creations, confrontations over large-scale purges of the source tree are not uncommon.Push back when accidental complexity is introduced into the systems for which they are responsible.With an eye towards minimizing accidental complexity, SRE teams should: However, if we write a web server in Java, we may introduce accidental complexity when trying to minimize the performance impact of garbage collection. For example, writing a web server entails dealing with the essential complexity of serving web pages quickly.
Essential complexity is the complexity inherent in a given situation that cannot be removed from a problem definition, whereas accidental complexity is more fluid and can be resolved with engineering effort. In the words of Google engineer Robert Muth, "Unlike a detective story, the lack of excitement, suspense, and puzzles is actually a desirable property of source code." Surprises in production are the nemeses of SRE.Īs Fred Brooks suggests in his "No Silver Bullet" essay, it is very important to consider the difference between essential complexity and accidental complexity. Unlike just about everything else in life, "boring" is actually a positive attribute when it comes to software! We don’t want our programs to be spontaneous and interesting we want them to stick to the script and predictably accomplish their business goals.
#Sample manager samplicity software
Building reliability into development allows developers to focus their attention on what we really do care about-the functionality and performance of their software and systems. As a result, once a bug surfaces, it takes less time to find and fix that bug. In fact, SRE’s experience has found that reliable processes tend to actually increase developer agility: rapid, reliable production rollouts make changes in production easier to see. At the same time, SREs ensure that this work has as little impact on developer agility as possible. SREs work to create procedures, practices, and tools that render software more reliable. Code that comes with an expiration date can be much more liberal with test coverage and release management because it will never be shipped to production or be seen by users.įor the majority of production software systems, we want a balanced mix of stability and agility. I’ve often approached an unfamiliar problem domain by conducting what I call exploratory coding-setting an explicit shelf life for whatever code I write with the understanding that I’ll need to try and fail once in order to really understand the task I need to accomplish. It sometimes makes sense to sacrifice stability for the sake of agility. In fact, a good summary of the SRE approach to managing systems is: "At the end of the day, our job is to keep agility and stability in balance in the system." 39 System Stability Versus Agility If we freeze the current user base, we’ll never have to scale the system. If the underlying hardware or libraries never change, neither of these components will introduce bugs. If we stop changing the codebase, we stop introducing bugs. 38 A software system can only be perfectly stable if it exists in a vacuum. Software systems are inherently dynamic and unstable. The price of reliability is the pursuit of the utmost simplicity.
0 kommentar(er)
