Heh, classic response. Whenever your project fails, your coach tells you it's your fault because you didn't do real Agile. Same with OOP, whenever your code inevitably becomes a tangled mess of classes, you will have all sorts of gurus making metric shit tons of money from books and consulting telling you you didn't do real OOP.
Guys, please, can you just admit there is no recipe for success (rhetorical question, of course you can't, that's where you money comes from, maybe you even believe your own bullshit)? There is no real Agile and OOP and other crap that I forget, they're just buzzwords that, when applied long or hard enough, produce shit. If you had kept you project to an absolute minimal level of Agile and OOP, it would probably still be alive and kicking. But you didn't, because you jumped on the bandwagon, you used religiously whatever was popular.
> Agile, done right ...
Yeah, heard that a thousand times before. Sadly, younger developers fall for this all the time, so shit grows exponentially. I'm aware my opinion has always been in minority but whatever.
I grant that there's no one right way. There are many, and they depend on circumstances. I certainly grant that there are an ocean of idiots selling bullshit. But you're throwing the baby out with the bathwater.
There are better and worse ways to make software. Teams can reflect on how they work and get better over time. Those teams can recognize patterns, and other teams can benefit from learning about those patterns and trying them out in their environment. And that's how things like Extreme Programming came to be: teams experimenting and sharing what they'd learned with other people who wanted to get better. That was exactly what the early Agile movement was.
Piss all over that if you like. But you'll be missing out.
Did you drink any kool-aid on the way in?
That is a really weird theory for a programmer to have about anything, let alone what he's chosen to spent 80,000 hours doing.
Your question prompted me to consider a thought experiment. Let's assume that management techniques are completely ineffective and the deciding factor in whether a project ships and is successful or not lies entirely with the programmers and designers. Now, let's take it one step further and say that most management techniques actually reduce the likelihood a product ships and is successful. Do you think that would stop management from trying to exert control over something that is completely out of their control? Do you think that would stop management from thinking that their input is actually making things better when in fact their input is making things worse? Managers are ultimately responsible for producing results, but they have no direct control over those results. Most humans, when put in that situation, will try to do something, anything, to make it feel like they have some control over the situation. Even if it makes that situation worse. Finally,what if what I have described above isn't actually a thought exercise, but a fairly good description of what is happening in the real world right now. Would we be able to tell?
Food for thought.
But the top-down thing is explicitly not what the Agile movement was about. As the early Extreme Programming community would say, "By-the-book Extreme Programming is where we suggest you start, but it's definitely not where you should end up." The notion was always that teams would take time every iteration to look at how they were working and improve it to match local conditions.
That was definitely true even at the beginning; "self-organizing teams" was one of the principles from 2001: http://agilemanifesto.org/principles.html
So the way to think about it isn't in terms of manager interventions. It's in terms of those non-interchangeable teams experimenting and then sharing what they've learned with other teams. Teams will learn things! Some of those things will apply to other teams. A few will apply widely. And that's exactly how the good Agile teams work today. They may start from some recommended set of practices, just like any novice does while learning things. But they are supposed to evolve from there to match local talent and conditions.
[1] I've written more about that here: http://agilefocus.com/2011/02/21/agiles-second-chasm-and-how...
Not so weird at all. Codebase and process don't matter to a customer, all they see and judge is the end product. Sometimes even the end product doesn't matter, as the likes of Google can put much more money into ads and marketing than you.
There might be a correlation between what people do and how the project goes if you're NASA or BMW. But for 99% of the software world, nobody cares if you have the most hacky codebase ever as long as it does what it's supposed to do and doesn't have too many bugs.
Pretty sure that's a big part of the problem Agile and other approaches to software development try to address.
There is absolutely nothing wrong with the Agile Manifesto, but this can not be said of the industry that was created on the back of it.
No true Scotsman would have misunderstood me.
1) Architecture. Architecture trumps everything. Even though "favor composition over inheritance" has been repeated for a very long time, some people just didn't get the memo, and you'll encounter mind-boggling inheritance hierarchies (sometimes even template inheritance, to make it fun) with more levels than circles of hell.
2) Class-itis. Everything must be a class, and free-floating functions are seen as coming straight from The call of Cthulhu. Most people are more concerned with the way the class will look and fit in the existing architecture than if the desired functionality is achieved.
3) Code reuse mania. If you write the same line of code in two different places, some people's palms start sweating. More than two identical lines in two different places and you'll have people screaming to move the coded to another place and share it, irrespective of whether it is beneficial or not.
4) God objects. When people just can't take it anymore and simply jam yet another object in the God object. Yes, I know a lot of people from the cult of OOP will tell you this is an anti-pattern, and I agree, but it happens. And when they unravel the God object, an even bigger mess emerges most of the time.
I don't know, I'm probably forgetting a dozen other manifestations of OOP.
You know what "you're not doing real Agile/OOP" sounds like? "You're not doing real communism". And we never will.
The original agile manifesto was meant to avoid following plans blindly like that. It's only four lines one of which is "Responding to change over following a plan".
Despite what the kanban people think, Agile isn't supposed to be "small waterfall" where the work and priorities are set in advance instead of discovered as you test hypotheses through trying different technological approaches and doing back and forth with the users.
What you propose means that if in a cycle you discover that the plan was sub optimal and not well prioritized (and when you are iterating, you are in the best position to find that out) you march on towards the dead end and only adjust after the "sprint" is over? That is not agile, it may fall under scrum but really it is just small waterfall.
Good agile as it was originally stated is compatible with and even comes from a similar line of reasoning as the Lean approaches. The core of Lean is that the people closest to the technology should be put in a close relationship with the users to be in the best position possible to resolve what I like to call the crux of innovation. Innovation's most difficult and most crucial part which is to figure out what work has the most value to effort ratio, what has the most risk and needs to be studied early to clear up that risk and ultimately what the team should be working on first. At least for any work that is somewhat leading edge or a bit experimental, priorities cannot be properly assessed without experimentation, user feedback and management of uncertainty and risk trough early experimentation.
Scrum tends to ignore this core problem by positing a product owner that has the answers. This is very reminiscent of waterfall where people disconnected from the technology and who aren't experimenting and putting things in front of users, who are ultimately in a bad position to make plans are making those plans anyways. IMO what you are describing and a lot of the ideas in scrum are the very things that original agile was meant to prevent and also goes against Lean approaches.
Here is the agile manifesto:
"Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan"
Also, instead of having broader estimates in terms of months, you force developers to rush constantly with sprint completion pressure. In case you didn't know, rushing developers is very, very counterproductive. Cost, Time, Scope. Pick 2.
But I do agree with you about "sprint completion pressure". With Kanban you don't have that and you don't have large day long "sprint planning sessions". You have just enough work in the "Dev ready" column to keep the pipeline going.
Of course not having the sprint planning pressure and not having a deadline to release doesn't work without a continuous delivery pipeline and some way to turn features on when ready.
It is, but it depends on the size of the iteration and who is breaking it down as to whether or not it is useful.
I much prefer, "here is the problem, solve it," to "here is the problem and I'm going to tell you how to solve it, even though I have no idea how software development works."
Of course, the most recent "official scrum" environment I worked in was horrible. They really used it to micro-manage development. We actually created all the stories for a multi-year project so we could give an overall timeline (waterfall) to management, then the business dictated the order of the stories even when they made no sense. It was a constant battle.
Yes I've been subjected to that also. But the right way to do it is to have an experienced developer working with the business representative/product owner to do "backlog grooming" before the item ever gets seen by the rest of the team.
What you are describing is the opposite of iterative. When you iterate, you go over the same territory multiple times, with more insight/detail.
And yet the very definition of the word, "Agility" is supposed to mean moving quickly and nimbly, able to easily change direction.
The side effect of shorter iterations is that requirements have to be broken down to fit inside the smaller iteration, so there is a price to be paid by those managing the backlog and generating requirements if change needs to happen quickly.
Agile methodologies don't enable change as needed, they create a structured way of handling inevitable change. And when the backlog is adjusted to accommodate that change, the consequences of that change to budget and delivery date are easy for everyone to see.
If you don't have controls in place, then there is no understanding of the cost of change. And without understanding the cost, good cost-value decisions can't be made.
Shortening the iterations means you now how to rechop all your tasks and do the estimates again wasting even more time. Also the smaller the task the less people focus on the bigger picture and your software just turns into a mess of puzzle pieces.
Just my experiences from having to go through Agile Hell.
Every control has to have consequences, or else bad behavior has no cost. Your organization is addicted to what the calendar says, and the software is neglected. The consequences are suboptimal productivity and/or quality. Appearing to work has more value than completing work.
No software process is immune to leadership failures.
Wasting time? Measuring twice and cutting once is done because it saves time. As a shirt I saw recently said, "weeks of programming saves hours of planning".
Agile, done right, is more about how work is broken down into consumables and deliverables. It's about clear prioritization and freedom to focus on the task at hand. But most development teams would iterate aimlessly, while the organization around them continued doing business as usual.
To successfully embrace Agile, the entire organization has to do so at some level or another. You have to break requirements down into pieces that can be consumed in an iteration. You have to prioritize clearly. And you can't change priorities until the iteration is complete.
Additionally, many software teams misunderstand how they work. I can't tell you how many times a team would insist to me they were using a waterfall process, but when I asked them to describe the previous workday they'd describe end-to-end firefighting. When I would introduce Agile and the controls that it brings, they would react negatively expecting that Agile was some magical organized free-for-all.
Additionally, lots of consultants made money off of the promise of Agile and the cult of Agile. They didn't provide practical solutions, and organizations resisted change. So much of the indigestion that developers have regarding Agile is due to their own experiences with organizations that bought the promise of Agile but didn't do the necessary work to make it successful.