The motivation of the agile approach is already clear from the choice of name: Agile means to be swift or versatile and refers to rapid reaction to changes in framework conditions. The original description was “lightweight”. This was however discarded due to possible negative associations with this term in the course of development.
Agile process models in software development break away from the classic Waterfall Model and its variations. Instead of the fixed sequence of “specification, design and implementation”, the project is carried out in very close and direct collaboration with the customer. The specification gradually occurs during implementation.
One important advantage of agile process models is the collaboration with the customer. The customer receives what he needs and not what he has specified. This is an important benefit for projects whose requirements are still unclear at the beginning or are subject to major changes caused by external influences.
Another advantage is the breakdown of bureaucratic structures, e.g. fewer documents need to be created and maintained. A typical criticism of classic process models is the distance from the client or user. While the specification still occurs in close cooperation, the client often has virtually no influence on the definition of the product during implementation. Agile software development on the other hand generally attempts to manage with less bureaucracy and fewer explicit rules.
The goal of agile software development is to make the development process flexible and slimline. In the development, the focus should rest more on the objectives to be achieved and be able to respond to technical and social problems in the software development.
Agile software development is a counter-movement to heavyweight, bureaucratic and, considered from the outside, traditional software development processes: It considers it important that rules first arise through the team work of the developer group. In this way the rules are more relevant and in turn produce more favorable results.
This viewpoint is specifically represented in the “Agile Manifesto”. In 2001, leading representatives of the agile software development movement met and adopted the agile manifesto. Among the signatories, in addition to Scrum co-founders Mike Beedle, Ken Schwaber and Jeff Sutherland, were luminaries of the scene such as Kent Beck (XP), Alistair Cockburn (Crystal), Ward Cunningham, Martin Fowler, Ron Jeffries, Andrew Hunt (Pragmatic Programmer), Robert C. Martin and Dave Thomas (Ruby on Rails).
The text of the Agile Manifesto reads:
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.
These key messages are deliberately brief and kept somewhat “bold and striking”. To explain this, it can be said of the philosophy behind the single points:
Generally, with all of these principles, the following has to be considered: “more important than” does not mean that the “classic” project characteristics are unimportant. There must, for example, always be plans, contracts and documentation. These should not stand in the way of the agile values or the progress of the project and should only be used where they are actually beneficial.