Tester’s Communication Matters

      

Overview:  This Post will focus on maintaining or establishing a good working relationship of a tester with the Project Team. Every tester might have experience of working with different personnel in the Project team. All the personnel in the Project team are not easy to handle. From a Tester point of view, a tester always has bad experience of working with one or more tough programmer compared to any other member in the Project Team. The tough programmer’s are the learning source for the tester which adds a lot of value in performing testing activity.

Software Testing:  In General, the Software Testing is about investigating or validating the software against the freeze requirement. Software tester is a technician who performs the software testing activity in a planned and controlled environment. Tester’s involvement starts from the requirement collection & verification till Test Report preparation. During this entire journey, tester interacts with many individuals starting from Stake Holder/Client, Product Manager, Project Manager, Developers, Help Page designer, Customer Care Team and so many. The tester’s communication should be better with the entire project team member in general but a tester needs to maintain a better working relationship with developer in particular. During a Project cycle a tester’s maximum interaction or communication is with developer and sometimes miss-communication happens in this level. 

Communication: The frequency of communication with all the personnel apart from developer is very less. If you take into consideration of the entire communication, 85% of the communication is with developer and rest 15% is with the remaining personnel in the Project team. Again out of 85% of the communication of the Developer, around 90% (90% of 85%) communication with developer is only over Bug/Issue. So need to see how a better communication benefits and avoid a lot of arguments and create a healthy relationship between a tester and a developer.

         Communication TIPS:

          

            Many times a tester’s first interaction starts with a developer with a bug / Issue. A tester can enhance his/her productivity by following these simple tips.

1.  Respect the Developer:

    Every tester should have respect towards developer and listen to them carefully before commenting on any point. Ensure that your bug report does not insult any developer. Your bug report should be about the product not about the developer.

2.  Test the critical part first and Log issue early:

          Test the critical section or module first to find important issue early. All the developer will be interested to know about the critical issue of their code early. Think from a user point of view and test the product to find important issue early. A critical issue will be more preferred over a customer expectation issue. Understand the product in bigger picture and apply different Heuristics to find important issue early.

Logging the issue early in the bug tacking tool will help a developer to get more time to fix and logging issue early helps developer to do better scheduling their effort.

3.  Look for Root Cause:

There is a difference between symptoms of an issue and root cause of an issue. When you find an issue, find the root cause of the issue and test probable impacted areas to ensure no other important issues are hidden.

4.  Assign severity correctly:

Always there is a debate between tester and developer regarding assignment of severity to the issue. Tester usually assigns the “Severity” not the “Priority”. When assigning “Severity” ensure you have justified reason for the severity level that you have assigned. Assigning appropriate “severity” will not create any argumentative situation.

5. Don’t focus on bug Count:

Some tester focuses on increasing the number of bugs and forgets about the test coverage. Developer does not want similar issues to be logged in separately. Try to log all similar issues in a single bug report instead of logging them separately which will give developer a good feeling.

As a tester if you are logging similar issues separately, you need to do justification for that. Some Project Managers look at the Bug tracking tool to evaluate about the quality of the

Product delivered for testing. As a tester you don’t have any rights to make someone look bad. Be careful about this mistake as it happens unintentionally with many of the tester.

6. Avoid Logging Duplicate Issues:

Developer doesn't want to see duplicated issues to be logged. So spend as much time as you can devote to do a through search in bug tracking tool before logging issues. Generally this duplication of issue happens when more number of testers are involved to test the same product.

7. Close/Reopen Issue Early:

  Always developer wants the fixed bugs to be tested and closed early on what (S)he has spent a   lot of time in fixing the issue. Not testing the issue quickly by the tester gives clear indication     that tester does not care for developer’s time. Sometimes testing the fixed issue early will help     in knowing whether this has fixed correctly or introduced any new issue. While closing the issue,   ensure you have mentioned the tested environments in details along with appropriate comments   which help a lot in understanding about the fix.

8. Improve on your communication skills:

 Communication skill as important as technical skill, So as a tester you need to improve both  written as well as spoken skill which will help you to present your thought exactly to the  intended recipient. As a tester, it’s a routine job to update about the status of the project,  Product or any other issue to appropriate stake holder.

 9. Be safe while communicating:

 There is a high chance of misinterpreting a tester’s statement. Assume a tester’s reply on  testing status of a product is “Product is tested and there is no issue”. Even a single issue in the  product would prove the tester statement is wrong. In the above statement, tester wanted to  convey that intentionally he has not hiding any issue.

  

“We need to realize that no product can be tested completely”. Need to be careful on this.

Better to mention as per defined test cases/Procedures, it appears to be there are no more issue.

10 Appreciation matters:

 Every individual wants to be appreciated for all the challenging work they accomplished. We all  work on a deadline to deliver a good quality product to the customer. At the end of the product  release send an appreciation email to the developer including his manager as they spend a lot of  time in clarifying your questions, able to adjust themselves till last minute requirement change  and fixing a lot of issue. Sending appreciation email on time will make them most happy if their  manager’s are in the loop.

11. Provide your support:

 There could be a situation where development team may want to use your environment, tools to  reproduce any issue or do a unit test of their fix, now it’s your time to provide complete support  to help the developer on this to achieve his task. This will definitely boost up your relationship  with the developer.

12. Talk to the developer to know weaker areas:

 Sometimes due to some reason developer is not able to fairly perform unit test of the last minute  requirement change functionality or he is not confident on some area of his implementation due  to his lack of knowledge. Talk to the developer to find out such functionality and focus on those  to find hidden issues.

13. Test by wearing user’s Hat:

  Programmer often focuses on functionality and does implementation as per design and mostly  forgets about the user’s usage point of view. As a tester it’s the responsibility to think about the  User’s usage, how they are going to use it in their environment. Think about different user, user  could be either computer-savvy or not, user could be from any age group based on the type of  application. 

14. Bug Report:

 If the bug report is not detailed reported then reproducing the issue for the developer would be  very difficult. It would be good practice to provide detailed steps to replicate the bug so that  anyone who reads your bug report can replicate the bug. Provide attachment (screen shot image  or recorded video) in the bug report which will give better clarity to fix the issue. Don’t be under  impression that the same programmer who coded the feature will fix the issue. Detailed bug  report will makes the developer job easy and hence will definitely enhance the relationship.

15. Why this issue needs a fix:

 Tester needs to mention about importance of issue which will help the Project Manager to decide  about fixing of the issue. If an issue has been deferred, you are not convince about the reason  of deferred then you may provide enough details why the issue  needs a fix.

16. Questioning skill:

 Every tester should work on his/her questioning skill which will give him/her better clarity on the  product/project. The more you question, the more clarity you get which will give an impression  to the Developer, stake holder about your attitude towards learning. This skill will help you to  perform better testing.

17. Bug review:

 During bug review, try to understand the bigger picture of each and every issue and provide your  valuable input to the developer instead of providing the input later which will not only upset the  developer but also takes considerable time to fix the issue.

18. Understanding Requirement helps:

 As a tester, need to thoroughly understand the features well and have a bigger picture of the  system which will help you not to log Won’t Fix issue or Works as Designed (WAD) issue.  Developers are not happy to see any issue logged which he needs to resolved as “Won’t fix or  WAD”. By understanding the requirement well definitely boosts your relationship.

19. Understand the developer situation:

 As a tester we always wanted to get clarified for all of our queries immediately from the  developer, but we need to understand their deadline, work time and target too before forcing on  them.

20. Speak their language:

 When you speak to any developer, speak in their language which they are comfortable. If you  ask them questions on interface wise or feature wise or how the  design control flow works  internally, they may be happy to clarify your query rather asking questions in simple English or  users language.

21. Speak the truth:

 When you report your issue, describe the steps accurately which not only help the developer to  reproduce easily and fix quickly but also this shows your competence. Sometimes some issue will  not be frequently reproducible or very difficult to reproduce any issue, describe all the work you  have done to reproduce will fetch your integrity.

22. Study the old bug report:

 Studying the existing bug report from the bug tracking system will give you idea how to log  better bug report and observe everyone’s comments in the bug report particularly developer’s  comment to understand what makes a developer confused or angry or appreciative.

23. Re-open issue needs special communication:

 As a tester when you retest any issue to arrive at a conclusion that whether the issue has fixed  correctly or not then either you close or reopen the issue. Closing the issue will not create any  problem but later will certainly do. When you re-open any issue, need to add your comments  with sufficient supportive details including recorder video or screen-shots. If developer sits in the  same location, find out developer time and walk in to his place and try to explain about your  observation in a friendly manner.

24. Don't upset the developer with your remark:

•  I can’t reproduce the issue for you

• I want this issue to be fixed

• Have you forgotten to do unit test your code?

•  You have introduced this issue

• Who hired you

• You are lazy developer

25. Don’t be upset with developer remark:

• This is not a bug
• Who asked you to test this
• Learn automation
• It’s not my piece of code
• Can you reproduce couple of times
• Don’t test all values
• Why you did not find this issue earlier
• Stupid tester

Conclusion: By following the above tips, a better collaboration with the development team is possible.