Software Architecture Terms
Essential terms and concepts related to software architecture, design patterns, and system design.
Abstraction
Section titled “Abstraction”The principle of hiding complex implementation details and showing only the necessary features of an object or system.
API Gateway
Section titled “API Gateway”A server that acts as a single entry point for a collection of microservices, handling routing, composition, and protocol translation.
Architectural Pattern
Section titled “Architectural Pattern”A general, reusable solution to a commonly occurring problem in software architecture within a given context.
Backend
Section titled “Backend”The server-side of an application that handles business logic, database interactions, authentication, and server configuration.
Bounded Context
Section titled “Bounded Context”A central pattern in Domain-Driven Design (DDD) that defines explicit boundaries within which a particular model is defined and applicable.
Circuit Breaker
Section titled “Circuit Breaker”A design pattern used to detect failures and prevent cascading failures in distributed systems by temporarily blocking requests to a failing service.
Cohesion
Section titled “Cohesion”The degree to which elements within a module belong together. High cohesion is desirable as it indicates a well-focused module.
Coupling
Section titled “Coupling”The degree of interdependence between software modules. Loose coupling is preferred as it makes systems more maintainable.
CQRS (Command Query Responsibility Segregation)
Section titled “CQRS (Command Query Responsibility Segregation)”An architectural pattern that separates read and write operations into different models, optimizing performance and scalability.
Distributed System
Section titled “Distributed System”A system whose components are located on different networked computers, which communicate and coordinate their actions by passing messages.
Domain-Driven Design (DDD)
Section titled “Domain-Driven Design (DDD)”An approach to software development that focuses on the core domain and domain logic, using a common language between developers and domain experts.
Event-Driven Architecture
Section titled “Event-Driven Architecture”An architectural pattern where the flow of the program is determined by events such as user actions, sensor outputs, or messages from other programs.
Event Sourcing
Section titled “Event Sourcing”A pattern where all changes to application state are stored as a sequence of events, allowing the state to be reconstructed by replaying events.
Facade Pattern
Section titled “Facade Pattern”A structural design pattern that provides a simplified interface to a complex subsystem.
Failover
Section titled “Failover”The capability to switch automatically to a redundant or standby system upon the failure of the currently active system.
Frontend
Section titled “Frontend”The client-side of an application that users interact with directly, typically involving UI/UX design and implementation.
Hexagonal Architecture (Ports and Adapters)
Section titled “Hexagonal Architecture (Ports and Adapters)”An architectural pattern that aims to create loosely coupled application components that can be easily connected to their software environment.
High Availability (HA)
Section titled “High Availability (HA)”A characteristic of a system designed to ensure an agreed level of operational performance, usually uptime, for a higher than normal period.
Horizontal Scaling
Section titled “Horizontal Scaling”Adding more machines or instances to distribute load, as opposed to vertical scaling (adding more power to an existing machine).
Idempotency
Section titled “Idempotency”A property of operations where performing the operation multiple times has the same effect as performing it once.
Layered Architecture
Section titled “Layered Architecture”An architectural pattern that organizes code into layers, each with a specific role and responsibility (e.g., presentation, business logic, data access).
Load Balancer
Section titled “Load Balancer”A device or software that distributes network or application traffic across multiple servers to ensure reliability and performance.
Microservices Architecture
Section titled “Microservices Architecture”An architectural style that structures an application as a collection of small, independent services that communicate through well-defined APIs.
Middleware
Section titled “Middleware”Software that acts as a bridge between an operating system or database and applications, especially on a network.
Model-View-Controller (MVC)
Section titled “Model-View-Controller (MVC)”An architectural pattern that separates an application into three interconnected components: Model (data), View (UI), and Controller (business logic).
Monolithic Architecture
Section titled “Monolithic Architecture”An architectural style where all components of an application are tightly integrated and deployed as a single unit.
N-Tier Architecture
Section titled “N-Tier Architecture”An architectural pattern that separates an application into multiple logical layers (tiers), typically presentation, application, and data tiers.
Publish-Subscribe (Pub/Sub)
Section titled “Publish-Subscribe (Pub/Sub)”A messaging pattern where publishers send messages to topics without knowledge of subscribers, and subscribers receive messages from topics they subscribe to.
Redundancy
Section titled “Redundancy”The duplication of critical components or functions of a system to increase reliability and availability.
Repository Pattern
Section titled “Repository Pattern”A design pattern that mediates between the domain and data mapping layers, providing a collection-like interface for accessing domain objects.
Resilience
Section titled “Resilience”The ability of a system to handle and recover from failures gracefully, continuing to provide service even under adverse conditions.
RESTful API
Section titled “RESTful API”An API that adheres to REST architectural constraints, using HTTP methods and stateless communication.
Scalability
Section titled “Scalability”The capability of a system to handle increased load by adding resources, either horizontally (more machines) or vertically (more powerful machines).
Service-Oriented Architecture (SOA)
Section titled “Service-Oriented Architecture (SOA)”An architectural pattern where functionality is grouped into distinct services that communicate over a network.
Separation of Concerns
Section titled “Separation of Concerns”A design principle for separating a computer program into distinct sections, each addressing a separate concern or aspect of functionality.
Singleton Pattern
Section titled “Singleton Pattern”A design pattern that restricts the instantiation of a class to a single instance and provides global access to that instance.
SOLID Principles
Section titled “SOLID Principles”Five design principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) for writing maintainable object-oriented code.
Stateless
Section titled “Stateless”A design where each request from client to server must contain all information needed to understand and process the request.
Three-Tier Architecture
Section titled “Three-Tier Architecture”A client-server architecture with three layers: presentation tier (UI), logic tier (business logic), and data tier (database).
Tight Coupling
Section titled “Tight Coupling”A condition where components are highly dependent on each other, making the system harder to maintain and modify.
Twelve-Factor App
Section titled “Twelve-Factor App”A methodology for building software-as-a-service applications that are portable, scalable, and maintainable.
Vertical Scaling
Section titled “Vertical Scaling”Increasing the capacity of a single machine by adding more resources (CPU, RAM, storage) rather than adding more machines.
YAGNI (You Aren’t Gonna Need It)
Section titled “YAGNI (You Aren’t Gonna Need It)”A principle of extreme programming that states programmers should not add functionality until it is necessary.
Understanding these architectural terms is essential for designing scalable, maintainable, and robust software systems.