When an Infestation Strikes

2025/Jan 06

We begin with a metaphor.

Let’s say, hypothetically, you found a bug in your residence. An insect. A creepy crawly critter that skitters about. It shouldn’t be there, or anywhere else in your home for that matter. The word “shouldn’t” is important here, because it can have multiple meanings. It could mean that the bug does not belong in your quarters, but it could further mean that you believed you’d employed effective measures to prevent their infiltration. Let’s say in this case that both are true. Thus you have two problems: there is a bug where you live, and your efforts to prevent that have failed.

Now, it’s natural that bugs may crop up from time to time. No defense or countermeasures are perfect, and even multiple layers of mitigations will eventually fail against the right foe. That is to say, the occasional bug isn’t much to be concerned about. The time for concern is when the bugs keep coming, when you find yourself needing to spend increasing amounts of time getting rid of them. To take a reactive approach to this situation is a losing battle—at some point, you need to tackle the problem at its root cause.

If what you’ve seen is a variety of different unwelcome guests, then your problem is likely general. Something about the way your home has been built allows the bugs to slip in without any fuss—you have a hole in your wall. Patching up a hole is a conceptually easy task: you plug up the hole with some material that will stop the bugs before they enter. You’ve just gotta fix the hole in the wall, or at the very least add some kind of obstacle to make it more difficult for the critters to make their way inside.

On the other hand, if you find yourself facing the same kinds of bugs over and over again, your problem runs deeper. Your home is a welcoming environment for a specific kind of bug, and so they have made it theirs. The problem you face is that the building you call home has seemingly been built to tailor to the needs of the bugs which are ruining it. To solve this conundrum requires a lot more work, but the end result will be that your home has become outright hostile to the bugs that’d plagued you.

When building a house, one must be cognisant not to use materials that welcome infestation or other kinds of difficult problems. This is a difficult but by no means impossible task—we as a civilization generally know how to build houses because we’ve built many. We know how most materials interact with most others; Construction techniques have been refined over millennia of human civilization. Chances are, if you’re assembling a specific combination of building materials, it’s already been done many times. Most possible complications are already known. It is unusual to invent entirely new ways to construct buildings when building a new edifice.

It is the norm to invent new ways of putting together software components when building a new application. Chances are, when building a new app, you’re utilizing an entirely new, never before seen combination of software components or design methodologies. Even if you use the most popular language’s most popular libraries to create an application that’s already been made a thousand times, the exact programming style will be unique to your idiosyncracies. The moment you add any new feature is the moment you decide to do something that’s never been done before. Once you’ve gone off the rails that have been laid down before you, you’ve entered the realm of invention.

Unlike construction, software development always involves uncharted territory. It’s like going out of your way to build a house using esoteric materials in an esoteric arrangement using esoteric techniques. With multiple levels of esotericism at play, you no longer have the safety of known failure modes. What you’re left with is a combinatorial explosion of unknown factors, each of which can invite bugs into your project.

Today, I observed a cascading series of similar bugs in an app I’m developing. Faced with unknown unknowns as I invent something new—or more appropriately, as I combine existing components in a novel fashion—I decided to take the bold step of removing the feature that caused the bugs. While on the face of it I am left with an app with fewer capabilities, where it may now take more time to do specific tasks, it will take less time overall because the user will now no longer need to contend with a feature that has been made fragile by the bugs which have infested it.

Perhaps once I’m more familiar with the materials I’ve used in this project, I will attempt this feature again. Not until I know which pitfalls to avoid, though.