Beware Of The Software Killer

What is the factor that, more than any other, determines the long-term viability of software? A problem to blame for the failure of the vast majority of software development projects?

What is the software killer? Is there such a thing?

Yes, there is.

I worked for a startup many years ago that was brought down by this one thing.

The startup didn’t go out of business, but it was so affected that it lost its market leadership and has never regained it. Giving up being the frontrunner in a market to a competitor is terrible. It means that customers prefer a competitor’s product. Another company is eating your lunch.

And we were not the only ones. Almost all software companies are adversely affected by this thing. It’s ubiquitous and an undesirable feature of most software.

OK, what is this thing?

It’s Unnecessary Complexity.

All software systems contain complexity. But not all complexity is created equal. There is a difference between Necessary Complexity and Unnecessary Complexity.

Necessary Complexity, as its descriptor states, is required. No further simplification is possible without changing the intended function of the system. As per Einstein’s quote: “Everything should be made as simple as possible but not simpler.“. By making it simpler still, we would lose something necessary and required.

Necessary Complexity’s evil brother is Unnecessary Complexity. It’s the extra complexity software developers unintentionally introduce.

Why is it unnecessary? Because the code could be more straightforward without loss of function. Easier to understand, simpler to change.

The picture below depicts the additive nature of Unnecessary Complexity in a small amount of code, say, a function or module. The code will perform its intended behaviour with either degree of complexity; Only Necessary, or Necessary and Unnecessary:

So far, so good.

The following image illustrates the real problem: A greater degree of complexity in a program will make it harder to understand for the programmer. They will have more difficulty making the correct change in the right place. In this way, a complex software system will become even more complex over time.

Any complexity over and above what is needed compounds like interest on a loan. Therefore it’s not hard to see how the amount of Unnecessary Complexity can overtake the Necessary Complexity. If you’re a programmer, I imagine you’ll have little trouble thinking of a system you recently worked on where the code was too hard to understand given the reasonably simple thing it did.

Caught up in the clutches of Unnecessary Complexity, total system complexity will sky-rocket while developer productivity plummets. That is not a good place to be.

How can we minimise Unnecessary Complexity?

We’ll discover that next time.