We Dont Need It Yet

I propose that YAGNI (YagNi, YouArentGonnaNeedIt) be deprecated, instead prefer WDNIY (WdNiy, WeDontNeedItYet).

Let me be clear, it is not the XP sentiment that I take issue with; the Extreme Programming practice that says: "Always implement things when you actually need them, never when you just foresee that you need them" is very valuable.

However, the practical task of saying "YAGNI" is often interpreted as confrontational, or as an intractable position.

Let's face it, the days of the lone hacker producing great works is past. Programming is a social activity that requires buy-in and co-operation from team members. Unfortunately, not all team members are as enlightened as we would prefer. Many simply give lip service to XP, to gain buzzword-compliance-points from management.

Ideally, coding is an ego-less activity, where feedback and constructive criticism is valued. Far too often the truth is quite the opposite: we feel a strong sense of ownership of "our" code because it is our very own creation of truth and purity forged by pure will from out of the chaos.

So, when you try to tell someone that they can avoid needless complexity of the feature they are about to implement because "YAGNI", they tend to react defensively:

Instead, I believe that we need to impart the wisdom in a way that indicates that you are on the same team, trying to get to the same goal. "We Don't Need It Yet" (WDNIY) expresses the same concept of YAGNI, but in a way that is much less antagonistic:

Sometimes, after several iterations, "Yet" never comes, and the application is completed without the added complexity of whatever "It" was.

Equally often, development eventually reaches the point where "It" really is needed in order for work to continue. Fine, implement it. But notice that in the time between when "It" first occurred to you and now, the rest of the app has solidified more, providing a better understanding of how "It" needs to be done in order to be done correctly. Less chance of having to go back and revisit the implementation of "It" to allow for forces that were unanticipated at the time "It" was first foreseen.

Aside: In the tradition of great computer science debates past, I considered using the title "YagniConsideredHarmful", but relented. ;-)

-- DouglasDickinson

Well done on both counts! Even more inclusive and less confrontational could be: WhenWillWeNeedIt?? You could be wrong, after all. Maybe all the preconditions for needing it already exist, and WeNeedItNowCos?... More likely, WeWontNeedItTill?..., which may still be within our planning horizon.

I would argue an underlying premise of YAGNI is that things can and will change between now and then, so what's the point of planning for it before you really do need it?

Why not just DoWeNeedIt?? Seems this would open discussion on the subject.

I think this is quite a good idea, for both the reasons you mention. But it's not quite as compelling as YouArentGonnaNeedIt, because it says 'yet'. It almost implies that we'll need it later. The main benefit of YAGNI is avoiding putting in unnecessary features altogether - ones that you don't need ever. But if we just don't need it yet, there isn't such a compelling reason to put it off (although of course there are all the secondary reasons mentioned on the YAGNI page.)

Practice showed that Yagni has the right impact on people - if they left ego at home. However, even if not, it can bring up a discussion that is focused on whether or not it will ever be needed. This discussion is likely to end up with the correct answer, since no might-might-not-maybe-we-will-maybe-we'll-not discussion is opened. It is straight forward - Yagni or not.

It just entered my mind: why not changing Yagni into Wagni (WeArentGonnaNeedIt) and eliminate the offensive You?

Ran.

This is beautiful. I love the "yet" because it implies planning. All too often, people (like me) interpret YagNi as "don't worry about tomorrow" and then burn up precious hours refactoring things we could have gotten right the first time. There's a big difference between chosing a simple path and choosing a simple path that will take you where you want to go. :)

-- MichalWallace

The problem with "DoWeNeedIt?" is in my opinion that it is too open for the rebuttal: "Yes, we need it. Feature Y which will [read: might] be implemented using this feature X, so WeAreGoingToNeedIt?". And there you are - you can't pull YAGNI on that.

What about WeDontKnowWeNeedItYet?? Doesn't imply that the feature is actually needed in the future... Then again, knowledge of the need can always be claimed. So it'd become WeDontReallyKnowWeNeedItYet? (WDRKWNIY or YDRKWNIY [which could be read WhyDorkWithItYet?, ignoring an N in the middle]). I guess the basic wisdom is that the knowledge of the need isn't absolute until you actually start implementing Feature Y - and that everything that isn't actually needed until Feature Y should be planned (and scratched) with the task for Feature Y and not under whatever task the coder was actually working with. (Hopefully, there was a reason that Feature Y wasn't deemed a priority to be implemented yet - so why waste time)

-- SimonBrenner

What about WeDontNeedItNow??

I was going to suggest this as I read the various YAGNI articles, but then I saw you had already done so. Well done.

EditText of this page (last edited March 2, 2011) or FindPage with title or text search