We are all Agilists now
Software agility is a tricky beast to pin down, due largely to its 'fluffy' nature
Agile methods tend not to describe concrete, tangible practices, but rather principles, attitudes, and so forth. So, heated discussions about the rights/wrongs of agility can rage on for months, until both sides collapse in an exhausted heap with no sign of agreement.
The discussions heat up still further when they border on such profound (and yet meaningless) questions as “what is agility?” Or, worse, “are you agile?” Emotions and egos can flare up because suddenly, agility (or non-agility) is being used as a personal epithet. At that point, you have to wonder what the arguments have to do with software development.
(I examined this personal-attacking “extremo culture” in my book Extreme Programming Refactored, which objectively throws XP into a pit of rabid hamsters).
Agility is more a state of mind than a set of concrete practices. If you can say that you’re responsive to customer requirements, then who’s to say you’re not being agile? Their ethereal nature is what makes agile methods difficult to criticise, which is why I tend to go after the specific practices laid down in XP and other agile methods instead. But on occasion, the agile state of mind needs to be examined as well, primarily because it is so ethereal and open to interpretation.
How else could the giant, heavyweight RUP have managed to reinvent itself as a nimble, fleet-footed agile process framework with little more than a change in marketing?
Let’s say a project manager has instigated a rigid, non-iterative process on his project, where all requirements must be signed off on and the concrete allowed to set before even a toe is dipped in the preliminary design. (On a side note, some might call this a “waterfall” process, but strictly speaking that isn’t true). Regardless of the clear-and-present danger that the overly rigid project will fail horribly, the project manager could still class the project as “agile” because the team is bending over backwards to create an agile software development ecosystem within the confines of the process: they’re pair programming; they use an open-plan office so that information can “radiate” in an ad-hoc way across the team; or they use a project wiki; or they have lava lamps to bathe the room in red when a unit test fails.
I’m not saying he’s right (or wrong for that matter) to call the project agile: just that there’s no clear cut-off point where the agile light switches from red to green. He might be supplying functionality to a third party on a fixed-price or fixed-length contract. It’s what the paying customer wants, and surely, the key point of agility is that you’re giving the customer what s/he wants?
There’s an industry pendulum which slowly swings, over a matter of years, from one extreme to the other. A few years back, it was stuck in the treacle-like extreme of “best practice” high-maintenance methodologies. Then the agile crowd (most notably Beck & Co.) managed to work it loose, and the pendulum swung quickly to the other extreme: the minimal, lightweight process. For many, the pendulum has swung too far though, and something is needed which is just agile enough: minimal yet sufficient.
Naturally, I’ll claim that the use case driven process described in my books is precisely that: it’s minimal yet sufficient, with just enough steps to get you from use cases to working, maintainable source code and unit tests. But you might well think otherwise: the right process for you depends heavily on your (and your customer’s) agile state of mind. ®
Sponsored: Network DDoS protection