When developing software there’s a situation where testers should fit in, but since we are putting money on the table, we must decide how to distribute that money. Should we focus on early testing or in late testing? Are the developers more important than the testers so we can just ignore the testers and focus on making developers to test more?
A fact is that you can’t test quality in, if the software sucks, the testing won’t contribute in making it better, it only checks if it has errors in it. On the other hand, the developers are the ones responsible for the quality, they do the code and they are the ones that can stop writing the bugs. Another problem is the time; time is money, to prevent losing money we should bet on early testing. Finding a bug early is far cheaper than finding it later, the absolute quickest way to find a bug is by checking for bugs when making the code and fix them right away. Having this said, we should invest in better and more careful developers. Another aspect that favors developers is that they write the code, the source of value of the software, while the testers write test plans, which are papers that are not being used and are forgotten really fast since those aren't shipped with the product.
The developers write the code, but they concentrate on one feature of the entire project at a time, that´s because the developers must be single minded. We don’t need developers seeing the whole project, making mistakes, making the software for their own use instead of focusing on how the user is going to react to the software. On these aspects we need someone else, someone with a wider perspective that knows how the user thinks and can view the system as a whole to test the integration of all the features. This is where the tester should fit in.
The developers and testers are now in a tie, facing quality baked in, by making the developers being more careful and testing fist, versus the integration and user perspective that the testers have. How can we decide where to put the bets on? The answer can be obtained by looking at the activities performed rather than the artifacts generated, the documents are useless if not being used and facing the fact that making them wastes a lot of time, but if we focus more on the test planning that makes the testers more productive, then we have something with great value. But how can a tester inform of bugs without making the documentation? This is where tools that help to control the bugs should be implemented.
In conclusion, we should bet more in late testing since it becomes of great value once the testers focus on finding bugs with the help of a tool rather than wasting time making useless artifacts.
Gerardo Lugo V.