Adaptive methods offer the ability to cope with changing requirements by adopting an iterative development approach. Iterative development is common to most forms of adaptive methods and provides some considerable advantages over conventional linear development approaches, as typified by the waterfall model. With an iterative approach, the entire project lifecycle is broken up into smaller pieces known as iterations, where each iteration is a complete "mini-waterfall" in its own right.
The approach is largely founded on the spiral model defined by Barry Boehm [Boehm, 1988]. The spiral model forms the basis of modern adaptive methods and is an incremental, risk-averse approach to software development. Boehm's approach was conceived in reaction to the observation that existing linear methods were discouraging more effective approaches to software engineering, such as prototyping and software reuse.
Instead of trying to digest the requirements of a system in one sitting, iterative development avoids heartburn by taking smaller, digestible bites out of the full system. These bites are known as iterations. A typical iteration takes a subset of the requirements through the standard phases of the waterfall model from requirements analysis through to functioning system.
Each iteration is conducted over a short, palatable timeframe, thereby providing near-term milestones for the team to achieve. At the conclusion of the iteration, a demonstrable system is available for inspection by the customer, although ideally the customer should provide input throughout the entire timeframe of the iteration.
Feedback received from the completed iteration is used for planning the objectives and scope of the next iteration. This ongoing planning effort, driven by the feedback from iterations, enables the project to adjust course as new requirements emerge and existing ones are consolidated.
Figure 3-2 shows the basic structure of an iterative development process.
Figure 3-2. Iterative development lifecycle.
Boehm described his approach as being spiral, as the model sees an iteration cycle through the phases of requirements analysis, design, implementation, and testingalthough Boehm's model contained several more phases, including the important activity of risk analysis. Subsequent cycles follow the same path, but the system spirals gradually outward as the software grows in terms of functionality, complexity, and investment.
The Benefits of an Iterative Approach
These next sections highlight the benefits of iterative development.
Accommodates Changing Requirements
A change in requirements can be a schedule-destroying event on a waterfall project if the change occurs downstream of the requirements phase. Iterative development projects are considerably more flexible and can be adjusted midcourse to align the project in the wake of any changes through the essential activity of iteration planning.
Encourages Refinement of System Requirements
Customers are notorious for not knowing what they want until they have seen it in action. This isn't a criticism but an observation of basic human nature, and is something of which we are all guilty.
Having each iteration conclude in a functioning system, demonstrating a subset of the total requirements, enables the end user to build up an accurate picture of how the system will look and behave. Based on this understanding, the end user is empowered to refine the requirements until the system exhibits the required functionality.
Addresses Major Risks Early in the Lifecycle
By continually going through each of the phases of development in each iteration, risks to the project are quickly identified. For example, integration issues can be highlighted in the first iteration when the system is still small. In comparison, the waterfall model will not uncover these same integration problems until late in the project, when the system is of such a bulk that integration problems are not easily remedied.
Produces a Robust Software Architecture
The analysis and design activity isn't carried out just once on an iterative project; it is revisited throughout the lifetime of the development. This enables the design and architecture of the system to evolve as the system grows. Problems can be detected early, and corrections can be more easily effected. Thus, a robust architecture is the result of a process of constant refinement.
Promotes Understanding and Facilitates Software Reuse
Iterative projects break the complexity of a system into manageable chunks. This has the advantage that initial iterations of the system are limited in scope and therefore easily understood by everyone on the team. Developers can build up an early understanding of the design and can appreciate where the system is heading in terms of a final architecture. As the system increases in functionality and consequently grows in complexity, developers can increment their understanding of the system accordingly.
This understanding of the design enables developers to make decisions as to where parts of the system can be reused or where further development is required. Conversely, waterfall projects, which have all design done up front, can leave developers ignorant of large parts of the system architecture. This runs the risk that developers will duplicate existing designs, since they may be unaware of the existence of a suitable component.
Provides a Good Environment for Learning
People learn from their mistakes. They also learn from their experiences. With a waterfall project, having made mistakes in the design phase and gained valuable experience from the design effort, software engineers have to wait until the next project before they can apply those skills again. On an iterative project, engineers can apply the knowledge they have gained from a previous iteration into the next. Thus, the existing project gains from the skills the team is building. Moreover, the team is able to hone its skills as the project progresses.
Software Quality Is Continually Assessed
The waterfall model leaves testing until the last phase of the project. This approach does nothing to mitigate the risk of poor-quality software being generated throughout the project. Often, with waterfall projects, good progress is made up until the point where the testing phase starts. At this time, the project team is deluged with defects, and the project schedule is immediately put in jeopardy. Iterative development has testing commencing early, enabling remedial action to be taken if the quality of the software is below expectations.
Estimates Are More Accurate and Realistic
Long-term plans, like long-term weather forecasts, are often nothing more than a best guess. Waterfall projects suffer badly from the effects of long-term estimation practices. Estimates are built on assumptions that may prove incorrect as the project progresses. Iterative development projects avoid detailed estimation efforts until planning an individual iteration. These estimates are far more realistic because the team is estimating over a much shorter timeframe, and team members have the knowledge accumulated from previous iterations on which to found their estimates. Thus, estimates on iterative developments tend to be accurate, and they increase in accuracy as the team's understanding of the software improves.
The Development Process Itself Can Be Evolved and Adapted
Iterations allow the continuous evolution of the development process, not just the software, as the project progresses. Shortcomings in the approach soon become apparent in early iterations, and the process can be adjusted accordingly between iterations.
Offers a More Enjoyable Team-Working Environment
Here, the team also includes the customer. People thrive on feedback from their efforts. By ensuring a running system is available at the conclusion of each iteration, the team builds up a sense of ownership for the software it creates. Furthermore, positive feedback from the customer helps keeps the team motivated for the course of the project. Likewise, the customer gains security from seeing a working system early in the project lifecycle. Customers also feel in control as they see their ideas and changes being quickly incorporated into their system.
The benefits of iterative development make the approach a central practice for all adaptive methods. In the next sections, we look at two types of adaptive methods. Each follows an incremental, iterative approach to software development: the IBM Rational Unified Process and the agile methodology Extreme Programming (XP).