I’m going to dedicate a couple of posts to the relationships between QA and Development (DEV) organizations.
Anyone who’s ever been in either of those organizations knows that sometimes there seems to be a conflict of interest between QA and DEV, which can lead to friction between the groups and the people. Obviously when both organizations are running under the same roof, there must be some joint interest/goal, but the challenge is to identify the expectations of each group in order to work toward their goal and accomplish their mission effectively.
The difficult cases are those that put more strain on one party, in order to optimize the effectiveness of another. Example – developers are asked to unit/integrate/system test their software before handing over a build to QA. Some developers might say that this is work that can be done by QA, and their time is better spent developing software. The QA engineers will say that they need to recieve stable input from the DEVs in order to streamline the coverage progression, and that the sooner issues are found, the lower the cost to fix them.
One way to look at these “protocols” between the groups is via the glasses of TOC (Theory of Constraints), identify the bottlenecks of the overall system/process, and fine-tune the protocol to relieve the bottleneck. People in those groups, and especially the leaders, should be mature enough to know that sometimes doing the “right thing” might be to take on more work, sometimes even not native work for their group.
One example is the issue of when to ask DEV guys to see problems the QA engineers have discovered.
Reasons for calling DEV might be:
- Wish to reopen a bug
- Bug was reproduced and a developer was interested to see the reproduction.
- New severe bug
There are a couple of forces affecting this issue:
- QA wishes to finish the context of the specific problem/defect, open the bug, and get on with their work.
- DEV wishes to finish the context of their specific task, and wish to avoid the “context switch” of looking at the QA issue.
- In general, both QA and DEV have learned to wave the “Context Switching Overhead” flag quite effectively. (A more pragmatic conclusion is that some context switching overhead is unavoidable, and sometimes the alternative is more expensive…)
- In some cases, “saving” the state of the problem for asynchronous later processing by DEV is difficult or takes too many resources to be a practical alternative.
A possible compromise between all those forces is to define some sort of SLA between the groups, stating the expected service provided by DEV to QA according to the specific situation (Reopen, Reproduced, New Severe, etc.). This SLA can provide QA a scope of time they can expect answers in, without feeling they are asking for personal favours or “bothering” the DEVs. The developers get some reasonable time to finish up the context they were in without feeling they are “avoiding” QA. The SLA can also cover the expected actions to be taken by QA before calling in the DEV, or in parallel to waiting for them. This maximizes the effectiveness of the DEV person when he does free up for looking at the issue, while better utilizing the time of the QA while waiting. (for example – fill the bug description, look for existing similar bugs, provide the connectivity information into the test environment, log excerpts/screenshots, etc.)
Another question is who to call on when QA needs help. The options here depend on the way the DEV group/teams share responsibility on the different modules of the system.
- In case there are strict “owners” for each module, and they are the only ones capable of effectively assisting QA, the only reasonable choice is to call on them… this requires everyone to always be available at some level.
I have to say though that I strongly advise against such an ownership mode. Look at code stewardship for a better alternative (in my oppinion) and see below how it looks better for this use case and in general… - In case there is a group of people that can look at each issue, one alternative is to have an “on call” cycle where people know they have QA duty for a day/week. In this case there will be issues which will require some learning on their part, and perhaps assistance from the expert on a specific area. This incurs overhead, but is worth its price in gold, when the time comes and you need to support that area in real time, need to send the DEVs to the field to survive on their own, or when the owner/expert moves on…
To sum up, like in many h2h (human-to-human) protocols, understanding the forces affecting both sides of the transaction is key to create a win-win solution. A pragmatic view trying to minimize the prices paid and showing the advantages of the solution to both sides and to the overall organization can solve some hard problems, as long as people are willing to openly discuss their issues and differences. I’ve seen this work in my organization, hopefully it helps others as well.
The problem you’ve raised is a well-known and painful one.
However, I’ve learned that many times the “context-switch” excuse is only a cover-up for a more serious problem. The thing is that usually, if no measures are taken to prevent it, the testing (what you call QA) personnel looks at opening defect reports as their main duty. In addition, the programmers find any potential bug to be their enemy and try to get rid of it as soon as possible. In an ideal world, both groups work for the same goal and the programmers would rush to research a potential bug in an effort to make their code better and the testers would be happy to find out that their so-called bug was not a bug after all, but it is not what happens in reality.
This is why the authority to say what would happen to a bug can be given to an external and objective body (somewhat like the CCB for change requests). This body does not have to have the knowledge to understand for each defect report whether it is a bug or not and what is it’s priority, vut it has the authority to assign defect research tasks to different people (through their team and group leaders). They are responsible to manage this research effort and after the research is done (and its results are documented and understood clearly by them), to decide what to do with the bug and when to do it.
I had experience with such methodology (seeing it from all the angles: programmer, tester and a member of the group) and it is very effecient (though, of course, might create a bottleneck, if planned incorrectly).