Agile software development

Most agile methods attempt to minimize risk by developing software in short timeboxes, called iterations, which typically last one to four weeks. Each iteration is like a miniature software project of its own, and includes all the tasks necessary to release the mini-increment of new functionality: planning, requirements analysis, design, coding, testing, and documentation. While an iteration may not add enough functionality to warrant releasing the product, an agile software project intends to be capable of releasing new software at the end of every iteration. At the end of each iteration, the team reevaluates project priorities.

Agile methods emphasize realtime communication, preferably face-to-face, over written documents. Most agile teams are located in a bullpen and include all the people necessary to finish software. At a minimum, this includes programmers and their "customers." (Customers are the people who define the product. They may be product managers, business analysts, or actual customers.) The bullpen may also include testers, interaction designers, technical writers, and management.

Agile methods also emphasize working software as the primary measure of progress. Combined with the preference for face-to-face communication, agile methods produce very little written documentation relative to other methods. This has resulted in criticism of agile methods as being undisciplined hacking.

The above covers a few of the most visible aspects of agile development. For a complete list, see the agile manifesto (discussed below).

The Agile Manifesto

Manifesto for Agile Software Development

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more.

Kent Beck, Mike Beedle, Arie van Bennekum, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, Jim Highsmith, Andrew Hunt, Ron Jeffries, Jon Kern, Brian Marick, Robert C. Martin, Steve Mellor, Ken Schwaber, Jeff Sutherland, Dave Thomas

© 2001, the above authors
this declaration may be freely copied in any form, but only in its entirety through this notice.

The authors of the manifesto invited the general public to sign the manifesto. As of April 20th, 2005, the manifesto continues to gain signatures; 29 signatures were added in the period from April 9th to April 20th.

Comparison with other types of methodologies

Agile methods are often characterized as being at the opposite end of a spectrum from "plan-driven" or "disciplined" methodologies. This distinction is misleading, as it implies that agile methods are "unplanned" or "undisciplined." A more accurate distinction is to say that methods exist on a continuum from "adaptive" to "predictive." Agile methods exist on the "adaptive" side of this continuum.

<--Agile--> <--Iterative--> <--Waterfall--> <----|-------------|----------------|-----> Adaptive Predictive Adaptive methods focus on adapting quickly to changing realities. When the needs of a project change, an adaptive team changes with it. Adaptive team have difficulty describing exactly what will happen in the future. The further away a date is, the more vague an adaptive method will be about what will happen on that date. An adaptive team can report exactly what tasks are being done next week, but only which features are planned for next month. When asked about a release six months from now, an adaptive team may only be able to report the mission statement for the release, or a statement of expected value vs. cost.

Predictive methods, in contrast, focus on planning the future in detail. A predictive team can report exactly what features and tasks are planned for the entire length of the development process. Predictive teams have difficulty changing direction. The plan is typically optimized for the original destination and changing direction can cause completed work to be thrown away and done over differently. Predictive teams will often institute a change control board to ensure that only the most valuable changes are considered.

Specific comparisons to other families of methodologies:

Iterative development

Most agile methods are a subset of iterative development methods and share iterative development's emphasis on building releasable software in short time periods. Agile methods differ from iterative methods in that their time period is measured in weeks rather than months. Most agile methods also differ by treating their time period as a strict timebox rather than a planned goal.

The waterfall model

Agile development has less in common with the waterfall model, a discredited but still popular form of software development. The waterfall model is the most predictive of the methodologies, stepping through requirements analysis, design, coding, and testing in a strict pre-planned sequence, partially completing every feature at each stage. The waterfall model produces releasable software at the very end of the cycle, a time period typically extending from several months to several years. Agile methods, in contrast, produce a completely developed features (but a very small set subset of the total) every few weeks.

Some agile teams use the waterfall model within their iteration, spending a few days or a week on each of the waterfall phases. Other teams, most notably Extreme Programming teams, do the activities simultaneously, so that there are no distinguisable phases.

Cowboy coding

Another "method" in common use is cowboy coding. Cowboy coding is the absence of a defined method: team members do whatever they feel is right. Agile development's frequent reevaluation of plans, emphasis on face-to-face communication, and relatively sparse use of documents sometimes causes people to confuse it with cowboy coding. Agile teams, however, do follow defined (and often very disciplined and rigorous) processes, distinguishing agile approaches from cowboy coding.

When to use agile

Agile development has been widely documented as working well for small (<10 developers) colocated teams. Agile development is particularly indicated for teams facing unpredictable or rapidly changing requirements. While there are experience reports of teams succeeding with agile development outside of these parameters, there too few experiences reported as of April 2005 to draw firm conclusions.

Agile development's applicability to the following scenarios is open to question:

• Large scale development efforts (>20 developers)
• Distributed development efforts (non-colocated teams)
• Mission- and life-critical efforts
• Command-and-control company cultures
  

  Boehm and Turner's risk-based approach

Agile home ground:

• Low criticality
• Senior developers
• High requirements change
• Small number of developers
• Culture that thrives on chaos

• High criticality
• Junior developers
• Low requirements change
• Large number of developers
• Culture that demands order

History

Extreme Programming, while not the first agile method, unarguably established the popularity of agile methods. Extreme Programming was created by Kent Beck in 1999 (? confirm date) as a way to rescue the struggling Chrysler Comprehensive Compensation (C3) project. The project was coached full-time by Ron Jeffries and the Extreme Programming methodology was refined through public discussion on Ward Cunningham's Portland Pattern Repository wiki. In early 2001, Kent Beck published the first book on Extreme Programming, _Extreme Programming Explained: Embrace Change_ [2].

Extreme Programming appears to be based on elements of Scrum and Ward Cunningham's Episodes pattern language.

DSDM is considered the first established agile method throughout Europe.

Agile methodologies