1/97
Comprehensive practice flashcards defining core vocabulary, concepts, models, and architectural styles across all 14 lecture sources in Software Design and Architecture.
System (systema)
A set of elements (components) that are connected to each other to form a whole, serving a particular purpose or function and taking inputs from the environment to produce outputs.
System Structure
The specific composition and arrangement of interconnected components that make up a system.
System Behaviour
The complex interactions among system components carried out over time to serve the system's purpose in response to internal or external events.
System Boundary
The dividing line between a system and its surroundings/environment, across which inputs enter and outputs leave.
Software System
A system in which all components, connections, and interactions are software entities running on specific hardware.
Model (IEEE 1471)
A simplified description or view of a system that focuses on specific aspects, including identifiable system components, their interfaces, and their interconnections.
Software Architecture
A collection of models of a software system at various abstraction and detail levels describing the system as a whole, its components, their connections, and how they interact to fulfill the system purpose.
Booch's Architectural Analogy
A comparison illustrating that architectural effort must match complexity, risk, and cost of failure: a dog kennel needs little formal planning; a house needs layout, material, and safety planning; and a skyscraper requires extensive analysis and coordination.
Attribute Driven Design (ADD)
An architectural design methodology that takes quality attributes as the starting point and applies architectural tactics to derive the system structure.
Siemens' 4 Views (S4V)
An architectural design method that identifies key architectural challenges and iteratively develops four views: conceptual, execution, module, and code.
Functional Requirements (Malan, 2001)
Descriptions of the behaviour (functions or services) of the IT system that support the users' goals, tasks, or activities.
Non-Functional Requirements (Malan, 2001)
System requirements consisting of constraints and qualities that specify operational attributes rather than specific end-user behaviours.
Constraint (Leffingwell, 2000)
A restriction on the degree of freedom available in providing a software solution, often stemming from technical, legal, or organizational contexts.
System Quality (Malan, 2001)
Properties or characteristics of a system that stakeholders care about and that affect their degree of satisfaction with the system.
Contextual Requirements
Environmental, organizational, technical, market, ethical, or legal factors—such as team expertise, available infrastructure, or regulatory compliance—that shape how a system can be built.
Narrative
A concrete description of a user's interaction with a system used iteratively by analysts and end-users to capture user expectations and illustrate system behavior.
Persona
A fictional character profile detailing demographic traits, goals, and background used to represent a specific user archetype interacting with the system.
Use-Case Map (UCM)
A visual notation showing an activity sequence initiated by an event as a continuous trace drawn across a system's structural components.
Conceptual Architecture
The initial architectural view that organizes a system into components and connectors representing domain-level responsibilities and information flow, independent of runtime deployment.
Conceptual Component
A cohesive set of related domain-level responsibilities derived primarily from functional requirements.
Conceptual Connector
A relationship between conceptual components indicating the exchange and direction of information flow.
Blob (Antipattern)
An architectural design flaw where a single component monopolizes system responsibilities while other components perform trivial single tasks.
Command Cluster (Antipattern)
An architectural design flaw characterized by an excessively high density of connectors among numerous finely fragmented single-responsibility components that should be merged.
Cohesion
A measure of how closely related and focused the responsibilities within a single software component are; high cohesion improves maintainability and reusability.
Coupling
The degree of interdependence between software components across physical, communicational, type system, process control, and platform dimensions.
Temporal Coupling
A coupling condition where the caller and receiver depend on specific execution timing or state sequence, requiring intermediate statuses such as 'pending' during delayed responses.
Execution Architecture
The architectural view focusing on the system's runtime structure, mapping hardware boundaries, concurrent subsystems, processes, and threads to analyze runtime qualities like performance and availability.
Concurrent Subsystem
A top-level execution unit that is long-lived, created at startup, and contains internal processes or threads treating similar processes as a unified runtime entity.
Process
An operating system execution unit running on a single computer that possesses its own dedicated, isolated memory address space.
Thread
A lightweight unit of execution that runs concurrently within the memory space of a parent process, sharing memory and code with sibling threads.

Execution Connector Types (Notation)
Visual conventions used in execution architecture models: (a) Synchronous call, where the caller halts and waits for a response; (b) Asynchronous call, where the caller continues without waiting; (c) Callback, where the caller establishes a mechanism for the callee to return results asynchronously at a later time.

Execution Component Stereotypes (Notation)
Semantic stereotypes for concurrent units: (a) User-initiated, triggered directly by user interaction and featuring an internal event thread; (b) Active, generating activity autonomously via internal loops or timers; (c) Service, waiting passively to fulfill incoming requests from other components.
Race Condition
A concurrency defect occurring when multiple concurrent threads access and modify shared state simultaneously, producing results that depend unpredictably on thread timing.
Heisenbug
A software bug that alters its behavior or disappears entirely when attempting to observe, isolate, or debug it, commonly found in complex concurrent systems.
Implementation Architecture
The architectural view showing how a system is constructed at the source and binary level, detailing packages, classes, libraries, frameworks, and build-time dependencies.
Application Component
A software module or package that directly implements domain-level functional responsibilities defined in the conceptual architecture.
Infrastructure Component
A component necessary for running the application—such as a database server, web server, or framework—that does not implement custom domain logic.
Container Component
A specialized infrastructure component that provides an execution environment for application components and manages their lifecycle across processes and threads.

Implementation Component Stereotypes (Notation)
Graphical stereotypes in implementation architecture diagrams: (a) Infrastructure, representing supporting runtime services; (b) Container, hosting and executing application components; (c) File, representing physical source code or configuration assets.

Implementation Connector Types (Notation)
Structural dependency relations in implementation models: (a) API Call, invoking an in-process interface method; (b) Callback, passing an object reference for deferred invocation; (c) Network protocol, enabling cross-process machine communication; (d) Signal, operating-system level messaging between co-located processes.
Port and Interface Notation
UML component conventions where an interface is shown as a lollipop symbol exposing available services, and a port is shown as a square boundary endpoint managing communication in and out of the component.
Weighted Scoring Method (WSM)
A multi-criteria evaluation technique to select software infrastructure by calculating S(Ai)=∑j=1mSijWj, where Sij is the alternative's score for criterion j and Wj is the criterion's assigned weight.
Technical Prototype
A throwaway, quick implementation used to test technical feasibility, explore framework capabilities, or quantify system parameters without meeting production quality standards.
Executable Prototype
A high-quality architectural skeleton containing end-to-end component structure with partial functionality, designed to be retained and evolved into the final system.
Impact Map
An architectural exploration tool that models which modules and components must change when a requirement, external interface, or quality goal is altered.
Architectural Style (Shaw, 1996)
A family of systems defined by a pattern of structural organization, specifying a vocabulary of component and connector types along with constraints on how they combine.
Antipattern (Brown, 1998)
A commonly occurring software solution or pattern that generates decidedly negative consequences, frequently representing a pattern applied in the wrong context.
Pipes and Filters Style
A data-flow architectural style where independent processing units (filters) transform streams of data received from and passed to communication channels (pipes) without knowing adjacent filters.
Batch-Sequential Style
A data-flow pattern in which each distinct processing stage must complete its full operation across the entire dataset before the subsequent step begins execution.
Typed Pipe
A pipe connector constrained to transport specifically structured, strongly typed data payloads rather than raw character or byte streams, resulting in tighter coupling between connected filters.
Bounded Pipe
A pipe with a predefined maximum buffer capacity that blocks upstream filters from writing once full, providing mechanical backpressure control.
Repository Style
A data-centered style consisting of a passive, centralized data store accessed and manipulated by independent client components via explicit requests.
Blackboard Style
An active data-centered style where a centralized shared repository proactively notifies subscribed expert components when data of interest is updated, allowing them to react incrementally.
Shared-Database Antipattern
A coupling antipattern where multiple independent services read and write directly to a single shared database schema, creating brittle cross-service dependencies.
Closed Layer (Strict Layering)
An architectural constraint in layered designs requiring every call to pass through the immediately adjacent lower layer without skipping any intervening abstraction.
Open Layer (Relaxed Layering)
A layering exception that allows higher layers to bypass an adjacent layer and call directly into a lower shared service layer, reducing boilerplate pass-through code.
Architecture Sinkhole Antipattern
A design issue in strictly layered architectures where requests pass through multiple intermediate layers without any meaningful processing, business logic, or transformation.
N-Tier Architecture
A client-server deployment style that physically segregates code into distinct execution tiers, typically separating presentation, business logic, and database persistence across multiple machines.
Layer vs. Tier
A layer is a logical boundary that organizes responsibilities in source code; a tier is a physical deployment unit, machine, or process boundary where code actually executes.
Rich Client
A client application that possesses complete application logic, dedicated user interface rendering, and local data processing, allowing it to function partially offline.
Thin Client
A lightweight client (such as a standard web browser) that contains minimal application knowledge, relying on a remote server to execute business logic and supply display data.
Display Server
A server-side component (e.g., X11, RDP, cloud gaming engines) that generates and renders graphical interface updates remotely, transmitting display buffers to a thin display client.
Notification Architecture (Publish-Subscribe)
An event-driven style where components publish events to an intermediary or directly to subscribers who have registered their interest, decoupling event producers from event consumers.
Update Storm
A severe performance degradation in publish-subscribe architectures triggered when a single high-profile event prompts millions of immediate cascade notifications simultaneously.
Scale Up (Vertical Scaling)
Increasing system capacity by adding more compute resources—such as faster CPUs or more RAM—to an existing single server machine.
Scale Out (Horizontal Scaling)
Increasing system capacity by adding more physical or virtual server instances across a network, distributing workload using a load balancer.
Stateless Server
A server architecture that does not retain client session context across requests; every request carries all necessary credentials and data, allowing any node to process it.
Peer-to-Peer (P2P) Style
A decentralized network architectural style where every node functions simultaneously as both client and server, sharing data and compute without centralized coordination.
Super Node
A node in hybrid peer-to-peer topologies (such as early Skype) that takes on auxiliary duties, such as peer discovery, routing, or directory maintenance, due to superior bandwidth or availability.
Broker Style
An architectural pattern that decouples clients and remote services by using an intermediary component to locate appropriate services, forward requests, and return responses transparently.
Interceptor Style
A pattern that intercepts incoming or outgoing calls to inject cross-cutting facilities (e.g., logging, security checks, caching) without modifying core application code, honoring the Open-Closed Principle.
Model-View-Controller (MVC)
A UI architectural pattern separating responsibilities into the Model (domain state and business rules), View (display representation), and Controller (translating user input into Model updates).
Heterogeneous Architecture
A realistic software architecture that combines multiple architectural styles at conceptual, execution, and implementation levels to satisfy diverse system requirements.
The Eight Fallacies of Distributed Computing (Peter Deutsch)
Eight false assumptions made by engineers: 1. The network is reliable; 2. Latency is zero; 3. Bandwidth is infinite; 4. The network is secure; 5. Topology doesn't change; 6. There is one administrator; 7. Transport cost is zero; 8. The network is homogeneous.
Accidental Complexity
System complexity that arises directly from the chosen implementation tools, code structures, or engineering methods, rather than being an inherent property of the problem itself.
Locality of Reference (Distributed Context)
The architectural practice of co-locating data with processing code (bringing compute to data) to minimize latency and network overhead.
Share Nothing Architecture
A distributed system design where independent nodes do not share memory or persistent disk storage, allowing near-linear horizontal scalability.
Distributed Lock
A synchronization mechanism across separate machines that guarantees mutual exclusion on a shared resource, preventing simultaneous modification across nodes.
Barrier (Distributed Computing)
A synchronization primitive that causes multiple distributed nodes to pause execution until all participating nodes have reached the barrier state.
Apache ZooKeeper
A centralized coordination service providing high-performance configuration management, distributed locks, synchronization watches, and naming registries for distributed systems.
Sharding
A horizontal data partitioning strategy where separate subsets of a dataset are assigned across different autonomous database servers or network nodes.
Anarchic Scalability
A design characteristic of massive distributed systems (such as the Web) where parts are built independently, tolerating missing, broken, or misbehaving nodes without central management.
Queue and Worker Architecture
An asynchronous distributed pattern where clients deposit request messages into a FIFO queue, and autonomous background workers poll the queue to execute tasks.
At-Least-Once Semantics
A distributed message processing guarantee ensuring every event will be executed, though transient failures or retries may cause an event to be processed more than once.
Exactly-Once Semantics
A rigorous distributed stream processing guarantee ensuring that each incoming event influences state updates exactly one time, avoiding both omissions and duplicate effects.
Lambda Architecture
A big data architecture that handles massive datasets by splitting data flows into a Batch Layer (immutable master dataset), a Speed Layer (low-latency real-time stream views), and a Serving Layer for unified query resolution.
Kappa Architecture
A big data streaming alternative to the Lambda Architecture that eliminates the separate batch pipeline, treating all data processing as an append-only, high-throughput log stream.
Resource-Oriented Architecture (ROA)
A web service architecture characterized by four core principles: addressability through unique URIs, a uniform interface via standard HTTP methods, statelessness, and connectedness via hypermedia links.
Representational State Transfer (REST)
An architectural style for network-based systems that relies on stateless communication, cacheability, client-server separation, uniform resource contracts, and standard HTTP verbs.
HATEOAS (Hypermedia As The Engine Of Application State)
A REST principle where the server supplies hypermedia links inside resource representations, dynamically instructing the client on available state transitions.
Service-Oriented Architecture (SOA)
An enterprise architectural style structuring systems around coarse-grained, discoverable services communicating across an enterprise service bus (ESB) using standardized XML contracts (WSDL/SOAP).
Web Services Description Language (WSDL)
An XML-based standard used in SOAP/SOA architectures to formally specify service endpoints, available operations, parameter schemas, and communication bindings.
Simple Object Access Protocol (SOAP)
A strict, XML-based messaging protocol providing envelope structures for remote procedure calls, supporting standardized security and routing extensions.
Software as a Service (SaaS)
A cloud delivery model where software applications are hosted by a provider and accessed over the web, typically utilizing multi-tenant architectures and subscription billing.
Multi-Tenant Architecture
A software architecture where a single physical application instance and database serve multiple client organizations (tenants), maintaining strict logical isolation of data and configuration.
Microservices Architecture
An architectural style structuring an application as a suite of small, independently deployable, fine-grained services organized around business capabilities, each managing its own isolated datastore.
Open Connect Appliance (OCA)
Dedicated, custom-built hardware appliances deployed by Netflix inside Internet Service Provider networks and IXPs to cache and serve streaming video traffic locally to clients.
Zuul 2
Netflix's asynchronous API gateway built on Netty server and client handlers, utilizing inbound, endpoint, and outbound filters to manage routing, load balancing, and security.