Application testing is an integral part of software development. Yet, there are still instances where the need for testing systems is questioned. Can a developer test an application then? Yes, they can. Would that be a good idea, though? Definitely yes. Does testing the system by developers suffice? There is a short and simple answer to this question: no, it’s not enough. Why? Michał Zaczyński, our software testing expert, shares his thoughts on it.
Humans, by nature, are incapable of objectively evaluating their work, and when time constraints add to this, an evaluation often ends up being superficial. The same thing can happen when developers test their own code. Typically, they focus primarily on an application’s main, most significant, and most positive paths while leaving out what happens if something gets wrong. The reason this approach is usually taken doesn’t stem from a lack of knowledge or willingness to test; in fact, I wouldn’t even dare to suggest that. In most cases, this is due to a lack of time to think deeply about potential problems and sentimentality about the code itself. Testers in task-dedicated roles have no connection to the application under test, and the goals they are charged with are quite different from those of developers. The tester’s job is to verify that the application works correctly, and they are relentless in their search for every detail that affects performance. Despite the sincerity of the programmer behind the work, they may not be entirely objective.
There is little understanding of techniques such as pair-wise testing, decision tables, and classification trees and how they work among developers. No surprise there! Ultimately, these are not application development issues but application testing ones. There is far more to it than just crossing over an application; it is a process requiring particular knowledge and experience, as well as the implementation of appropriate techniques, whether formal or informal. Software testing is a full-fledged specialization within the IT industry. To test the increasing complexity of systems being developed, one needs extensive knowledge in the area, which must be continuously supplemented on top of that. Our testers are certified by ISTQB, an organization that sets the highest standards in software testing. Solwit has been its Platinum Partner for almost twelve years as one of two companies in Poland.
Roles between testers and developers are not solely based on their knowledge. They each belong to a different software development stage, meaning neither is better nor worse. Cooperation is vital; even the best-prepared application can only stand with it.
For instance, during requirements gathering, when the developer is responsible for preparing the architecture, the tester should assess whether verifying the correct implementation of each task will be possible. As the developer implements the next steps of the application, the tester checks its quality by testing the completed modules. At the end of the development process, the tester must often confirm whether the application is ready for release. While they may not have the final say, their experience, and opinion often significantly impact whether the system under test is given the green light.
The myths surrounding developer-tester collaboration are numerous. Luckily, most of those stories fall within the realm of fairy tales. Creating close-knit, interdisciplinary teams is what we do every day because we understand that a working, tested application relies on an array of competencies.
Last but not least, there is the financial aspect. Although the IT market shows that testers and developers are equalizing, a tester still costs less per hour than a developer. This should serve as the ultimate argument, especially for decision-makers, that developers should use 100 percent of their time on application development tasks and leave testing to testers. Having this handled by specialists will ensure optimal results and save you money.
One more thing…Though fitting it into any of the above categories may be difficult. However, I find it highly significant, if not the most important. Developers (mostly, but not always!) are not very fond of testing, so if you assign this task to them, they will perform it cursorily and may even become frustrated, resulting in a change of jobs. Bearing in mind the well-being of the development team and the preceding factors, it is worth handing over software testing to specialists who will ensure the quality of the application produced.