Software Architecture
Architecture patterns and principles for maintainable applications.
Terms in Software Architecture
API Gateway
An API gateway provides a common entry point for clients accessing multiple backend services.
CQRS
Command Query Responsibility Segregation separates operations that change state from operations that read state.
Circuit Breaker
The circuit breaker pattern temporarily stops calls to an unhealthy dependency to prevent cascading failures.
Clean Architecture
Clean Architecture separates business rules from external frameworks and infrastructure.
Dependency Inversion Principle
The Dependency Inversion Principle encourages high-level logic to depend on abstractions rather than concrete implementations.
Domain-Driven Design
Domain-Driven Design structures software around domain concepts and business rules.
Event-Driven Architecture
Event-driven architecture uses events to communicate that something has happened in a system.
Facade Pattern
The Facade pattern provides a simplified interface over a more complex subsystem.
Factory Pattern
The Factory pattern centralizes object creation so callers do not need to know construction details.
Hexagonal Architecture
Hexagonal architecture separates core application logic from external systems through ports and adapters.
Layered Architecture
Layered architecture organizes software into logical layers with distinct responsibilities.
MVC
Model-View-Controller separates application data, presentation, and request handling responsibilities.
Microservices
Microservices architecture divides an application into independently deployable services.
Modular Monolith
A modular monolith is a single deployable application organized into well-defined internal modules.
Monolithic Architecture
A monolithic application is deployed as a single application unit.
Observer Pattern
The Observer pattern allows objects to receive notifications when another object changes state.
Open-Closed Principle
The Open-Closed Principle encourages software components to be open for extension but closed for unnecessary modification.
SOLID
SOLID is a group of object-oriented design principles intended to support maintainable software.
Single Responsibility Principle
A component should have a focused responsibility and a reason to change.
Strategy Pattern
The Strategy pattern allows interchangeable algorithms behind a common interface.