Synthèse IALTEM - Software Architecture (Vocabulary Flashcards)

Vocabulary flashcards covering key concepts from the lecture notes on software architecture, design views, quality attributes, patterns, styles, and concurrency.

Software architecture

The set of structures of a software system including software elements, their externally visible properties, and the relationships among them; influenced by technical, business, and social factors.

Static structure

The architectural part that is fixed at compile time (code and components) rather than runtime.

Dynamic structure

Runtime aspects of the architecture, including data flows, control flows, and interactions during execution.

External properties

Visible properties of the system from the outside, including behavior and quality attributes.

Quality attributes

Non-functional requirements like security, performance, maintainability, and availability.

Element architectural

A fundamental architectural building block possessing defined responsibilities, a defined boundary, and well-defined interfaces.

Boundary

The dividing line around an architectural element that separates it from others.

Interfaces

Defined entry/exit points that expose the services provided by an element.

Stakeholder

An individual, group, or organization with interests or concerns regarding the architecture.

Concern

An expectation or objective held by a stakeholder; may be conflicting with others.

Architecture Description (AD)

A set of deliverables that document an architecture; the description language should fit the audience.

Candidate architecture

A particular arrangement of static and dynamic structures with potential to meet required behavior and quality properties.

Role of the architect

Lead design and documentation; engage stakeholders; derive and justify architectures; guide realization.

ABC (Architecture Business Cycle)

A seven-phase method for architectural design: case creation, needs understanding, architecture creation/selection, documentation, analysis/evaluation, implementation, maintenance.

ABC Phase 1: Case creation

Identify/involve stakeholders; capture interests; define architecture to address them; guide realization.

ABC Phase 2: Understanding needs

Capture and clarify requirements; recognize informal/chidden factors.

ABC Phase 3: Architecture creation/selection

Create or select an architecture that achieves required behaviors and qualities.

ABC Phase 4: Documentation and communication

Provide clear, unambiguous, stakeholder-tailored documentation; use standard templates.

ABC Phase 5: Analysis and evaluation

Rational justification of choices; assess against quality attributes.

ABC Phase 6: Implementation

Build the system in accordance with the architecture.

ABC Phase 7: Maintenance

Maintain the architecture and its representations over time.

Kruchten 4+1 views

A model using five views (logical, development, process, physical/deployment, and scenarios) to describe software architecture.

Kruchten: Logical view

Functional structure: classes, objects, and their relationships to realize functionality.

Kruchten: Development view

Organization of software modules for developers (component and module concerns).

Kruchten: Process view

Dynamic behavior, concurrency, and interaction of processes at runtime.

Kruchten: Physical/Deployment view

Mapping of software artifacts to hardware nodes and deployment topology.

Kruchten: Scenarios

Use cases illustrating how views interact to fulfill system requirements.

Conceptual integrity

Clarity and coherence of the system design, ideally achieved by a small group collaborating.

Fault

An error or defect occurring in a system that is not necessarily visible to users.

Failure

An event where the system does not perform as expected, visible to users.

Availability

The degree to which a system is ready for and capable of use when needed.

Modifiability

Ease and cost of making changes to the system to accommodate new requirements.

Performance

System responsiveness and throughput; latency, throughput, and resource usage.

Security

Protection of information and services from unauthorized access, disclosure, or disruption.

Testability

Ease and effectiveness of testing a system, including observability and controllability.

Usability

Ease with which users learn, operate, and enjoy the system; includes learnability, efficiency, error tolerance, adaptability, and satisfaction.

Architectural tactics

Techniques used to achieve quality attributes within an architecture.

Singleton

Ensures a class has only one instance and provides a global access point to it.

Abstract Factory

Creates families of related objects without specifying their concrete classes.

Prototype

Creates new objects by cloning a prototype instead of constructing them anew.

Configuration

Centralizes configuration state in a single object to control system behavior.

Facade

Unifies and simplifies access to a set of interfaces in a subsystem.

Decorator

Adds responsibilities to objects dynamically by wrapping them with additional behavior.

Proxy

Controls access to another object, often adding a layer of indirection.

Composite

Treats individual objects and compositions uniformly as part-whole hierarchies.

Bridge

Separates an object's abstraction from its implementation.

Flyweight

Shares many small objects to support large numbers of similar objects efficiently.

Visitor

Encapsulates operations to be performed on elements of an object structure, enabling new operations without changing the objects.

Memento

Captures and externalizes an object's internal state for later restoration.

State

Allows an object to alter its behavior when its internal state changes.

Strategy

Encapsulates interchangeable algorithms; selects one at runtime.

Observer

Defines a one-to-many dependency so that when one object changes, others are notified.

Command

Encapsulates a request as an object, enabling parameterization and queuing of requests.

Interpreter

Transforms a language/grammar into executable actions.

Mediator

Coordinates interactions among a set of objects through a central intermediary.

Immutable

An object whose state cannot be modified after creation.

Read-only object

An object interface that exposes only read access to its state.

Interceptor

Extends or refines a component’s behavior by dynamically adjusting its operations.

Pipes & Filters

Data flows through filters that transform it; pipes carry data between filters.

Publish-Subscribe

Producers publish events; consumers subscribe; a mediator broker routes events.

REST style

Stateless client-server interactions using identified resources, representations, and HATEOAS.

Connection-Oriented Style

Data transfer with an established, managed connection and QoS guarantees.

Connection-Less Style

Data transfer without a persistent connection; typically faster but less reliable.

Client-Server Style

Resources and services served centrally; clients request services from servers.

Client-Stateless Server

Servers do not retain client session state between requests.

Remote Evaluation

Client sends code to be executed remotely by the server.

Code on Demand

Server provides executable code to clients to extend functionality.

Mobile Agent

Code that moves across hosts to perform tasks, reducing network load.

SOA (Service-Oriented Architecture)

Architecture based on publishable services with interoperable interfaces.

ESB (Enterprise Service Bus)

Middleware that routes and transforms messages between service providers and consumers.

Orchestration

Coordinating multiple services to implement a business process.

ETL (Extract, Transform, Load)

Pattern for moving and transforming data from sources into a target system.

MOM (Message Oriented Middleware)

Middleware using queues to store and transport messages between producers and consumers.

Queue operations (PUT/GET/POLL/NOTIFY)

Mechanisms for sending, retrieving, polling, or notifying about messages in queues.