software-design - Concepts
Explore concepts tagged with "software-design"
Total concepts: 29
Concepts
- Defensive Programming - A coding practice that anticipates potential errors and edge cases, writing code that fails safely and provides clear error information.
- Ubiquitous Language - A shared, rigorous vocabulary between developers and domain experts used consistently throughout code, documentation, and conversation in Domain-Driven Design.
- Local-First - Software design where data lives primarily on your devices, with cloud as optional sync.
- Graceful Degradation - A design approach where systems continue to function with reduced capability when components fail, rather than failing completely.
- Monolithic Architecture - A software architecture pattern where an entire application is built as a single, unified unit.
- Value Object - An immutable domain object defined entirely by its attributes rather than by a unique identity, where two instances with the same values are considered equal.
- Separation of Concerns - A design principle for dividing a system into distinct sections, each addressing a separate concern or responsibility.
- Microservices Architecture - A distributed architecture style that structures an application as a collection of small, autonomous services organized around business capabilities.
- Fault Tolerance - The ability of a system to continue operating correctly even when some of its components fail.
- Clean Architecture - A software architecture pattern that emphasizes separation of concerns through concentric layers with dependencies pointing inward.
- Breaking Loudly - A software design principle where failures produce visible errors, exceptions, or warnings rather than silently continuing.
- Context Mapping - A strategic DDD technique for visualizing and managing the relationships and integration patterns between bounded contexts.
- Design Patterns - Reusable solutions to commonly occurring problems in software design, providing templates for solving design challenges.
- Saga Pattern - A pattern for managing distributed transactions across multiple services by coordinating a sequence of local transactions with compensating actions for failures.
- Worse Is Better - A software design philosophy arguing that simpler, 'worse' solutions often succeed over more complete but complex alternatives.
- Anti-Corruption Layer - A translation layer that isolates a bounded context from external or legacy systems, preventing their models from contaminating the internal domain model.
- Convention Over Configuration - A software design paradigm that reduces decisions developers need to make by providing sensible defaults based on conventions.
- Entity - A domain object defined by its unique identity that persists through time and state changes, rather than being defined by its attributes.
- Aggregate - A cluster of domain objects treated as a single unit for data changes, with a root entity that controls all access and enforces invariants.
- Opinionated Software - Software that prescribes a particular way of doing things, making design decisions for users rather than offering maximum flexibility.
- Domain Event - A record of something significant that happened in the business domain, used to communicate state changes and trigger side effects across system boundaries.
- Domain-Driven Design - An approach to software development that centers the design on the core business domain and its logic.
- CQRS - A pattern that separates read and write operations into distinct models, allowing each to be optimized, scaled, and evolved independently.
- Event Storming - A collaborative workshop technique for rapidly exploring and modeling complex business domains by discovering domain events on sticky notes.
- Event Sourcing - A pattern that persists the state of an entity as a sequence of immutable events rather than storing only the current state.
- Service-Oriented Architecture - An architectural style that organizes software as a collection of interoperable services that communicate through standardized interfaces.
- Error Handling - The practice of anticipating, detecting, and responding to errors in software to maintain system stability and provide meaningful feedback.
- Modulith - A modular monolith architecture that combines the simplicity of monoliths with the organizational benefits of microservices.
- Bounded Context - A central pattern in Domain-Driven Design that defines explicit boundaries within which a domain model is defined and applicable.
← Back to all concepts