This is the response article of ‘Developers and testers: friends or foes? Using fuzzy set theory to decide on the correct ratio of developers to testers in agile teams ‘ by GAN. Firstly, this article will briefly reveal the benefits and the limitations of the original article based on personal opinion. Secondly, it will compare the importance between programmers and test engineers. Thirdly, the required critical skills of test engineers will be elucidated. Finally, this article will justify the basic rules of the software testing progress.
Strong points and limitations of the original article
Accordingly, both developers and testers play an indispensable role in the large-scale and long-term software development. There is no doubt that fight and cooperation never stop between developers and testers in the real world. In particular, test engineers can help the programmers to find the risks or bugs, which hide behind the seemingly perfect code. Moreover, they can also prove whether the project is in the right direction or not.
However, when some serious issues appear, both the developers and the testers will shirk the responsibility. For example, if an error is found during the debugging progress, the programmers might argue that the testing is incorrect and they always say: ‘The program works well on my computer’. On the other hand, the test engineers will believe the problem lies in the code rather than in their testing process. Therefore, as GAN said, an outstanding management of developers and testers will impel the weaknesses become strengths.
In addition, one focus of the original article is ‘how to decide on the correct ratio of developers to testers on an agile team’. Unfortunately, the calculation of this ratio value is extremely difficult. Because both the company size, the complexity of the developed software and the length of the project duration will affect the testing progress. In fact, the professional capability level of testing group is much more essential than the number of testing members . The following section will describe the main testing skills.
Finally, GAN said that testers and developers will become one role in the future. This opinion is quite special, but it is absolutely correct. Every developer will easily have the testing skills owing to their familiarity. Furthermore, to hire more testers will highly increase the project budget.
Programmers v.s Test Engineers
In the real world, testing is a low-level work in software development and most developers are used to do the testing work before. As a matter of fact, if the salary is unchanged, none programmer will want to change their job to testing. For testers, some of them will agree to join in coding group, but others will not due to their terrible programming skills. Accordingly, most developers look down testers.
In the ideal situation, test engineers also have the outstanding programming skills and their work is comfortable and effortless. However, most of them cannot coding and the testing progress is extremely boring and vague. In particular, testing does not have the clear written requirements. If the testers have some confusing understanding, they have to ask the project manager or a related programmer. Nevertheless, the answers they obtain always are: ‘You do not need to discern this!’, ‘You do not need to understand that!’, ‘You only need to test it by this way!’.
Undoubtedly, this situation will cause the testing job to become useless. Moreover, the project manager and programmers have to handle and complete a lot of testing work. Such as the managers have to check whether the project is in the correct direction or not. Moreover, they need to teach the testers how to plan a useful test case, which will meet the requirements and the technical characteristics. Hence, in order to reduce the testing cost and increasing the testing efficiency, some developers will be involved in the testing progress. In fact, testing plays a pushing role in software development, it not only can rectify the direction and the defect, but also can reduce the rework risks. That is why the testers should have the following required and professional skills.
The required skills of test engineers.
Figure 1  indicates the skills that testers should have. Actually, most testers only understand the ‘test theory and method’ and realize some of the ‘business knowledge’. For other skills, their cognitive might almost be zero. That is why testers have to accept the discrimination of programmers and the company’s disregard. However, the skills that are listed in this figure might be too much. If a test engineer has all these skills, he tends to leave the testing job. Thus, the following rules can appear.
The basic rules of the software testing progress
Mainly, there are seven rules that might improve the testing efficiency and effect.
- Rule 1: The real difficulty of testing.
The complicated of software testing is not less than developing. Some testers might insist that the testing progress is to click their mouse on the completed user interface. For the highest testing, they merely need to comprehend some performance testing tools, such as LoadRunner. In fact, according to the above figure, testers at least satisfy ‘Essential skills’ and ‘Advanced skills’. If they do not have these skills, the testing cannot be smoothly performed.
- Rule 2: Rejected the second-hand requirements.
‘Second-hand requirements’ are the requirements that testers identify them from their manager, but not from the customers. It will reduce the accuracy rate and expand the tricky level of testing. The way of directly obtained first-hand demand is that all testers should be involved in the requirements analyzing.
- Rule 3: Rejected be involved in the project in midway.
Numerous projects will arrange the testing members at the late stage, and these testers might be responsible for another project testing at the same time. Undoubtedly, testers must join in the whole project life cycle, namely, each project should at least have a ‘complete’ test engineer.
- Rule 4: Testing decides whether the defect exists or not.
During the testing progress, if a tester finds a defect that is not recognized by developers, the following situations might occur.
- Owing to the poor experience and limited knowledge, the tester will be convinced by the programmer and agree that the project is completely perfect.
- The project manager will deliver the final decision. However, most managers used to be the developers before, so finally the defect might not be recognized.
- Customers will give the final decision.
- According to the majority rule. Testing members are certainly in the minority part of the group, so that the defect will not be accepted.
In fact, the testers should make this decision. Because their opinions are closer to customers and they require the responsibility and power of making a correct judgment, which can enhance their working enthusiasm. Moreover, hiding defect is equal to a time bomb is buried in the project.
- Rule 5: Daily testing
Every tester should install the software development tool on their own computers. They need to acquire the developed code every day and process the compilation. Namely, this is the front work of the final testing. It will avoid the terrible situation that all the dilemmas appear just before the project delivery .
- Rule 6: Do not need to write the exhaustive test cases.
The common and simple work does not need the documentation. Only the complex, error-prone and intricate contents require the response test cases. Furthermore, the job of test case description is to point out the key testing process rather than including every step in details. When the condition is mature, the company may gradually establish a test case library, which allows the testers to learn and use.
- Rule 7: The available resources between testing and developing.
If both the programmers and the testers can understand the work of each other, the project cost might reduce and the development progress will become more efficient . Currently, most developers do not have the testing conscious. And a great number of test engineers are not familiar with the software development. Hence, the project manager should train the coding capacity of some outstanding testers and let the programmers to respond some testing jobs of the project. In addition, the basic principle is that the programmers cannot test the modules which are developed by themselves.
In summary, testing is not a low-technical work, in contrary, the importance and difficulty of testing are no less than software design. It is one of the most critical parts of project development, which can ensure the correct direction. In addition, testing cannot be carried out at the late stage of the project. Therefore, all the testers should improve their ability of the above testing skills. Moreover, the project managers should track the project based on the testing principle and provide the improved opportunities and the decision-making power to the test engineers. Finally, the programmers need to humbly and carefully check their work. Any potential defects should be taken seriously.
 GAN (2014), Developers and testers: friends or foes? Using fuzzy set theory to decide on the correct ratio of developers to testers in agile teams.
 Whelan, D. (2009), Agile Testing: The Role Of The Agile Tester.
 Tutorialspoint.com, “Software Testing Tutorial“, Simply Easy Learning
 Bach, J. (1999), “Risks and Requirements Based Testing“, IEEE Computer Society, pp. 113-114.
 Kaner, C., Hendrickson, E. & Brock, J.S. (2001), “MANAGING THE PROPORTION OF TESTERS TO (OTHER) DEVELOPERS“, Northwest Software Quality