Terms about Project Scope
| Term | Description |
|---|---|
| Environment | Everything outside the project's scope that interacts directly with the system. |
| System | Everything inside the project's scope. |
Terms about Systems
| Term | Description |
|---|---|
| Approach | A method that is used to decompose the system. |
| Building block | A structural element that contains a part of the system. |
| Relationship | The connection between building blocks. |
Terms about Technology
| Term | Description |
|---|---|
| Ecosystem | A collection of related technologies and tools that function together within a shared environment. |
| Stack | A set of software tools and technologies (e.g., programming language, framework, database) used together to build and run an application. |
| Platform | An underlying system or environment that supports the development and execution of applications, providing common services and resources. |
| Library | A collection of pre-written code (functions, classes, etc.) that provides reusable functionality to be used in applications. |
Terms about System Decomposition
| Term | Description |
|---|---|
| Subsystem | A high-level component of a system (often the first level of breakdown) that groups related functionality. |
| Module | A self-contained unit of software that encapsulates a set of related functions or data, typically as part of a larger system or subsystem. |
| Component | A part of a system that encapsulates specific functionality behind a well-defined interface. |
| Part | A general term for any fundamental piece or segment of a system. |
| Unit | The smallest piece of software that can be tested in isolation, often a single function or class. |
| Entity |
A distinct thing or object of interest in the system's domain, typically representing a real-world concept (e.g., a database record). Definition in the context of UML: A classifier that represents objects that share the same attributes, operations, relationships, and semantics. In UML models, entities often correspond to real-world concepts in the problem domain. |
| Interface | Structural elements that define the relationship between components. |
| Item | A single element or entry in a system or collection, often one instance among many. |
| Element | A fundamental component or constituent of a system. |
| Object |
An instance of a class that bundles data and behavior together. Definition in the context of UML: An instance of a class, representing a specific, concrete entity in the system at a particular point in time. Objects are shown in object diagrams and have specific attribute values. |
| Property |
An attribute or characteristic of an object or entity, representing a piece of its data. Definition in the context of UML: A named attribute of a class that describes a range of values that instances of the class may hold. Properties define the structural characteristics of objects. |
| Method | A function associated with an object (in object-oriented programming) that defines a behavior of that object. |
| Variable | A named memory location that holds a value which can change during program execution. |
| Operation |
A specific action or process that a system or one of its components can perform. Definition in the context of UML: A behavioral feature of a class that specifies the name, type, parameters, and constraints for invoking an associated behavior. Operations define what a class can do. |
Component-Centric Architectural Styles
| Term | Description |
|---|---|
| Clean Architecture | An architectural style organized as concentric circles with dependencies pointing inward toward the core domain. The inner circles contain business rules (entities and use cases) while outer circles contain technical details (frameworks, UI, databases). This ensures the core business logic remains independent of external concerns. |
| Hexagonal Architecture | An architectural pattern that uses ports and adapters to isolate the application core from external concerns. Ports define interfaces for interaction, while adapters implement these interfaces to connect external systems (UIs, databases, etc.). This enables testing with mock adapters and technology swapping without changing core logic. |
| Onion Architecture | A form of layered architecture structured as concentric rings, with the domain core at the center and outer layers depending only on inner layers. This preserves the independence of the core from external concerns as the system grows. |
| Layered Architecture | An architecture that organizes software into horizontal layers (e.g., presentation, business logic, data access). In strict layering, each layer only interacts with the layer directly below it. In relaxed layering, layers can call any lower layer. Both variants ensure clear separation of concerns. |
Distribution-Oriented Architectural Styles
| Term | Description |
|---|---|
| Client-Server Architecture | A distributed architecture where multiple client applications request services from centralized server applications, separating the providers (servers) and consumers (clients). |
| Event-Driven Architecture | An architecture where components communicate by emitting and reacting to events (messages) asynchronously, which decouples them and makes the system more scalable and responsive. |
| Peer-to-Peer Architecture | A decentralized architecture where each node (peer) can act as both client and server, sharing resources directly with other peers, resulting in a self-organizing, resilient network without a central server. |
| Microservices | An architectural style that structures an application as a collection of small, independent services. Each service focuses on a specific business capability, runs in its own process, and communicates via lightweight mechanisms (often HTTP APIs), allowing independent development, deployment, and scaling. |
| Monolithic Architecture | An architecture where all components of the system are integrated into a single, unified application that is deployed as one unit. |
| Pipe-and-Filter Architecture | An architectural style where data passes through a sequence of processing components (filters) connected by channels (pipes). Each filter transforms the data and passes it to the next, enabling easy composition and parallel processing of tasks. |
| Broker Architecture | An architectural pattern where a central broker component mediates communication among different components, routing messages so that senders and receivers remain decoupled and do not need direct knowledge of each other. |
| Service-Oriented Architecture (SOA) | An architectural style that structures application components as services that can be discovered and composed to create business applications. SOA promotes reuse through standardized service contracts, loose coupling, abstraction, and composability of services. |
| Actor Model | An architecture where independent actors communicate exclusively through asynchronous message passing, each maintaining its own state and processing messages sequentially. Each actor can create new actors, send messages, and define behavior for the next message. |
Terms with diverging definitions
| Term | Description |
|---|---|
| MVC | Architectural pattern that separates an application into three components: Model (data and business logic), View (presentation layer), and Controller (input handling). Implementations vary widely across frameworks, with some treating controllers as application logic orchestrators and others as thin request routers. |
| REST | Architectural style for distributed systems defined by six constraints: client-server architecture, statelessness, cacheability, layered system, uniform interface, and code-on-demand (optional). Most "REST APIs" implement varying subsets of these constraints. |
Terms with many definitions
| Term | Description |
|---|---|
| Service |
Definition in the context of the Windows Operating System: A program that runs in the background without a user interface, performing system functions or providing resources to other applications even when no user is logged in. Definition in the context of Angular: A singleton class that handles data sharing and business logic across components, with various types including services for API communication, state management, and utility functions. Definition in the context of Clean Architecture: A component that implements specific business rules and use cases, often sitting in the application layer and orchestrating entity interactions. Definition in the context of iDesign: A stateless class that encapsulates business logic and provides required functionality to clients. Definition in the context of microservices: In microservices, a separately deployable, scalable unit organized around business capabilities that communicates via lightweight protocols. Definition in the context of service-oriented architecture: In service-oriented architecture (SOA), a logical representation of a repeatable business activity with a specified outcome. |
| Controller |
Definition in the context of MVC: The component that handles user input, manipulates the model, and determines which view to render in response to the request. Definition in the context of Spring Framework: A class annotated with @Controller that handles HTTP requests and returns appropriate responses, typically mapping to specific URL patterns. Definition in the context of Angular: A TypeScript class that controls the behavior of the view, binding data from services to the UI and handling user interactions. Definition in the context of embedded systems: A hardware component or software module that manages physical devices and regulates their operations based on sensor inputs. Definition in the context of ASP.NET MVC: A C# class that inherits from Controller or ControllerBase, containing action methods that handle HTTP requests and return responses (Views, JSON, redirects, etc.), serving as the entry point for web requests in the MVC pattern. |
| Repository |
Definition in the context of Domain-Driven Design: An object that encapsulates the logic for accessing domain entities and enforces the aggregate boundaries. Definition in the context of Git: A storage location for code and version history, containing all files and change history for a project. Definition in the context of package management: A centralized storage location containing software packages and metadata used by package managers like npm, Maven, or NuGet. |
| Component |
Definition in the context of React: A reusable piece of UI that combines markup, styling, and logic, which can be function-based or class-based. Definition in the context of Angular: A TypeScript class with the @Component decorator that defines a view with its HTML template and associated behavior. Definition in the context of UML: A modular, deployable, and replaceable part of a system that encapsulates implementation and exposes a set of interfaces. Definition in the context of COM: A binary standard for software components that enables interprocess communication and dynamic object creation in a programming language-independent way. |
| Model |
Definition in the context of MVC: The component that manages the data, logic, and rules of the application, independent of the user interface. Definition in the context of machine learning: An algorithm or mathematical representation trained on data to make predictions or decisions without being explicitly programmed for the task. Definition in the context of database design: A representation of the data structures, relationships, and constraints within a database system. Definition in the context of 3D graphics: A mathematical representation of a three-dimensional object using vertices, edges, and faces. Definition in the context of UML: A representation of a system or part of a system that shows its structure, behavior, and relationships using standardized notation and diagrams. |
| Interface |
Definition in the context of object-oriented programming: A contract that defines a set of methods and properties that a class must implement, without specifying their implementation details. Definition in the context of user experience: The visual elements and interactive components through which users interact with a software application or hardware device. Definition in the context of APIs: The specified methods, protocols, and tools that allow different software components to communicate with each other. Definition in the context of UML: A contract that specifies the behavior that implementing classes must provide, defining a set of operations without their implementation. Interfaces are shown in class diagrams and realized by classes. |