The importance of good software design

Introduction

Here we will see why good software design is important.
In this case study, the data I am going to present comes from a real company.

The size of the development team

This first graph shows the evolution of development iterations based on the size of the development team.
When observing it, one might think that it's very encouraging to see the development team grow as the releases progress.

The number of lines of code

The second graph shows the evolution of development iterations based on the number of lines of code.
At the very beginning, we can observe exponential growth, but we quickly reach a plateau before stagnating.

The cost per line of code

This third graph becomes worrisome.
Here we observe the cost of each line of code based on the release.

Why do we observe such a change in the development team's productivity?
Why is the code 40 times more expensive between release 1 and release 8?

Productivity

Graph #4 shows a significant drop in developer productivity over the course of the releases. The further the releases progress, the more productivity declines.

From the developers' perspective, this is very frustrating because they feel like they are working harder and harder to achieve less and less.

Payroll

If you thought things were bad, imagine what it looks like for the managers who see costs increasing exponentially.
This fifth graph shows the skyrocketing payroll over the course of the releases.

Release #1 was completed with a payroll of a few hundred thousand dollars.
But by the time we get to release #8, the payroll has climbed to 20 million dollars, and it keeps increasing.

This graph alone is already frightening, but if we compare it with the number of lines of code produced from graph #2.
We can see that at the beginning, we had a lot of features for a cost of a few hundred thousand dollars.

But by the 8th release, we are spending 20 million dollars for almost no new features.

So the first question that comes to mind is: "What action can we take to stop this vicious cycle?"

What happened?

The answer to this question is found in the fable of the hare and the tortoise:

• The hare is the developer who runs very fast, who codes very fast, who adds features very quickly.
• The tortoise is the developer who takes time, thinks about the design, and makes careful technical choices.

At first, the hare is ahead, having already added many features.
But at some point, he realizes that he has made poor technical choices and must backtrack to fix his mistakes.

The hare believes in the well-known myth, which is:

"I can clean up the code later, the priority is to deliver the product."

Of course, the code will never be cleaned up because the market is highly competitive.
Once the product is available, the competition is already working on the next version, and you need to keep up by adding new features as quickly as possible.

Just like the hare, who was too confident in his speed, the developer who codes too quickly is too confident in his ability to clean up the code later.

Conclusion

In this case study, the biggest lie is that writing messy code is faster in the short term, and the slowdowns will only show up later.

In reality, doing things quickly will always be slower than doing them right from the beginning.

"The only way to go fast is to go well" - Robert C. Martin

Moral: Good software design is a long-term investment.