If you implement minimal testing practices, you can only expect minimal testing results.

Many organizations are motivated to conduct testing and employ test professionals only because testing is a necessary part of software engineering. Acting out of necessity, organizations also tend to lean quite heavily on the de facto standard ways of performing testing activities, often relying on practices that have been in place and unchallenged for years. The problem with testing motivated by necessity and the enforcement of generic practices and standards is that many testing practices simply do not align with modern development methodologies or an organization's culture.

Documentation is often perceived as the critical part of the testing process, and I would not for a moment argue that documenting your tests is a wasteful exercise. In many organizations, it is a critical part of compliance activity. However, what we choose to document is of critical importance, and ensuring that the amount of documentation we produce is consistent with the effort available to maintain it is also important. But there's more to testing than just documentation.

This article aims to educate the reader on how, by challenging traditional testing conventions, it is possible to improve your approach to software testing and raise the game of your testing team. This is not an exhaustive list of the approaches you should take, but rather five small steps that can help you think differently about how you conduct software testing.

1. Encourage a Reactive Testing Team

An age-old creed of many in the software testing world is "Plan your work and work your plan." What happens if you plan your work and then the project changes and evolves? As you begin to work your plan, you are testing antiquated functionality or designs, often without the full context and awareness of what's changed. Development teams are becoming leaner and more agile, and testing teams should be doing everything they can to keep up.

Test engineers need to assume everything around them could change on a dime and implement appropriate procedures or process to ensure that they are aware of and familiar with all project changes (changes in timescale, requirements changes, specification changes, coding changes, etc.). This may involve automated notifications of documentation changes or may be as simple as enhancing the communication between testers and developers.

As things change, test engineers also need to update their testing methodologies and not be afraid to throw away redundant test cases. Remember: Our main motivation here is to discover software defects. We don't want to spend time executing tests that will always report pass metrics, and we want complex test cases that will uncover requirements, design, or coding defects.

Keep in mind the Pareto principle and how it applies here: 80 percent of defects will be found with 20 percent of the effort. As test engineers, we just need to make sure we're working on the right 20 percent, which is a constantly moving target.

2. Explore, Investigate, and Cheat (aka Beg, Borrow, and Steal)

Software testing is never easy, yet many recommended practices aim to make software testing look easy. For example, requirements-based testing is a practice that is often misinterpreted. Test engineers are encouraged to map test cases directly to requirements and gain adequate coverage, with an arbitrary metric used to analyze coverage. The confusion here is on what it means to have adequate coverage.

There is really only one sensible way to determine adequate coverage: through exploration and investigation. Cause-effect analysis is a technique testers can use to explore and investigate the sufficient number of test cases required for a requirement. This technique requires significant discipline and a solid understanding of the software system being tested. It also requires a deep understanding of all the possible things that could go wrong. Once all the appropriate causes are identified, test cases should be authored and prioritized in order to facilitate efficient planning.

It is also of critical importance to remember our first point: If you document the test cases, make sure you monitor requirements changes that could impact the testing. Since identifying the necessary test cases is an exploratory, investigative process, cheat if you must. Engage with developers, architects, anyone who has a greater understanding of the system or process being tested. You don't have to work alone to find the information.

3. The Defect Quota

A successful salesperson usually has a very clear understanding of his job: If he sells products or services to meet company expectations, he will be handsomely rewarded. He carries a sales quota, and the risk of inadequate performance is often job loss. Occasionally, you will come across a salesperson who has taken on the role without fully understanding this fact. The result is that he will often thrash around, focusing on everything but selling.

Many testing professionals suffer this same fate. What all testing professionals need to understand is that their role is to carry out testing in order to find defects.

So the question is, why don't testing professionals carry a quota? With a defect quota, suddenly the end game changes. It's less about producing perfect documentation and completing a certain amount of testing under pressured timescales, and it's more a case of finding every defect possible. Of course, the quota should not be based simply on the number of defects, but rather the number of defects weighted by their complexity, severity, and uniqueness.

The biggest challenge here is figuring out how high to set the bar and how to reward testers when they meet quota. In contrast, would developers be rewarded when testing teams fail to meet quota? Likely not, since a lack of defects is not a guarantee that they don't exist, only that they have not been discovered.

4. Follow Your Nose

This principle goes part and parcel with the defect quota. If we have a defect quota, we need to follow our instincts sometimes to fully understand why a system is behaving a certain way. It is very easy for testing teams to fall into the trap of authoring specific test cases, with granular test steps that guide the test engineer through each step of the testing process. It is very tempting for some organizations to encourage this behavior as a means to simplify testing, making test execution a role that can be performed by junior staff or delivered through an outsourced model.

This leads to behaviors that contradict the whole notion of explore and investigate. On the surface, a test case may appear to have passed, but fundamentally other things may be going on in the background, resulting in failures. Test engineers need to be given a certain amount of room to explore and follow their noses to find the hidden defects.

Rigid test case definitions and automated test scripts are useful only if your customers are guaranteed to be following that script when using the system. This approach is only rarely applicable in the system-testing and acceptance-testing phases. If you make test execution a humdrum activity, you can expect the results to be equally as uninteresting.

5. Keep an Eye on Automation; It's Expensive

Many organizations automate test suites with a focus on gaining efficiency; they put implicit trust in the automated test suite and continue to invest in its maintenance even when it's no longer yielding value (i.e., defects).

Let's look at the first thing teams do when an automated test suite fails. They task someone to investigate. The question you need to ask is whether those investigations are yielding significant defects. Of all the testing metrics you can capture, one of the most significant metrics will be the percentage or number of defects discovered by a particular automation suite--or any suite for that matter. If the only defects you are uncovering are defects with the automated suite being broken, how valuable is the automated suite?

How much more manual testing could you have accomplished if you weren't fixing the automated testing suite? Could that time be better spent on statistics and diagnostic tools being built into the product or process being tested, making manual investigation and exploration easier for test engineers?

A growing trend among software packages today is automating the submission of detailed bug reports and logs when a product crashes or encounters an error. Even if this approach is not viable in your customer-facing application, having detailed error logging and automated recognition of errors when routine testing takes place increases the potential of discovering defects. Think creatively about how you can change your approach to automated testing to discover a higher concentration of defects.

Testing, Testing...

Software testing is often viewed as a science, but as with any science, there is still room for innovation, creativity, and goals. I encourage any person responsible for a testing team to examine closely the behaviors of their test engineers. Ask yourself these questions: Are my test engineers adapting to change? Are they exploring and investigating? Have I set clear goals and objectives for them? By breaking the traditional mold of a testing team, you may be surprised by the results.

It may also be important to examine the technologies test engineers are using. Test engineers need the right set of tools to support exploration and investigation as well as to determine the value of a particular test suite or test case. Measuring the value can be as simple as ensuring that the relationship between the test artifacts and its corollary requirements and defects is adequately captured. From a management perspective, utilizing a test management solution that connects the testing process to the rest of the application lifecycle will be beneficial.

Bridging organizational silos and improving communication between test engineers, developers, and analysts can go a long way in improving efficiency and software quality. Consider solutions that provide traceability between requirements, development, and testing processes to help facilitate requirements-based testing and support IT governance.

Remember, if you implement minimal testing practices, you can only expect minimal testing results.