As the old saying goes “a picture is worth a thousand words”, this graphic is meant to explain the importance of refactoring and code-quality without going into detail too much.
In the grahpic, you can see two axes. The x-axis describes the time, which is spent in the current project (the time spent on the software).
The y-axis describes the time, which is spent on the implementation of new features or the time spent on bug-fixing.
The matrix in general is meant to describe the correlation between time, which has passed, and the effort which is needed to implement new features or fix existing bugs.
The red and green lines describe what happens if you do/don’t do refactoring
The quadrant on the lower left is the quadrant in which every new project starts. It’s too early to say something about the quality of the code, because there simply isn’t much code.
The quadrant on the upper left should never be reached in any project. If this quadrant is reached, it means that you need a lot of time do implement new features in the early phase of the project. This might still happen, if
The quadrant on the lower right is the quadrant in which every project should be. In this quadrant,
This quadrant can be reached by constantly doing refactoring and constantly thinking about improvements of the code-quality and software architecture.
As you can clearly see in the graphic, the green line does not converge to zero, it’s more like a sinus curve. This means, that you can’t develop the “perfect” software architecture and never need to think about this stuff again. It means, that whatever is done in the project, the developers have to think and do something about the software-architecture/clean-code.
The quadrant on the upper left is the quadrant, which a project should never ever reach. In this quadrant,
The red line in this quadrant looks like the half of a parabola, which means that the red curve will rise very fast. Every feature implemented in such a project will take longer and longer for every feature that is developed.
This means, that after some time, the software will not be maintainable anymore. New features can’t be developed, because they would break something somewhere. It is therefore very important, that a project never gets too deep into the “danger zone”, because it might never leave it again.