Architectural Pattern
An Architectural Pattern is a design pattern that structures system architectures and component relationships (to solve system design problems and optimize architectural solutions).
- AKA: System Architecture Pattern, Architectural Style Pattern, System Structure Pattern, Architecture Solution Pattern.
- Context:
- It can typically organize System Structure through component arrangement and relationship definition.
- It can typically manage System Complexity through architecture decomposition and component isolation.
- It can typically enable System Quality through architectural property and design attribute.
- It can typically support System Evolution through architecture adaptation and structure modification.
- It can typically guide System Integration through component interaction and interface design.
- ...
- It can often facilitate System Scalability through growth accommodation and capacity expansion.
- It can often improve System Maintainability through component separation and dependency management.
- It can often enhance System Performance through resource optimization and efficiency improvement.
- It can often ensure System Reliability through fault tolerance and failure management.
- ...
- It can range from being a Simple Architecture Pattern to being a Complex Architecture Pattern, depending on its system scope.
- It can range from being a Monolithic Pattern to being a Distributed Pattern, depending on its deployment model.
- It can range from being a Static Architecture Pattern to being a Dynamic Architecture Pattern, depending on its adaptation capability.
- It can range from being a Domain-Specific Pattern to being a General Architecture Pattern, depending on its application scope.
- It can range from being a Concrete Architecture to being an Abstract Architecture, depending on its implementation level.
- ...
- It can have Quality Attributes through architectural property.
- It can have Implementation Guides through pattern application.
- It can have Evaluation Metrics through effectiveness measure.
- ...
- It can have Pattern Language through architectural vocabulary.
- It can have Implementation Framework through software platform.
- It can have Business Impact through risk management.
- ...
- Examples:
- Communication Architecture Patterns, such as:
- Network-Oriented Architecture Patterns, such as:
- Message Exchange Patterns (for system communication), such as:
- Broker Patterns (for service mediation), such as:
- Network-Oriented Architecture Patterns, such as:
- Data Architecture Patterns, such as:
- Data Integration Patterns, such as:
- Extract-Transform-Load Patterns (for data processing), such as:
- Data Storage Patterns (for information management), such as:
- Data Integration Patterns, such as:
- System Organization Patterns, such as:
- Structural Patterns, such as:
- Blackboard Systems (for knowledge integration), such as:
- Action-Domain-Responders (for request handling), such as:
- Structural Patterns, such as:
- Enterprise Integration Patterns, such as:
- System Integration Patterns, such as:
- ...
- Communication Architecture Patterns, such as:
- Counter-Examples:
- Behavioral Design Pattern, which focuses on object interaction rather than system structure.
- Concurrency Pattern, which addresses execution control rather than architectural organization.
- Creational Design Pattern, which manages object creation rather than system architecture.
- Structural Design Pattern, which deals with class composition rather than system composition.
- Implementation Detail, which lacks architectural scope and system perspective.
- Design Decision, which lacks pattern structure and solution reuse.
- Component Specification, which lacks architectural relationship and system context.
- Technical Solution, which lacks architectural principle and pattern guidance.
- See: System Design, Architecture Framework, Design Pattern, System Structure, Component Design, Integration Pattern, Pattern Language, Architecture Style.
References
2022
- (Wikipedia, 2022) ⇒ https://en.wikipedia.org/wiki/architectural_pattern Retrieved:2022-11-9.
- An architectural pattern is a general, reusable solution to a commonly occurring problem in software architecture within a given context.[1] The architectural patterns address various issues in software engineering, such as computer hardware performance limitations, high availability and minimization of a business risk. Some architectural patterns have been implemented within software frameworks.
The use of the word "pattern" in the software industry was influenced by similar concepts as expressed in traditional architecture, such as Christopher Alexander's A Pattern Language (1977) which discussed the practice in terms of establishing a pattern lexicon, prompting the practitioners of computer science to contemplate their own design lexicon.
Usage of this metaphor within the software engineering profession became commonplace after the publication of Design Patterns (1994) by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides—now commonly known as the "Gang of Four"—coincident with the early years of the public Internet, marking the onset of complex software systems "eating the world" and the corresponding need to codify the rapidly sprawling world of software development at the deepest possible level, while remaining flexible and adaptive.
Architectural patterns are similar to software design patterns but have a broader scope.
- An architectural pattern is a general, reusable solution to a commonly occurring problem in software architecture within a given context.[1] The architectural patterns address various issues in software engineering, such as computer hardware performance limitations, high availability and minimization of a business risk. Some architectural patterns have been implemented within software frameworks.
- ↑ Taylor, R.N.; Medvidović, N.; Dashofy, E.M. (2009). Software architecture: Foundations, Theory and Practice. Wiley. ISBN 9780470167748.