Iterative and Incremental
The third fundamental tenet of the Unified Process is its iterative and incremental nature. An iteration is a mini-project that results in a version of the system that will be released internally or externally. This version is supposed to offer incremental improvement over the previous version, which is why the result of an iteration is called an increment.
The section "Iterations and Increments," which appears later in this chapter, describes how iterations and increments fit into the larger context of the overall process. Meanwhile, the following subsections describe the advantages of iterative and incremental development.
Logical Progress Toward a Robust Architecture
An earlier section, "Architecture-Centric," describes the central place of architecture in the Unified Process. The process specifies how the project team should focus on particular aspects of the architecture during each of the iterations of the system. During early iterations, the team puts together a candidate architecture that offers the beginnings of a solid foundation; later iterations find the team expanding the vision of the full architecture, which in turn influences most, and in some cases all, of the development tasks being performed as part of a given iteration. Building the architecture in an iterative and incremental fashion enables the team to make necessary major changes early in the process at considerably less cost than they would inflict later in the project.
Dealing With Ongoing Changes in Requirements
Processes based on the waterfall approach, which dictates that all of the requirements be gathered and analyzed before design starts, face what now seems to be an inevitable problem: Requirements tend to be unstable. Also, customers have difficulty envisioning a system when all they have is documentation. The Unified Process advocates breaking the system down into builds, where each build is a working version of some meaningful chunk of the full system. By focusing on bounded sets of use cases and making effective use of prototypes, the project team and the customers can negotiate requirements on an ongoing basis, thus reducing the (often very large) risk associated with trying to specify all of the requirements up front. One of the reviewers of the manuscript for this book indicated that his company practices "ruthless prioritization," which involves dealing with changing requirements by aggressively identifying priorities and eliminating lower-priority features from consideration.
Greater Flexibility to Change the Plan
Since each iteration is a mini-project, the project team addresses, to some extent, all the risks associated with the project as a whole each time it builds an increment of the system. As risks become greater, as delays occur, and as the environment becomes more unstable, the team is able to make necessary adjustments on a relatively small scale and propagate those adjustments across the entire project. During the postmortem for each iteration, the project leaders can decide whether the iteration was a success and change the iteration plan as appropriate before work proceeds with the next iteration. The goal is to isolate problems within iterations and deal with them on a relatively small scale, rather than allowing them to spread.
Each increment brings a combination of new features and improved functionality to the system. This enables all the stakeholders to measure the progress of the project toward specific goals, rather than toward more abstract and general requirements. By continually integrating new increments, the development team is also able to isolate problems that it might bring to the system and address those problems in ways that don't disrupt the integrity of the working system. This kind of setup makes it easier for the team to go as far as throwing a particular increment away and starting over, since the process gives it the ability to define iterations that take less time to perform.
Each of the activities that the team performs during an iteration is straight-forwardly defined, as is the sequence of activities within each workflow and across workflows. The process is designed to enable reliance on things like ongoing mentoring, rather than forcing people to go through extensive training before becoming productive members of the team. Well-defined iterations allow room to experiment and make mistakes, because those mistakes will be isolated such that their impact on schedule and budget can be minimized. As work proceeds, the team can leverage its understanding of what it's trying to build and the associated risks, thus building momentum, which in turn enables the team to make continuous improvements in the way it goes about its tasks.
Ongoing Focus on Risk
Perhaps the most important advantage that iterative and incremental development, as defined by the Unified Process, brings to the table is the project team's ability to focus its efforts on addressing the most critical risks early in the life cycle. The team has a mandate to organize iterations based on addressing risks on an ongoing basis; the goal is to mitigate risks to the greatest extent possible during each iteration, so each iteration poses fewer risks of less importance than its predecessors.
Various people have come up with many different ways to categorize risks to software development projects. See UML Distilled (Martin Fowler with Kendall Scott; Addison-Wesley, 1999) for one view of risks. Three categories of risks useful in discussing the Unified Process are described next.
Technical risks are those associated with the various technologies that will come into play during the project and with issues such as performance and the "-ilities" (reliability, scalability, and so forth). For example, if the system will use Enterprise Java Beans (EJBs) in the context of the Common Object Request Broker Architecture (CORBA), the project team must solve a number of potential technical problems along the way to building a system that will perform acceptably. The process doesn't specifically address technical risks; however, the emphasis on architecture (see below) reflects the principle that the team should address technical risks early, before coding starts.
Architectural risks are those associated with the ability of the architecture to serve as a strong foundation of the system and also be sufficiently resilient and adaptable to the addition of features in future releases of the system. Risks associated with "make versus buy" decisions are also part of this category. The process addresses architectural risks by defining activities that involve analyzing, designing, and implementing the architecture, and by defining a number of other activities that include keeping the architecture description up to date so it can assume its place front and center within the development effort.
Requirements risk is the risk of not building the right systemthe system that the customers are paying forby not understanding the requirements and not using associated use cases to drive development. The process addresses requirements risk with activities specifically defined to facilitate the discovery and negotiation of requirements and with its premise that use cases should drive all aspects of development.