This chapter provides guidelines for using architecture patterns.
Patterns for describing Enterprise Architectures are becoming increasingly important to practitioners. The diverse and multi-disciplinary nature of Enterprise Architecture requires that patterns be developed in different disciplines, domains, and levels of detail.
Previous versions of this standard did not fully embrace architecture patterns due to their perceived lack of maturity. Today, many organizations are using patterns to describe their architectures at various levels ranging from software design patterns to business patterns. It remains true that there is no single standard for describing Enterprise Architecture patterns. However, it can be said that there is a pattern for describing patterns.
A "pattern" has been defined as: "an idea that has been useful in one practical context and will probably be useful in others" (Source: Analysis Patterns - Re-usable Object Models, by M. Fowler).
In the TOGAF standard, patterns are considered to be a way of putting building blocks into context; for example, to describe a re-usable solution to a problem. Building blocks are what you use: patterns can tell you how you use them, when, why, and what trade-offs you have to make in doing so.
Patterns offer the promise of helping the architect to identify combinations of Architecture and/or Solution Building Blocks (ABBs/SBBs) that have been proven to deliver effective solutions in the past, and may provide the basis for effective solutions in the future.
Pattern techniques are generally acknowledged to have been established as a valuable architectural design technique by Christopher Alexander, a buildings architect, who described this approach in his book The Timeless Way of Building, published in 1979. This book provides an introduction to the ideas behind the use of patterns, and Alexander followed it with two further books (A Pattern Language and The Oregon Experiment) in which he expanded on his description of the features and benefits of a patterns approach to architecture.
Software and buildings architects have many similar issues to address, and so it was natural for software architects to take an interest in patterns as an architectural tool. Many papers and books have been published on them since Alexander's 1979 book, perhaps the most renowned being Design Patterns: Elements of Re-usable Object-Oriented Software (Gamma et al., 1994). This book describes simple and elegant solutions to specific problems in object-oriented software design.
Several different formats are used in the literature for describing patterns, and no single format has achieved widespread acceptance. However, there is broad agreement on the types of things that a pattern should contain. The headings which follow are taken from Pattern-Oriented Software Architecture: A System of Patterns (Buschmann et al., 1996). The elements described below will be found in most patterns, even if different headings are used to describe them.
- A meaningful and memorable way to refer to the pattern, typically a single word or short phrase.
- A description of the problem indicating the intent in applying the pattern - the intended goals and objectives to be reached within the context and forces described below (perhaps with some indication of their priorities).
- The preconditions under which the pattern is applicable - a description of the initial state before the pattern is applied.
- A description of the relevant forces and constraints, and how they interact/conflict with each other and with the intended
goals and objectives. The description should clarify the intricacies of the problem and make explicit the kinds of trade-offs that
must be considered. (The need for such trade-offs is typically what makes the problem difficult, and generates the need for the
pattern in the first place.) The notion of "forces" equates in many ways to the "qualities" that architects seek to optimize, and
the concerns they seek to address, in designing architectures. For example:
- Security, robustness, reliability, fault-tolerance
- Efficiency, performance, throughput, bandwidth requirements, space utilization
- Scalability (incremental growth on-demand)
- Extensibility, evolvability, maintainability
- Modularity, independence, re-usability, openness, composability (plug-and-play), portability
- Completeness and correctness
- etc., ...
- A description, using text and/or graphics, of how to achieve the intended goals and objectives. The description should identify both the solution's static structure and its dynamic behavior - the people and computing actors, and their collaborations. The description may include guidelines for implementing the solution. Variants or specializations of the solution may also be described.
- Resulting Context
- The post-conditions after the pattern has been applied. Implementing the solution normally requires trade-offs among competing
This element describes which forces have been resolved and how, and which remain unresolved. It may also indicate other patterns that may be applicable in the new context. (A pattern may be one step in accomplishing some larger goal.) Any such other patterns will be described in detail under Related Patterns.
- One or more sample applications of the pattern which illustrate each of the other elements: a specific problem, context, and set of forces; how the pattern is applied; and the resulting context.
- An explanation/justification of the pattern as a whole, or of individual components within it, indicating how the pattern actually works, and why - how it resolves the forces to achieve the desired goals and objectives, and why this is "good". The Solution element of a pattern describes the external structure and behavior of the solution: the Rationale provides insight into its internal workings.
- Related Patterns
- The relationships between this pattern and others. These may be predecessor patterns, whose resulting contexts correspond to the initial context of this one; or successor patterns, whose initial contexts correspond to the resulting context of this one; or alternative patterns, which describe a different solution to the same problem, but under different forces; or co-dependent patterns, which may/must be applied along with this pattern.
- Known Uses
- Known applications of the pattern within existing systems, verifying that the pattern does indeed describe a proven solution to a recurring problem. Known Uses can also serve as Examples.
Patterns may also begin with an Abstract providing an overview of the pattern and indicating the types of problems it addresses. The Abstract may also identify the target audience and what assumptions are made of the reader.
Although design patterns have been the focus of widespread interest in the software industry for several years, particularly in the object-oriented and component-based software fields, it is only recently that there has been increasing interest in architecture patterns - extending the principles and concepts of design patterns to the architecture domain.
The technical literature relating to this field is complicated by the fact that many people in the software field use the term "architecture" to refer to software, and many patterns described as "architecture patterns" are high-level software design patterns. This simply makes it all the more important to be precise in the use of terminology.
The term "design pattern" is often used to refer to any pattern which addresses issues of software architecture, design, or programming implementation. In Pattern-Oriented Software Architecture: A System of Patterns, the authors define these three types of patterns as follows:
- An Architecture Pattern expresses a fundamental structural organization or schema for software systems
It provides a set of predefined subsystems, specifies their responsibilities, and includes rules and guidelines for organizing the relationships between them.
- A Design Pattern provides a scheme for refining the subsystems or components of a software system, or the relationships
It describes a commonly recurring structure of communicating components that solves a general design problem within a particular context.
- An Idiom is a low-level pattern specific to a programming language
An idiom describes how to implement particular aspects of components or the relationships between them using the features of the given language.
These distinctions are useful, but it is important to note that architecture patterns in this context still refers solely to software architecture. Software architecture is certainly an important part of the focus of the TOGAF standard, but it is not its only focus.
In this section we are concerned with patterns for enterprise system architecting. These are analogous to software architecture and design patterns, and borrow many of their concepts and terminology, but focus on providing re-usable models and methods specifically for the architecting of enterprise information systems - comprising software, hardware, networks, and people - as opposed to purely software systems.
Although architecture patterns have not (as yet) been integrated into the TOGAF standard, each of the first four main phases of the ADM (Phases A through D) gives an indication of the stage at which relevant re-usable architecture assets from the Enterprise Architecture Continuum should be considered for use. Architecture patterns are one such asset.
An enterprise that adopts a formal approach to the use and re-use of architecture patterns will normally integrate their use into the Enterprise Architecture Continuum.
Architecture views are selected parts of one or more models representing a complete system architecture, focusing on those aspects that address the concerns of one or more stakeholders. Patterns can provide help in designing such models, and in composing views based on them.
Relevant architecture patterns may well be identified in the work on business scenarios.
- The Patterns Home Page (refer to hillside.net/patterns) hosted by the Hillside Group provides information about patterns, links to online patterns, papers, and books dealing with patterns, and patterns-related mailing lists
- The Patterns-Discussion FAQ (refer to g.oswego.edu/dl/pd-FAQ/pd-FAQ.html) maintained by Doug Lea provides a very thorough and highly readable FAQ about patterns
- Patterns and Software: Essential Concepts and Terminology by Brad Appleton (refer to www.bradapp.com/docs/patterns-intro.html) provides another thorough and readable account of the patterns field
- The SOA Patterns community website (refer to www.soapatterns.org/), dedicated to the ongoing development and expansion of the SOA design pattern catalog
- The Cloud Computing Design Patterns community website (refer to www.cloudpatterns.org)
return to top of page