This section revisits the best practices introduced by Grady Booch in Chapter 1 and maps them to major components of the Rational Unified Process. The RUP, however, contains many other best practices in all aspects of software development.
The iterative approach recommended by the Rational Unified Process is generally superior to a linear, or waterfall, approach for a number of reasons:
It lets you take into account changing requirements. The truth is that requirements usually change. Changing requirements and requirements "creep" have always been primary sources of project trouble, which lead to late delivery, missed schedules, unsatisfied customers, and frustrated developers.
In the Rational Unified Process, integration is not one "big bang" at the end; instead, elements are integrated progressively. This iterative approach is almost a process of continuous integration. What used to be a lengthy time of uncertainty and pain—taking up to 40% of the effort at the end of a project—is now broken into six to nine smaller integrations that begin with far fewer elements to integrate.
The iterative approach lets you mitigate risks earlier because integration is generally the only time that risks are discovered or addressed. As you unroll the early iterations, you go through all process components, exercising many aspects of the project, such as tools, off-the-shelf software, people skills, and so on. Perceived risks will prove not to be risks, and new, unsuspected risks will be revealed.
It provides management with a means of making tactical changes to the product for whatever reason, for example, to compete with existing products. You can decide to release a product early with reduced functionality to counter a move by a competitor, or you can adopt another vendor for a given technology.
It facilitates reuse because it is easy to identify common parts as they are partially designed or implemented instead of identifying all commonality in the beginning before anything has been designed or implemented. Identifying and developing reusable parts is difficult. Design reviews in early iterations allow architects to identify unsuspected potential reuse and then develop and mature common code for it in subsequent iterations.
It results in a very robust architecture because you correct errors over several iterations. Flaws are detected even in the early iterations as the product moves beyond inception into elaboration rather than in one massive testing phase at the end. Performance bottlenecks are discovered at a time when they can still be addressed instead of creating panic on the eve of delivery.
Developers can learn along the way, and their various abilities and specialties are employed more fully during the entire lifecycle. Testers start testing early, technical writers write early, and so on. In a noniterative development, the same people would be waiting around to begin their work, making plan after plan but not making concrete progress. What can a tester test when the product consists only of three feet of design documentation on a shelf? Training needs or the need for additional people is spotted early, during assessment reviews.
The development process itself can be improved and refined along the way. The assessment at the end of an iteration not only looks at the status of the project from a product/schedule perspective but also analyzes what should be changed in the organization and in the process to make it perform better in the next iteration.
Project managers often resist the iterative approach, seeing it as a kind of endless and uncontrolled hacking. In the Rational Unified Process, the iterative approach is very controlled; iterations are planned in number, duration, and objectives. The tasks and responsibilities of the participants are defined. Objective measures of progress are captured. Some reworking takes place from one iteration to the next, but this, too, is controlled carefully.
Chapter 4 describes this iterative approach in more detail, and Chapter 7 describes how to manage an iterative process and, in particular, how to plan it.
Requirements management is a systematic approach to eliciting, organizing, communicating, and managing the changing requirements of a software-intensive system or application.
The benefits of effective requirements management include the following:
Better control of complex projects
Lack of understanding of the intended system behavior and requirements "creep" are common factors in out-of-control projects.
Improved software quality and customer satisfaction
The fundamental measure of quality is whether a system does what it is supposed to do. This can be assessed only when all stakeholders2 have a common understanding of what must be built and tested.
Reduced project costs and delays
Fixing errors in requirements is very expensive; therefore, decreasing these errors early in the development cycle cuts project costs and prevents delays.
Improved team communication
Requirements management facilitates the involvement of users early in the process, helping to ensure that the application meets their needs. Well-managed requirements build a common understanding of the project needs and commitments among the stakeholders: users, customers, management, designers, and testers.
In Chapter 9, The Requirements Discipline, we revisit and expand on this important feature of the Rational Unified Process. Chapter 13, The Configuration and Change Management Discipline, discusses the aspects related to tracking changes.
Architecture and Use of Components
Use cases drive the Rational Unified Process throughout the entire lifecycle, but the design activities are centered on the notion of architecture—either system architecture or, for software-intensive systems, software architecture. The main focus of the early iterations of the process is to produce and validate a software architecture that, in the initial development cycle, takes the form of an executable architectural prototype that gradually evolves to become the final system in later iterations.
The Rational Unified Process provides a methodical, systematic way to design, develop, and validate an architecture. It offers templates for describing an architecture based on the concept of multiple architectural views. It provides for the capture of architectural style, design rules, and constraints. The design process component contains specific activities aimed at identifying architectural constraints and architecturally significant elements, as well as guidelines on how to make architectural choices. The management process shows how planning the early iterations takes into account the design of an architecture and the resolution of the major technical risks.
A software component can be defined as a nontrivial piece of software, a module, a package, or a subsystem that fulfills a clear function, has a clear boundary, and can be integrated into a well-defined architecture. It is the physical realization of an abstraction in your design. Component-based development can take various flavors:
In defining a modular architecture, you identify, isolate, design, develop, and test well-formed components. These components can be tested individually and integrated gradually to form the whole system.
Furthermore, some of these components can be developed to be reusable, especially the components that provide common solutions to a wide range of common problems. These reusable components are typically larger than mere collections of utilities or class libraries. They form the basis of reuse within an organization, thereby increasing overall software productivity and quality.
More recently, the advent of commercially successful infrastructures that support the concept of software components has launched a whole industry of off-the-shelf components for various domains, allowing developers to buy and integrate components rather than develop them in-house.
The first point exploits the old concepts of modularity and encapsulation, bringing the concepts underlying object-oriented technology a step further. The final two points shift software development from programming software (one line at a time) to composing software (by assembling components).
The Rational Unified Process supports component-based development in several ways:
The iterative approach allows developers to identify components progressively and decide which ones to develop, which ones to reuse, and which ones to buy.
The focus on software architecture allows you to articulate the structure. The architecture enumerates the components and the ways they integrate as well as the fundamental mechanisms and patterns by which they interact.
Concepts such as packages, subsystems, and layers are used during analysis and design to organize components and specify interfaces.
Testing is organized around single components first and then is gradually expanded to include larger sets of integrated components.
Chapter 5 defines and expands the concept of architecture and its central role in the Rational Unified Process.
Modeling and the UML
A large part of the Rational Unified Process is about developing and maintaining models of the system under development. Models help us to understand and shape both the problem and its solution. A model is a simplification of the reality that helps us master a large, complex system that cannot be comprehended in its entirety. We introduce several models in this book: a use-case model (Chapter 6), business models (Chapter 8), and design models and analysis models (Chapter 10).
The Unified Modeling Language (UML) is a graphical language for visualizing, specifying, constructing, and documenting the artifacts of a software-intensive system. The UML gives you a standard means of writing the system's blueprints, covering conceptual items such as business processes and system functions as well as concrete items such as classes written in a specific programming language, database schemas, and reusable software components.3
The UML is a common language to express the various models, but it does not tell you how to develop software. It provides the vocabulary, but it doesn't tell you how to write the book. That is why Rational has developed the Rational Unified Process hand-in-hand with the UML to complement our work with the UML. The Rational Unified Process is a guide to the effective use of the UML for modeling. It describes which models you need, why you need them, and how to construct them. RUP 2000 and later versions use UML version 1.4.
Configuration and Change Management
Particularly in an iterative development, many work products are modified and modified often. By allowing flexibility in the planning and execution of the development and by allowing the requirements to evolve, iterative development emphasizes the vital issues of tracking changes and ensuring that everything and everyone is in sync. Focused closely on the needs of the development organization, change management is a systematic approach to managing changes in requirements, design, and implementation. It also covers the important activities of keeping track of defects, misunderstandings, and project commitments as well as associating these activities with specific artifacts and releases. Change management is tied to configuration management and to measurements.
Chapter 13, The Configuration and Change Management Discipline, expands on these important aspects of software management and their interrelationships.