5 ms·
Assuming facts not in evidence error at line 1: Presumption that Agile ever ascended. The basic problem with the Agile movement is that it took a few proven he
by Silhouette 15y ago
Assuming facts not in evidence error at line 1: Presumption that Agile ever ascended.
The basic problem with the Agile movement is that it took a few proven helpful practices -- almost all of which were well known and often used by experienced software developers before the buzzwords were attached, even if managers didn't realise -- and instead of promoting those, it wrote a "manifesto" so vague that it would make a political speechwriter proud, which didn't actually say anything at all about the practical steps that were useful.
Then concrete examples of "Agile" processes started to appear, and a few less proven or even discredited practices were added to the basically good ideas. Suddenly, despite valuing people over processes or some such vacuous claim, it's all about The Process again.
The predictable result was something non-technical managers thought sounded good but didn't really understand, and technical people who didn't drink the Kool-Aid looked at sceptically while asking where the evidence was that it was better than what they had been doing already.
And the only answer the Agile community has collectively agreed on in the ten years since then seems to be that people aren't doing Agile properly in most cases, but look at the successes where smart people have made it work! Of course, those smart people probably could have run a successful project starting from any other process, too, because if it didn't help they would have thrown it out in favour of things that did, just as they always had. And if most of the case studies of your supposedly superior process don't show significant benefits, you start to lose credibility after a while by claiming that they're all doing it wrong.
And now, we're doing the same thing all over again with the not-at-all-pretentiously-titled Software Craftsmanship movement, and the result will be the same: lots of people selling books and charging consultancy fees to peddle snake oil mixed with just enough actually proven ideas to be credible for a while until the results come in, by which time they will have moved on to the new hotness.
I am not normally a fan of Zed Shaw's style, but in this case, I sympathise with his point of view:
http://programming-motherfucker.com/ http://programming-motherfucker.com/
- dcsobral 15y agoCitation needed. Please provide studies to the effect that the practices you consider "proven" are, indeed, effective and references to the fact that they were widely adopted before the agile movement. Because, so far, you've drawn a line based on personal opinions -- actually, just your own personal opinion -- about what's effective and what's not, what was common practice and what was not, said everything effective was common and everything not common is unproven, and then, based on this edifice or your own single opinion, declared that the agile movement didn't improve anything. I'm very impressed with how much you deduced from your own thoughts, which means you are probably omniscient. In that case, you'll have no trouble providing actual evidence backing your statements.
- jt2190 15y agoThe basic problem with the Agile movement is that it took a few proven helpful practices -- almost all of which were well known and often used by experienced software developers before the buzzwords were attached, even if managers didn't realise -- and instead of promoting those, it wrote a "manifesto" so vague that it would make a political speechwriter proud, which didn't actually say anything at all about the practical steps that were useful. Avoiding creating a list of helpful practices was by design. The signatories of the Agile Manifesto were all very seasoned developers, and like all seasoned developers they knew that a practice that helps in one case harms in another. You can kind of see how it might go wrong from there: * Seasoned developer makes list of helpful practices, without providing context, i.e. "Helps in this case, harms in this case." * Unseasoned developer doesn't understand when and where practice is "helpful", tries to use it in all and every case. Sometimes it works, sometimes it fails. * Unseasoned developer who complains: "Helpful practice X didn't work for me" is told "You're doing it wrong." Again, no explanation of when and where the practice is helpful is provided. The takeaway here is to always, always, ALWAYS describe the context when describing a solution, i.e. "This is what worked for me, in this situation."
- Silhouette 15y agoI don't notice any hesitation from those "seasoned developers" when it comes to advocating specific practices elsewhere. According to Bob Martin, if you don't do TDD you're not even professional, for example.
- jt2190 15y agoYes that's what I was implying. (I guess I wasn't clear enough.) If Bob Martin said something like that, and he couldn't list even _one_ case where TDD wasn't the best approach, I'd question whether he had fully thought out the problem.
- Silhouette 15y agoBob Martin has said exactly that, without any kind of qualification at all, on many occasions over the past year or two. Then again, this is the same man who doesn't think there are any more kinds of programming language left to be invented.
- BadassFractal 15y agoOrganizing groups of people to put together something decent in a highly limited amount of time and with humane treatment is extremely hard. I don't see Programming, Motherfucker addressing that in any way.
- Silhouette 15y agoI don't see much evidence of Agile methodologies addressing that in any way, either. That's rather the point. After this long, if Agile is as superior to the alternatives as its advocates frequently claim, there should be heaps of empirical data miles high to justify each and every practice these consultants charge so much to explain by now. So where are they? The best I've seen any big name Agile consultant cite is a handful of small-scale experiments, mostly using CS students rather than experienced industrial practitioners, invariably not controlling for using unit tests alone without the TDD process, that show that projects using TDD have modest but inconsistent and frankly unspectacular gains over projects that don't bother unit testing at all. I'm a scientist. I believe in the data in front of me, and my conclusions on these matters are falsifiable. I will be happy to revise my opinions if and when new evidence shows any of them to be incorrect, but that evidence had better be more than a few alleged experts telling me what they think I should believe if I'm going to change the development practices of entire teams based on it.
- wpietri 15y agoIt would be awesome if somebody would fund those experiments. But since Agile methods are mainly about sustaining high quality over the long term for teams of experts, studies with a useful n would be stunningly expensive. And honestly, there's no great reason to believe Agile consultants. Most of the market for software process improvement is in helping the clueless and/or terminally lazy. (And there's often even better money in not helping them, but instead just making them feel special.) Plus, a lot of the benefit from particular practices depends on the existing code, the business conditions, and the people involved. I think the right way to deal with Agile techniques is the same way one deals with new tools or new languages: try 'em for a while and see. E.g., I tried out TDD for a while and ended up liking it a lot. As does the rest of my team, such that they all were specifically looking for test-driven shops when I hired them. But even we tend to only use it on core code; test-driving most UI just doesn't pay off.
- wpietri 15y agoThat is approximately the opposite of how it happened. Several different groups of people invented processes that worked for them (e.g., Scrum (1995), XP (1996), FDD (1997), DSDM (1994)). They all liked what they had done, but discovered they had commonalities that were worth talking about. They got together for a long weekend and came up with the Agile Manifesto (2001). Having lived through the transition, I promise not all the good practices were "well known and often used". Frequent releases were generally considered dangerous, and weekly iterations were seen as heretical. Unit testing was done by a small number of projects, but mainly in safety-critical areas. Test-driven development was unheard of. Continuous integration was certainly rare, as was using refactoring (supported by high test coverage) as a way to manage change. Personally, I think the Agile movement is irredeemably doomed at this point. It's basically a question of incentives: http://agilefocus.com/2011/02/21/agiles-second-chasm-and-how-we-fell-in/ http://agilefocus.com/2011/02/21/agiles-second-chasm-and-how... However, the current sad mess happened in spite of the good intentions and major discoveries of the people behind the methods that got rolled up into Agile(TM).
- Silhouette 15y agoYou're not the only one who lived through the transition. And IME the good practices that are used in Agile processes mostly are the ones that were well-known and widely-used. People have written automated tests for decades. People have been testing at the interface level since the dawn of OO and before. Put those together and you've got what is now called unit tests. People have been making small changes to improve the design of code without changing its behaviour forever, too. Fowler published Refactoring in 1999, but even then it was common practice among experienced programmers to work that way. I assume you're not seriously going to suggest that no-one thought of doing things like moving a method up and down a class hierarchy or splitting a long function into a higher level control function using lower level functions for the details before the book was out. (I'm not disputing that Fowler did a good job of pulling a lot of common knowledge together in a way that is helpful to those just starting out.) I also assume you're not seriously going to dispute that long-term projects have been managed using shorter-term milestones for a very long time. That's hardly unique to software development, never mind to Agile processes. Every project I've ever worked on professionally has seen developers naturally pair up or form small teams around the same computer or whiteboard to work through difficult problems or review each other's solutions. People have been doing what is called continuous integration today for as long as there have been source control systems with check-in hooks. I first had the idea of organising a big project by keeping a pool of little projects and picking out the most important one to do next when I was about 13 or 14, so I rather suspect that plenty of managers were using the same idea to prioritise long before anyone called it a backlog and worked through it in sprints. I could go on, but I think you get my point. Now, there are plenty of other practices required by various Agile processes that weren't (in my experience) almost universal among good programmers before Agile came along. They include: - TDD - Full-time pair programming (same computer, two keyboards) - Collective code ownership (everyone owns everything) - Forcing short-term milestones into periods of exactly the same length - Frequent meetings (daily in some processes) - Relying on organic designs that evolve through arbitrary refactoring by individual developers rather than a carefully planned architecture and smaller-scale designs that are peer reviewed by multiple people If you want to claim those as the gifts Agile has given us, you're welcome to them. As I said before, most of the good practices were already in use, and the consultants mixed in a bunch of unproven ones later.