Software Systems Architecture: Viewpoints and Views
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.
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.
Let’s take a look at what this approach means for software architecture.
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.
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.