Software Systems Architecture: Viewpoints and Views
This chapter is from the book
This chapter is from the book
This chapter is from the book
When you start the daunting task of designing the architecture of your system, you will find that you have some difficult architectural questions to answer.
- What are the main functional elements of your architecture?
- How will these elements interact with one another and with the outside world?
- What information will be managed, stored, and presented?
- What physical hardware and software elements will be required to support these functional and information elements?
- What operational features and capabilities will be provided?
- What development, test, support, and training environments will be provided?
A common temptation—one you should strongly avoid—is to try to answer all of these questions by means of a single, heavily overloaded, all-encompassing model. This sort of model (and we’ve all seen them) will probably use a mixture of formal and informal notations to describe a number of aspects of the system on one huge sheet of paper: the functional structure, software layering, concurrency, intercomponent communication, physical deployment environment, and so on. Let’s see what happens when we try to use an all-encompassing model in our AD, by means of an example.
As the example shows, this sort of AD is really the worst of all worlds. Many writers on software architecture have pointed out that it simply isn’t possible to describe a software architecture by using a single model. Such a model is hard to understand and is unlikely to clearly identify the architecture’s most important features. It tends to poorly serve individual stakeholders because they struggle to understand the aspects that interest them. Worst of all, because of its complexity, a monolithic AD is often incomplete, incorrect, or out-of-date.
Example
Although the airline reservation system we introduced in Chapter 2 is conceptually fairly simple, in practice some aspects of this system make it very complicated indeed.
- The system’s data is distributed across a number of systems in different physical locations.
- A number of different types of data entry devices must be supported.
- The system must be able to present some information in different languages.
- The system must be able to print tickets and other documents on a wide range of printers.
- The plethora of international regulations complicates the picture even further.
After some discussion, the architect draws up a first-cut architecture for the system, which attempts to represent all of its important aspects in a single diagram. This model includes the full range of data entry devices (including various dumb terminals, desktop PCs, and wireless devices), the multiple physical systems on which data is stored or replicated data is maintained, and some of the printing devices that must be supported (the model does not cover remote printing because it is done at a separate facility). The model is heavily annotated with text to indicate, for example, where multilanguage support is required and where data must be audited, archived, or analyzed to support regulatory requirements.
However, no details of the network interfaces between the different components are included—these are abstracted out into a network icon because they are so complex. (In fact, the network design is probably the most complicated aspect of the architecture, requiring support for a number of different and largely incompatible network protocols, routing over public and private networks, synchronous and asynchronous interactions, and varying levels of service reliability and availability.) Furthermore, the model does not address any of the implications of having the same data distributed around multiple systems.
Because it is so complex and tries to address a wide mix of concerns in the same diagram, the model fails to engage any of the stakeholders. The users find it too complex and difficult to understand (particularly because of the large number of physical hardware components represented). The technology stakeholders, on the other hand, tend to disregard it because of the detail that is left out, such as the network topology. The legal team members can’t use it to satisfy themselves that the regulatory aspects will be adequately handled, and the sponsor finds it completely incomprehensible.
Furthermore, the architect spends an inordinate amount of time keeping it up-to-date—every time a new type of data entry device or printer is discussed, for example, the diagram needs to be updated and reprinted on a very large sheet of paper.
Because of these problems, the diagram soon becomes obsolete and is eventually forgotten. Unfortunately, the issues that the model fails to address do not disappear and thus cause many problems and delays during the implementation and the early stages of live operation.
Principle
It is not possible to capture the functional features and quality properties of a complex system in a single comprehensible model that is understandable by, and of value to, its stakeholders.
We need to represent complex systems in a way that is manageable and comprehensible by a range of business and technical stakeholders. A widely used approach—the only successful one we have found—is to attack the problem from different directions simultaneously. In this approach, the AD is partitioned into a number of separate but interrelated views, each of which describes a separate aspect of the architecture. Collectively, the views describe the whole system.
To help you understand what we mean by a view, let’s consider the example of an architectural drawing for one of the elevations of an office block. This portrays the building from a particular aspect, typically a compass bearing such as northeast. The drawing shows features of the building that are visible from that vantage point but not from other directions. It doesn’t show any details of the interior of the building (as seen by its occupants) or of its internal systems (such as plumbing or air conditioning) that influence the environment its occupants will inhabit. Thus the blueprint is only a partial representation of the building; you have to look at—and understand—the whole set of blueprints to grasp the facilities and experience that the whole building will provide.
Another way that a building architect might represent a new building is to construct a scale model of it and its environs. This shows how the building will look from all sides but again reveals nothing about the mechanisms to be used in its construction, its interior form, or its likely internal environment.
Strategy
A complex system is much more effectively described by a set of interrelated views, which collectively illustrate its functional features and quality properties and demonstrate that it meets its goals, than by a single overloaded model.
Let’s take a look at what this approach means for software architecture.
Architectural Views
An architectural view is a way to portray those aspects or elements of the architecture that are relevant to the concerns the view intends to address—and, by implication, the stakeholders to whom those concerns are important.
This idea is not new, going back at least as far as the work of David Parnas in the 1970s and more recently Dewayne Perry and Alexander Wolf in the early 1990s. However, it wasn’t until 1995 that Philippe Kruchten of the Rational Corporation published his widely accepted written description of views, Architectural Blueprints—The “4 + 1” View Model of Software Architecture. This suggested four different views of a system and the use of a set of scenarios (use cases) to elucidate its behavior. Kruchten’s approach has since evolved to form an important part of the Rational Unified Process (RUP).
IEEE Standard 1471 (the predecessor of ISO Standard 42010) formalized these concepts in 2000 and brought some welcome standardization of terminology. In fact, our definition of a view is based on and extends the one from the original IEEE standard.
Definition
A view is a representation of one or more structural aspects of an architecture that illustrates how the architecture addresses one or more concerns held by one or more of its stakeholders.
When deciding what to include in a view, ask yourself the following questions.
- View scope: What structural aspects of the architecture are you trying to represent? For example, are you trying to define the runtime functional elements and their intercommunication, or the runtime environment and how the system is deployed into it? Do you need to represent the dynamic or static elements of these structures? (For example, in the case of the functional element structure, do you wish to show the elements and the connectors between them, or the sequence of interactions they perform in order to process an incoming request, or both?)
- Element types: What type(s) of architectural element are you trying to categorize? For example, when considering how the system is deployed, do you need to represent individual server machines, or do you just need to represent a service environment (like Force.com SiteForce or Google AppEngine) that your system elements are deployed into?
- Audience: What class(es) of stakeholder is the view aimed at? A view may be narrowly focused on one class of stakeholder or even a specific individual, or it may be aimed at a larger group whose members have varying interests and levels of expertise.
- Audience expertise: How much technical understanding do these stakeholders have? Acquirers and users, for example, will be experts in their subject areas but are unlikely to know much about hardware or software, while the converse may apply to developers or support staff.
- Scope of concerns: What stakeholder concerns is the view intended to address? How much do the stakeholders know about the architectural context and background to these concerns?
- Level of detail: How much do these stakeholders need to know about this aspect of the architecture? For nontechnical stakeholders such as users, how competent are they in understanding its technical details?
As with the AD itself, one of your main challenges is to get the right content into your views. Provide too much irrelevant detail, for example, and your audience will be overwhelmed; too little information, and you risk your audience being confused or making assumptions that may not be valid. There are two key questions you should ask yourself when deciding what to include in a view. First of all, can the stakeholders that it targets use it to determine whether their concerns have been met? And second, can those stakeholders use it to successfully undertake their role in building the system?
We will explore the second question in more detail in Chapter 9, but for now we will summarize these questions as follows.
Strategy
Only include in a view information that furthers the objectives of your AD—that is, information that helps explain the architecture to stakeholders or demonstrates that the goals of the system (i.e., the concerns of its stakeholders) are being met.