Agile Development: Onverview

8 Agile Development

Agile Development is a family of software engineering approaches designed for fast, flexible delivery of working software. It emphasises short iterations, close customer collaboration, and the ability to respond to change at any stage of the project.

Agile shifts the focus from heavy up-front planning and documentation to continuous feedback, working software, and adaptive planning. It is not a universal solution, but a set of principles and practices that teams tailor to their domain, team size, risk profile, and customer needs.

8.1 Overview of Agile Development

In many business situations, organisations need a working software product soon after stating their requirements. Market pressure, competition, and rapidly changing environments make long, rigid development cycles less feasible. Agile Development was created to address this need for speed and adaptability.

Key characteristics of Agile:

• Flexibility and responsiveness to changing requirements
• Close customer collaboration throughout the project
• Iterative and incremental delivery of working software
• Focus on people and communication over rigid processes

Agile stands in contrast to linear, plan-driven models such as the Waterfall model, which assume requirements are relatively stable and changes are costly and infrequent.

Example: Plan-Driven vs Agile Delivery

• In a traditional plan-driven project, most design and documentation are completed before coding begins, and the customer only sees a working product near the end.
• In an agile project, working features are delivered in short cycles (for example, every 2–4 weeks), enabling the customer to give feedback early and often.

8.1 Agility Principles

The Agile Alliance, through the Agile Manifesto, outlines a set of principles that guide teams in practicing agility. The following twelve principles capture the spirit of Agile development:

1. Customer satisfaction through early and continuous delivery: Deliver valuable working software early and regularly to satisfy the customer.
2. Welcome changing requirements: Even late in development, changes are welcome. Agile processes harness change for the customer’s competitive advantage.
3. Frequent delivery of working software: Deliver operational software frequently (from a couple of weeks to a couple of months), with a preference for the shorter timescale.
4. Close collaboration: Business stakeholders and developers must work together daily throughout the project.
5. Build projects around motivated individuals: Give them the environment and support they need and trust them to get the job done.
6. Face-to-face communication: The most efficient and effective method of conveying information within a development team is face-to-face conversation (or its closest practical equivalent).
7. Working software as the primary measure of progress: Documentation and plans are useful, but working software is the key indicator.
8. Sustainable development: Agile processes promote sustainable development. Sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9. Continuous attention to technical excellence and good design: Good engineering practices and quality design enhance agility.
10. Simplicity: Simplicity—the art of maximizing the amount of work not done—is essential.
11. Self-organising teams: The best architectures, requirements, and designs emerge from self-organising teams.
12. Reflection and adaptation: At regular intervals, the team reflects on how to become more effective and then tunes and adjusts its behaviour accordingly.

These principles form the conceptual foundation of Agile software engineering. Their practical implementation may vary depending on project constraints, domain, and organisational culture.

For further reading on the underlying philosophy, see the Agile Manifesto (Beck et al., 2001).