Testing during the software development process is usually seen as a separate step to be completed after the code is fully written. 3Pillar’s SVP of Engineering, Jeff Nielsen, explains why it’s important for development teams to implement continuous testing practices to ensure the highest quality product.
Many people think of testing as a separate step in the software development process—something that you do after you write the code. You code and then you test. But with an agile software development approach, we are after a steady stream of defect free software. And if you are serious about that, then thinking of testing as a phase or a separate activity doesn’t work very well. You need a whole different way of thinking about building and testing software to achieve that.
To explain this different mindset, I came up with an analogy years ago that I think is helpful. That is an analogy to making a hand-dipped candle. You may have seen this or even participated in it. You take a wick and a large container of hot wax, and you repeatedly dip the wick into the wax. And at each step along the way, a little bit more of the wax adheres to that wick until after a large number of dips, you get a sizable taper candle. The reason I think this is a good analogy for agile software development is because at each step along the way you’ve got a working candle. Even after that very first dip, you’ve got an embryonic candle—a working version of the final product. Now it might not burn very long, but it actually is functional. And each additional dip after that only serves to increase the size and the capability of the candle. That is exactly the same way that agile software development works. We start by building an embryonic version—but working version—of the system that we want, and then we gradually layer on functionality a little bit at a time.
That works great as long as your approach to quality is sound. Imagine trying to make a flawless candle with this hand-dipped method. You would want to make sure to check the candle after each dip—check its roundness, check to make sure that it is still perfectly straight, even pull out your optical densitometer and check the overall consistency of the candle. That would be the best way to ensure a flawless candle at the end—to ensure a flawless candle at each step along the way.
It is exactly the same for software development. The best way to ensure a defect-free big system is to ensure that, at each step along the way, you are remaining defect-free. And that is a different approach to testing and quality assurance. That’s the approach that I call continuous testing. What that approach means is that testing is not a separate phase or separate activity or done by a separate group of people. Rather, it is an integral part of the team’s day-to-day work. For example, you’ve got developers every few minutes doing testing with automated developer tests (ideally). You’ve got testers daily looking at the stories that are in progress, the ones that are just finishing—not waiting until the stories are done, but continually testing the system from the user’s point of view. You’ve got exploratory testing happening every day, where we are checking for strange interactions of things that we just built and how they interact with other things. And then, at least once per iteration, you’ve got some sort of user acceptance testing where you are looking at fitness for purpose—whether what you built actually accomplishes the objectives.
And if you have got that kind of activity happening literally every hour and every day of your project, you can see why testing is not a phase. Testing is just part of something we do all the time. And that is how you ensure quality with an incremental, agile approach to software. It might be tempting to think, “We’ll just do a whole bunch of work and then we will test it and fix all the problems together in a batch.” It is a very tempting philosophy, but you can see why it wouldn’t work very well with candles, and it doesn’t work very well with software.