My spicy opinion on agile—pretty much any software development methodology—is that the method is never and has never been the problem. Agile can work. Scrum can work. Waterfall can work.

The problem has always been management and executives and their obsession with command and control tactics. If you don’t fix management, shuffling things around on the dev side won’t matter one jot.

Read the original papers on waterfall-style dev and you’ll find that they are eerily similar to many agile approaches.

The dev methodology has never been the problem. The problem has always been management.

@baldur I agree. If you read what the phased model folks were saying (like Benington) it's not too far away from the foundations of good software delivery.

You'd make pragmatic adjustments based on the invention of tools like source control, build servers, deployment automation - and to account for the huge difference in economics.

@baldur None of the papers I studied advocated for command and control (or top-down programming as Benington called it).

I wrote down my thoughts here:

https://octopus.com/devops/history/

A brief history of software delivery

How we got to where we are with software delivery.

@baldur YES!

I keep having this conversation with everyone around me, and it just Strick's me that manager use "agile" as a way to both be over reach into dev workflow and so they can relax themselves from having well done specs

There is no silver bullet

@baldur I agree. The reason I've sometimes pushed for processes in the past is specifically to mitigate some of the damage of poor managers.

By insisting on sprints, you can (try to) force managers to decide what goes into the sprint and what has to wait, instead of them just throwing stuff into a pile.

By insisting on planning meetings you can (try to) force managers to describe their thinking clearly or risk throwing the card back for clarification.

@baldur Kanban-style limits on how many tasks can be "in progress" can give developers an explanation why they can't just pick up something new. Retrospective meetings allow developers to say "this didn't work" in a neutral setting rather than complaining about a specific manager.

Not that often helps, but it *sometimes* helps. Sadly, as you say, if management see themselves as "leaders" to control the "workers", there's no fixing the core of the problem.

@baldur I don't think that's spicy at all.

Project management in general is (one) way to manage risk and process is usually a (poor) replacement for trust.

At a certain org scale, you have to have process, because humans aren't wired to trust that many people.

@baldur one of the core misconceptions about any of these approaches is that it's linear and acyclic (Waterfall is usually llustrated and conceptualized as a sequence of steps that go in one direction with a start and end, rather than a circle)

It's a LifeCYCLE. It's the same several steps over and over.

The longer each phase is, the more leverage that phase has over the whole process. So you really want that proces to be a small circle rotating fast, rather than a big circle rotating slowly.

@baldur
I agree. In my last job, the greatest obstacle for us developers was management inability to make decisions. They waffled and wavered about each item until it became moot, so some things just never got done. They also wasted a lot of breath on Agile.
It’s a people problem. Methodologies mostly lead management into the trap solving a problem in the wrong layer.
@baldur that's a spicy take? Maybe for the cargo cult members.
I'm sure that if you look up the first reference to "waterfall does not work" it's probably the first half of the sentence. The second half being "for this kind of project structure/management".
@baldur I agree. I have seen methodological dogma impede productivity.

@baldur @lisamelton Spicy? Maybe.

Absolutely correct? Definitely?

@baldur

This is a great take IMHO.

@baldur In my experience, on dev teams and management teams, both on waterfall and agile projects, it's not "always" management's fault. Sometimes it is, of course. Other times it's executive leadership (or lack thereof). Sometimes it's simply ::gasp!:: ineffective developers. What I do know is that it's always Someone Else's fault, whomever that might be. Anything /can/ work, and I'm no cargo cultist, but I still believe the odds of success increase when using Agile properly.
@baldur I mean, yeah, self-managing teams is explicitly a core tenet of Scrum. (Of course that doesn't help when 9 out of 10 times "Scrum" is implemented in an org it ends up being "Scrum-in-name-only"…)
@baldur Every new methodology is just a creative way of keeping management from meddling too much.

@baldur One of the most valuable things I've ever read, supports your point.

http://www.laputan.org/mud/

Big Ball of Mud

While much attention has been focused on high-level software architectural patterns, what is, in effect, the de-facto standard software architecture is seldom discussed. This paper examines the most frequently deployed architecture: the BIG BALL OF MUD

@baldur Scrum is (fairly) agile but planning software development "up front" can't work. You never know enough, unless you've done it before, using the same tools. If you have, why do it again?
@baldur I completely agree that bad managers can destroy anything though. That's why really agile teams fight to manage themselves.