You are previewing Practical Software Architecture: Moving from System Context to Deployment.
O'Reilly logo
Practical Software Architecture: Moving from System Context to Deployment

Book Description

Getting Architecture Just Right: Detailed Practical Guidance for Architecting Any Real-World IT Project

To build effective architectures, software architects must tread a fine line between precision and ambiguity (a.k.a. big animal pictures). This is difficult but crucial: Failure to achieve this balance often leads directly to poor systems design and implementation. Now, pioneering IBM Distinguished Engineer and Chief Technology Officer Tilak Mitra offers the first complete guide to developing end-to-end solution architectures that are “just enough”--identifying and capturing the most important artifacts, without over-engineering or excessive documentation, and providing a practical approach to consistent and repeated success in defining software architectures.

Practical Software Architecture provides detailed prescriptive and pragmatic guidance for architecting any real-world IT project, regardless of system, methodology, or environment. Mitra specifically identifies the artifacts that require emphasis and shows how to communicate evolving solutions with stakeholders, bridging the gap between architecture and implementation.

Through a real-world case study, Mitra guides you iteratively through building an end-to-end solution architecture. Step by step, he addresses key topics in developing system contexts, architecture overviews, architecture decisions, functional models, operational models, integration patterns for systems design, infrastructure matters, and more. Throughout, you’ll find clear, crisp, and accurate guidance for crafting architectures that can be confidently delivered on time and budget.

Coverage Includes

  • Using architecture to promote communication, enable planning, and support functional as well as nonfunctional capabilities (such as scalability, performance, maintainability, and security)

  • Focusing on the architectural problem at hand and avoiding overreliance on theory and generalization

  • An architectural introduction to analytics

  • Capturing “just enough” about system context, architecture overview, architecture decisions, functional models, and operational models

  • Integration patterns and their usage in architecture design

  • Infrastructure matters in any software architecture

  • A real-world case study and its software architecture

  • Table of Contents

    1. About This E-Book
    2. Title Page
    3. Copyright Page
    4. Dedication
    5. Contents
    6. Foreword
    7. Preface
    8. Acknowledgments
    9. About the Author
    10. Chapter 1. Case Study
      1. The Business Problem
        1. The Technical Challenge
        2. Use Cases
      2. Summary
    11. Chapter 2. Software Architecture: The What and Why
      1. Some Background
      2. The What
      3. The Why
        1. A Communication Vehicle
        2. Influences Planning
        3. Addresses Nonfunctional Capabilities
        4. Contracts for Design and Implementation
        5. Supports Impact Analysis
      4. Architecture Views and Viewpoints
      5. Summary
      6. References
    12. Chapter 3. Capturing Just Enough
      1. Architecture Aspects in Focus
      2. Summary
    13. Chapter 4. The System Context
      1. The Business Context Versus System Context Conundrum
      2. Capturing the System Context
        1. The System Context Diagram
        2. The Information Flows
      3. Case Study: System Context for Elixir
        1. Elixir: System Context Diagram
        2. Elixir: Information Flows
      4. Summary
      5. References
    14. Chapter 5. The Architecture Overview
      1. What It Is
      2. Why We Need It
      3. The Enterprise View
        1. Users and Delivery Channels
        2. Core Business Processes
        3. Data and Information
        4. Technology Enablers
      4. The Layered View
        1. Layer 1: Operational Layer
        2. Layer 2: Service Components Layer
        3. Layer 3: Services Layer
        4. Layer 4: Business Process Layer
        5. Layer 5: Consumers Layer
        6. Layer 6: Integration Layer
        7. Layer 7: QoS Layer
        8. Layer 8: Information Architecture Layer
        9. Layer 9: Governance Layer
        10. Further Tips on Using the Layered View
      5. The IT System View
      6. Case Study: Architecture Overview of Elixir
        1. Elixir: Enterprise View
        2. Elixir: Layered View
        3. Elixir: IT System View
      7. Summary
      8. References
    15. Chapter 6. Architecture Decisions
      1. Why We Need It
      2. How to Get Started
      3. Creating an Architecture Decision
      4. Case Study: Architecture Decisions for Elixir
      5. Summary
    16. Chapter 7. The Functional Model
      1. Why We Need It
      2. A Few Words on Traceability
      3. Developing the Functional Model
        1. Logical-Level Design
        2. Specified-Level Design
        3. Physical-Level Design
      4. Case Study: Functional Model for Elixir
        1. Logical Level
        2. Specified Level
        3. Physical Level
      5. Summary
      6. References
    17. Chapter 8. The Operational Model
      1. Why We Need It
      2. On Traceability and Service Levels
      3. Developing the Operational Model
        1. Conceptual Operational Model (COM)
        2. Specification Operational Model (SOM)
        3. Physical Operational Model (POM)
      4. Case Study: Operational Model for Elixir
        1. COM
        2. SOM
        3. POM
      5. Summary
      6. References
    18. Chapter 9. Integration: Approaches and Patterns
      1. Why We Need It
      2. Approaches to Integration
        1. User Interface Integration
        2. Data-Level Integration
        3. Message-Level Integration
        4. API-Level Integration
        5. Service-Level Integration
      3. Integration Patterns
        1. Synchronous Request-Response
        2. Batch
        3. Synchronous Batch Request-Response
        4. Asynchronous Batch Request-Response
        5. Store and Forward
        6. Publish-Subscribe
        7. Aggregation
        8. Pipes and Filters
        9. Message Router
        10. Message Transformer
      4. Case Study: Integration View of Elixir
        1. Following Flow Labels 1 Through 5
        2. Following Flow Labels 6 Through 8
        3. Following Flow Labels 9 and 10
        4. Following Flow Labels 11 and 12
      5. Summary
      6. References
    19. Chapter 10. Infrastructure Matters
      1. Why We Need It
      2. Some Considerations
        1. Networks
        2. Hosting
        3. High Availability and Fault Tolerance
        4. Disaster Recovery
        5. Capacity Planning
      3. Case Study: Infrastructure Considerations for Elixir
      4. Summary
      5. So Where Do We Stand?
      6. References
    20. Chapter 11. Analytics: An Architecture Introduction
      1. Why We Need It
      2. Dimensions of Analytics
        1. Operational Analytics
        2. Descriptive Analytics
        3. Predictive Analytics
        4. Prescriptive Analytics
        5. Cognitive Computing
      3. Analytics Architecture: Foundation
        1. The Layered View: Layers and Pillars
        2. The Horizontal Layers
        3. The Vertical Layers
        4. The Pillars
      4. Architecture Building Blocks
        1. Data Types ABBs
        2. Data Acquisition and Access ABBs
        3. Data Repository ABBs
        4. Models ABBs
        5. Data Integration and Consolidation ABBs
        6. Analytics Solutions ABBs
        7. Consumers ABBs
        8. Metadata ABBs
        9. Data and Information Security ABBs
        10. Descriptive Analytics ABBs
        11. Predictive Analytics ABBs
        12. Prescriptive Analytics ABBs
        13. Operational Analytics ABBs
        14. Cognitive Computing ABBs
      5. Summary
      6. References
    21. Chapter 12. Sage Musings
      1. Agility Gotta Be an Amalgamate
      2. Traditional Requirements-Gathering Techniques Are Passé
      3. The MVP Paradigm Is Worth Considering
      4. Do Not Be a Prisoner of Events
      5. Predictive Analytics Is Not the Only Entry Point into Analytics
      6. Leadership Can Be an Acquired Trait
      7. Technology-Driven Architecture Is a Bad Idea
      8. Open Source Is Cool but to a Point
      9. Write Them Up However Trivial They May Seem
      10. Baseline Your Architecture on Core Strengths of Technology Products
      11. Summary
      12. References
    22. Appendix A. 25 Topic Goodies
      1. What Is the Difference Between Architecture and Design?
      2. What Is the Difference Between Architectural Patterns, Design Patterns, and a Framework?
      3. How Can We Compare a Top-Down Functional Decomposition Technique and an Object-Oriented Analysis and Design (OOAD) Technique?
      4. What Is the Difference Between Conceptual, Specified, and Physical Models?
      5. How Do Architecture Principles Provide Both Flexibility and Resilience to Systems Architecture?
      6. Why Could the Development of the Physical Operational Model (POM) Be Broken into Iterations?
      7. What Is a Service-Oriented Architecture?
      8. What Is an Event-Driven Architecture?
      9. What Is a Process Architecture?
      10. What Is a Technology Architecture?
      11. What Is an Adapter?
      12. What Is a Service Registry?
      13. What Is a Network Switch Block?
      14. What Are Operational Data Warehouses?
      15. What Is the Difference Between Complex Event Processing (CEP) and Stream Computing?
      16. What Is the Difference Between Schema at Read and Schema at Write Techniques?
      17. What Is a Triple Store?
      18. What Is a Massively Parallel Processing (MPP) System?
      19. IBM Watson Is Built on DeepQA Architecture. What Is DeepQA?
      20. What Is the Difference Between Supervised and Unsupervised Learning Techniques?
      21. What Is the Difference Between Taxonomy and Ontology?
      22. What Is Spark and How Does It Work?
      23. What Are Some of the Advantages and Challenges of the Cloud Computing Platform and Paradigm?
      24. What Are the Different Cloud Deployment Models?
      25. What Is Docker Technology?
      26. Summary
      27. References
    23. Appendix B. Elixir Functional Model (Continued)
      1. Logical Level
        1. Component Identification
        2. Component Collaboration
      2. Specified Level
        1. Component Responsibility Matrix
        2. Interface Specification
        3. Associate Data Entries with Subsystems
        4. Component Assignment to Layers
      3. Physical Level
    24. Index
    25. Code Snippets