sadp

1. Pattern-Oriented
Software Architecture:
A System of Patterns
Chapter 1: Patterns- An Introduction
16MDSE25 – SADP Unit 1 – 2025-26 Odd

2. Agenda
•What is a Pattern?
•What Makes a Pattern?
•Pattern Categories
•Relationships between Patterns
•Pattern Description
•Patterns and Software Architecture

3. What is a Pattern?
•A recurring, good solution to a common problem in a specific context.
•Captures proven expertise and design experience.
•Analogy: Architectural patterns (e.g., arch, dome) – proven solutions for
structural problems.

4. Pattern Components
-Name: A handle for referencing the pattern.
- Problem: Describes when to apply the pattern.
- Context: Conditions under which the pattern is applicable.
- Forces: Constraints or issues that influence the problem and solution.
- Solution: A general arrangement of objects and classes.
- Consequences: Results and trade-offs of applying the pattern.
- Examples: Real-world usage scenarios.

5. Features
• A pattern addresses a recurring design problem that arises in specific design
situations, and presents a solution to it.
• Each pattern is a three-part rule, which expresses a relation between a certain
context, a problem, and a solution.
• Patterns identify and specify abstractions that are above the level of single classes
and instances, or of components
• Patterns document existing, well-proven design experience.
• Patterns provide a common vocabulary and understanding for design principles
• Patterns are a means of documenting software architectures
• Patterns support the construction of software with defined properties.
• Patterns help you build complex and heterogeneous sofhoare architectures.

6. Pattern is Defined as …
• A pattern for software architecture describes a
particular recurring design problem that arises
in specific design contexts, and presents a
well-proven generic scheme for its solution.
• The solution scheme is specified by describing
its constituent components, their
responsibilities and relationships, and the
ways in which they collaborate.

7. Why Use Patterns?
•Capture Expert Knowledge: Preserves successful design decisions.
•Promote Reuse: Reuse of design, not just code.
•Improve Communication: Provides a common vocabulary
(e.g., "Use a Singleton here").
•Reduce Development Time & Risk: Leverage pre-existing solutions.
•Enhance Software Quality: Leads to more robust, maintainable,
and flexible systems.
•Facilitate Learning: Easier for new team members to grasp system design.

8. Making a Pattern
• To create a pattern:
1. Observe and identify a recurring design problem.
2. Abstract a solution that effectively resolves the problem.
3. Analyze the context, forces, and consequences.
4. Document the pattern using a consistent template.
5. Validate the pattern through examples and real use cases.

9. Schema

10. What Makes a Pattern? (Structure)
•Most patterns follow a structured format for clarity and completeness.
•Common Sections
•Pattern Name: Unique and descriptive.
•Problem: Clear statement of the issue.
•Context: Situations where it applies.
•Solution: Core design elements, their relationships, and collaborations.
•Consequences: Benefits, drawbacks, trade-offs.
•Known Uses: Real-world examples.
•Related Patterns: Connections to other patterns.
Structure, Dynamics, Implementation may also be described

11. Pattern Categories- A Spectrum of
Abstraction
Patterns exist at different levels of abstraction and scope.
•Architectural Patterns: High-level, overall system structure.
•Design Patterns: Mid-level, class and object interactions.
•Idioms: Low-level, language-specific programming techniques.
•Analysis Patterns: Domain-specific conceptual models.

12. Pattern Categories- Details
• Architectural Patterns:
• Scope: Fundamental structural organization schemes for software systems.
•Granularity: Large-scale, defining the overall system's shape.
Examples:
• Layers: Separates concerns into distinct levels.
• Pipes and Filters: Processing data in a pipeline.
• Model-View-Controller (MVC): Separates data, presentation, and control logic.

13. PatternCategories-Details
Design Patterns:
• Scope: Recurring design problems for communicating objects and classes.
• Granularity: Medium-scale, within subsystems or modules.
• Examples (GoF):
• Creational: Factory Method, Singleton (object creation).
• Structural: Adapter, Decorator (composing classes/objects).
• Behavioral: Observer, Strategy (object communication/behavior).

14. PatternCategories-Details
Idioms:
•Scope: Language-specific implementation techniques.
•Granularity: Small-scale, often code snippets.
•Example:
"Resource Acquisition Is Initialization (RAII)" in C++.

15. Relationships Between Patterns
Patterns rarely stand alone; they form a "system" or "language."
•Complementary: Work well together to achieve a larger goal
(e.g., MVC often uses Observer).
•Alternative: Solve similar problems with different trade-offs.
•Refinement: One pattern provides a more detailed solution for another.
•Composition: A larger pattern built from several smaller ones.
•Variation: One pattern is a specific adaptation of another.

16. Relationships Between Patterns
Importance:
• Helps in pattern selection.
• Enables effective combination.
• Facilitates understanding the pattern landscape.

17. Pattern Systems and Languages
• A pattern system is a cohesive set of patterns that work together.
• A pattern language organizes patterns to guide the entire software
design.
• It defines how patterns interconnect, providing a roadmap for
developing complex systems.

18. Pattern Description (Recap)
• A standardized format is crucial for clear communication and effective application.
• Purpose: To make patterns understandable, shareable, and applicable across
projects.
• Key Sections (summarized):
• Name, Problem, Context, Solution, Consequences.
• Structural and behavioral aspects (often with diagrams).
• Implementation notes, examples, known uses.
• Relationships to other patterns. Image Suggestion: A blueprint graphic or a
document icon with a magnifying glass.

19. Patterns and Software Architecture
•Architectural Drivers: Patterns are fundamental for designing robust,
scalable, and maintainable systems.
•Blueprint for Design: Architectural patterns provide the high-level structural
foundation.
•Common Language: Facilitate communication among architects and
developers.
•System of Patterns: Architectures often arise from the thoughtful composition
and interaction of multiple patterns.
•Addresses Non-Functional Requirements: Patterns help achieve qualities
like performance, security, flexibility, and extensibility.
•Promotes Evolution: Well-architected systems using patterns are easier to
adapt and extend over time.

20. Summary
•What are Patterns? Proven solutions to recurring problems in a given
context.
•Why use them? Enhance quality, communication, productivity, and
maintainability.
•Categories: Range from high-level architectural patterns to low-level idioms
and domain-specific analysis patterns.
•Relationships: Patterns are interconnected, forming a "system of patterns."
•Impact on Architecture: Essential for constructing resilient, flexible, and
understandable software systems.

21. References
• - Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P., & Stal, M.
(1996). Pattern-Oriented Software Architecture – A System of Patterns.
Wiley.
- Gamma et al. (1994). Design Patterns: Elements of Reusable Object-
Oriented Software.
- Alexander, C. (1977). A Pattern Language.