Software Architecture

Understanding where architecture fits in the software lifecycle is key to making early, high-impact decisions.
This session explores traditional and agile lifecycle models, emphasizing how architecture evolves across phases—from requirements to delivery—and why iterative, incremental design is essential for modern systems.

In this lecture, we explore how to identify, analyze, and engage stakeholders. Learn how stakeholder concerns become architectural drivers and how tools like power-interest grids and salience models help manage complexity.

Not all architecture design methods are created equal.
This lecture presents a classification of software architecture design methods based on scope and source. Understand the difference between single-system and multi-system scope architectures, and identify the various  requirements-, pattern-, and domain-driven architecture design approaches.

In this lecture, we dive into a requirements-driven architecture design method and discuss the limitations of deriving architecture directly from stakeholder requirements.

Explore how established architectural patterns—like Layers, Pipes & Filters, and Blackboard—guide the construction of systems. This lecture covers the pattern selection process and its challenges, from composition to applicability.

Domain-driven design focuses on extracting architectural insights from domain models. Learn how to identify architectural abstractions from domain concepts and how to structure systems that align with expert knowledge and long-term stability.

This lecture introduces domain analysis as a structured method for collecting and organizing domain knowledge. Discover how domain concepts form the building blocks of architecture, and how to conduct analysis systematically.

Learn how to focus your architectural efforts by identifying relevant domains, evaluating knowledge sources, and understanding stakeholder context. This lecture introduces heuristics for selecting high-quality, relevant domain information.

This lecture covers how to represent domain knowledge using models—from feature diagrams to conceptual models. Learn how to capture variability, define reusable components, and support scalable software product lines through domain modeling.

Learn how to use architectural modeling as a foundation for system design. This lecture covers the purpose of modeling, levels of model maturity (sketch, blueprint, executable), and how models guide understanding, communication, and implementation in architecture.

ADLs offer precision beyond informal diagrams. This lecture introduces ADLs, their components (components, connectors, configurations), examples like Wright and UniCon, and their benefits and challenges in modeling and analyzing software architecture.

One system, many perspectives. Understand how architecture views represent a system from the perspective of different stakeholders and concerns. Learn about views, viewpoints, and how to organize architectural knowledge for communication, design, and analysis.

Dive into frameworks like 4+1, Views & Beyond, and C4. This session explains how architecture frameworks structure viewpoints to address concerns systematically, enabling consistency, modularity, and traceability across architectural decisions.

Every system exists within a context. This lecture shows how to model a system’s boundaries and interactions using context diagrams, from black-box views to top-level system scopes—laying the groundwork for clear architectural communication.

Break it down! Learn how to represent the static structure of a system by decomposing it into subsystems and modules. Understand top-down views that help organize complexity, clarify responsibility, and support maintainability.

Understand dependencies between components. The Uses View captures how modules rely on one another, highlighting control and data flow for better modularity and impact analysis. Includes both visual and matrix representations.

Get granular with components. This lecture defines software components, their interfaces (provided/required), and ports. It includes real-world examples and UML-based modeling to show how components interact within the system.

Where does the software live? This session explains how to map software components to physical infrastructure—such as servers, nodes, and networks. Learn how deployment decisions affect performance, reliability, and scalability.

Choosing the right path. Learn how to select an architecture framework based on organizational goals, constraints, tool support, and domain fit. The lecture provides a structured selection process and criteria for evaluating frameworks.

This lecture introduces a structured approach for selecting viewpoints that reflect stakeholder concerns and system priorities. Learn how to identify, map, and prioritize viewpoints to ensure your architecture communicates effectively and supports sound decision-making—without becoming bloated or inconsistent.

In this lecture, we explore best practices for documenting software architecture—from structured views to rationale, from prescriptive blueprints to real-world descriptive records. Learn how to create clear, consistent, and reader-focused documentation that guides development, supports maintenance, and survives evolution.

Architecture design is where strategic thinking meets structure.

This lecture introduces the fundamentals of software architecture design—defining the system’s high-level structure, making key design decisions, and applying engineering principles such as decomposition, abstraction, and modularity. Learn how to move from sketches to blueprints to executable models.

Why invent from scratch when patterns exist?

Explore architecture patterns as proven templates for solving recurring problems. Understand how experienced architects match problems, contexts, and forces with reusable solutions—and how to adapt these patterns to fit specific system needs.

Structure your system like a stack of responsibilities.

The Layers Pattern organizes a system into hierarchical subsystems, each building on services from the layer below. This lecture explains layering principles, modeling strategies, segmenting monolithic layers, and handling practical variations.

Decouple what your system knows, shows, and controls.

This lecture introduces the MVC pattern and its modern variants (MVP, MVVM). Learn how to separate logic from presentation, synchronize user interfaces, and adapt systems for different platforms—all while maintaining architectural clarity.

Streamline complex processing with reusable steps.

This lecture covers the Pipes and Filters pattern, where data flows through independent transformation units. Perfect for systems requiring sequential or parallel data processing. Learn design rules, common variations, and how to model flexible pipelines.

Solve complex problems collaboratively and iteratively.

The Blackboard Pattern enables multiple independent modules to contribute partial solutions to a shared problem. This lecture explores its application in AI, diagnostics, and reasoning systems—where no single module holds all the answers.

The classic model behind distributed systems.

Learn how the Client-Server pattern supports centralized resource sharing, scalability, and maintainability. This lecture covers variations like two-tier, three-tier, and n-tier, and explains how to distinguish logical layers from physical tiers.

Decouple clients and servers in distributed systems.

The Broker Pattern introduces a mediation layer that coordinates remote service calls and dynamic server discovery. Learn how brokers enable location transparency, runtime adaptability, and service proxies in large, heterogeneous systems.

Build modular, interoperable systems through services.

This lecture introduces SOA—an architecture pattern for composing loosely coupled, discoverable services. Learn about service registries, orchestration, standard protocols (REST, SOAP), and designing for reusability and business flexibility.

Design for agility and scale—one service at a time.

Microservices break systems into independently deployable services, each aligned with a specific business function. This lecture contrasts monoliths and microservices, covers key principles (API Gateway, service registry, database per service), and shows how modern cloud-native architectures evolve.

Summary of Part I

Summary of Part 2 - Rationale and Impact Software Architecture

Summary of Part 3 - Software Architecture Design Methods

Summary of Part 4 - Software Architecture Design Patterns