Like I’ve mentioned before, all software has bugs when its first built. You don’t get to see them as the developers take the time to find and fix the bugs. Also you have be sure that the application has its logic right and working the way its intended to every time and in every case. Frankly, its rather embarrassing if your users are finding bugs and pointing them out to you.
This needs to be avoided at all costs. This is what testing is all about.
Testing does add an over head to the development cost but this is by far the highest ROI of all the development steps. Unfortunately this is the first to be skipped if budget is a concern.
A stitch in time ..
As with any thing else, finding and fixing bugs as soon as they are found makes the debugging process faster and more economical. More so if the bugs were found during the development rather than when all the development is done.
This allows the original developer (the guy who knows what its for) to fix it with out some one needing to spend time and get to grips with his work.
So How do we find bugs during the development? Don’t you kind of need to build it before you run it?
It was that way till some one got sick of going back and fixing stuff all the time. Software testing is, for the most part, an automated process. The program is given a set of conditions and tested to see if it works, fails, or breaks.
Hey, if it an automated process why not run that before the code is written? You write your tests conditions first – setting the boundaries of what the code is to do and then develop the code to fall in to the boundaries. This is Test First Development or Behavior Driven Development.
So every time the code is changed the tests are automatically run and the code is checked to fall within the rules.
This, when properly done, allows the code to be clean, independent and of course, free of most of the bugs.
The code is put through few more testing cycles – UI, integration, business logic, data integrity, security etc. to get any bugs we may have missed.
And lastly manual testing. this is where each aspect of every module is gone over meticulously. Every thing from misalignment in UI to bugs in logic. This is where we catch them.