January 8th, 2021
Snipping the top bit of Nicholas C. Zakas’s Top of the Month newsletter (go sign up!), with permission.
One of my favorite things in the world is painter’s tape (also called masking tape). It seems like something silly: some tape you put on a wall when you’re painting to avoid getting paint on the wall. The tape doesn’t have a strong adhesive, so it can be pulled back off the wall without damaging it. What I love about painter’s tape is the philosophy behind it: painting is messy, and rather than trying to avoid making a mess, painter’s tape allows you to make a mess initially and then clean it up easily. Even the best, most talented painter is going to splatter some paint here and there, get distracted, or otherwise end up with paint going where it shouldn’t. It’s a lot faster, easier, and less frustrating to use painter’s tape to cover up areas where the paint is likely to go and then remove the tape to create a nice, clean, finished area. What does this have to do with software engineering?
Painters tape is all about a concept called fault tolerance. Instead of expecting everything to go well, you instead expect that there will be mistakes. When you expect there to be mistaken, you make decisions not to avoid all mistakes but rather to easily recover when a mistake occurs. Got paint where it shouldn’t be? It doesn’t matter if that spot was covered by painter’s tape. Forgot to put on the painter’s tape? Now that mistake is a bigger deal. As software engineers, we can think the same way with the code we write.
Making your code fault-tolerant is about asking yourself the question: how will this fail? Not if it will fail, but assuming that it will fail, and in which ways will it fail?
The original post Painters Tape and Fault Tolerance.