Life cycle of the bug

no eggs for this time

   Bug is like a butterfly (this sentence sounds silly, butterflies are bugs, but still software testing here, not biology). I can think of three simple stages for a bug lifetime - larva, cocoon and spreading wings butterfly. And it is hard to imagine smashing butterfly with shoe as soon as You see it, but cockroach doesn't fit for this example in my head.

   I will try to focus in three different bugs and three different stages for each of them. While everything is still in my head everything seems good, but we will see how it will unroll.

   First one seems simple - error in code. Something like misspelled element name, incorrect variable used, too much variables sent to function, exception handling missed or something similar, I hope You got right idea. Some of them can be caught early and simple, and I'm focusing on them (no hard thinking for today).

   First stage - larva. If Your editor didn't catch error, it will be caught in compilation stage or if code is compiling correctly - still it can appear easily somewhere. But it could not end here, it could slip though all checking, be wrapped in some kind code cocoon, and survive till next stage.

   Sitting quietly until next stage is coming - sounds really like cocoon. And in next stage, then code is delivered somewhere, doesn't matter where, tester, customer, machine, that non-malicious cocoon - will be seen. Cocoon will become butterfly. That butterfly will flying around place. Would not let focus on work, until it will be removed from the room.

   Now we are walking to gray area. Bug is not a bug, if tested didn't say so. "In this case code is written correctly, but in "decision table" testing one case was left not checked." Now I have example of bug and from here I start to build my example about stages.

   As a larva, this bug, started in head of tester - as missed case, as not expected scenario, ate it's way to some place where it can easily stay as a cocoon. Test cases where prepared, all functionality seems working as expected, seems, everything is ready for release. But there, somewhere is cocoon, which will sooner or later will become butterfly. And we are releasing. Seems everything is great. Cases didn't failed, functionality working, customer is happy. Until. That cocoon - missing test case from "decision table", edge case, which was not thought through - becomes butterfly. With big wings, that makes hard to focus on full picture, which is working correctly, only to the bug, which is messing all the picture.

   From gray area - to even grayer one. What if in the begging of something, bug already was there. It is not code issue, not a missing test case, what if larva starts eating its way in description of project/feature/enchantment. Starts on first document, or even at the idea. Finds a nice and cozy place and sits there as cocoon through development, testing, till the end.

   Having that product in hands - you can't find bug, no missing edge cases, but it just feels not right. Cocoon become butterfly only when final product is ready. No issue in code, no issues in testing, bug was there all the time, bug in project/feature/enchantment design. No bug, but still not usable.

   Enough horror stories for today.  But more will come, more stories, more bugs, more problems, and I or we will try to discuss them.

Your friendly neighborhood Tester