Today, it seems that almost every software development organization employing more than one programmer subscribes to the Agile methodology. In fact, it’s difficult to find one that doesn’t. Given its pervasiveness now, it’s hard to remember that only a few years ago, Agile was a newfangled idea that only a few development shops were trying, while others dismissed it as a passing fad or were “waiting to see…”
How did Agile go from zero to hero in such a short time?
The Origins of Agile
For many years, the standard practice in software development was the “waterfall” process, in which a client would provide general business requirements, the system architecture would be designed, and the design would be divided up into modules that were doled out to developers to code and unit-test. When the modules were completed, the system was put together and “thrown over the wall” to the software testers; this was followed by one or more (and often many) cycles of bug-fixing and retesting. Eventually, the finished product would be delivered to the client.
By the 1980s, the limits of this approach were becoming obvious. The waterfall method was unable to keep up with the increasing complexity of software systems, and even with the best project management, it was not possible to deliver usable, bug-free software that met the business requirements without repeated delays. Clearly, a new approach was needed.
Many alternatives were proposed. The 1990s saw a number of ideas that attempted to overcome the limitations of the waterfall approach, including rapid application development, dynamic systems development, and extreme programming. Although many of these provided useful tactical tools, some in the development industry realized that what was really needed was a set of strategic guiding principles for software development project management. By 2005, a group of developers led by Alistair Cockburn proposed a set of principles they called “Agile.”
Agile’s Key Values
The core principles of the Agile approach are simple but radically different from previous development project management approaches. They are:
- Individuals and interactions: Projects succeed when stakeholders work as a team rather than in isolation. The more experience they have as a team, the better they become.
- Working software: Frequent delivery of releasable software that can be demonstrated is more important (and accurate) than frequent status reports.
- Customer collaboration: The client should be involved at every stage of the project, not just the beginning and the end. When they are involved throughout the process, there are fewer surprises.
- Responding to change: The built-in ability to take in stride changes in requirements and priorities means that such changes are less likely to derail a project.
Agile’s Main Differentiator: It Works
Software development agencies are notorious for their reluctance to try new approaches. So why has Agile been adopted so overwhelmingly in the industry? Simply because it works. The organizations who really bought into it—the ones who didn’t dismiss it with “It couldn’t work here,” or tried to combine bits and pieces of it with their traditional approaches—found that once they got past the initial learning curve, the method worked as advertised, and had numerous benefits:
- Better product: The end product was of higher quality and had fewer bugs.
- Happier developers: With strict timeboxing, developers weren’t burned out by having to slog through never-ending projects.
- Happier management: With projects actually meeting their stated delivery dates, resource planning became easier.
- Happier customers: With continuous involvement in the project, customers could see actual progress being made, provide instant feedback, and ultimately have their expectations met.
Once the early adopters started having some success with Agile, others—attracted by the benefits and dismayed by the limitations of their traditional approaches—started to join the crowd, and the snowball effect eventually pulled in almost everyone in the industry. It’s one of the greatest success stories in the history of computing.