It was September 9, 1945. Grace Hopper discovered a moth that caused a problem on the machine back then. Bug is now known as software defect with Wikipedia define it as below.

A software bug is an error, flaw, failure or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways.

Some argue that’s not accurate enough and define it as below…

A software bug is an error, flaw, failure, or fault in a computer program or system that causes it to violate at least one of its functional or non-functional requirements.

Software Bug Cost

At the same time, there are many reports on the cost of bugs, which increases over time through the development phases.

This is so scary 😱. Sounds like we need to find all the bugs before shipping, else we’ll look like we have a high price to pay. 💸💸💸.

Can we fix all the bugs?

That would be a perfect world! Unfortunately, life is not perfect. Like it or not, there will be bugs. We should prevent them and eliminate them as much. But it is impossible to find them all, and infeasible to fix all that was discovered.

But the good news is…

Cheer up… Not all bugs are PEST!

Software Pest — the bad bugs

What I mean pest is, bugs that really have a detrimental impact on the software and organization. If we don’t hunt them down, they will haunt us down.

Software Pest is Software Bugs that have detrimental impact to the software and organization

Not all bugs are in this category. So it’s important to distinguish them as a priority. Let’s have a fun look at them below.

The Locust

This bug comes in swamp, and would wipe out the entire vegetation. Super disruptive.

Software bugs like locust are bugs that will affect your entire population of users. It could be a

bad crash on startup of your software. Imagine a blue screen always when you run a software.

functional failure on your most used feature. Imagine if Facebook app friend feed page showing blank page constantly.

a server change that will crash the existing apps on using mobile phones. (This happens quite a bit, as sometimes the crash happens only on the older version which still has lots of users out there.

Another good example is App Database migration, which is shared below

This type of bug is not common, else someone head will row. It normally could be easily detected with some basic sanity testing, proper regression, automation, and unit test.

Some people use Beta release or Phase release (i.e. release to a small percentage of users first) to cautious and watch out for such bugs.

No software release should proceed when Locust is detected.

The Mosquito

Mosquito itself is not as disruptive. But this is the bug that is known for spreading deadly diseases. Sometimes with just one stink, the diseases it spread could be fatal.

Security threat bugs are like mosquitos. Imagine if

you are using your site is using a cleartext HTTP instead of HTTPS, such bug opens up opportunities for intruders to come in and attack.

your code is not obfuscated and could be easily decompiled

or you are still showing printed log in the release app as shared by the link below

Just like a disease, the issue caused by security bug doesn’t appear immediately or might not happen, if no one discovers the vulnerability. But once someone found it, and take advantage of it, it grows like wildfire… there go the high price to pay.

One good example is the LinkedIn case below.

One thing for sure, the more popular your software is, the more likely intruder will try to attack it. So one has to constantly watch out for mosquito and eliminate them all even if you see them in a small number.

Keep look out for Mosquito and explore ways of preventing it; the more when your software getting established.

The Termites

A small number of termites can do not much harm. But termites with large numbers would chew up your house foundation, and your house would collapse.

Similarly, technical debt seems to be okay in the beginning. It’s not good but no one felt the impact yet. A hacky code seems okay when there is only one. Everything still feeling good when the software is released.

However, if it is not addressed later, a hack code might need another hack code to get feature enhancements. An un-refactor duplicate code fixes will miss fixes as people only fix on one side.

Over time these termites slowly eat up the foundation and make the software architecture brittle. The software itself might be in an un-expandable state.

Until one day, the entire software would be in an unstable condition where no more change could be done. Code can’t be easily traced and fixing one thing cause another issue. Everything just collapse. The only way to move forward is to rebuild everything from scratch.

It’s literally like termites in the house, no one feels it when it is within initially. Slowly we will see holes and if not handled, the entire house will collapse.

Hence to prevent it, good practices like Peer Code Review, having a custodian over TODO tasks, constantly update to a newer version of libraries, eliminates warnings, and having lint tools enforced would help reduce the Termites

A regular routine of termites control is essential to ensure software foundation health is preserved

The Ants

Like it or not, ants are everywhere. If you observe your surrounding close enough, you’ll find them. A little number of small ants is okay as you don’t usually see them. But if you notice a big one or the number is increasing, then it’s irritating. Your house won’t collapse, but no one would like to come to your house.

Performance issues in software are like ants. Most software has some of those, e.g.

startup response time,

janky scrolling,

unoptimized memory usage,

high battery consumption (for mobile apps),

inefficient network calling,

too much operation on the main thread.

memory leaks

When they are little, it’s not noticeable. But when they grow in numbers and size, it’s time to remove them before they irritate our users away.

Sometimes we wonder if we should spend time keep improving on the performance, or work on new business requirements… judgment call is needed. The question to ask is how noticeable and if users get frustrated with them. If yes, it’s important to get rids of these ants.

Don’t let the ants grows within your software till it irritates your users away. Constantly look out and remove them.

The Spider

Spiders create web and prevent things from getting through the web. If the web is blocking the critical entrance, no one will get through.

Some software bugs though doesn’t crash the app, nor degrade performance, but it blocks your user to access your introduce features. Things like

Some page once you enter, you can’t exit from it anymore

An entry to a feature that requires login, but once user login, it goes to another screen (user would forget how to access the feature again)

Push notification bug that once click, goes to nowhere or anywhere except what the push notification indicates.

Unnoticeable entry to your features (unclear font or coloring)

Unresponsive coach-mark that introduce your feature

Remote configuration to turn on a feature that doesn’t work consistently.

Hard to access buttons (too small and hard to tap)

Some though seem UX problems, but it has a major impact on the software. Why work hard and introduce a feature that only a very limited group of people can use it? This would be a waste of resources.

Removes all spiders especially those close to the entrance to your software main feature to promotes.

The Bed Bug

Bed bugs normally live in your bed. Your friends visiting you doesn’t realize it. No one outside your family notice or cares. But it hurts you badly every night.

Bed bugs are are software bugs that customers don’t care about, as it is not impacting them at all. They use your product happily and will stay on with your product. Is there such a bug?

Yes, let me give some examples below

Wrong analytics result, that misled you. (e.g. missing or duplicate, or inconsistent)

Your link to crash reporting is not working anymore, no more feedback

Your software bug creates more access to some cloud resources than it should. Cost 💸 is involved here!

Brittle regression testing and fails intermittently cover up actual failures. No one trust the test result eventually.

Buggy CI process and slow the process of compiling your software. Waste time!

You get the idea. Customers doesn’t care about all these issues. But they are super important to you. And you can’t leave it unfixed, as the longer the bed bugs are out there (or inside), the worst you’ll get bitten.

Bed bugs are internal suckers. Your customer don’t feel it, but it hurts you badly. Eliminate it!

The Black Widow

You don’t need to have many black widows at your home. One is enough to make a major scare to many people. One bite would be super painful and could be deadly if not handled well.

Legal implication bug or bug issue that really affects big damage and takes life is like a Black Widow. One bite could potentially rip your organization away. E.g.

Any copyright infringement in your code, assets, user flow, etc.

Not compliance with privacy law, e.g. the recent GDPR in Europe. (or a bug that cause)

If you use an open-source that is GPL, which force you to open source all your codes

Some code that accidentally store more user information more than you should

Some claim wording and branding stated in your software that could be misleading.

Software bug that could cause major catastrophic

Some are directly legal-related branding, claims, license inclusion, etc where developers can’t know by seeing it. Hire Legal team to handle those.

However, some are because real software bug that introduces those legal issues (e.g. bug that accidentally removes legal disclaimer or preventing the user from opt out some privacy feature).

Many times, these areas are normally not frequently checked before release and could be missed unknowingly. Dangerous.

Have a release checklist to ensure all parts of software is compliance legally, ensure no Black Widow hiding within.

Not as bad a bug

Other than Software PEST, we have other bugs. I wouldn’t call them a good bug, as no bug is good (99.9% of the time). We don’t want any bug there, but can’t remove them all.

However, some bug doesn’t harm (that much perhaps). This type of bugs, we should remove them if it doesn’t involve too much effort, or we have nothing better to do.

Some bugs, we should only remove if it is conveniently removed, or we have nothing better to do.

Is there’s such a bug? Check out below …

The Camouflage Bugs

There’s no specific bug type here. Various bugs could camouflage into a hard to detect form. Once a while we could see it, but most of the time no one sees them. Even after seeing it, it’s hard to find them again.

I think we could quickly identify the nature of the bug that this relates to. It is those bug that we see it once, and don’t know how to duplicate them. They are there, but only once in a blue moon. It could be the few crash report, out of a million user sessions. Who cares about those bugs. User doesn’t even worry about it.

Of course, if the occurrence increases, and we could duplicate them, it needs to be triage. Or if it is a Black Widow or mosquito… that’s a different story.

Try reasonable effort to hunt the more apparent camouflage bug down. Else, leave them alone. It’s okay, we could live with it.

If we can’t find the camouflage bug again, don’t worry about them as long as they are not the harmful type.

The Moth

Moth is a relatively quiet bug most of the time, staying in one spot. Sometimes it is not easily noticed too, but once notice you know it’s there. Some people don’t even bother their existence.

There are some old bugs you found that’s already in your production software. It has been there for so long. No one complained, and concerns about it. As a developer, we don’t like to see it there; but we also recognize it does no harm so far.

My recommendation is to log it down as a case, but triage as a lower priority. Look into them only one you have time, and see how important vs your other tasks.

One cautious though. Sometimes no one complaints of such bug, it is not because they are not important, but it is because that particular feature that contains the bugs is not even used by the user. That’s a totally different problem to tackle. It may be a sign of inaccessible feature (a spider somewhere?). Watch out.

If user ain’t concern about the Moth, and it is not causing harm, only get to it if is is low enough to get rid of.

The Bee

Bees build hives and generate honey. We love the honey but afraid of the bees as its stink is painful. If we go disrupt it, we’ll be stink badly. Either remove all or leave it alone (since it’s generating honey anyway).

Some legacy modules in your software code base are like beehives. They are still working, and nobody knows well how it functions. The code has been there for a long time, there might be some minor issues, but nothing glaring, everything still works fine.

My recommendation is don’t go and touch it, trying to improve or fix it. You might break something major and lose all your honey!

You might want to consider the long term to replace it entirely but for the moment perhaps it is not the time yet. Try to avoid making any minor changes in those areas. It is risky. Like the famous phrase says, if it ain’t broke don’t fix it.

Also, keep it isolated, and don’t try to introduce a new item link to that module. Break out and rebuild something new elsewhere. The work in somewhere else it’s not a bug fixing work, instead, it’s a re-architecture work to be scheduled in.

Don’t touch the Bee or its Hives. Keep harvesting its honey, but you might want to start making another honey generator.

The Butterfly

It was a caterpillar, it does chew some leaves away initially. But after a while it turns into a beautiful flying creates that everyone loves to see them around. The butterfly.

You might have heard of the phrase, It’s not a bug; it’s a feature!. It’s like an accidental feature God bless from heaven. Never a plan. Just like the discovery of Penicillin. It’s rare but does happen!

There are quite some examples out there shared in the below link

Those Moths are like bug (check the Moth above), might be a Butterfly. Be cautious of removing them, in case some users like it (since it was there quite a bit).

Put it this way, anything that stays with the Software for quite a while and doesn’t deteriorate the software is part of the Software. Just like a mole or birthmark, it’s part of the body, and not worth worry about.