WS4 - ASE - Software Architecture: Layers, Ports & Adapters, Domain Logic, and MVC Patterns

Comprehensive vocabulary flashcards covering structural software architecture patterns, including Layers, Ports & Adapters (Hexagonal Architecture), Domain Logic organization (Transaction Script and Domain Model), and Model-View-Controller (MVC) and its modern variants.

Layers Pattern

An architectural pattern that structures applications into groups of subtasks where each group is positioned at a particular level of abstraction, granularity, hardware-distance, or other partitioning criteria.

Strict Layering

A pure form of the Layers pattern in which higher-level layers access lower-level layers strictly through the adjacent layer directly beneath them, prohibiting layer bypassing.

Presentation Layer

The enterprise application layer responsible for providing services, displaying information (such as in Windows or HTML), and handling user requests, HTTP requests, command-line invocations, and batch APIs.

Domain Layer

The enterprise application layer that encapsulates the business logic representing the core objective and real point of the system.

Data Source Layer

The enterprise application layer dedicated to communication with databases, messaging systems, transaction managers, and external packages.

Cascading Changes

A downside of layered architectures where modifying or adding an element (such as a UI field that must be persisted in a database) forces changes across every layer in between.

Ports & Adapters (Hexagonal Architecture)

An architecture where the application core defines ports in its own domain vocabulary, while external adapters translate between ports and concrete technologies, keeping dependencies pointing inward toward the core.

Driving (Primary) Adapters

Adapters that initiate application operations by calling inbound ports exposed by the application core (e.g., REST controllers, CLI commands, and acceptance tests).

Driven (Secondary) Adapters

Adapters that implement outbound ports defined by the application core to integrate with infrastructure and external services (e.g., database repositories, email notifiers, and payment gateways).

Inbound Ports

Interfaces defined by the application core expressed in the domain vocabulary that expose core use cases to driving adapters.

Outbound Ports

Interfaces defined by the application core that declare required external capabilities and are implemented by driven adapters.

Revenue Recognition

A common business problem concerning when an organization can legally count received money on its accounting books, governed by volatile professional standards, regulation, and company policies.

Transaction Script Pattern

A domain logic pattern that organizes business logic into procedural routines where each procedure handles a single request coming from the presentation layer.

Domain Model Pattern

An architectural pattern that represents domain logic as an object-oriented network incorporating both behavior and data, structured primarily around domain nouns.

AI Architectural Placement Principle

An architectural guideline establishing that AI components should suggest recommendations or strategies, while deterministic domain logic validates invariants and commits decisions.

Model-View-Controller (MVC) Pattern

An architectural pattern that divides an interactive system into three components: a Model for domain logic and data, Views for information display, and Controllers for user input handling.

Model (MVC)

The component in MVC that encapsulates core application data and domain manipulation logic independently of any user interface.

View (MVC)

The component in MVC that observes the Model and renders a specific visual representation of application data to the user.

Controller (MVC)

The component in MVC associated with a View that receives user input events and translates them into update requests to the Model.

MVC Change Propagation Mechanism

The publish-subscribe or observer-notify mechanism that ensures consistency across all registered Views and Controllers when the Model updates.

Model-View-Presenter (MVP)

An MVC successor pattern where the View and Model communicate exclusively through a Presenter via explicit calls and events to facilitate automated UI testing.

Model-View-ViewModel (MVVM)

An MVC successor pattern where the View synchronizes with a ViewModel using declarative two-way data bindings, prominent in XAML stacks and MAUI.

Flux / Redux

A front-end architecture featuring a unidirectional data flow ($\text{View} \rightarrow \text{Actions} \rightarrow \text{Dispatcher / Reducers} \rightarrow \text{Store} \rightarrow \text{View}$) with immutable state management.

Model-View-Update (MVU)

A declarative architecture where $\text{View} = f(\text{Model})$ and state transitions follow $\text{Msg} \rightarrow \text{Update} \rightarrow \text{Model}$ via pure, immutable, and unidirectional updates.

Model-View-Intent (MVI)

A reactive UI architecture where user actions are captured as intents flowing into reducers ($\text{View} \rightarrow \text{Intents} \rightarrow \text{Reducers} \rightarrow \text{Model} \rightarrow \text{View}$) via unidirectional reactive streams.

Hierarchical MVC (HMVC)

An architecture that structures multiple MVC triads into an organized tree hierarchy with parent-child communication to support complex, nested user interfaces.

Server-driven UI ("HTML over the wire")

A web architecture where the server renders and dispatches HTML fragments or diffs directly to the client, which patches them into the DOM (e.g., Hotwire, LiveView, htmx).

Streaming UIs with MVC

An adaptation of MVC for streaming tokens where partial chunks stream directly to the View via an orchestrator without altering the Model, committing to the Model only once at completion.