Having described what an architecture is, and having defined the characteristics of the architect role, now we can look at some of the themes, or characteristics, that underlie the process of architecting. We will not go into the detail of each task, because this detail is covered throughout the remainder of this book. Also, those characteristics of architecting that can be described in terms of benefits are described later in this chapter.
- [Software architecting represents] the activities of defining, documenting, maintaining, improving, and certifying proper implementation of an architecture. (IEEE 1471 2000)
The scope of architecting is fairly broad. Figure 2.5 shows a metamodel that defines various aspects of the process of software architecting. This metamodel is derived from that given in the IEEE 1471 standard and can be considered to be a road map through the various aspects of architecting that an architect is concerned with. Additional elements of the metamodel will be considered throughout this book. We elaborate on the Architectural Description element, for example, in Chapter 4, "Documenting a Software Architecture," where we consider how an architecture is documented. We provide a complete description of the metamodel used in this book in Appendix A, "Software Architecture Metamodel."
Figure 2.5 A Metamodel of Architecting-Related Terms
The relationships in this metamodel that are taken directly from the IEEE 1471 standard, in words, are
- A system has an architecture.
- A system fulfills one or more missions.
- A system has one or more stakeholders.
- A system inhabits an environment.
- An environment influences a system.
- An architecture is described by an architectural description.
- An architectural description identifies one or more stakeholders.
- An architectural description identifies one or more concerns.
- An architectural description provides rationale.
- A stakeholder has one or more concerns.
- A concern is important to one or more stakeholders.
A side benefit of the IEEE 1471 standard is that it not only applies to documenting a software architecture, but also can be thought of as being a reasoning framework for concepts that architects need to be concerned with in their work. Additional relationships in the figure that are not part of the IEEE 1471 standard are
- A development project is staffed by a team.
- A development project follows a development process.
- A development project develops a system.
- The development process includes architecting.
- The team includes an architect.
- The architect performs architecting
- The architect creates an architecture.
- The architect is a kind of stakeholder.
- Architecting results in an architecture.
- Rationale justifies one or more architecture decisions.
- An architecture decision addresses one or more concerns.
Architecting Is a Science
Architecting is a recognized discipline, albeit one that is still emerging. With this recognition comes an emphasis on techniques, processes, and assets that focus on improving the maturity of the process of architecting. One way to advance this maturity is to draw on an existing body of knowledge. In general terms, architects look for proven solutions when developing an architecture rather than reinventing the wheel, thereby avoiding unnecessary creativity. Codified experience in terms of reference architectures, architectural and design patterns, and other reusable assets also has a part to play.
There is still some way to go, however, before the process of software architecting is anywhere near as mature as, for example, the processes in civil engineering. This maturity can be considered in many dimensions, including the use of standards and an understanding of best practices, techniques, and processes.
Architecting Is an Art
Although architecting can be seen as a science, there is always a need to provide some level of creativity, particularly true when dealing with novel and unprecedented systems. In such cases, no codified experience may be available to draw on. Just as painters look for inspiration when faced with a blank canvas, architects may on occasion see their work as being more like an art than a science. For the most part, however, the artistic side of architecting is minimal. Even in the most novel of systems, it normally is possible to copy solutions from elsewhere and then adapt them to the system under consideration.
As the process of software architecting becomes more mainstream, it is likely that it will no longer be seen as some mysterious set of practices that only the chosen few are able to comprehend, but as a broadly accessible set of well-defined and proven practices that have some scientific basis and are widely accepted.
Architecting Spans Many Disciplines
The architect is involved in many aspects of the software development process beyond architecting:
- The architect assists in the requirements discipline, for example, ensuring that those requirements of particular interest to the architect are captured.
- The architect is involved in prioritizing requirements.
- The architect participates in implementation, defining the implementation structures that will be used to organize the source code as well as executable work products.
- The architect participates in the test discipline, ensuring that the architecture is both testable and tested.
- The architect is responsible for certain elements of the development environment, in terms of defining certain project standards and guidelines.
- The architect assists in defining the configuration management strategy, because the configuration management structures (which support version control) often reflect the architecture that has been defined.
- The architect and project manager work closely together, and the architect has input in the project planning activities.
All these elements are described further later in this book.
Architecting Is an Ongoing Activity
Experience shows that architecting is not something that's performed once, early in a project. Rather, architecting is applied over the life of the project; the architecture is grown through the delivery of a series of incremental and iterative deliveries of executable software. At each delivery, the architecture becomes more complete and stable, which raises the obvious question of what the focus of the architect is through the life of the project.
Successful software architecting efforts are results-driven. Thus, the focus of the architect changes over time as the desired results change over time. This profile is indicated in Figure 2.6, which is attributed to Bran Selic.
Figure 2.6 Project Emphasis over Time
Figure 2.6 shows that early in the project, the architect focuses on discovery. The emphasis is on understanding the scope of the system and identifying the critical features and any associated risks. These elements clearly have an impact on the architecture. Then the emphasis changes to invention; the architect's primary concern is developing a stable architecture that can provide the foundation for full-scale implementation. Finally, the emphasis changes to implementation when the majority of discovery and invention has taken place.
It should be noted that the concerns of discovery, invention, and implementation are not strictly sequential. Some implementation occurs early in the project as architectural prototypes are constructed, and some discovery occurs late in the project as lessons are learned and different strategies for implementing certain elements of the architecture are put in place. This changing emphasis of architecting over time is discussed in more detail in Chapter 3, "Method Fundamentals."
The process of architecting is not complete until the system is delivered; therefore, the architect must be involved until the end of the project. An organization often has a strong desire to remove the architect from a project when the architecture has stabilized so as to use this precious resource on other projects. However, architectural decisions may still need to be made late in the project. In practice, a middle ground is often found: After the major decisions that affect the architecture have been made, the architect becomes a part-time member of the team. The architect should not disengage completely, however. A much more flexible situation exists when the role of the architect is fulfilled by a team, because some of the members may be used on other projects, whereas those who remain continue to ensure the architectural integrity of the system.
Architecting Is Driven by Many Stakeholders
An architecture fulfills the needs of a number of stakeholders. The process of architecting, therefore, must accommodate all these stakeholders to ensure that their concerns—specifically, those that are likely to have an impact on the architecture—are captured, clarified, reconciled, and managed. It is also necessary to involve the relevant stakeholders in any reviews of the solution to these concerns.
Involving all the stakeholders is critical to ensuring a successful outcome in terms of the resulting architecture. The stakeholders influence many aspects of the process, as discussed further in this book, including the manner in which the requirements are gathered, the form in which the architecture is documented, and the way in which the architecture is assessed.
Architecting Often Involves Making Trade-Offs
Given the many factors that influence an architecture, it is clear that the process of architecting involves making trade-offs. Quite often, the trade-off is between conflicting requirements, and the stakeholders may need to be consulted to assist in making the correct trade-off. An example of a trade-off is between cost and performance; throwing more processing power at the problem will improve performance, but at a cost. This may be a conflict in requirements and, assuming that the architect has been diligent in his or her work by exploring all options, is a matter that needs to be resolved with the stakeholders whose needs are in conflict.
Other trade-offs occur in the solution space. The use of one technology over another, one third-party component over another, or even the use of one set of patterns over another are all trade-offs concerned with the solution rather than the requirements. Making trade-offs is not something that the architect can or should avoid. The architect is expected to consider alternatives, and making trade-offs among them is an essential aspect of the process of architecting.
Figure 2.7 provides a simple classification of some of the forces at work in architecting a solution. In addition to the function provided by the system, you must be concerned with nonfunctional requirements that include run-time qualities (such as performance and usability), non-run-time qualities (such as maintainability and portability), business constraints (such as regulatory and resource constraints), and technical constraints (such as mandated technology standards and mandated solution components).
Figure 2.7 Making Trade-Offs Addresses Opposing Forces
Architecting Acknowledges Experience
Architects rarely work from a blank sheet of paper. As noted earlier, they actively seek experience that may be codified in architectural patterns, design patterns, off-the-shelf components, and so on. In other words, the architect seeks out reusable assets. Only the most ignorant architect does not consider what has gone before.
- A reusable asset is a solution to a recurring problem. A reusable asset is an asset that has been developed with reuse in mind. (RAS 2004)
Although it is true that elements of an architecture are reusable in the context of the current system, architects may also look upon their architecture, or elements of it, as reusable assets that can be used outside the current system. The subject of reuse is discussed later in this chapter and in Chapter 5, "Reusable Architecture Assets."
Architecting Is Both Top-Down and Bottom-Up
Many architectures are often considered in a top-down manner, where stakeholder needs are captured and requirements developed before the architecture is defined, architectural elements are designed, and these elements are implemented. Architectures rarely are driven totally from the top down, however. The primary reason is that most systems do not start from a blank sheet of paper. Some heritage usually exists, in the form of existing solution elements that need to be accommodated and that influence the architecture. Such elements range from complete applications that are to be reengineered to mandated design or implementation elements that constraint the architecture. An example might be a constraint that the design will use a relational database or interface to an existing system.
An architecture may also be driven from the bottom up as a result of lessons being learned from any executable software that has been created, such as an architecture proof of concept, where these lessons result in the architecture being refined accordingly.
Successful architects acknowledge that both approaches to architecting are necessary and that their architectures are created both top-down and bottom-up, which could be referred to as the "meet-in-the-middle" approach to architecting.