YAGNI is a conscious and iterative task prioritization process. From a Pareto perspective, it just means to focus on the 20% of functionality that provides 80% of the value first.
That's not to say the other 80% of requests should be ignored. But instead well documented and groomed in a backlog.
In practice, YAGNI works out exactly how C3 ended up. Your architecture and design ends up myopic and short sighted, and gets overwhelmed by deferring complexity that could have been dealt with adequately early on, it is much harder to retrofit back onto an existing code base.
Fowler means it literally. He had examples published on Artima.com years ago where he gives examples of hard coding things left and right and adding better support “only when you absolutely need it”.
To be clear I am not arguing for big design up front. I am arguing to keep an eyeball on your roadmap, and that is not only OK to anticipate the future but maybe do some small amount of work to make the future work easier.
The fallacy of “You Ain’t Gonna Need It” is that you so very often do, and the developers down the road are cursing out the devs who ignored the future.
If you subscribe to "You Are Gonna Need It", how do you ever get around to shipping software if you are always implementing the things that are fun, but unnecessary, and not focusing on the things that are needed to progress?
The "premature optimization" thing warned against making code hard to read/debug for the sake of performance in areas where performance is unlikely to ever be a concern. If you don't ship software, it is understandable this is isn't much of a problem.
Although I'm not sure how applicable that really is today anyway. The tools have changed dramatically. Often you want to make your code as readable/debuggable as possible as that also gives the best chance for the compiler to find the optimizations. These days, if you try to get fancy, you'll probably make the performance worse.
If you subscribe to "You Are Gonna Need It", how do you ever get around to shipping software if you are always implementing the things that are fun, but unnecessary, and not focusing on the things that are needed to progress?
The point is that you aren't always implementing things that are unnecessary. You probably have a roadmap where you're pretty sure what you're going to be doing for the next few days and weeks and less sure as you look further ahead. Obviously you don't want to spend months building some over-engineered, over-architected monstrosity. But there are plenty of people out there who take YAGNI very literally and argue that you shouldn't implement anything you don't need right now. That's absurdly inefficient if you can guess with 80-90% accuracy what you're also going to need a month from now and you can save a lot of effort by implementing everything mostly right the first time and not repeatedly reworking code you've only just written over that time only to end up at the same place anyway.
YAGNI is about not implementing features until they are needed. It’s not about ignoring the complexities of the domain. You can adhere to the principle while still designing a system that acknowledges the complexities but defers implementation until it is needed.
I have no horse in this race but I believe what the other poster was saying is that you might not need it but you should still think about it and decide if you should factor it into your designs.
Developers aren't great at sharing nomenclature, but by what seems to be the most common definition, YAGNI refers to not going off and implementing something that is more fun to implement, but isn't needed right away (if ever). Focus on what you actually need to get your project to a desirable state.
It doesn't say you should not consider future considerations in your design. In fact, it suggests that you should design your software to be as accommodating as possible, most notably by ensuring testing is core to your design to assist you when the time for change comes. The other poster you refer to and YAGNI seem to be in alignment.
YAGNI is more about design than implementation. It's about worrying about future concerns rather than what you know you need right now.
The truth is in the middle, sometimes you need to design for the future and sometimes you don't. Often designing for the future just means making sure you haven't designed yourself into a corner rather than being able to fully deal with the future but that's a nuance most people miss.
Not as it seems to be usually defined, but I agree that programmers are bad for not sharing a common nomenclature. We can't even agree what something as simple as enums are. So, no doubt that there are camps who hold that perspective. enterprise_cog clearly comes from the "don't implement", not "don't design" definition, though.
While I accept your definition, because, hey, programmer's can't agree on definitions at the best of times, that is not the definition that was used earlier. And is not the definition presented by the XP gang.
John Carmack of Doom fame seems to share your definition, suggesting that attempts to plan architecture in advance will only come to bite you, but I'm not sure he is an XP subscriber and he certainly wasn't involved in C3.
oh yeah, you're right, what the XP guys meant was "spend all your time building the architecture with all kinds of extension points just don't implement them... YAGNI!".
It's a mis-interpretation and it's not a reasonable one either.
Pretty much. Central to the YAGNI message is ensuring that your design brings test coverage to help you build the things you need when you need it. Kent Beck is credited with having invented TDD, so of course that's at the heart of their theorem.
You need those extension points to keep your tests sane. They come naturally as part of the testing process.
It's always strange when someone on a discussion forum defers to someone else for their thoughts. Why even bother?
It's even stranger when the deferral isn't even relevant.
Stranger still, the premise appears to be made up. I can find no mention of "Code that's hard to test in isolation is poorly designed" anywhere on the internet other than that blog post and another blog that cites DHH.
Beck's insight with TDD, over the testing that came before it, was really just that if you write the test first then you have certainty that the test fails. If you are writing tests for code that you have already written, there is no way to know if your test passes because your code is conformant or because there is a bug in your test.
But, whether your write your tests first or last, you do need extension points to keep your tests sane. Rails is no exception. In fact, I would argue Rails' success was directly related to it leaning into testing and it showing developers what extension points are most relevant for web applications as a result. Before Rails came along, throwing MySQL calls haphazardly into the middle of the HTML was the norm.
> this is all just a defensive mechanism to try and dismiss the point.
I figured.
> What's going to happen is that over time you'll eventually have the experience to understand what's being described here.
I've been around long enough to be aware of the surface level motivation – accepting the point without defensive dismissal would cause harm to your ego. I just don't get the appeal. Who cares about the ego? If you have no thoughts to share, why post anything? Surely if DHH wants to share his thoughts here, he can come here himself?
> Because it turns out there's a lot of things that young people find weird that they later understand.
Curiously, older people almost universally state that getting older means caring about the ego less and less. Maybe what you are trying to say here is that you are still too young to understand that? Fair enough.
it'd be akin to someone arguing with a 10 year old about how they should feel losing someone they've been married to for over 40 years. That 10 year old just flat doesn't have the tools to understand so why bother.
But the question asked why you would bother, not why someone who has been married for 40 years would bother. You don't need to know anything about anyone else to answer the question.
It is recognized that you did answer the question. You said as a defence mechanism. That is understood. But the follow up is asking on deeper level: What needs to be defended against, exactly? What is that you think your ego going to do to you if you don't put up these defences?
The last coherent thought you had was an assertion that YAGNI may include not implementing extension points. But then DHH, while admittedly starting with a made up premise that made no sense, came along and obliterated that notion by the end, detailing how extension points – what he calls model, integration, and system – are necessary to keep tests sane.
And, since YANGI emphasizes testing, we can be assured it actually does include implementing integration points.
As it turns out, in many complex domains, you ARE going to need it, so you should factor that into your design sooner rather than later.
This is also why many consulting lead projects fail, because the developers do not understand the complexities of the domain.
Not everything is a CRUD website.