Software Architecture and Architectural Styles

Comprehensive practice flashcards covering software requirements engineering, foundational architecture concepts, architectural tactics, design patterns, and four major architectural styles: Layered, Repository, Pipe-and-Filter, and Microservices.

Requirements Engineering (RE)

A systematic set of activities that identify, document, and communicate the purpose of a software application, serving as a bridge between users' real-world needs and the capabilities delivered by the software.

Software Requirement

A specification of what services, functionalities, or constraints a software system must deliver and satisfy, intentionally omitting how the system should be designed or implemented.

Traceability

An essential requirement quality ensuring that each requirement can be tracked backward to its original stakeholder need or document and forward to the corresponding architectural designs, source code, and test cases.

Software Architecture

The set of principal design decisions made about a software system to be developed, serving as the blueprint for system construction and evolution in terms of components, connectors, configuration, and design rationale.

Software Component

A modular, self-contained unit of software computation or data that encapsulates its internal implementation details and private data while exposing a defined public interface for external access.

Software Connector

An architectural element that enables and governs interactions and data transfers between software components, such as method calls, network API requests, shared memory, message queues, and unidirectional pipes.

Architectural Topology

The structural layout and physical or logical arrangement of software components and their connecting communication pathways within a system.

KWIC (Key Word in Context)

An indexing system that generates an alphabetical index of all circular shifts of lines of text; used as a classic benchmark problem to illustrate how identical functional requirements lead to completely different architectures depending on targeted quality attributes.

Architectural Style

A named, reusable pattern of architectural design decisions that provides a framework defining component types, connector types, structural topology, and design rationale to confer specific quality attributes.

Reference Architecture

A standardized, proven model defining principal design decisions, components, and interactions for an entire application domain to enable rapid product line derivation and interoperability (e.g., Microsoft Office or the ISO OSI model).

Gang of Four (GoF)

The collective name for Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, who cataloged $23$ classic object-oriented design patterns classified across purpose (Creational, Structural, Behavioral) and scope (Class, Object).

Adapter Pattern

A GoF structural design pattern that bridges incompatible interfaces, enabling an existing class to collaborate with other classes by converting its interface into one that clients expect without modifying its source code.

Observer Pattern

A GoF behavioral design pattern establishing a publish-subscribe dependency where a single subject automatically broadcasts state change notifications to an arbitrary number of registered observer objects.

Architectural Tactics

Concrete, reusable design decisions and implementation techniques applied within an architecture to directly satisfy targeted quality attributes such as modifiability, performance, availability, or security.

Layered Architecture Style

An architectural pattern in which software components are structured into a vertical hierarchy where each layer possesses a distinct responsibility, exposes services to the layer above, and relies only on services from the layer below.

Strict Layering

A structural constraint in a layered architecture stipulating that any given layer may invoke only the layer directly beneath it, strictly prohibiting calls that bypass intermediate layers.

Presentation Layer

The top layer of a layered system that manages user input and displays output or error messages to the user while performing no domain decision-making or direct data storage.

Business Logic Layer

The central layer in a layered architecture that enforces domain business rules, validates the legitimacy of user requests, and orchestrates actions without knowing details of user interface presentation or storage implementations.

Data Access Layer

The bottom layer in a layered architecture that interfaces directly with persistent storage (such as memory arrays, files, or databases) to store and retrieve data facts without evaluating business logic.

OSI 7-Layer Model

A foundational networking reference architecture consisting of seven hierarchical abstraction layers: Physical, Data Link, Network, Transport, Session, Presentation, and Application.

Repository Architecture Style

A data-centered architectural style in which a centralized data store maintains the shared system state, and independent, decoupled client components interact strictly through the repository without calling or directly referencing each other.

Passive Repository

A central data store variation where client components must actively query or poll the repository to inspect or retrieve state changes at scheduled intervals or on demand.

Active Repository (Blackboard)

A central data store variation that actively alerts and invokes registered client components via notifications or callbacks whenever relevant data in the central store changes.

Pipe-and-Filter Architecture Style

An architectural pattern where data flows unidirectionally through a chain of discrete, independent processing filters that transform incoming streams and transfer results along connecting pipes without maintaining shared global state.

Filter

A standalone processing element within a pipe-and-filter system that ingests an input data stream, performs a local transformation, and emits an output stream, unaware of preceding or following filters.

Pipe

A unidirectional communication connector that buffers and passes a continuous data stream directly from the standard output of one filter to the standard input of the subsequent filter.

Batch Sequential Pipeline

A legacy pipeline processing model where each processing program executes to complete termination and writes its entire dataset to an intermediate storage buffer (e.g., magnetic tape) before the downstream program begins execution.

Spell-Checker Pipeline

A classic Unix demonstration of pipe-and-filter reuse where an author-written stream splitter (prep) combines with off-the-shelf utilities (sort, uniq, comm) to identify misspelled words across text without custom logic files.

Monolithic Architecture

An architectural approach where all capabilities, including presentation, business rules, and database access logic, are packaged, compiled, and deployed as a single, inseparable executable unit on a server.

Service-Oriented Architecture (SOA)

An enterprise-level architectural paradigm originating in the 2000s that decomposes monolithic apps into coarse-grained, reusable business services communicating via an enterprise service bus ('smart pipes') and shared databases.

Microservices Architecture Style

An architectural style that decomposes an application into a collection of small, autonomous, independently deployable services organized around business capabilities, communicating via lightweight protocols with decentralized data storage.

Bounded Context

A core Domain-Driven Design (DDD) principle designating an explicit boundary within a complex domain inside which a specific domain model, vocabulary, and data store are strictly defined and maintained.

Two-Pizza Team

An organizational rule attributed to Jeff Bezos stating that an engineering team should be small enough to be fed by two pizzas, ensuring autonomous, full lifecycle ownership over an individual microservice.

Conway's Law

A principle formulated by Melvin Conway in 1968 asserting that organizations designing software systems are constrained to produce system architectures that replicate the communication structures of the organization.

Inverse Conway Maneuver

The organizational management tactic of deliberately structuring small, autonomous, cross-functional teams around desired service boundaries to guide the emergence of a decoupled microservices architecture.

Polyglot Persistence

The architectural practice within microservices where each service independently owns its private database, choosing the optimal storage technology (e.g., relational SQL, document store, or key-value) for its unique data requirements.

API Gateway

A single entry-point reverse proxy positioned between clients and microservices that routes incoming traffic, translates protocols, aggregates multi-service responses, and consolidates cross-cutting concerns like authentication and rate limiting.

Circuit Breaker Pattern

A distributed system resiliency pattern that detects repeated remote call failures and halts subsequent requests immediately for a specified duration, preventing resource exhaustion and cascading failures.

Strangler Fig Pattern

A legacy migration pattern formulated by Martin Fowler wherein a monolithic application is gradually replaced by intercepting calls at an API gateway and redirecting them to new microservices until the monolith is retired.

Architectural Styles Comparison

The comparative framework evaluating Layered, Repository, Pipe-and-Filter, and Microservices styles across components, connections, data placement, core strengths, and primary architectural risks.