irreducible-tradeoff
Kind: resolution-mechanism
Record: vocabulary:resolution-mechanism-irreducible-tradeoff
Canonical: Schema
A resolution in which an operating point is measured, chosen and written down beside the choice.
Listed in Controlled vocabularies, after scope-separation and before mitigation.
Mechanism of
- Domain-Driven Design (DDD) / Simple CRUD
- Domain Model / Persistence Simplicity
- Bounded Context / Cross-Context Reuse
- Context Mapping / Documentation Overhead
- Anti-Corruption Layer / Mapping Overhead
- Explicit Boundaries / Cross-Cutting Concerns
- Aggregate / Aggregate Size
- Value Object / Object Count
- Entity / Value Object
- Domain Service / Aggregate
- Runtime Discovery / Predictability
- Runtime Discovery / Static Analysis
- Runtime Discovery / Startup Cost
- Service Discovery / Operational Complexity
- Dynamic Binding / Static Safety
- Dynamic Binding / Predictability
- Dynamic Binding / Debugging
- Dynamic Dispatch / Traceability
- Runtime Extensibility / Predictability
- Runtime Extensibility / Security
- Causality / Parallelism
- Causal Consistency / Latency/Availability
- Happens-Before Relationship / Parallel Execution
- Event Ordering / Throughput
- Causal Dependency / Graph Complexity
- Dependency Graph / Dynamic Loading
- Directed Acyclic Graph (DAG) / Bidirectional Collaboration
- Vector Clocks / Metadata Size
- Lamport Clocks / No Concurrent Causality Distinction
- Hybrid Logical Clocks / Clock Skew
- CRDTs / Metadata Overhead
- CRDTs / Last-Write-Wins Overwrite
- Total-Order Broadcast / Latency
- CAP Theorem / Latency
- PACELC Theorem / Throughput
- Design by Contract / Development Speed
- Explicit Contracts / Rapid Prototyping
- Stable Interfaces / Evolution Speed
- Interface-Based Design / Interface Overuse
- Contract-First Design / Iteration Speed
- API Contract / Evolution
- Service Contract / Distributed Evolution
- Data Contract / Flexible Ingestion
- Schema Contract / Schema Flexibility
- Semantic Contracts / Cross-Domain Translation
- Preconditions / Permissive APIs
- Postconditions / Runtime Cost
- Invariant / Flexibility
- Backward Compatibility / Cleanup / Simplification
- Forward Compatibility / Strong Validation
- Versioning / Version Sprawl
- Protocol Compatibility / Protocol Optimization
- Interoperability / Domain-Specific Optimization
- Uniform Interface / Specialized Endpoints
- Consumer-Driven Contracts / Provider Autonomy
- Control Plane / Availability
- Orchestration / Centralized Coordinator Coupling
- Centralized Configuration / Central Dependency Risk
- Centralized Authentication / Identity Provider Availability
- Centralized Logging / Cost/Personal Data Exposure
- Decentralization / Consistency
- Leader Election / Availability
- Consensus / Latency
- Consensus / Availability
- Choreography / Traceability
- Determinism / Runtime Adaptivity
- Predictability / Dynamic Runtime Behavior
- Referential Transparency / Stateful IO
- Pure Functions / Stateful Operations
- Immutability / Allocation Cost
- Reproducibility / Continuous Updates
- Repeatability / Real-World Variability
- Correctness / Delivery Speed
- Formal Verification / Cost/Complexity
- Specification-Based Testing / Spec Maintenance
- Property-Based Testing / Shrinking/Debug Complexity
- Static Analysis / False Positives
- Testability / Encapsulation Extremes
- Validation / Iteration Speed
- Verification / Cost
- Portability / Platform Optimization
- Platform Independence / Native Optimization
- Environment Parity / Cost
- Containerization / Image Complexity
- Infrastructure as Code / Tooling Complexity
- Standards Compliance / Innovation/Flexibility
- Protocol Independence / Protocol-Specific Features
- Configuration Externalization / Config Sprawl
- Immutable Infrastructure / Deploy Time
- Single Responsibility Principle (SRP) / Excessive Fragmentation
- Separation of Concerns / Over-Layering
- Do Not Repeat Yourself (DRY) / Simplicity
- High Cohesion / Over-Specialization
- Low Coupling / Runtime Indirection
- Encapsulation / Debuggability
- Information Hiding / Observability
- Abstraction / Simplicity
- Modularity / Cross-Cutting Concerns
- Composability / Performance Overhead
- Composition Over Inheritance / Simplicity for Trivial Reuse
- Reusability / YAGNI
- Reusability / Over-Generalization
- Replaceability / Deep Optimization
- Interchangeability / Specialized Optimization
- Independence / Coordination Cost
- Autonomy / Global Consistency
- Interface Segregation Principle (ISP) / Interface Proliferation
- Dependency Inversion Principle (DIP) / Runtime Indirection
- Open/Closed Principle (OCP) / Simplicity
- Liskov Substitution Principle (LSP) / Narrow Specialized Behavior
- Polymorphism / Traceability
- Event-Driven Architecture / Debuggability
- Event-Driven Architecture / Strong Consistency
- Publish/Subscribe Pattern / Delivery Ordering
- Message Queue / Latency
- Message Broker / Operational Dependency
- Event Bus / Event Storm / Traceability
- Event Stream / Storage Volume
- Event Sourcing / Query Complexity
- Command Query Responsibility Segregation (CQRS) / Eventual Consistency
- Domain Events / Event Granularity
- Integration Events / Duplication with Domain Events
- Asynchronous Communication / Immediate Consistency
- Eventual Consistency / User Expectations
- Eventual Consistency / Strong Immediate Consistency
- Saga Pattern / Workflow Complexity
- Outbox Pattern / Relay Complexity
- Compensating Transaction / Business Complexity
- Append-Only Log / Storage Growth
- Dead-Letter Queue / Operational Overhead
- Idempotent Consumer / State Overhead
- Competing Consumers / Ordering
- Defensive Programming / Verbosity
- Fail Fast / Graceful Degradation
- Fail Safe / Availability
- Fail Secure / Availability
- Graceful Degradation / Consistency / Feature Completeness
- Fault Tolerance / Cost
- Resilience / Complexity
- Robustness Principle / Strict Validation
- Error Handling / Simplicity
- Error Boundaries / Hidden Errors
- Fallback Pattern / Stale/Reduced Results
- Retry Pattern / Load Amplification
- Timeout Pattern / Slow Operation Tolerance
- Circuit Breaker Pattern / Availability of Degraded Dependency
- Bulkhead Pattern / Resource Utilization
- Backpressure / Throughput
- Assessment / Time Cost
- Architecture Review / Delivery Speed
- Design Review / Iteration Speed
- Code Review / Throughput
- Impact Analysis / Analysis Overhead
- Gap Analysis / Time Cost
- Fitness Functions / Rule Maintenance
- Quality Attributes / Competing Attributes
- Architecture Decision Records (ADR) / Documentation Maintenance
- Evolutionary Architecture / Governance Discipline
- Minimum Viable Architecture / Future Scalability
- Greenfield Development / Unknown Requirements
- Greenfield Development / Legacy Constraints
- First-Principles Design / Reuse of Established Patterns
- Reference Architecture / Team Autonomy
- Pattern Consistency / Local Optimization
- Architectural Consistency / Local Autonomy
- Standardization / Innovation/Autonomy
- Self-Describing Architecture / Metadata Drift
- Self-Describing API / Payload Verbosity
- Self-Describing Structures / Size Overhead
- Metadata-Driven Design / Debuggability
- Declarative Configuration / Dynamic Complexity
- Convention over Configuration / Explicitness
- Capability Declaration / Declaration Drift
- Manifest-Based Design / Manifest Drift
- Homoiconicity / Readability
- Code as Data / Safety/Debuggability
- Metaprogramming / Debuggability
- Metaprogramming / Static Analysis
- Metaprogramming / Explicit Handwritten Code
- Reflection / Performance/Safety
- Reflection / Static Analysis
- Introspection / Encapsulation
- Compile-Time Evaluation / Build Complexity
- Compile-Time Evaluation / Runtime Dynamic Evaluation
- Runtime Code Generation / Security/Debugging
- Runtime Code Generation / Static Safety
- Domain-Specific Language (DSL) / Tooling/Maintenance
- Language-Oriented Programming / Toolchain Complexity
- Language-Oriented Programming / One-Size General-Purpose Code
- Artificial Intelligence Architecture / Determinism
- Artificial Intelligence Architecture / Explainability
- Machine Learning Architecture / Experimentation Speed
- Model Governance / Experiment Velocity
- Model Evaluation / Metric Completeness
- Model Inference / Latency/Cost
- Retrieval-Augmented Generation (RAG) / Retrieval Quality/Latency
- Vector Search / Explainability/Recall
- Knowledge Graphs / Curation Cost
- Explainability / Model Complexity
- Model Safety / Capability/Utility
- Prompt Engineering / Robustness
- Model Drift Monitoring / Monitoring Cost
- Agentic Architecture / Determinism
- Observability / Cost/Noise
- Logging / Noise/Personal Data Leakage
- Monitoring / Alert Noise
- Alerting / Alert Fatigue
- Auditability / Storage/Privacy
- Audit Logging / Privacy
- Traceability / Metadata Propagation Overhead
- Correlation ID / Header/Metadata Management
- Causation ID / Metadata Verbosity
- Distributed Tracing / Overhead/Sampling
- SLO/SLI / Feature Velocity
- Dashboards / Dashboard Sprawl
- Strategy Pattern / Class Count
- Template Method Pattern / Inheritance Coupling
- Observer Pattern / Ordering
- Observer Pattern / Debuggability
- Mediator Pattern / Mediator God Object
- Command Pattern / Simplicity
- State Pattern / Class Proliferation
- Chain of Responsibility Pattern / Traceability
- Iterator Pattern / Simplicity
- Visitor Pattern / Element Stability
- Memento Pattern / Memory Footprint
- Null Object Pattern / Silent No-Op Risk
- Finite State Machine / State Explosion
- Statecharts / Tooling Complexity
- Factory Pattern / Simplicity
- Factory Method Pattern / Inheritance Complexity
- Abstract Factory Pattern / Boilerplate
- Builder Pattern / Boilerplate
- Prototype Pattern / Copy Semantics
- Singleton Pattern / Testability
- Singleton Pattern / Dependency Injection
- Adapter Pattern / Mapping Overhead
- Facade Pattern / Over-Centralization
- Proxy Pattern / Transparency / Debugging
- Bridge Pattern / Indirection
- Decorator Pattern / Stack Debugging
- Composite Pattern / Type Safety
- Flyweight Pattern / Complexity
- Scalability / Simplicity
- Scalability / Consistency
- Horizontal Scaling / Distributed Coordination
- Vertical Scaling / Cost/Limit
- Elasticity / Warm-Up Latency
- Load Balancing / Session Affinity
- Sharding / Cross-Shard Queries
- Partitioning / Rebalancing Complexity
- Caching / Consistency
- Caching / Always-Fresh Reads
- Statelessness / State Access Latency
- Concurrency / Complexity
- Parallelism / Coordination Overhead
- Throughput / Latency
- Latency / Throughput/Batching
- Performance Engineering / Maintainability
- Algorithmic Efficiency / Implementation Simplicity
- Time Complexity / Space Complexity
- Big O Notation / Constant-Factor Practicality
- Optimization / Readability/Maintainability
- Profiling / Measurement Overhead
- Benchmarking / Environment Drift
- Bottleneck Analysis / Distributed Complexity
- Resource Utilization / Over-Provisioning
- Rate Limiting / User Experience
- Memory Efficiency / CPU Cost
- CDN / Edge Caching / Cache Invalidation
- Read Replica / Read-Your-Writes Consistency
- Queuing Theory / Model Assumptions
- Streaming Architecture / Ordering/State
- Streaming Architecture / Batch-Only Processing
- Single-Pass Processing / Global Optimization
- Single-Pass Processing / Multi-Pass Full Materialization
- Pipeline Architecture / Error Propagation/Debugging
- Lazy Evaluation / Debuggability/Resource Lifetime
- Lazy Evaluation / Eager Full Materialization
- Sequential Access / Lookup Performance
- Sequential Access / Random Access Requirement
- Forward-Only Processing / Complex Grammar/Global State
- Forward-Only Processing / Backtracking Algorithm
- Dataflow Architecture / State Coordination
- Stateless Processing / Stateful Business Rules
- Windowing / Late-Data Handling
- Fan-out/Fan-in / Coordination Overhead
- Fan-out/Fan-in / Serial Item Processing
- Batch-vs-Stream / Operational Duplication
- Plugin Architecture / Static Analysis
- Plugin Architecture / Security
- Extension Points / API Surface Growth
- Inversion of Control (IoC) / Traceability
- Dependency Injection / Constructor Complexity
- Service Registry / Registry Availability
- Registry Pattern / Global State
- Service Locator Pattern / Testability
- Service Locator Pattern / Dependency Inversion Principle (DIP)
- Service Locator Pattern / Explicit Dependencies
- Feature Toggle / Flag Debt
- Self-Healing Architecture / Unsafe Automation
- Health Checks / False Positives
- Failover / Consistency
- Redundancy / Cost
- Replication / Consistency Lag
- Auto-Scaling / Cost/Cold Start
- Auto-Scaling / Fixed Capacity
- Auto-Remediation / Unsafe Automation
- Auto-Remediation / Manual Remediation
- Rollback / Data Migration Compatibility
- Blue-Green Deployment / Infrastructure Cost
- Canary Deployment / Rollout Complexity
- Chaos Engineering / Production Risk
- Graceful Shutdown / Shutdown Latency
- RAID Redundancy / Write Amplification
- Schema Validation / Flexible Input
- Type Safety / Rapid Scripting
- Canonical Model / Bounded Context Autonomy
- Canonical Data Model / Bounded Context Purity
- Canonical Data Model / Local Model Autonomy
- Canonical Schema / Service-Specific Schemas
- Canonicalization / Lossless Preservation
- Single Source of Truth / Availability
- Semantic Consistency / Polysemy Across Contexts
- Ubiquitous Language / Cross-Context Terminology
- Intent-Revealing Interface / Concise Naming
- Principle of Least Surprise / Clever Abstractions
- Security by Design / Developer Ergonomics
- Defense in Depth / Complexity
- Least Privilege / Operational Convenience
- Zero Trust Architecture / Latency/Complexity
- Secure by Default / Ease of Initial Use
- Attack Surface Reduction / Feature Exposure
- Threat Modeling / Delivery Speed
- Authentication / User Experience
- Authorization / Policy Complexity
- Access Control / Usability
- Role-Based Access Control (RBAC) / Role Explosion
- Attribute-Based Access Control (ABAC) / Policy Complexity
- Input Validation / Input Flexibility
- Output Encoding / Formatting Flexibility
- Encryption at Rest / Key Operations
- Encryption in Transit / Certificate Management
- Secrets Management / Operational Complexity
- Privacy by Design / Analytics/Personalization
- Compliance / Delivery Speed
- Governance / Team Velocity
- Policy Enforcement / False Positives
- Policy as Code / Policy Maintenance
- Risk Management / Speed
- Continuous Compliance / Pipeline Complexity
- CSRF Protection / Client Complexity
- Parameterized Queries / Dynamic Query Flexibility
- Session Management / User Convenience
- Ports and Adapters Architecture / Boilerplate
- Ports and Adapters Architecture / Initial Complexity
- Clean Architecture / Boilerplate
- Layered Architecture / Anemic Layers
- Component-Based Architecture / Integration Overhead
- Package by Feature / Shared Technical Concerns
- Microservices / Operational Complexity
- Microservices / Consistency
- Monolith Architecture / Team Autonomy
- Monolith Architecture / Independent Scaling
- Pipes and Filters / End-to-End Traceability
- Service-Oriented Architecture / Operational Overhead
- Space-Based Architecture / Consistency
- Closed Vocabulary / Naming Expressiveness
- Bounded Nesting Depth / Tree Compactness
- Idempotency / State Tracking
- Atomicity / Distributed Scalability
- ACID / Distributed Availability
- ACID / BASE/Eventual Consistency
- Transaction Boundary / Large Transaction Scope
- Unit of Work Pattern / Repository Complexity
- Consistency / Availability
- Consistency / Latency
- Isolation / Throughput
- Concurrency Control / Performance
- Optimistic Locking / Retry Complexity
- Pessimistic Locking / Deadlock Freedom
- Pessimistic Locking / Latency
- Pessimistic Locking / Lock-Free Throughput
- State Isolation / Data Sharing
- Controlled Side Effects / Performance Optimization
- Petri Nets / Modeling Overhead