YAGNI: You Ain’t Gonna Need It
Do not add functionality until it is completely necessary
Introduction
YAGNI, You Ain’t Gonna Need It, or You Aren’t Going to Need It is a principle from Extreme Programming (and somehow related with Lean Thinking) that states that a programmer should not add functionality until it is completely necessary:
“Always implement things when you actually need them, never when you just foresee that you need them.”
Even if you are totally sure that you will need a feature or piece of code later on, do not implement it now. Most likely, you will not need it after all or what you actually need is quite different from what you foresaw needing earlier.
Involved Costs
Whatever the outcome, you will incur a series of costs that can be either avoided or deferred:
Here’s a quick breakdown:
- Cost of building — All the effort spent on analyzing, programming, and testing a feature.
- Cost of delay — The lost opportunity to build and release another feature now.
- Cost of carry — The complexity added by the feature to the code, making the software harder to modify and debug.
- Cost of repair — The effort spent on modifying a feature because it is not exactly what you need now.
Enabling Practices: Avoiding Technical Debt
It is important to know that YAGNI is meant to be used in combination with several other practices, such as continuous refactoring, continuous automated unit testing, and continuous integration.
Used without these practices, it could lead to disorganized code and massive rework (known as Technical Debt).
Finding the balance
You could apply YAGNI principle in the most strict way and not writing one line of code that is not completely necessary for the current requirements.
However, IMO there is always a balance between having some up-front design or using patterns, and being completely strict. It should be always leaned towards the simplest way, though.
If you are in doubt as to how Software Design and YAGNI can work together, there is a paper of Martin Fowler called “Is Design Dead?” that you might find insightful.
Further Reading
The YAGNI principle is brilliantly explained in a Martin Fowler’s article (from which I borrowed some concepts and the diagram). And he wrote this other paper about Software Design and YAGNI that I mentioned above.
It is also well explained (but referred to as incremental design) in these books:
- O’Reilly’s Learning Agile, Chapter 7 “XP, Simplicity, and Incremental Design”
- Kent Beck’s Extreme Programming Explained, Chapter 7 “Primary Practices”
Finally, you can find a reference in this C2 Wiki entry.
