Software bugs are like real bugs

I read it in the “Software Testing: a Profession of paradoxes – a special report by CTG” a few years ago, that some similarities exist between the real bugs and software bugs. And from some experience, I second that and suggest to: “Treat software bugs as if they live and behave like real bugs”.


(photo from

So how it will help. Let’s see:

  • Where there is one, there are many

The real bugs live in colonies and they always build a network. You’ll never see one Ant moving around a hole, you’ll see something from dozens to hundreds.

The software bugs also live in pockets and some features like them so much that they start building colonies over there. The neat areas are usually free from bugs. There have been studies so as prove this like Programmer having a bad day or a bad habit etc. (more details in the same report above from CTG)

One lesson from this is: If you find a few software bugs in an area, dig deeper and you’ll find many.

  •  They become immune to Pesticide

Research shows that if you continue to use the same Pesticide to kill bugs, it’s effectiveness weakens and the bugs become immune to that particular pesticide.

In software testing world, this is known as the Pesticide paradox by Beizer (see the report above for details) which states that no matter how good is your test approach, you’ll stop finding defects using the same defects.

So how we overcome this: First thought is to improve or change the formula of pesticide by introducing a new strategy or change test data. The other possibility is to change the sprayer as it can matter: try putting a new tester to test the feature.

  • They can bite hard

Some real bugs bite so badly that they can take away a part of your body, some of them are toxic enough to cause even deaths. Read more about the Deadly bugs.

Software bugs do a huge blow to your reputation in eye of your beloved customers. They can cause you spend a lot of money and the relationship still remains broken. Read more about some of the deadliest software bugs from history. Just recently Apple was hit badly due to Mapping app failures.

One thought from this is: never take bugs non-seriously and do an effort to combat them. Else they’ll some day bite you, how hard will depend.

  • They don’t finish, ever

No matter how much you spray cockroach killers, or pay heavy amount to specialist companies, cockroaches don’t die and resurface in some time. There is absolutely no way to finish a specie of bugs, they are built to last.

“No software is bug free” is one of the first lessons for the testers. No matter how good your tests are, or you run how many circles of regression, the release will still have some bugs in it.

One idea from this is: don’t overkill yourself to go for zero-bug release. If you can get comparably neat areas, feel good about it.

Can you think of some other similarities? Or you dare to say that they are different?


5 responses to “Software bugs are like real bugs”

  1. SamreenM says :

    You know there are some Eco-friendly bugs which are actually good for eco system than dangerous. Putting heavy amount of pesticides risk their killing along with the nasty ones. Just wondering if we have software-friendly bugs too? =)


    • majd says :

      That is a very good point Samreen. Some real bugs are very important for the eco system though I could not think of such in software bugs 🙂

      The only thought I had was, well, their existence ask us to change our test strategy and improve quality as a result. But do we want some software bugs to be existing?. No, we don’t.


  2. Ather Imran says :

    We as professionals have learnt a lot from nature and its phenomenons and our terminologies reflect so. Neural networks (learning model based on how human brain’s neural network learns), waterfall (project management process modeled on how a waterfall flows) and bugs (as detailed here) are some examples. There is another category of professional models and tools based on second level human activities (i.e. stuff that we as humans have learnt or build). An example may be ‘Sprint’, Hierarchical models, inheritance etc.


Trackbacks / Pingbacks

  1. Bug finding heuristics | Knowledge Tester - December 18, 2013
  2. 3 Tips for near-perfect Test Planning | Knowledge Tester - September 11, 2017

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.