Chapter 1, The Meaning of Software Architecture, begins the book by providing a definition of software architecture. The book establishes what makes up a software architecture and the reasons why it is important to a software system. It also details the software architect role, including the responsibilities of software architects and what they are expected to know.
Chapter 2, Software Architecture in an Organization, focuses on software architecture in the context of an organization. It covers the different types of software architect roles and software development methodologies that you may encounter. Non-technical topics such as project management, office politics, and risk management are explained. The development of software product lines and the creation of architectural core assets are also covered.
Chapter 3, Understanding the Domain, discusses the business aspects of being a software architect. It covers topics such as familiarizing yourself with your organization's business, domain-driven design (DDD), and how to effectively elicit requirements for the software system from stakeholders.
Chapter 4, Software Quality Attributes, covers software quality attributes and their importance to a software architecture. Some common software quality attributes are presented, including maintainability, usability, availability, portability, interoperability, and testability.
Chapter 5, Designing Software Architectures, concentrates on the important topic of software architecture design. It details what is involved with architecture design and its importance to a software system. The chapter discusses different approaches to architecture design, the drivers for it, and the design principles that can be leveraged during the process.
The chapter presents the use of various systematic approaches to software architecture design, including attribute-driven design (ADD), Microsoft's technique for architecture and design, the architecture-centric design method (ACDM), and the architecture development method (ADM).
Chapter 6, Software Development Principles and Practices, describes proven software development principles and practices that can be used to build high-quality software systems. Concepts such as loose coupling and high cohesion are covered, as well as principles such as KISS, DRY, information hiding, YAGNI, and the Separation of Concerns (SoC).
The chapter includes a discussion of the SOLID principles, which include the single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion principles. The chapter closes with topics related to helping your team succeed, including unit testing, setting up development environments, pair programming, and reviewing deliverables.
Chapter 7, Software Architecture Patterns, discusses one of the most useful software architecture design concepts. Learning the architecture patterns that are available to you and when to properly apply them is a key skill for software architects. The chapter details a number of software architecture patterns, including layered architecture, event-driven architecture (EDA), Model-View-Controller (MVC), Model-View-Presenter (MVP), Model-View-ViewModel (MVVM), Command Query Responsibility Segregation (CQRS), and Service-Oriented Architecture (SOA).
Chapter 8, Architecting Modern Applications, explains the software architecture patterns and paradigms that are used with modern applications deployed to the cloud. After describing a monolithic architecture, the chapter details microservices architecture, serverless architecture, and cloud-native applications.
Chapter 9, Cross-Cutting Concerns, places its focus on functionality that is used in multiple areas of the system. It explains how to handle cross-cutting concerns in your applications. Topics covered include using Dependency Injection (DI), the decorator pattern, and aspect-oriented programming (AOP) to implement cross-cutting concerns. The chapter also provides a look at different cross-cutting concerns, including caching, configuration management, auditing, security, exception management, and logging.
Chapter 10, Performance Considerations, takes a close look at performance. It describes the importance of performance and techniques to improve it. Topics such as server-side caching and database performance are discussed. An examination of web application performance is included in the chapter, including coverage of HTTP caching, compression, minimizing and bundling of resources, HTTP/2, content delivery networks (CDNs), optimizing web fonts, and the critical rendering path.
Chapter 11, Security Considerations, covers the critical topic of software application security. Security concepts such as the confidentiality, integrity, and availability (CIA) triad and threat modeling are presented. The chapter provides readers with various principles and practices for creating software that is secure by design.
Chapter 12, Documenting and Reviewing Software Architectures, places its focus on software architecture documentation and reviewing software architectures. It describes the various uses for software architecture documentation and explains how to use UML to document a software architecture. The chapter discusses various software architecture review methods, including the software architecture analysis method (SAAM), architecture tradeoff analysis method (ATAM), active design review (ADM), and active reviews of intermediate designs (ARID).
Chapter 13, DevOps and Software Architecture, provides coverage of the culture, practices, tools, and culture of DevOps. The chapter explains key DevOps practices such as continuous integration (CI), continuous delivery (CD), and continuous deployment.
Chapter 14, Architecting Legacy Applications, provides readers with an understanding of how to work with legacy applications. The widespread use of legacy applications makes this topic important for software architects. The chapter covers refactoring legacy applications and how to migrate them to the cloud. It discusses modernizing build and deployment processes for legacy applications as well as how to integrate with them.
Chapter 15, The Soft Skills of Software Architects, is all about the soft skills that software architects should possess to be an effective software architect. After describing what soft skills are, the chapter proceeds to topics such as communication, leadership, negotiation, and working with remote resources.
Chapter 16, Evolutionary Architecture, teaches how to design software systems so that they have the ability to adapt to change. It explains that change is inevitable, so software architects should design software architectures that can evolve over time. The chapter explains some of the ways that change can be handled and it introduces the use of fitness functions to ensure that an architecture continues to meet its desired architectural characteristics as it undergoes change.
Chapter 17, Becoming a Better Software Architect, stresses to readers that the process of career development is an ongoing one. After becoming a software architect, one must seek to continuously gain new knowledge and improve their skills. The chapter details ways that a software architect can practice self-improvement, including continuous learning, participating in open source projects, writing your own blog, spending time teaching others, trying new technologies, continuing to write code, attending user groups and conferences, taking responsibility for your work, and attending to your general well-being.