7 Principles of Software Testing
Table of Contents

7 Principles of Software Testing

Since 1957, testing was just a process to find out to is software working as expected. It was just a simple debugging and error checking without its special identity. Usually made by a programmer who developed software.  

After a while, software testing evolved into its own segment in the software development cycle. With this evolution, 7 principles arose, which became the common practices across testing teams in the world. In this article, we will evaluate each of them.

1. Exhaustive testing is not possible  
2. Defect clustering
3. Pesticide paradox
4. Testing shows the presence of defects
5. Absence of errors fallacy
6. Early testing
7. Testing is context-dependent

These 7 rules are the holy grail of testing. How you will use them depends on you. You can apply them strictly to your work or ignore them.

One fun fact is that you will use them without being aware, and might only realize that after only some time. Even if you are not familiar with the above, we will describe them from tester’s point of view and define them along with giving you more details. Let’s look closely at each.  

Exhaustive Testing is not Possible

Yes, it is not possible and usually testing revolves around confidence and its levels. It’s about how confident we can be something works.  

The more we tested, the higher confidence level should be achieved. Sometimes, we may be overtesting. This brings nonefficiency. While not entirely an issue in big teams, it is a great obstacle in smaller teams, which cannot afford the luxury of wastefulness.

What we need in that case is a well-constructed and considered coverage of an application based on the risk assessments. Having a good plan for testing is the biggest time saver. Without it, we may be going in circles and spending too much time testing one aspect when others are left to be.  

Defect Clustering  

This rule shows that most of the bugs are coming from other bugs or have the same root cause as the other ones.  

What is worth mentioning is that those are usually the small things. Experienced software developers or testers are usually prepared for this. They also know that there are certain areas that are generating more bugs than others. For example, an area that is often to blame is handling the back button in Flutter.

What is important is that you shouldn’t fall into a routine and test the same modules repeatedly.

Pesticide Paradox

This one is simple. Using the same testing technic repeatedly will not bring any new results. You may use the same pesticide over and over, but it won't remove the pests, that remained after previous usages. Paradoxically, the number of pests may even increase!

How to avoid Pesticide Paradox? Use your team and switch tasks with your colleagues. Sometimes others will notice something you didn’t. After all, two heads are better than one. Focus on various areas of the project.

As a side note, this paradox is a very well documented one, and you may found the abundance of information on it, and even mathematical formulas.

Testing Shows the Presence of Defects

Testing is the best strategy to get bug-free software.  

Without testing, you can't possibly feel confident about releases, and you won’t know the real behavior of your application. The bugs that you uncover would have shown up sooner or later. This principle could be connected to the fallacy of blaming the person for delivering bad news. The idiom “don’t shoot the messenger” is there for a reason!

We will reiterate: being fully confident about your software is impossible. Tests will simply show if you are on the good path to achieving the expected results that your client requested.

Absence of Errors Fallacy  

Even if your tests show that your software is bug-free, it’s most likely not the case.  

Sometimes you could just identify your client's needs incorrectly or the requirements will be changed once you were on your leave. This is just an example of how swiftly projects can change and with the changes, those errors can be generated. Though overly pessimistic, software engineers ought to always assume the worst and try to do their best regardless of circumstances.  

Then again, some bugs like to hide, and some are quite enigmatic. Even the best software teams will produce defects, and the only thing we can do is to strive to do better. Whether perfection is possible or not, writing good software is like making fine porcelain: it will always be appreciated.

Early Testing

Just as the early bird gets the worm, the early bird is more confident in its software. The earlier we will test out things, the more time we will get for certain actions. So once the client defines the requirements and describes the intended behavior, we can test the theory against the expected results. The faster we test everything, the smaller amount of work we will need to put in defects to fix them down the line, and it should lower the overall costs.

Testing is Context-Dependent  

This is a quintessential rule.  

Not all testing approaches work in each project. Some will work in one environment, while others in other environments.

Use different approaches, different techniques and try to be creative about them as each type of software differs from another. Sometimes you will have to learn odd rules, but each lesson comes with a profit at the end. The lessons you might frown at one day could become invaluable at any stage of your career.  


To summarize, those 7 rules can improve your testing or understanding of software development.  

What we observe is that once you gain some experience in the area of software development, you will use the aforementioned even without thinking of them. For the ones who just begin their journeys, they are all a great cheat sheet to have, in addition to other good practice that you should introduce to your work when mastering software engineering.  

Finally, we must ask you: would you say the rules above are helpful? Maybe one of them is a mistake? Did you know them or even used on the daily basis? If yes, then you can get in touch with us and share your thoughts with us. Maybe you are looking for some specialists who apply those in their work? Feel free to contact us, and we will see how we can deliver value to your company.  

Liked the article? subscribe to updates!
360° IT Check is a weekly publication where we bring you the latest and greatest in the world of tech. We cover topics like emerging technologies & frameworks, news about innovative startups, and other topics which affect the world of tech directly or indirectly.

Like what you’re reading? Make sure to subscribe to our weekly newsletter!

Join 17,850 tech enthusiasts for your weekly dose of tech news

By filling in the above fields and clicking “Subscribe”, you agree to the processing by ITMAGINATION of your personal data contained in the above form for the purposes of sending you messages in the form of newsletter subscription, in accordance with our Privacy Policy.
Thank you! Your submission has been received!
We will send you at most one email per week with our latest tech news and insights.

In the meantime, feel free to explore this page or our Resources page for eBooks, technical guides, GitHub Demos, and more!
Oops! Something went wrong while submitting the form.

Related articles

Our Partners & Certifications
Microsoft Gold Partner Certification 2021 for ITMAGINATION
ITMAGINATION Google Cloud Partner
© 2024 ITMAGINATION. All Rights Reserved. Privacy Policy