by Dan Berry
Posted by bugfinders on Thursday 08 June 2017
Posted by bugfinders on Thursday 08 June 2017
It may sound counter-intuitive to say that developers shouldn’t perform testing on the software products they produce. After all, who knows a site or app better than those who created it? Aren’t developers exactly the people who should be testing software, given that they put it together and know how it’s supposed to work?
It’s this common-sense assumption that lies behind the idea that developers should assist crowdsourced test teams with strategies like unit testing, if not take complete responsibility for testing themselves. The latter approach – having all testing, GUI and functional, carried out by developers, rather than a dedicated QA team – has been adopted by many development and digital agencies, which seems logical.
It also seems prudent in terms of costs. Full-time QA teams are expensive to maintain and, because of the intermittent nature of software testing, are often under-utilised. From this perspective, having developers perform testing as and when it’s needed makes more sense than employing testers who will always have too much downtime.
But as rational as all of this may sound, it’s not a good idea to do without professional software testers. The reason? Software is often more likely to be released with bugs when tested by developers, not less likely.
There are several contributing factors here, but one of the most important is that testing overburdens developers with workloads that are too heavy. A developer who has spent all day coding and is then required to put in a couple of hours’ testing is likely to tire quickly, lose focus and make mistakes, resulting in crucial bugs being missed.
This creates a need for post-go live fixes, which further increase workloads and make it even more likely that exhausted developers will miss bugs on other software testing projects, too. A self-defeating cycle can result, where all efforts to ensure that software works better end up making it worse.
Another contributing factor is the fact that, often, developers simply don’t have enough time to perform software testing effectively. When testing has to be fitted in around development work and completed within the standard time frame of the two or three days before a site or app goes live, it is difficult for developers to ensure good functionality by covering a broad range of web and mobile platforms.
Broad device coverage is becoming increasingly indispensable to success online. As the mobile device market continues to expand, and apps and websites are used on a wider array of Smartphones and tablets, any piece of software that has only been tested on a handful of devices runs the risk of functioning poorly for many of its users.
Compounding these issues of time and energy is the repetitive nature of software testing itself. As a website is tested on more and more devices and browsers, the individual doing the testing can quickly develop expectations as to how that site should look on the next device or browser, and these expectations can come to replace the perception of what’s actually there, leading to bugs being missed.
For this reason, and generally speaking, a single individual should not test the same website on more than 2 different browsers or devices, in order to remain effective. This principle, however, can be hard to put into practice when a handful of developers need to try to test software on multiple platforms, as quickly as possible.
In fact, developers are at a further disadvantage here precisely because they know the software they produce so well. An intimate knowledge of the functionality and design of sites and apps can lead to developers having stronger pre-conceived notions of what to expect when testing than professional testers, making it even more likely that obscure bugs will be overlooked.
In addition to these all of these pressures and constraints, there’s the crucial fact that software testing, as a discipline, requires a very specific set of skills, many of which are not necessarily shared with the practice of software development.
From effectively dividing up a piece of software for unit testing, to writing test scripts, deciding which aspects of a site would benefit from exploratory testing, and collating and acting on the results of successive test cycles, professional software testers structure their work in many different ways to ensure that software is exposed to the greatest amount of scrutiny possible.
Although developers may achieve a certain amount of success with a largely exploratory approach to testing their software, there can be no substitute for highly-structured testing that utilises years of professional knowledge and expertise.
In light of these drawbacks and complications, the strategy of having developers perform testing looks short-sighted and counter-productive. Not only does it often result in bugs on apps and websites escaping into the live environment and damaging user experience, rather than the elimination of those bugs, it also degrades developers’ well-being and the quality of their work.
As well as putting exhausted developers into a self-defeating cycle of ineffective testing and post-go live fixes, having them test software can also harm their creativity and attention to detail while developing. This can pose a significant threat to the long-term vitality of development and digital agencies, which need to invest in working with professional software testers to safeguard the quality of their output.
Recognising that such professional software testing is not a relatively unimportant, extra task that can be assigned to developers, but an essential component in the production of outstanding software, will thus enable agencies to keep their service levels high, not to mention their developers’ energy and enthusiasm levels, too.
BugFinders is a worldwide leading crowdsourced software testing company.