You are previewing Designing Software Architectures: A Practical Approach.
O'Reilly logo
Designing Software Architectures: A Practical Approach

Book Description

Designing Software Architectures will teach you how to design any software architecture in a systematic, predictable, repeatable, and cost-effective way.

This book introduces a practical methodology for architecture design that any professional software engineer can use, provides structured methods supported by reusable chunks of design knowledge, and includes rich case studies that demonstrate how to use the methods.

Using realistic examples, you’ll master the powerful new version of the proven Attribute-Driven Design (ADD) 3.0 method and will learn how to use it to address key drivers, including quality attributes, such as modifiability, usability, and availability, along with functional requirements and architectural concerns.

Drawing on their extensive experience, Humberto Cervantes and Rick Kazman guide you through crafting practical designs that support the full software life cycle, from requirements to maintenance and evolution. You’ll learn how to successfully integrate design in your organizational context, and how to design systems that will be built with agile methods.

Comprehensive coverage includes

  • Understanding what architecture design involves, and where it fits in the full software development life cycle

  • Mastering core design concepts, principles, and processes

  • Understanding how to perform the steps of the ADD method

  • Scaling design and analysis up or down, including design for pre-sale processes or lightweight architecture reviews

  • Recognizing and optimizing critical relationships between analysis and design

  • Utilizing proven, reusable design primitives and adapting them to specific problems and contexts

  • Solving design problems in new domains, such as cloud, mobile, or big data 

  • Table of Contents

    1. About This E-Book
    2. Title Page
    3. Copyright Page
    4. Contents
    5. Dedication Page
    6. Preface
    7. Acknowledgments
    8. 1. Introduction
      1. 1.1 Motivations
      2. 1.2 Software Architecture
        1. 1.2.1 The Importance of Software Architecture
        2. 1.2.2 Life-Cycle Activities
      3. 1.3 The Role of the Architect
      4. 1.4 A Brief History of ADD
      5. 1.5 Summary
      6. 1.6 Further Reading
    9. 2. Architectural Design
      1. 2.1 Design in General
      2. 2.2 Design in Software Architecture
        1. 2.2.1 Architectural Design
        2. 2.2.2 Element Interaction Design
        3. 2.2.3 Element Internals Design
      3. 2.3 Why Is Architectural Design So Important?
      4. 2.4 Architectural Drivers
        1. 2.4.1 Design Purpose
        2. 2.4.2 Quality Attributes
        3. 2.4.3 Primary Functionality
        4. 2.4.4 Architectural Concerns
        5. 2.4.5 Constraints
      5. 2.5 Design Concepts: The Building Blocks for Creating Structures
        1. 2.5.1 Reference Architectures
        2. 2.5.2 Architectural Design Patterns
        3. 2.5.3 Deployment Patterns
        4. 2.5.4 Tactics
        5. 2.5.5 Externally Developed Components
      6. 2.6 Architecture Design Decisions
      7. 2.7 Summary
      8. 2.8 Further Reading
    10. 3. The Architecture Design Process
      1. 3.1 The Need for a Principled Method
      2. 3.2 Attribute-Driven Design 3.0
        1. 3.2.1 Step 1: Review Inputs
        2. 3.2.2 Step 2: Establish the Iteration Goal by Selecting Drivers
        3. 3.2.3 Step 3: Choose One or More Elements of the System to Refine
        4. 3.2.4 Step 4: Choose One or More Design Concepts That Satisfy the Selected Drivers
        5. 3.2.5 Step 5: Instantiate Architectural Elements, Allocate Responsibilities, and Define Interfaces
        6. 3.2.6 Step 6: Sketch Views and Record Design Decisions
        7. 3.2.7 Step 7: Perform Analysis of Current Design and Review Iteration Goal and Achievement of Design Purpose
        8. 3.2.8 Iterate If Necessary
      3. 3.3 Following a Design Roadmap According to System Type
        1. 3.3.1 Design of Greenfield Systems for Mature Domains
        2. 3.3.2 Design of Greenfield Systems for Novel Domains
        3. 3.3.3 Design for an Existing System (Brownfield)
      4. 3.4 Identifying and Selecting Design Concepts
        1. 3.4.1 Identification of Design Concepts
        2. 3.4.2 Selection of Design Concepts
      5. 3.5 Producing Structures
        1. 3.5.1 Instantiating Elements
        2. 3.5.2 Associating Responsibilities and Identifying Properties
        3. 3.5.3 Establishing Relationships Between the Elements
      6. 3.6 Defining Interfaces
        1. 3.6.1 External Interfaces
        2. 3.6.2 Internal Interfaces
      7. 3.7 Creating Preliminary Documentation During Design
        1. 3.7.1 Recording Sketches of the Views
        2. 3.7.2 Recording Design Decisions
      8. 3.8 Tracking Design Progress
        1. 3.8.1 Use of an Architectural Backlog
        2. 3.8.2 Use of a Design Kanban Board
      9. 3.9 Summary
      10. 3.10 Further Reading
    11. 4. Case Study: FCAPS System
      1. 4.1 Business Case
      2. 4.2 System Requirements
        1. 4.2.1 Use Case Model
        2. 4.2.2 Quality Attribute Scenarios
        3. 4.2.3 Constraints
        4. 4.2.4 Architectural Concerns
      3. 4.3 The Design Process
        1. 4.3.1 ADD Step 1: Review Inputs
        2. 4.3.2 Iteration 1: Establishing an Overall System Structure
        3. 4.3.3 Iteration 2: Identifying Structures to Support Primary Functionality
        4. 4.3.4 Iteration 3: Addressing Quality Attribute Scenario Driver (QA-3)
      4. 4.4 Summary
      5. 4.5 Further Reading
    12. 5. Case Study: Big Data System
      1. 5.1 Business Case
      2. 5.2 System Requirements
        1. 5.2.1 Use Case Model
        2. 5.2.2 Quality Attribute Scenarios
        3. 5.2.3 Constraints
        4. 5.2.4 Architectural Concerns
      3. 5.3 The Design Process
        1. 5.3.1 ADD Step 1: Review Inputs
        2. 5.3.2 Iteration 1: Reference Architecture and Overall System Structure
        3. 5.3.3 Iteration 2: Selection of Technologies
        4. 5.3.4 Iteration 3: Refinement of the Data Stream Element
        5. 5.3.5 Iteration 4: Refinement of the Serving Layer
      4. 5.4 Summary
      5. 5.5 Further Reading
    13. 6. Case Study: Banking System
      1. 6.1 Business Case
        1. 6.1.1 Use Case Model
        2. 6.1.2 Quality Attribute Scenarios
        3. 6.1.3 Constraints
        4. 6.1.4 Architectural Concerns
      2. 6.2 Existing Architectural Documentation
        1. 6.2.1 Module View
        2. 6.2.2 Allocation View
      3. 6.3 The Design Process
        1. 6.3.1 ADD Step 1: Review Inputs
        2. 6.3.2 Iteration 1: Supporting the New Drivers
      4. 6.4 Summary
      5. 6.5 Further Reading
    14. 7. Other Design Methods
      1. 7.1 A General Model of Software Architecture Design
      2. 7.2 Architecture-Centric Design Method
      3. 7.3 Architecture Activities in the Rational Unified Process
      4. 7.4 The Process of Software Architecting
      5. 7.5 A Technique for Architecture and Design
      6. 7.6 Viewpoints and Perspectives Method
      7. 7.7 Summary
      8. 7.8 Further Reading
    15. 8. Analysis in the Design Process
      1. 8.1 Analysis and Design
      2. 8.2 Why Analyze?
      3. 8.3 Analysis Techniques
      4. 8.4 Tactics-Based Analysis
      5. 8.5 Reflective Questions
      6. 8.6 Scenario-Based Design Reviews
      7. 8.7 Architecture Description Languages
      8. 8.8 Summary
      9. 8.9 Further Reading
    16. 9. The Architecture Design Process in the Organization
      1. 9.1 Architecture Design and the Development Life Cycle
        1. 9.1.1 Architecture Design During Pre-Sales
        2. 9.1.2 Architecture Design During Development and Operation
      2. 9.2 Organizational Aspects
        1. 9.2.1 Designing as an Individual or as a Team
        2. 9.2.2 Using a Design Concepts Catalog in Your Organization
      3. 9.3 Summary
      4. 9.4 Further Reading
    17. 10. Final Words
      1. 10.1 On the Need for Methods
      2. 10.2 Next Steps
      3. 10.3 Further Reading
    18. A. A Design Concepts Catalog
      1. A.1 Reference Architectures
        1. A.1.1 Web Applications
        2. A.1.2 Rich Client Applications
        3. A.1.3 Rich Internet Applications
        4. A.1.4 Mobile Applications
        5. A.1.5 Service Applications
      2. A.2 Deployment Patterns
        1. A.2.1 Nondistributed Deployment
        2. A.2.2 Distributed Deployment
        3. A.2.3 Performance Patterns: Load-Balanced Cluster
      3. A.3 Architectural Design Patterns
        1. A.3.1 Structural Patterns
        2. A.3.2 Interface Partitioning
        3. A.3.3 Concurrency
        4. A.3.4 Database Access
      4. A.4 Tactics
        1. A.4.1 Availability Tactics
        2. A.4.2 Interoperability Tactics
        3. A.4.3 Modifiability Tactics
        4. A.4.4 Performance Tactics
        5. A.4.5 Security Tactics
        6. A.4.6 Testability Tactics
        7. A.4.7 Usability Tactics
      5. A.5 Externally Developed Components
        1. A.5.1 Spring Framework
        2. A.5.2 Swing Framework
        3. A.5.3 Hibernate Framework
        4. A.5.4 Java Web Start Framework
      6. A.6 Summary
      7. A.7 Further Reading
    19. B. Tactics-Based Questionnaires
      1. B.1 Using the Questionnaires
      2. B.2 Availability
      3. B.3 Interoperability
      4. B.4 Modifiability
      5. B.5 Performance
      6. B.6 Security
      7. B.7 Testability
      8. B.8 Usability
      9. B.9 DevOps
      10. B.10 Further Reading
    20. Glossary
    21. About the Authors
    22. Index