Back

Collaborating with Developers

To understand how to test a feature, and ultimately create a better product, testers may need to collaborate with developers. Since developers write the code, they have a better understanding of how the code works, and what behaviors to expect. By sharing this expertise with testers, developers can show testers where vulnerabilities might be. This knowledge equips testers to bolster their testing routines. Because of how a specific feature is written, there may be edge cases in the programming that do not seem obvious when using the product. When testers work with developers to look at the code and how it is written, they can see where problems might crop up.

Collaborating with Customers

In addition to working with developers, testers may gain insight from working with customers to create better testing procedures. Since customers actually use a product more than testers or developers, they know how the software behaves in practice. Also, because businesses may rely on this software to make money, they usually find the most efficient workflows and shortcuts to get work done as quickly as possible. In some cases, this could result in customers using the product in ways that neither developers or testers could anticipate.

By talking with customers to see how they use the product, testers may learn that they need to test in new ways. Additionally, developers may need to write code for safeguards against crashes and unexpected input in these cases. Ultimately, developers need to accommodate for how users actually make use of a software product.

How to Handle Bugs

When bugs and errors do occur, the development team needs a plan on how to fix them, and in what order to fix problems. Teams must prioritize problems based on their importance. Some organizations employ a system of priority and severity. Bugs with a higher priority and severity get fixed sooner than bugs with a lower priority and severity. Some bugs may have a high priority and low severity, or vice versa. By quantifying these metrics, a team can ensure that they work on the most important problems first, and continue creating valuable software features for customers.

Regression Testing

Developers can sometimes accidentally break old features when developing new features. To minimize the risk of creating problems with old code and catch them early if they do, developers can use regression testing. Regression tests are automated tests that developers or testers create to make sure features work as intended. For every new feature added to a product, the team creates regression tests that ensure the feature works. They then run these regression tests periodically, either when changes are made to the code base, or when new development goes through a quality assurance phase. If the regression tests produce unexpected results, they flag this problem for a tester or developer to investigate further.

If a team plans to use regression testing, they usually create new regression tests for every feature. Regression testing can be labor intensive, and writing regression tests for all existing features of a product well into the development process can be difficult. Because of the complexity of large products, making sure to write a regression test for every behavior of every feature is nearly impossible. However, by writing new regression tests as these features are completed, the team is more likely to keep up with new tests, and recognize bugs in old code more quickly.

Iteration Metrics

While bugs and errors happen with any team and any product, it is important to monitor how frequently these problems occur, and how quickly they are resolved. As such, many teams use iteration metrics to quantify their ability to detect and correct problems in the product. In addition to monitoring the velocity of a development team, iteration metrics are another way to make sure a team stays on course to finish a project in a timely manner.

Specific metrics used depend on the team and project. Some teams use story points planned versus story points completed. This allows the team to see if they regularly overestimate their ability to complete features. Another popular metric is to monitor how many new bugs are introduced versus how many bugs are completed. An ideal team should fix more bugs than they create over time. If the team creates more bugs than they fix, they may need to work more on fixing problems than writing new code.

Developers and testers have to work together to write good software that satisfies customer requirements. By following test driven development practices and using regression testing, teams can make sure that both new and old features continue to work as designed. Also, by working with developers and customers, testers can make sure that they find bugs quickly, and alert developers to these problems so that they can get a fix to customers as soon as possible.

Recommended Further Reading

The following materials may assist you in order to get the most out of this course:

Translate »