The Ontology

A canon of software architecture you can query: every principle with its relations and its repair, every term with its definition, every algorithm with its contract, the reasoning that derives them, the layers they live in and the resolution of every tension between them. Every reference one record makes to another is a link, so any record is a starting point.

Schema

485 of 485 shown

The kind taxonomy

The closed kind taxonomy every record is classified by, in decision order: the discriminator, what each kind is distinguished from, the definition openings that signal it, and how many principles and terms carry it.

The canon resolves: every edge names a record that exists and every kind is in range.

anti-pattern

  • Principles of this kind: 78
  • Terms of this kind: 314
Details
Discriminator
an undesirable, recurring solution or condition that a well-designed system avoids
Distinguished from
vs quality-attribute — it is a thing to eliminate, not a good property; it is referenced only via conflicts_with
Definition openings
a defect where, a defect in which, a failure that, an undesirable

metric

  • Principles of this kind: 5
  • Terms of this kind: 11
Details
Discriminator
a quantitative measure or rate tracked as a number
Distinguished from
vs quality-attribute — the measurement itself (Cost, Latency), not the property being measured (Performance)
Definition openings
a measure of, the rate at which, the resource or financial

quality-attribute

  • Principles of this kind: 29
  • Terms of this kind: 317
Details
Discriminator
a desirable property a system exhibits to a degree ('the degree to which…')
Distinguished from
vs capability — a property the system has more or less of, not a discrete thing it can do
Definition openings
the degree to which, the ease with which, the extent to which, the proportion of time

principle

  • Principles of this kind: 71
  • Terms of this kind: 6
Details
Discriminator
a normative design rule prescribing how to build ('you should…')
Distinguished from
vs constraint — a prescriptive ideal/value, not a hard boundary that must hold
Definition openings
none

constraint

  • Principles of this kind: 25
  • Terms of this kind: 181
Details
Discriminator
a rule or precondition that must hold for correctness or acceptance ('requires that…')
Distinguished from
vs principle — a binding boundary/requirement, not a prescriptive ideal
Definition openings
predefined conditions, a rule or precondition, a clear assignment of responsibility

capability

  • Principles of this kind: 6
  • Terms of this kind: 331
Details
Discriminator
a discrete ability the system gains ('the ability to…')
Distinguished from
vs mechanism — what can be done, not the concrete facility that provides it
Definition openings
the ability to, the ability of, the capacity to

activity

  • Principles of this kind: 25
  • Terms of this kind: 34
Details
Discriminator
an action or process that is performed ('the activity of …-ing')
Distinguished from
vs technique — the doing itself, not the reusable method for doing it
Definition openings
the activity of, the act of, the practice of

pattern

  • Principles of this kind: 69
  • Terms of this kind: 8
Details
Discriminator
a named, reusable structural solution to a recurring design problem
Distinguished from
vs mechanism — a design-level arrangement of parts, not a concrete runtime facility
Definition openings
an architecture that, an architecture isolating, a design pattern

mechanism

  • Principles of this kind: 71
  • Terms of this kind: 39
Details
Discriminator
a concrete facility or means that implements behavior at runtime ('a facility that…')
Distinguished from
vs technique — a runtime thing that operates, not a method a person or tool applies
Definition openings
a facility that, a mechanism that

technique

  • Principles of this kind: 15
  • Terms of this kind: 17
Details
Discriminator
a repeatable method or skill applied to achieve a result ('a technique for…')
Distinguished from
vs approach — a specific method, not a broad guiding strategy
Definition openings
a technique for, a method for

approach

  • Principles of this kind: 9
  • Terms of this kind: 13
Details
Discriminator
a broad strategy or paradigm for tackling a class of problems
Distinguished from
vs style — a problem-solving strategy, not a convention of expression
Definition openings
an approach in which, a strategy for, a paradigm

model

  • Principles of this kind: 18
  • Terms of this kind: 17
Details
Discriminator
a conceptual representation or abstraction of a domain, data, or behavior ('a model of…')
Distinguished from
vs artifact — the conceptual representation, not a concrete produced instance of it
Definition openings
a conceptual representation, an abstraction of

artifact

  • Principles of this kind: 9
  • Terms of this kind: 67
Details
Discriminator
a concrete produced or consumed thing — a document, schema, or data
Distinguished from
vs mechanism — a static thing produced or read, not active behavior
Definition openings
a formal definition of, a precise, authoritative description, descriptive data about

style

  • Principles of this kind: 16
  • Terms of this kind: 2
Details
Discriminator
a convention of expression or organization ('a … style')
Distinguished from
vs approach — how something is written or arranged, not the strategy for solving
Definition openings
a convention of

The relation ranges

The relation ranges: which kinds each edge relation may point at. The one relation that points only at anti-patterns is the polarity law.

Relations diagram
Which kinds each relation may point at.
flowchart LR
    n_relation_conflicts_with["conflicts_with"]
    n_relation_enables["enables"]
    n_relation_reinforces["reinforces"]
    n_relation_requires["requires"]
    n_relation_tensions_with["tensions_with"]
    n_anti_pattern["anti-pattern"]
    n_metric["metric"]
    n_quality_attribute["quality-attribute"]
    n_principle["principle"]
    n_constraint["constraint"]
    n_capability["capability"]
    n_activity["activity"]
    n_pattern["pattern"]
    n_mechanism["mechanism"]
    n_technique["technique"]
    n_approach["approach"]
    n_model["model"]
    n_artifact["artifact"]
    n_style["style"]
    n_relation_conflicts_with --> n_anti_pattern
    n_relation_enables --> n_metric
    n_relation_enables --> n_quality_attribute
    n_relation_enables --> n_principle
    n_relation_enables --> n_constraint
    n_relation_enables --> n_capability
    n_relation_enables --> n_activity
    n_relation_enables --> n_pattern
    n_relation_enables --> n_mechanism
    n_relation_enables --> n_technique
    n_relation_enables --> n_approach
    n_relation_enables --> n_model
    n_relation_enables --> n_artifact
    n_relation_enables --> n_style
    n_relation_reinforces --> n_metric
    n_relation_reinforces --> n_quality_attribute
    n_relation_reinforces --> n_principle
    n_relation_reinforces --> n_constraint
    n_relation_reinforces --> n_capability
    n_relation_reinforces --> n_activity
    n_relation_reinforces --> n_pattern
    n_relation_reinforces --> n_mechanism
    n_relation_reinforces --> n_technique
    n_relation_reinforces --> n_approach
    n_relation_reinforces --> n_model
    n_relation_reinforces --> n_artifact
    n_relation_reinforces --> n_style
    n_relation_requires --> n_metric
    n_relation_requires --> n_quality_attribute
    n_relation_requires --> n_principle
    n_relation_requires --> n_constraint
    n_relation_requires --> n_capability
    n_relation_requires --> n_activity
    n_relation_requires --> n_pattern
    n_relation_requires --> n_mechanism
    n_relation_requires --> n_technique
    n_relation_requires --> n_approach
    n_relation_requires --> n_model
    n_relation_requires --> n_artifact
    n_relation_requires --> n_style
    n_relation_tensions_with --> n_metric
    n_relation_tensions_with --> n_quality_attribute
    n_relation_tensions_with --> n_principle
    n_relation_tensions_with --> n_constraint
    n_relation_tensions_with --> n_capability
    n_relation_tensions_with --> n_activity
    n_relation_tensions_with --> n_pattern
    n_relation_tensions_with --> n_mechanism
    n_relation_tensions_with --> n_technique
    n_relation_tensions_with --> n_approach
    n_relation_tensions_with --> n_model
    n_relation_tensions_with --> n_artifact
    n_relation_tensions_with --> n_style

The forces

The canonical forces the algorithms and principles are joined by: each force names the contracts that answer to it and the principles whose scope it is.

ai governance

Details
Contracts
Advanced Tool Escalation, Agent Activation Invocation, Agent Document Responsibility, Agent Generation Completion, <Agent Generation Concern>, Agent Sequence Definition, AI Model Architecture Governance, AI Model Governance, Anti-Pattern Inversion, Architecture Smell Record, Canonical Config Resolution, Canonical Data, Canonical Semantics, Capability Invocation Protocol, Causality and Ordering, Causality Ordering, <Checklist Governance Concern>, Checklist Integration, Context Forking Configuration, Cross-Stage Invariants, Custom-Rule Derivation, Declarative Metaprogramming, Delta Capture, Domain Boundary Governance, DSL Compliance Loading, Evidence-Based Claim Verification, Evidence-Before-Generation, Evidence Grounding Validation, First-Time Initiation, Four-Dimensional Agent Graph, Four-Dimensional Phase Graph, Handoff Signal, Hybrid Workflow Orchestration, Living Profile Kernel, Machine Verdict Derivation, Metaprogramming Safety, Orchestrator Action, PAG Ambiguity Reduction, PAG Authoring Kernel, PAG Constraint Boundary, <PAG Instruction Concern>, PAG Validation Gate, PAG Well-Formedness Validation, Parallel Batch Execution, Performance and Scalability, Phase Documentation Template, Phase Validation Requirement, Profile Compose, Quality Governance Loop, RAG Knowledge Boundary, Research Guidance, Runtime-Agnostic Adapter Boundary, Security Governance, Security Policy, Self-Description Manifest, Sequential Agent Execution, Shared Document Workspace, Template Assembly, Type-Migration Centralization, Universal Architectural Concern Template, Validation Stage, Validation Strategy Composition, Verb-Based Execution Classification, Violation Detection, Vocabulary Admission Gate, Workflow Coordination Sequence, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Principles Mapping, Workflow Recovery Loop, Workflow Type Document Selection, Workflow Validation Gate, Workspace Configuration Discovery
Principles
Schema Drift, Boundary Leakage, Inconsistent Error Model, Anemic Domain Model, Vendor Lock-In Leakage, Security Theater, Authorization Scattering, Architecture Astronaut, AI Prompt Sprawl, Ungrounded AI Output, Model Version Ambiguity

architecture evolution

Details
Contracts
Admissibility Constraint Gate, Analysis Workspace, Anti-Pattern Elimination Verification, Anti-Pattern Relationship Record, Anti-Reintroduction Gate, Architectural Contract Algebra, Architectural Force Classification, Architectural Recommendation, Architectural Relationship Algebra, Architecture Assessment, Architecture Decision Support, Architecture Evolution Governance, Architecture Fitness Function Generation, Architecture Knowledge Graph, Backup-Verified Migration, <Centralization Concern>, Centralization Kernel, Centralized Reference Resolver, Checklist Creation Kernel, <Checklist Governance Concern>, Checklist Integration, Checklist Output Rendering, Codebase Pattern Enforcement, Compilation Stage, Concept Cluster Extraction, Container Reshape, Contract Compatibility, Coverage Ledger, Cross-Cutting Surface Coverage, Cross-Stage Invariants, CSS Type-Cascade Kernel, Dependency Closure, Detection Registry, Distillation Metrics, DSL Compliance Loading, Enforcement Gate, Entry Point Migration, Four-Dimensional Phase Graph, Fractal Scale Duplication, Governance Evolution, Hierarchical Numbering, Knowledge Capture, Layer Fitness Enforcement, Legacy Elimination, Master Architecture Governance Kernel, Migration Action Mapping, Migration Ordering, Naming Convention Remediation, Completion Truthfulness, Phase Decomposition, Planning Stage, Principle Activation, Reinforcement Propagation, Rendering Stage, Reshape Risk Priority, Ripple Chain Analysis, Rollback-Centered Execution, Semantic Debt Policy, Severity Assignment, Taxonomy Jurisdiction, Taxonomy Kernel, Taxonomy Ledger, Teleological Intent Gate, Template Assembly, Test Coverage Kernel, Type-Migration Centralization, Universal Architectural Concern Template, Validation Suite Battery, Verification Fitness, Version Provenance, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Validation Gate
Principles
Unowned Risk, Unversioned Breaking Change, Stringly Typed Programming, Boolean Trap, Golden Hammer, Lava Flow, Zombie Code, Cyclic Deployment Dependency, N Plus One Query, PII Oversharing, Irreversible Migration

causality ordering

Details
Contracts
Architectural Contract Kernel, Automation Priority Ordering, Boundary Reconciliation, Causal Wiring Duplication, Causality and Ordering, Causality Ordering, Dependency Linearization, Event and Messaging Consistency, Event Messaging, Living Plan State, Migration Ordering, Observability and Auditability, PAG Coordination Construct, Sequential Chain Duplication, Stage Ordering, Streaming Dataflow, Versioned Turn Provenance
Principles
Implicit Contract, Temporal Coupling

contract compatibility

Details
Contracts
Abstraction Boundary Principle, Adapter Rendering, Agent Creator Kernel, <Agent Generation Concern>, AI Model Architecture Governance, Anti-Pattern Classification, Anti-Pattern Inversion, Anti-Reintroduction Gate, Architectural Contract Algebra, Architectural Contract Kernel, Architectural Relationship Algebra, Architectural Relationship Record, Architectural Style Boundary, <Architecture Anti-Pattern>, Architecture Selection Meta-Algorithm, Architecture Smell Record, Streaming Dataflow, Architecture Validation Before Persistence, <Automation Concern>, Automation Kernel, Automation Operation Mode, Base-Class Candidate Selection, Behavioral Dispatch, Behavioral Self-Test, Composed Turn Contract, Concrete-vs-Abstract Responsibility Split, Console Usage Remediation, Construction Boundary, Consumer Config SSOT, <Context Verification Concern>, Contract-Based Verification Kernel, Contract Compatibility, Correctness Verification, Coupling Control, CSS Type-Cascade Kernel, Custom Type Registration, Declarative Metaprogramming, Document Truth Alignment, Domain Knowledge Base, DSL Compliance Loading, Dynamic Extension Architecture, Enforcement Gate, Error Boundary, Event and Messaging Consistency, Extension Interface Discovery, Extension Point, File-Scoped Fix, Four-Dimensional Agent Graph, Four-Dimensional Phase Graph, Interface Contract, Layer Fitness Enforcement, Manifest-Driven Documentation, Metaprogramming Safety, Mode Contract Validation, <Mode-Driven Response Schema>, Name Projection, Operation Mode Gating, PAG Authoring Kernel, PAG Document Declaration, PAG Phase Decomposition, PAG Tool Invocation, <Pattern Distillation Concern>, Pattern Selection, Phase-Separated Execution, Placement Isolation, Portable Contract Composition, Principle Activation, Refactor Selection, Responsibility Boundary, Risk Complexity Reversibility, Runtime-Agnostic Adapter Boundary, Runtime Discovery, Runtime Extensibility, Safe Arithmetic Contract, Scope Extraction, Security Policy, Self-Description and Discovery, Self-Description Manifest, Semantic Operation Boundary, State and Transaction Safety, Streaming Dataflow, Structural Mediation, Substitutability, Technique and Invariant Selection, Template Assembly, Template Method Lifecycle, Type-Keyed Appearance, Universal Architectural Concern Template, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Validation Gate
Principles
Schema Drift, Implicit Contract, Unobservable Failure, Unversioned Breaking Change, Distributed Monolith, Feature Envy, Inappropriate Intimacy, Data Clumps, Long Parameter List, Over-Abstraction, Pattern Cargo Cult, Temporal Coupling, Anemic Domain Model, Chatty Interface, Silent Data Corruption, Read-Your-Writes Violation, Irreversible Migration, Test Pyramid Inversion, Mock Mirage, AI Prompt Sprawl

control coordination

Details
Contracts
Admissibility Constraint Gate, Agent Activation Invocation, Agent Sequence Definition, Automation Completion Status, <Automation Concern>, Automation Opportunity Detection, Behavioral Dispatch, Behavioral Signature Extraction, Bounded Repair Loop, Checklist Creation Kernel, Checklist Integration, Compilation Stage, Concrete-vs-Abstract Responsibility Split, Context Forking Configuration, Control Plane, Control Plane Coordination, Cross-Stage Invariants, Dependency Linearization, Explicit Termination, Four-Dimensional Agent Graph, Four-Dimensional Phase Graph, Handoff Signal, Hierarchical Numbering, Hybrid Workflow Orchestration, Loop Class Labeling, Orchestrator Action, Orientation Stage, PAG Control-Flow Determinism, PAG Coordination Construct, Parallel Batch Execution, Pattern Selection, Phase Decomposition, Phase Documentation Template, Planning Stage, Rendering Stage, Repair Stage, Sequential Agent Execution, Severity Assignment, Severity Failure Routing, Shared Document Workspace, Task Atomization, Teleological Intent Gate, Template Assembly, Temporal Coupling Detection, Verb-Based Execution Classification, Verb Template Binding, Workflow Coordination Sequence, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Type Document Selection
Principles
God Object, Middle Man, Transaction Script Sprawl, Fat Controller, Repository Dump

correctness verification

Details
Contracts
Action Log, Adaptive Phase Boundary, Admissibility Constraint Gate, Advanced Tool Escalation, Adversarial Input Testing, Agent Creator Kernel, Agent Generation Completion, <Agent Generation Concern>, Agent Sequence Definition, File Modification Recovery, AI Model Governance, Algorithmic Embodiment Validation, Anomaly Outlier Detection, Anti-Pattern Elimination Verification, Anti-Pattern Inversion, Anti-Pattern Priority Matrix, Anti-Pattern Propagation Kernel, Anti-Pattern Remediation Algebra, Anti-Pattern Rule Compiler, Anti-Reintroduction Gate, Architectural Contract Algebra, Architectural Contract Kernel, Architectural Relationship Algebra, <Architecture Anti-Pattern>, Architecture Compliance Targeting, Architecture Evolution Governance, Architecture Refactoring Roadmap, Architecture Selection Meta-Algorithm, Architecture Smell Record, Architecture Validation Before Persistence, Atomic Refactor Phase, Audit Artifact, Authoritative Source Loading, Automation Completion Status, <Automation Concern>, Automation Kernel, Automation Operation Mode, Automation Session Report, Backup-Verified Migration, Base-Class Compliance Remediation, Boundary Reconciliation, Bounded Cascade Termination, Cache Correctness, Canonical Data, Capability Degradation, Capability Invocation Protocol, Capability Profile, Causality and Ordering, Causality Ordering, <Centralization Concern>, Centralization Kernel, Centralization Report, Checklist Creation Kernel, <Checklist Governance Concern>, Checklist Output Rendering, Codebase Pattern Enforcement, Codebase Verification Kernel, Comment Normalization Remediation, Compilation Stage, Completion Report, Completion Truthfulness, Compliance Gap, <Compliance Verification Concern>, Console Usage Remediation, Consumer Config SSOT, Context Forking Configuration, Context Initialization, <Context Verification Concern>, Contract-Based Verification Kernel, Contract Compatibility, Correctness Verification, Coverage Completion, Coverage Ledger, Coverage Risk Prioritisation, Coverage Workspace, Cross-Stage Invariants, CSS Token Remediation, Custom-Rule Derivation, Declarative Metaprogramming, Dependency Linearization, Detection Registry, Deterministic Core, Deterministic Merge Core, Discovery Verification, Document Truth Alignment, DOM Factory Remediation, Domain Cache Validation, DSL Compliance Loading, Dynamic Extension Architecture, Dynamic Failure Isolation, Early Success Exit, Enforcement Gate, Environment Capability Verification, Event and Messaging Consistency, Evidence-Based Claim Verification, Evidence-Gated Claim Verification, Evidence Grounding Validation, Evidence Verdict, Existing Pattern Extraction, Explicit Termination, Extension Point, File Limit Remediation, File Modification Recovery, File-Scoped Fix, Final Generation Report, Governed Autonomous Plan Loop, <Governed Plan Concern>, Handoff Signal, Import Boundary Remediation, Intent & Directionality Normalization, Investigation Report, Iteration Bound, Knowledge Capture, Legacy Elimination, Lifecycle Symmetry Remediation, <Living Accumulation Concern>, Living Plan State, Loop-Owned Mode Selection, Machine Verdict Derivation, Manifest-Driven Documentation, Master Architecture Governance Kernel, Measured-vs-Estimated Validation, Metaprogramming Safety, Migration Ordering, Mode Contract Validation, <Mode-Driven Response Schema>, Modular Boundary Compliance, Naming Convention Remediation, Operation Mode Gating, Orientation Stage, PAG Ambiguity Reduction, PAG Authoring Kernel, PAG Constraint Boundary, PAG Control-Flow Determinism, <PAG Instruction Concern>, PAG Keyword Ontology, PAG Validation Gate, PAG Well-Formedness Validation, Partial Success Reporting, Pattern Classification, Completion Truthfulness, <Pattern Distillation Concern>, Pattern Distiller Kernel, Pattern-Specific Validation, Phase Close Gate, Phase Decomposition, Phase-Separated Execution, Phase Validation Requirement, Plan Phase Verification, Planning Stage, Portability and Deployment Environment, Portability Environment, Portable Contract Composition, Principle Activation, Protocol Semantic Selection, Quality Governance Loop, RAG Knowledge Boundary, Recursive Self-Verification, Refactor Selection, Relationship Schema Validation, Rendering Stage, Repair Stage, Replacement Refactor, Replacement Safety, Reshape Risk Priority, Reverification Gate, Ripple Chain Analysis, Rollback-Centered Execution, Runtime Discovery, Runtime-Neutral Automation Boundary, Security Governance, Security Policy, Semantic Compliance Validation, Semantic Debt Policy, Sequential Agent Execution, Severity-Ordered Remediation, Skeptical Context Acquisition, Smell Taxonomy, State and Transaction Safety, Static-to-Dynamic Readiness, Stylelint Post-Fix, Substitutability, Surface Grid Walk, Task Atomization, Taxonomy Completion, Taxonomy Kernel, Technique and Invariant Selection, Teleological Intent Gate, Test Authoring, <Test Coverage Concern>, Test Coverage Kernel, Tool Calibration, Trust Anchor, Trust Anchor Declaration, Type-Migration Centralization, Uncovered Gap Derivation, Universal Architectural Concern Template, Validation Gate, Validation Score, Validation Stage, Validation Strategy Composition, Validation Suite Battery, Validator Coverage, Verb Template Binding, Verification Execution, Verification Fitness, Verification Loop, Violation Classification, Workflow Coordination Sequence, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Recovery Loop, Workflow Validation Gate, Zero-Duplication Verification
Principles
Manual-Only Governance, Middle Man, Primitive Obsession, Long Parameter List, Pattern Cargo Cult, Temporal Coupling, Exception Control Flow, Transaction Script Sprawl, Fat Controller, Repository Dump, Cache Poisoning by Design, Silent Data Corruption, Log-as-Control-Flow, Mock Mirage, Flaky Test Normalization

domain boundary

Details
Contracts
Adaptive Phase Boundary, Agent Creator Kernel, <Agent Generation Concern>, Architectural Style Boundary, Architectural Style Selection, Audit Artifact, <Automation Concern>, Base-Class Candidate Selection, Behavioral Signature Extraction, Conceptual Duplication Detection, Concern Classification, Creation History Collision, Domain Boundary, Domain Boundary Governance, Domain Cache Validation, Domain Knowledge Base, Event Messaging, Evidence-Before-Generation, Final Generation Report, Intentional Static Separation, Knowledge Documentation Relevance, Non-Destructive Domain Investigation, PAG Phase Decomposition, Port Adapter, Portable Contract Composition, Principle Extraction, Relational Graph Duplication, Risk Complexity Reversibility, Scope Extraction, Semantic Domain Partitioning
Principles
God Object, Primitive Obsession, Magic Value, Anemic Domain Model, Transaction Script Sprawl, Repository Dump, Utility Dump, Framework Leakage, Vendor Lock-In Leakage, Big-Upfront Frozen Architecture, Architecture Astronaut

event messaging

Details
Contracts
Causality and Ordering, Causality Ordering, Console Usage Remediation, DSL Compliance Loading, Event and Messaging Consistency, Event Messaging, Handoff Signal, Hybrid Workflow Orchestration, Orchestrator Action, PAG Coordination Construct, Parallel Batch Execution, Profile Compose, Quality Governance Loop, Saga Compensation, Sequential Agent Execution, Template Assembly, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Validation Gate
Principles
Unversioned Breaking Change, Message Chain, Hidden Side Effect, Action at a Distance, Dual Write

metaprogramming modeling

Details
Contracts
Authoritative Source Loading, Declarative Metaprogramming, DSL Compliance Loading, Dynamic Discovery Pattern Generation, First-Time Initiation, Metaprogramming Safety, Orientation Stage, PAG Authoring Kernel, PAG Document Declaration, <PAG Instruction Concern>, PAG Keyword Ontology, Phase Decomposition, Phase Documentation Template, Template Assembly, Verb Template Binding, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Validation Gate
Principles
Opaque Runtime Behavior

modularity

Details
Contracts
Abstraction Boundary Principle, Adaptive Phase Boundary, Agent Document Responsibility, Agent Sequence Definition, Anti-Pattern Propagation Kernel, Architectural Contract Algebra, Architectural Style Boundary, Architectural Style Selection, <Architecture Anti-Pattern>, Architecture Compliance Targeting, Assembly Composition, Base-Class Candidate Selection, Base Schematic Composition, Canonical Data, Cascade Layer Partition, Centralized Reference Resolver, Comment Normalization Remediation, Concrete-vs-Abstract Responsibility Split, Construction Boundary, Consumer Config SSOT, Container Reshape, Correctness Verification, Coupling Control, Custom-Rule Derivation, Defensive String Normalization, Delta Capture, Document Truth Alignment, DOM Factory Remediation, Domain Boundary, Domain Boundary Governance, Entry Point Migration, Error Boundary, Extension Interface Discovery, File Limit Remediation, Fractal Scale Duplication, Governed Construction Boundary, Handoff Signal, Import Boundary Remediation, Intentional Static Separation, Manifest-Driven Documentation, Modular Boundary Compliance, Observability and Auditability, PAG Phase Decomposition, PAG Validation Gate, Path Role Walk, <Pattern Distillation Concern>, Pattern Distillation History, Pattern Distiller Kernel, Phase Validation Requirement, Planning Stage, Profile Compose, RAG Knowledge Boundary, Relational Graph Duplication, Responsibility Boundary, Rollback-Centered Execution, Runtime-Agnostic Adapter Boundary, Runtime-Neutral Automation Boundary, Scope Extraction, Semantic Domain Partitioning, Semantic Operation Boundary, State and Transaction Safety, Structural Mediation, Task Atomization, <Taxonomy Concern>, Taxonomy Kernel, Transaction Boundary, Trust Anchor Declaration, Universal Architectural Concern Template, Validation Strategy Composition
Principles
Big Ball of Mud, God Object, Concrete Coupling, Shared Mutable State, Boundary Leakage, Distributed Monolith, Shotgun Surgery, Divergent Change, Feature Envy, Inappropriate Intimacy, Middle Man, Long Parameter List, Premature Abstraction, Temporal Coupling, Anemic Domain Model, Utility Dump, Vendor Lock-In Leakage, Circular Dependency, Synchronous Chain Trap, Chatty Interface, Secret Sprawl

observability traceability

Details
Contracts
AI Model Governance, <Architecture Anti-Pattern>, <Automation Concern>, Causality and Ordering, Checklist Output Rendering, Console Usage Remediation, Discovery Verification, Dynamic Extension Architecture, Event and Messaging Consistency, Evidence-Gated Claim Verification, Evidence Grounding Validation, Extension Point, Non-Destructive Domain Investigation, Observability and Auditability, Observability Trace, Plan Phase Verification, Recovery Deployment, Structured Observability Context, Taxonomy Ledger, Universal Architectural Concern Template, Validation Suite Battery, Versioned Turn Provenance, Violation Detection, Workflow Coordination Sequence
Principles
Observability Noise, Mock Mirage

resilience recovery

Details
Contracts
File Modification Recovery, Streaming Dataflow, <Automation Concern>, Automation Kernel, Boundary Reconciliation, Bounded Cascade Termination, Bounded Repair Loop, Cache Correctness, Capability Degradation, Centralized Reference Resolver, Cross-Cutting Surface Coverage, Dynamic Extension Architecture, Error Boundary, Event and Messaging Consistency, Explicit Termination, File Modification Recovery, Governed Autonomous Plan Loop, Idempotent Side Effect, Manual Fallback Preservation, Orchestrator Action, Persistence Fork, Recovery Deployment, Repair Stage, Resilience Control, Resilience Policy, Rollback-Centered Execution, Severity Failure Routing, State and Transaction Safety, Static-to-Dynamic Readiness, Streaming Dataflow, Workflow Creation Kernel, Workflow Principles Mapping, Workflow Recovery Loop
Principles
Retry Storm, Timeout Omission, Missing Backpressure, Log-as-Control-Flow, Manual Runbook Dependency

runtime extensibility

Details
Contracts
Agent Creator Kernel, <Agent Generation Concern>, Algorithmic Embodiment Validation, <Automation Concern>, Automation Kernel, Automation Opportunity Detection, Automation Session Report, Cache Invalidation Strategy, <Centralization Concern>, Centralization Kernel, Checklist Creation Kernel, <Checklist Governance Concern>, Compliance Gap, Composed Turn Contract, Context Forking Configuration, Context Initialization, Convention Strength Analysis, Correctness Verification, Detection Registry, DSL Compliance Loading, Dynamic Discovery Pattern Generation, Dynamic Extension Architecture, Dynamic Failure Isolation, Enforcement Gate, Entry Point Migration, Evidence-Before-Generation, Extension Interface Discovery, Extension Point, Governed Autonomous Plan Loop, Hybrid Workflow Orchestration, Intentional Static Separation, Iterative Variation Discovery, Knowledge Documentation Relevance, Measured-vs-Estimated Validation, Migration Action Mapping, <Mode-Driven Response Schema>, Non-Destructive Domain Investigation, PAG Tool Invocation, Pattern Classification, Completion Truthfulness, Pattern Distiller Kernel, Performance-Aware Discovery Design, Phase-Separated Execution, Protocol Semantic Selection, Registry Baseline, Registry Regeneration, Ripple Chain Analysis, Runtime Discovery, Runtime Extensibility, Runtime-Neutral Automation Boundary, Scalability Projection, Self-Description and Discovery, Skeptical Context Acquisition, Static-to-Dynamic Readiness, Validator Coverage, Verification Fitness, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Validation Gate, Workspace Configuration Discovery
Principles
Opaque Runtime Behavior, Speculative Generality

security governance

Details
Contracts
AI Model Architecture Governance, AI Model Governance, Architectural Contract Kernel, Architecture Catalog Compiler, Architecture Evolution Governance, Checklist Creation Kernel, <Checklist Governance Concern>, Conflict and Tension Resolution, Control Plane, Control Plane Coordination, Cross-Cutting Surface Coverage, Domain Boundary Governance, Error Boundary, Governance Evolution, Governed Autonomous Plan Loop, <Governed Plan Concern>, Loop-Owned Mode Selection, Master Architecture Governance Kernel, <Mode-Driven Response Schema>, PAG Constraint Boundary, Phase Close Gate, Plan Phase Verification, Quality-Engine Kernel, Quality Governance Loop, Recursion Control, Security Governance, Security Policy, Severity Policy, Trust Anchor, User Decision Gate, Version Provenance
Principles
Schema Drift, Manual-Only Governance, Fat Controller, Cache Poisoning by Design, Security Theater, Authorization Scattering, Secret Sprawl, Feature-Only Design

semantic consistency

Details
Contracts
Additive Debt Gate, Agent Document Responsibility, Anomaly Outlier Detection, Anti-Pattern Classification, Anti-Pattern Elimination Verification, Anti-Pattern Propagation Kernel, Architecture Compliance Targeting, Streaming Dataflow, Automation Opportunity Detection, Base-Class Candidate Selection, Base-Class Compliance Remediation, Behavioral Inconsistency, Behavioral Signature Extraction, Cache Invalidation Strategy, Canonical Config Resolution, Canonical Data, Canonical Semantics, Canonical Variation Selection, Capability Disclosure, Causal Wiring Duplication, <Centralization Concern>, Centralization Kernel, Centralization Report, Centralized Reference Resolver, Comment Normalization Remediation, Completion Truthfulness, Composed Turn Contract, Conceptual Duplication Detection, Concern Classification, Console Usage Remediation, Control Plane, Control Plane Coordination, Creation History Collision, Cross-Class Pattern Detection, Custom Type Registration, Defensive String Normalization, Distillation Metrics, Domain Boundary, Domain Cache Validation, Entry Point Migration, Existing Pattern Extraction, Existing Solution Conflict, Idempotent Side Effect, Intent & Directionality Normalization, Interface Contract, Iterative Variation Discovery, Measurement Normalization, <Mode-Driven Response Schema>, Name Projection, PAG Ambiguity Reduction, PAG Document Declaration, <PAG Instruction Concern>, PAG Keyword Ontology, Path Role Walk, Pattern Classification, Completion Truthfulness, <Pattern Distillation Concern>, Pattern Distiller Kernel, Pattern-Specific Validation, Persistence Fork, Portable Contract Composition, Protocol Semantic Selection, Quality-Engine Kernel, Quality Governance Loop, Refactor Intent Classification, Replacement Refactor, Runtime-Agnostic Adapter Boundary, Runtime-Neutral Automation Boundary, Seed Composition, Semantic Compliance Validation, Semantic Debt Policy, Semantic Domain Partitioning, Semantic Operation Boundary, Sequential Chain Duplication, Shared Document Workspace, Stage Ordering, Surface Grid Walk, Taxonomy Completion, <Taxonomy Concern>, Taxonomy Jurisdiction, Taxonomy Kernel, Template Method Lifecycle, Temporal Coupling Detection, <Test Coverage Concern>, Test Coverage Kernel, Token Source-of-Truth, Transaction Boundary, Type-Migration Centralization, Validation Stage, Violation Classification, Vocabulary Admission Gate, Workflow Coordination Sequence, Workspace Configuration Discovery, Zero-Duplication Verification
Principles
God Object, Hardcoded Configuration, Null Semantics Drift, Anemic Domain Model, Flaky Test Normalization

state transaction

Details
Contracts
File Modification Recovery, Atomic Refactor Phase, Automation Operation Mode, Context Forking Configuration, Custom-Rule Derivation, Early Success Exit, Event and Messaging Consistency, File Modification Recovery, Governed Autonomous Plan Loop, <Governed Plan Concern>, Hybrid Workflow Orchestration, Idempotent Merge, Idempotent Side Effect, <Living Accumulation Concern>, Living Plan State, Loop-Owned Mode Selection, Non-Destructive Domain Investigation, Operation Mode Gating, Orchestrator Action, <Pattern Distillation Concern>, Phase Close Gate, Phase-Separated Execution, Replacement Safety, Resilience Policy, Rollback-Centered Execution, Sequential Agent Execution, State and Transaction Safety, Transaction Boundary, Versioned Turn Provenance, Workflow Creation Kernel, <Workflow Orchestration Concern>, Workflow Principles Mapping, Workflow Recovery Loop
Principles
Big Ball of Mud, Hardcoded Configuration, Shared Mutable State, Distributed Monolith, Ambient Context, Transaction Script Sprawl, Lost Update, Big-Bang Release

The layer topology

The layer topology: the four core layers, the domains beneath them and the cross-cutting domains, and the edges that join them. Every layer is an algorithm contract, and each record names the categories of principle and term that belong to it.

Relations diagram
The layer topology.
flowchart TB
    n_layer_atomic_boundary["Atomic Boundary"]
    n_layer_causality_core["Causality Core"]
    n_layer_computation_core["Computation Core"]
    n_layer_contracts_core["Contracts Core"]
    n_layer_correctness_core["Correctness Core"]
    n_layer_declarative_core["Declarative Core"]
    n_layer_design_patterns_core["Design Patterns Core"]
    n_layer_domain_modeling["Domain Modeling"]
    n_layer_enforcement_core["Enforcement Core"]
    n_layer_evolution_principles["Evolution Principles"]
    n_layer_execution_core["Execution Core"]
    n_layer_extensibility_core["Extensibility Core"]
    n_layer_human_factors["Human Factors"]
    n_layer_observability["Observability"]
    n_layer_performance_core["Performance Core"]
    n_layer_resource_core["Resource Core"]
    n_layer_security_core["Security Core"]
    n_layer_structural_core["Structural Core"]
    n_layer_resource_core -- observe --> n_layer_computation_core
    n_layer_computation_core -- feeds --> n_layer_execution_core
    n_layer_resource_core -- feeds --> n_layer_execution_core
    n_layer_execution_core -- feeds --> n_layer_structural_core
    n_layer_structural_core -- feedback --> n_layer_execution_core
    n_layer_structural_core -- feeds --> n_layer_human_factors
    n_layer_structural_core -- feeds --> n_layer_evolution_principles
    n_layer_evolution_principles -- feeds --> n_layer_human_factors
    n_layer_correctness_core -- cross-cuts --> n_layer_structural_core
    n_layer_security_core -- cross-cuts --> n_layer_structural_core
    n_layer_performance_core -- cross-cuts --> n_layer_structural_core
    n_layer_contracts_core -- cross-cuts --> n_layer_structural_core
    n_layer_causality_core -- cross-cuts --> n_layer_structural_core
    n_layer_declarative_core -- cross-cuts --> n_layer_structural_core
    n_layer_extensibility_core -- cross-cuts --> n_layer_structural_core
    n_layer_observability -- cross-cuts --> n_layer_structural_core
    n_layer_enforcement_core -- cross-cuts --> n_layer_structural_core
    n_layer_atomic_boundary -- cross-cuts --> n_layer_structural_core
    n_layer_domain_modeling -- cross-cuts --> n_layer_structural_core
    n_layer_design_patterns_core -- cross-cuts --> n_layer_structural_core

Structural Core

Details
Member categories
Codebase / System Architecture Styles, Core Modular Design, SOLID / Object-Oriented Design, Taxonomy / Classification / Naming, Core Vocabulary
Outgoing edges
feedback → Execution Core, feeds → Human Factors, feeds → Evolution Principles
Incoming edges
feeds → Execution Core, cross-cuts → Correctness Core, cross-cuts → Security Core, cross-cuts → Performance Core, cross-cuts → Contracts Core, cross-cuts → Causality Core, cross-cuts → Declarative Core, cross-cuts → Extensibility Core, cross-cuts → Observability, cross-cuts → Enforcement Core, cross-cuts → Atomic Boundary, cross-cuts → Domain Modeling, cross-cuts → Design Patterns Core

The membership

Which layer every category of principle and term belongs to.

The resolutions

Every tension edge in the canon, resolved: the two records, the mechanism that settles it, the layer each side owns, and the rule. An explicit resolution is one the canon states; the rest are derived from the layers the two sides occupy.

Do Not Repeat Yourself (DRY) against Locality of Behavior

  • Mechanism: mitigation
  • Stated by the canon
Details
Scope of the first
Do Not Repeat Yourself (DRY) · Layer: Structural Core
Scope of the second
Locality of Behavior · Layer: Structural Core
Rule
Centralize knowledge — rules, schemas, single source of truth — for SEMANTIC duplication; keep incidental co-occurrence local, never abstracting coincidental textual similarity into false shared code. The discriminator is semantic vs incidental, not textual sameness.

Normalization against Query Performance

  • Mechanism: scope-separation
  • Stated by the canon
Details
Scope of the first
Normalization · Layer: Contracts Core
Scope of the second
Query Performance · Layer: Performance Core
Rule
Normalize the source of truth — one canonical store, no duplication; denormalize DERIVED read models (projections) for query performance, never the canonical store. The two live in separate scopes: system-of-record vs read-projection.

Normalization against Denormalized Read Models

  • Mechanism: scope-separation
  • Stated by the canon
Details
Scope of the first
Normalization · Layer: Contracts Core
Scope of the second
Denormalized Read Models · Layer: Performance Core
Rule
Normalize the canonical store; denormalize only derived read models rebuilt from it. Normalization governs the write model, denormalization the read projection — different scopes, not a single store to compromise.

Database Normalization against Read Performance

  • Mechanism: scope-separation
  • Stated by the canon
Details
Scope of the first
Database Normalization · Layer: Contracts Core
Scope of the second
Read Performance · Layer: Performance Core
Rule
Keep the canonical schema normalized; serve read performance from derived, denormalized projections rebuilt from it, never by denormalizing the source of truth.

Artificial Intelligence Architecture against Determinism

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Artificial Intelligence Architecture · Layer: Correctness Core
Scope of the second
Determinism · Layer: Computation Core
Rule
"artificial-intelligence-architecture" (correctness-core layer) is traded against "Determinism" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Determinism" and choosing an explicit operating point.

Artificial Intelligence Architecture against Explainability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Artificial Intelligence Architecture · Layer: Correctness Core
Scope of the second
Explainability · Layer: Correctness Core
Rule
"artificial-intelligence-architecture" (correctness-core layer) is traded against "Explainability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explainability" and choosing an explicit operating point.

Machine Learning Architecture against Experimentation Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Machine Learning Architecture · Layer: Correctness Core
Scope of the second
Experimentation Speed · Layer: Correctness Core
Rule
"machine-learning-architecture" (correctness-core layer) is traded against "Experimentation Speed" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Experimentation Speed" and choosing an explicit operating point.

Model Governance against Experiment Velocity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Model Governance · Layer: Correctness Core
Scope of the second
Experiment Velocity · Layer: Correctness Core
Rule
"model-governance" (correctness-core layer) is traded against "Experiment Velocity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Experiment Velocity" and choosing an explicit operating point.

Model Evaluation against Metric Completeness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Model Evaluation · Layer: Correctness Core
Scope of the second
Metric Completeness · Layer: Correctness Core
Rule
"model-evaluation" (correctness-core layer) is traded against "Metric Completeness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metric Completeness" and choosing an explicit operating point.

Model Inference against Latency/Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Model Inference · Layer: Correctness Core
Scope of the second
Latency/Cost · Layer: Performance Core
Rule
"model-inference" (correctness-core layer) is traded against "Latency/Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Cost" and choosing an explicit operating point.

Retrieval-Augmented Generation (RAG) against Retrieval Quality/Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Retrieval-Augmented Generation (RAG) · Layer: Correctness Core
Scope of the second
Retrieval Quality/Latency · Layer: Performance Core
Rule
"retrieval-augmented-generation" (correctness-core layer) is traded against "Retrieval Quality/Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Retrieval Quality/Latency" and choosing an explicit operating point.

Knowledge Graphs against Curation Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Knowledge Graphs · Layer: Correctness Core
Scope of the second
Curation Cost · Layer: Performance Core
Rule
"knowledge-graphs" (correctness-core layer) is traded against "Curation Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Curation Cost" and choosing an explicit operating point.

Explainability against Model Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Explainability · Layer: Correctness Core
Scope of the second
Model Complexity · Layer: Correctness Core
Rule
"explainability" (correctness-core layer) is traded against "Model Complexity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Model Complexity" and choosing an explicit operating point.

AI Safety against Capability/Utility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
AI Safety · Layer: Correctness Core
Scope of the second
Capability/Utility · Layer: Correctness Core
Rule
"ai-safety" (correctness-core layer) is traded against "Capability/Utility" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Capability/Utility" and choosing an explicit operating point.

Prompt Engineering against Robustness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Prompt Engineering · Layer: Correctness Core
Scope of the second
Robustness · Layer: Correctness Core
Rule
"prompt-engineering" (correctness-core layer) is traded against "Robustness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Robustness" and choosing an explicit operating point.

Model Drift Monitoring against Monitoring Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Model Drift Monitoring · Layer: Correctness Core
Scope of the second
Monitoring Cost · Layer: Performance Core
Rule
"model-drift-monitoring" (correctness-core layer) is traded against "Monitoring Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Monitoring Cost" and choosing an explicit operating point.

Agentic Architecture against Determinism

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Agentic Architecture · Layer: Correctness Core
Scope of the second
Determinism · Layer: Computation Core
Rule
"agentic-architecture" (correctness-core layer) is traded against "Determinism" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Determinism" and choosing an explicit operating point.

Assessment against Time Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Assessment · Layer: Evolution Principles
Scope of the second
Time Cost · Layer: Structural Core
Rule
"assessment" (evolution-principles layer) is traded against "Time Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Time Cost" and choosing an explicit operating point.

Architecture Review against Delivery Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Architecture Review · Layer: Evolution Principles
Scope of the second
Delivery Speed · Layer: Structural Core
Rule
"architecture-review" (evolution-principles layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.

Design Review against Iteration Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Design Review · Layer: Evolution Principles
Scope of the second
Iteration Speed · Layer: Structural Core
Rule
"design-review" (evolution-principles layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.

Code Review against Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Code Review · Layer: Evolution Principles
Scope of the second
Throughput · Layer: Performance Core
Rule
"code-review" (evolution-principles layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.

Impact Analysis against Analysis Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Impact Analysis · Layer: Evolution Principles
Scope of the second
Analysis Overhead · Layer: Evolution Principles
Rule
"impact-analysis" (evolution-principles layer) is traded against "Analysis Overhead" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Analysis Overhead" and choosing an explicit operating point.

Gap Analysis against Time Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Gap Analysis · Layer: Evolution Principles
Scope of the second
Time Cost · Layer: Structural Core
Rule
"gap-analysis" (evolution-principles layer) is traded against "Time Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Time Cost" and choosing an explicit operating point.

Fitness Functions against Rule Maintenance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fitness Functions · Layer: Evolution Principles
Scope of the second
Rule Maintenance · Layer: Evolution Principles
Rule
"fitness-functions" (evolution-principles layer) is traded against "Rule Maintenance" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rule Maintenance" and choosing an explicit operating point.

Quality Attributes against Competing Attributes

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Quality Attributes · Layer: Performance Core
Scope of the second
Competing Attributes · Layer: Evolution Principles
Rule
"quality-attributes" (performance-core layer) is traded against "Competing Attributes" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Competing Attributes" and choosing an explicit operating point.

Architecture Decision Records (ADR) against Documentation Maintenance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Architecture Decision Records (ADR) · Layer: Evolution Principles
Scope of the second
Documentation Maintenance · Layer: Evolution Principles
Rule
"architecture-decision-records" (evolution-principles layer) is traded against "Documentation Maintenance" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Documentation Maintenance" and choosing an explicit operating point.

Evolutionary Architecture against Governance Discipline

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Evolutionary Architecture · Layer: Evolution Principles
Scope of the second
Governance Discipline · Layer: Evolution Principles
Rule
"evolutionary-architecture" (evolution-principles layer) is traded against "Governance Discipline" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Governance Discipline" and choosing an explicit operating point.

Minimum Viable Architecture against Future Scalability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Minimum Viable Architecture · Layer: Evolution Principles
Scope of the second
Future Scalability · Layer: Evolution Principles
Rule
"minimum-viable-architecture" (evolution-principles layer) is traded against "Future Scalability" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Future Scalability" and choosing an explicit operating point.

Greenfield Development against Unknown Requirements

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Greenfield Development · Layer: Evolution Principles
Scope of the second
Unknown Requirements · Layer: Evolution Principles
Rule
"greenfield-development" (evolution-principles layer) is traded against "Unknown Requirements" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Unknown Requirements" and choosing an explicit operating point.

Greenfield Development against Legacy Constraints

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Greenfield Development · Layer: Evolution Principles
Scope of the second
Legacy Constraints · Layer: Evolution Principles
Rule
"greenfield-development" (evolution-principles layer) is traded against "Legacy Constraints" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Legacy Constraints" and choosing an explicit operating point.

First-Principles Design against Reuse of Established Patterns

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
First-Principles Design · Layer: Evolution Principles
Scope of the second
Reuse of Established Patterns · Layer: Evolution Principles
Rule
"first-principles-design" (evolution-principles layer) is traded against "Reuse of Established Patterns" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Reuse of Established Patterns" and choosing an explicit operating point.

Reference Architecture against Team Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reference Architecture · Layer: Evolution Principles
Scope of the second
Team Autonomy · Layer: Human Factors
Rule
"reference-architecture" (evolution-principles layer) is traded against "Team Autonomy" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Autonomy" and choosing an explicit operating point.

Pattern Consistency against Local Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pattern Consistency · Layer: Evolution Principles
Scope of the second
Local Optimization · Layer: Evolution Principles
Rule
"pattern-consistency" (evolution-principles layer) is traded against "Local Optimization" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Optimization" and choosing an explicit operating point.

Architectural Consistency against Local Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Architectural Consistency · Layer: Evolution Principles
Scope of the second
Local Autonomy · Layer: Evolution Principles
Rule
"architectural-consistency" (evolution-principles layer) is traded against "Local Autonomy" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Autonomy" and choosing an explicit operating point.

Standardization against Innovation/Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Standardization · Layer: Evolution Principles
Scope of the second
Innovation/Autonomy · Layer: Evolution Principles
Rule
"standardization" (evolution-principles layer) is traded against "Innovation/Autonomy" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Innovation/Autonomy" and choosing an explicit operating point.

Strategy Pattern against Class Count

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Strategy Pattern · Layer: Design Patterns Core
Scope of the second
Class Count · Layer: Design Patterns Core
Rule
"strategy-pattern" (design-patterns-core layer) is traded against "Class Count" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Class Count" and choosing an explicit operating point.

Template Method Pattern against Inheritance Coupling

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Template Method Pattern · Layer: Design Patterns Core
Scope of the second
Inheritance Coupling · Layer: Design Patterns Core
Rule
"template-method-pattern" (design-patterns-core layer) is traded against "Inheritance Coupling" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Inheritance Coupling" and choosing an explicit operating point.

Observer Pattern against Ordering

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Observer Pattern · Layer: Design Patterns Core
Scope of the second
Ordering · Layer: Causality Core
Rule
"observer-pattern" (design-patterns-core layer) is traded against "Ordering" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering" and choosing an explicit operating point.

Observer Pattern against Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Observer Pattern · Layer: Design Patterns Core
Scope of the second
Debuggability · Layer: Observability
Rule
"observer-pattern" (design-patterns-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.

Mediator Pattern against Mediator God Object

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Mediator Pattern · Layer: Design Patterns Core
Scope of the second
Mediator God Object · Layer: Design Patterns Core
Rule
"mediator-pattern" (design-patterns-core layer) is traded against "Mediator God Object" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mediator God Object" and choosing an explicit operating point.

Command Pattern against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Command Pattern · Layer: Design Patterns Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"command-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

State Pattern against Class Proliferation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
State Pattern · Layer: Design Patterns Core
Scope of the second
Class Proliferation · Layer: Design Patterns Core
Rule
"state-pattern" (design-patterns-core layer) is traded against "Class Proliferation" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Class Proliferation" and choosing an explicit operating point.

Chain of Responsibility Pattern against Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Chain of Responsibility Pattern · Layer: Design Patterns Core
Scope of the second
Traceability · Layer: Observability
Rule
"chain-of-responsibility-pattern" (design-patterns-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.

Iterator Pattern against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Iterator Pattern · Layer: Design Patterns Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"iterator-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Visitor Pattern against Element Stability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Visitor Pattern · Layer: Design Patterns Core
Scope of the second
Element Stability · Layer: Design Patterns Core
Rule
"visitor-pattern" (design-patterns-core layer) is traded against "Element Stability" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Element Stability" and choosing an explicit operating point.

Memento Pattern against Memory Footprint

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Memento Pattern · Layer: Design Patterns Core
Scope of the second
Memory Footprint · Layer: Design Patterns Core
Rule
"memento-pattern" (design-patterns-core layer) is traded against "Memory Footprint" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Memory Footprint" and choosing an explicit operating point.

Null Object Pattern against Silent No-Op Risk

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Null Object Pattern · Layer: Design Patterns Core
Scope of the second
Silent No-Op Risk · Layer: Design Patterns Core
Rule
"null-object-pattern" (design-patterns-core layer) is traded against "Silent No-Op Risk" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Silent No-Op Risk" and choosing an explicit operating point.

Finite State Machine against State Explosion

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Finite State Machine · Layer: Design Patterns Core
Scope of the second
State Explosion · Layer: Design Patterns Core
Rule
"finite-state-machine" (design-patterns-core layer) is traded against "State Explosion" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Explosion" and choosing an explicit operating point.

Statecharts against Tooling Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Statecharts · Layer: Design Patterns Core
Scope of the second
Tooling Complexity · Layer: Human Factors
Rule
"statecharts" (design-patterns-core layer) is traded against "Tooling Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling Complexity" and choosing an explicit operating point.

Causality against Parallelism

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Causality · Layer: Causality Core
Scope of the second
Parallelism · Layer: Performance Core
Rule
"causality" (causality-core layer) is traded against "Parallelism" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Parallelism" and choosing an explicit operating point.

Causal Consistency against Latency/Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Causal Consistency · Layer: Causality Core
Scope of the second
Latency/Availability · Layer: Causality Core
Rule
"causal-consistency" (causality-core layer) is traded against "Latency/Availability" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Availability" and choosing an explicit operating point.

Happens-Before Relationship against Parallel Execution

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Happens-Before Relationship · Layer: Causality Core
Scope of the second
Parallel Execution · Layer: Causality Core
Rule
"happens-before-relationship" (causality-core layer) is traded against "Parallel Execution" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Parallel Execution" and choosing an explicit operating point.

Event Ordering against Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event Ordering · Layer: Causality Core
Scope of the second
Throughput · Layer: Performance Core
Rule
"event-ordering" (causality-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.

Causal Dependency against Graph Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Causal Dependency · Layer: Causality Core
Scope of the second
Graph Complexity · Layer: Causality Core
Rule
"causal-dependency" (causality-core layer) is traded against "Graph Complexity" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Graph Complexity" and choosing an explicit operating point.

Dependency Graph against Dynamic Loading

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dependency Graph · Layer: Causality Core
Scope of the second
Dynamic Loading · Layer: Causality Core
Rule
"dependency-graph" (causality-core layer) is traded against "Dynamic Loading" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Loading" and choosing an explicit operating point.

Directed Acyclic Graph (DAG) against Bidirectional Collaboration

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Directed Acyclic Graph (DAG) · Layer: Causality Core
Scope of the second
Bidirectional Collaboration · Layer: Causality Core
Rule
"directed-acyclic-graph" (causality-core layer) is traded against "Bidirectional Collaboration" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bidirectional Collaboration" and choosing an explicit operating point.

Vector Clocks against Metadata Size

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Vector Clocks · Layer: Causality Core
Scope of the second
Metadata Size · Layer: Causality Core
Rule
"vector-clocks" (causality-core layer) is traded against "Metadata Size" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Size" and choosing an explicit operating point.

Lamport Clocks against No Concurrent Causality Distinction

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Lamport Clocks · Layer: Causality Core
Scope of the second
No Concurrent Causality Distinction · Layer: Causality Core
Rule
"lamport-clocks" (causality-core layer) is traded against "No Concurrent Causality Distinction" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "No Concurrent Causality Distinction" and choosing an explicit operating point.

Hybrid Logical Clocks against Clock Skew

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Hybrid Logical Clocks · Layer: Causality Core
Scope of the second
Clock Skew · Layer: Causality Core
Rule
"hybrid-logical-clocks" (causality-core layer) is traded against "Clock Skew" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Clock Skew" and choosing an explicit operating point.

CRDTs against Metadata Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CRDTs · Layer: Causality Core
Scope of the second
Metadata Overhead · Layer: Causality Core
Rule
"crdts" (causality-core layer) is traded against "Metadata Overhead" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Overhead" and choosing an explicit operating point.

CRDTs against Last-Write-Wins Overwrite

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CRDTs · Layer: Causality Core
Scope of the second
Last-Write-Wins Overwrite · Layer: Causality Core
Rule
"crdts" (causality-core layer) is traded against "Last-Write-Wins Overwrite" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Last-Write-Wins Overwrite" and choosing an explicit operating point.

Total-Order Broadcast against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Total-Order Broadcast · Layer: Causality Core
Scope of the second
Latency · Layer: Performance Core
Rule
"total-order-broadcast" (causality-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

CAP Theorem against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CAP Theorem · Layer: Causality Core
Scope of the second
Latency · Layer: Performance Core
Rule
"cap-theorem" (causality-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

PACELC Theorem against Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
PACELC Theorem · Layer: Causality Core
Scope of the second
Throughput · Layer: Performance Core
Rule
"pacelc-theorem" (causality-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.

Ports and Adapters Architecture against Boilerplate

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Ports and Adapters Architecture · Layer: Structural Core
Scope of the second
Boilerplate · Layer: Structural Core
Rule
"ports-and-adapters-architecture" (structural-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.

Hexagonal Architecture against Initial Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Hexagonal Architecture · Layer: Structural Core
Scope of the second
Initial Complexity · Layer: Structural Core
Rule
"hexagonal-architecture" (structural-core layer) is traded against "Initial Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Initial Complexity" and choosing an explicit operating point.

Clean Architecture against Boilerplate

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Clean Architecture · Layer: Structural Core
Scope of the second
Boilerplate · Layer: Structural Core
Rule
"clean-architecture" (structural-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.

Layered Architecture against Anemic Layers

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Layered Architecture · Layer: Structural Core
Scope of the second
Anemic Layers · Layer: Structural Core
Rule
"layered-architecture" (structural-core layer) is traded against "Anemic Layers" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Anemic Layers" and choosing an explicit operating point.

Component-Based Architecture against Integration Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Component-Based Architecture · Layer: Structural Core
Scope of the second
Integration Overhead · Layer: Structural Core
Rule
"component-based-architecture" (structural-core layer) is traded against "Integration Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Integration Overhead" and choosing an explicit operating point.

Package by Feature against Shared Technical Concerns

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Package by Feature · Layer: Structural Core
Scope of the second
Shared Technical Concerns · Layer: Structural Core
Rule
"package-by-feature" (structural-core layer) is traded against "Shared Technical Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shared Technical Concerns" and choosing an explicit operating point.

Microservices against Operational Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Microservices · Layer: Structural Core
Scope of the second
Operational Complexity · Layer: Structural Core
Rule
"microservices" (structural-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.

Microservices against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Microservices · Layer: Structural Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"microservices" (structural-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Monolith Architecture against Team Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Monolith Architecture · Layer: Structural Core
Scope of the second
Team Autonomy · Layer: Human Factors
Rule
"monolith-architecture" (structural-core layer) is traded against "Team Autonomy" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Autonomy" and choosing an explicit operating point.

Monolith Architecture against Independent Scaling

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Monolith Architecture · Layer: Structural Core
Scope of the second
Independent Scaling · Layer: Structural Core
Rule
"monolith-architecture" (structural-core layer) is traded against "Independent Scaling" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Independent Scaling" and choosing an explicit operating point.

Pipes and Filters against End-to-End Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pipes and Filters · Layer: Structural Core
Scope of the second
End-to-End Traceability · Layer: Structural Core
Rule
"pipes-and-filters" (structural-core layer) is traded against "End-to-End Traceability" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "End-to-End Traceability" and choosing an explicit operating point.

Service-Oriented Architecture against Operational Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service-Oriented Architecture · Layer: Structural Core
Scope of the second
Operational Overhead · Layer: Resource Core
Rule
"service-oriented-architecture" (structural-core layer) is traded against "Operational Overhead" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Overhead" and choosing an explicit operating point.

Space-Based Architecture against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Space-Based Architecture · Layer: Structural Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"space-based-architecture" (structural-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Design by Contract against Development Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Design by Contract · Layer: Contracts Core
Scope of the second
Development Speed · Layer: Contracts Core
Rule
"design-by-contract" (contracts-core layer) is traded against "Development Speed" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Development Speed" and choosing an explicit operating point.

Explicit Contracts against Rapid Prototyping

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Explicit Contracts · Layer: Contracts Core
Scope of the second
Rapid Prototyping · Layer: Contracts Core
Rule
"explicit-contracts" (contracts-core layer) is traded against "Rapid Prototyping" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rapid Prototyping" and choosing an explicit operating point.

Stable Interfaces against Evolution Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Stable Interfaces · Layer: Contracts Core
Scope of the second
Evolution Speed · Layer: Contracts Core
Rule
"stable-interfaces" (contracts-core layer) is traded against "Evolution Speed" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Evolution Speed" and choosing an explicit operating point.

Interface-Based Design against Interface Overuse

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Interface-Based Design · Layer: Contracts Core
Scope of the second
Interface Overuse · Layer: Contracts Core
Rule
"interface-based-design" (contracts-core layer) is traded against "Interface Overuse" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Interface Overuse" and choosing an explicit operating point.

Contract-First Design against Iteration Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Contract-First Design · Layer: Contracts Core
Scope of the second
Iteration Speed · Layer: Structural Core
Rule
"contract-first-design" (contracts-core layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.

API Contract against Evolution

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
API Contract · Layer: Contracts Core
Scope of the second
Evolution · Layer: Contracts Core
Rule
"api-contract" (contracts-core layer) is traded against "Evolution" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Evolution" and choosing an explicit operating point.

Service Contract against Distributed Evolution

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Contract · Layer: Contracts Core
Scope of the second
Distributed Evolution · Layer: Contracts Core
Rule
"service-contract" (contracts-core layer) is traded against "Distributed Evolution" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Evolution" and choosing an explicit operating point.

Data Contract against Flexible Ingestion

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Data Contract · Layer: Contracts Core
Scope of the second
Flexible Ingestion · Layer: Contracts Core
Rule
"data-contract" (contracts-core layer) is traded against "Flexible Ingestion" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexible Ingestion" and choosing an explicit operating point.

Schema Contract against Schema Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Schema Contract · Layer: Contracts Core
Scope of the second
Schema Flexibility · Layer: Contracts Core
Rule
"schema-contract" (contracts-core layer) is traded against "Schema Flexibility" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Schema Flexibility" and choosing an explicit operating point.

Semantic Contracts against Cross-Domain Translation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Semantic Contracts · Layer: Contracts Core
Scope of the second
Cross-Domain Translation · Layer: Contracts Core
Rule
"semantic-contracts" (contracts-core layer) is traded against "Cross-Domain Translation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Domain Translation" and choosing an explicit operating point.

Preconditions against Permissive APIs

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Preconditions · Layer: Contracts Core
Scope of the second
Permissive APIs · Layer: Contracts Core
Rule
"preconditions" (contracts-core layer) is traded against "Permissive APIs" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Permissive APIs" and choosing an explicit operating point.

Postconditions against Runtime Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Postconditions · Layer: Contracts Core
Scope of the second
Runtime Cost · Layer: Contracts Core
Rule
"postconditions" (contracts-core layer) is traded against "Runtime Cost" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Cost" and choosing an explicit operating point.

Invariants against Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Invariants · Layer: Contracts Core
Scope of the second
Flexibility · Layer: Contracts Core
Rule
"invariants" (contracts-core layer) is traded against "Flexibility" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexibility" and choosing an explicit operating point.

Backward Compatibility against Cleanup / Simplification

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Backward Compatibility · Layer: Contracts Core
Scope of the second
Cleanup / Simplification · Layer: Contracts Core
Rule
"backward-compatibility" (contracts-core layer) is traded against "Cleanup / Simplification" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cleanup / Simplification" and choosing an explicit operating point.

Forward Compatibility against Strong Validation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Forward Compatibility · Layer: Contracts Core
Scope of the second
Strong Validation · Layer: Contracts Core
Rule
"forward-compatibility" (contracts-core layer) is traded against "Strong Validation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Validation" and choosing an explicit operating point.

Versioning against Version Sprawl

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Versioning · Layer: Contracts Core
Scope of the second
Version Sprawl · Layer: Contracts Core
Rule
"versioning" (contracts-core layer) is traded against "Version Sprawl" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Version Sprawl" and choosing an explicit operating point.

Protocol Compatibility against Protocol Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Protocol Compatibility · Layer: Contracts Core
Scope of the second
Protocol Optimization · Layer: Contracts Core
Rule
"protocol-compatibility" (contracts-core layer) is traded against "Protocol Optimization" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Protocol Optimization" and choosing an explicit operating point.

Interoperability against Domain-Specific Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Interoperability · Layer: Contracts Core
Scope of the second
Domain-Specific Optimization · Layer: Contracts Core
Rule
"interoperability" (contracts-core layer) is traded against "Domain-Specific Optimization" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Domain-Specific Optimization" and choosing an explicit operating point.

Uniform Interface against Specialized Endpoints

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Uniform Interface · Layer: Contracts Core
Scope of the second
Specialized Endpoints · Layer: Contracts Core
Rule
"uniform-interface" (contracts-core layer) is traded against "Specialized Endpoints" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Specialized Endpoints" and choosing an explicit operating point.

Consumer-Driven Contracts against Provider Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Consumer-Driven Contracts · Layer: Contracts Core
Scope of the second
Provider Autonomy · Layer: Contracts Core
Rule
"consumer-driven-contracts" (contracts-core layer) is traded against "Provider Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Provider Autonomy" and choosing an explicit operating point.

Control Plane against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Control Plane · Layer: Execution Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"control-plane" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Orchestration against Centralized Coordinator Coupling

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Orchestration · Layer: Execution Core
Scope of the second
Centralized Coordinator Coupling · Layer: Execution Core
Rule
"orchestration" (execution-core layer) is traded against "Centralized Coordinator Coupling" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Centralized Coordinator Coupling" and choosing an explicit operating point.

Centralized Configuration against Central Dependency Risk

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Centralized Configuration · Layer: Execution Core
Scope of the second
Central Dependency Risk · Layer: Execution Core
Rule
"centralized-configuration" (execution-core layer) is traded against "Central Dependency Risk" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Central Dependency Risk" and choosing an explicit operating point.

Centralized Authentication against Identity Provider Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Centralized Authentication · Layer: Execution Core
Scope of the second
Identity Provider Availability · Layer: Execution Core
Rule
"centralized-authentication" (execution-core layer) is traded against "Identity Provider Availability" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Identity Provider Availability" and choosing an explicit operating point.

Centralized Logging against Cost/PII

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Centralized Logging · Layer: Execution Core
Scope of the second
Cost/PII · Layer: Execution Core
Rule
"centralized-logging" (execution-core layer) is traded against "Cost/PII" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/PII" and choosing an explicit operating point.

Decentralization against Governance

  • Mechanism: scope-separation
  • Derived from the layers
Details
Scope of the first
Decentralization · Layer: Execution Core
Scope of the second
Governance · Layer: Security Core
Rule
"decentralization" governs the execution-core layer and "Governance" the security-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.

Decentralization against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Decentralization · Layer: Execution Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"decentralization" (execution-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Leader Election against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Leader Election · Layer: Execution Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"leader-election" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Consensus against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Consensus · Layer: Execution Core
Scope of the second
Latency · Layer: Performance Core
Rule
"consensus" (execution-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

Consensus against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Consensus · Layer: Execution Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"consensus" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Choreography against Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Choreography · Layer: Execution Core
Scope of the second
Traceability · Layer: Observability
Rule
"choreography" (execution-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.

Single Responsibility Principle (SRP) against Excessive Fragmentation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Single Responsibility Principle (SRP) · Layer: Structural Core
Scope of the second
Excessive Fragmentation · Layer: Structural Core
Rule
"single-responsibility" (structural-core layer) is traded against "Excessive Fragmentation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Excessive Fragmentation" and choosing an explicit operating point.

Separation of Concerns against Over-Layering

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Separation of Concerns · Layer: Structural Core
Scope of the second
Over-Layering · Layer: Structural Core
Rule
"separation-of-concerns" (structural-core layer) is traded against "Over-Layering" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Layering" and choosing an explicit operating point.

Do Not Repeat Yourself (DRY) against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Do Not Repeat Yourself (DRY) · Layer: Structural Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"duplicate-code" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

High Cohesion against Over-Specialization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
High Cohesion · Layer: Structural Core
Scope of the second
Over-Specialization · Layer: Structural Core
Rule
"high-cohesion" (structural-core layer) is traded against "Over-Specialization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Specialization" and choosing an explicit operating point.

Low Coupling against Runtime Indirection

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Low Coupling · Layer: Structural Core
Scope of the second
Runtime Indirection · Layer: Structural Core
Rule
"low-coupling" (structural-core layer) is traded against "Runtime Indirection" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Indirection" and choosing an explicit operating point.

Encapsulation against Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Encapsulation · Layer: Structural Core
Scope of the second
Debuggability · Layer: Observability
Rule
"encapsulation" (structural-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.

Information Hiding against Observability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Information Hiding · Layer: Structural Core
Scope of the second
Observability · Layer: Observability
Rule
"information-hiding" (structural-core layer) is traded against "Observability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Observability" and choosing an explicit operating point.

Abstraction against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Abstraction · Layer: Structural Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"abstraction" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Modularity against Cross-Cutting Concerns

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Modularity · Layer: Structural Core
Scope of the second
Cross-Cutting Concerns · Layer: Structural Core
Rule
"modularity" (structural-core layer) is traded against "Cross-Cutting Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Cutting Concerns" and choosing an explicit operating point.

Composability against Performance Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Composability · Layer: Structural Core
Scope of the second
Performance Overhead · Layer: Structural Core
Rule
"composability" (structural-core layer) is traded against "Performance Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance Overhead" and choosing an explicit operating point.

Composition Over Inheritance against Simplicity for trivial reuse

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Composition Over Inheritance · Layer: Structural Core
Scope of the second
Simplicity for trivial reuse · Layer: Structural Core
Rule
"composition-over-inheritance" (structural-core layer) is traded against "Simplicity for trivial reuse" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity for trivial reuse" and choosing an explicit operating point.

Reusability against YAGNI

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reusability · Layer: Structural Core
Scope of the second
YAGNI · Layer: Structural Core
Rule
"reusability" (structural-core layer) is traded against "YAGNI" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "YAGNI" and choosing an explicit operating point.

Reusability against Over-Generalization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reusability · Layer: Structural Core
Scope of the second
Over-Generalization · Layer: Structural Core
Rule
"reusability" (structural-core layer) is traded against "Over-Generalization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Generalization" and choosing an explicit operating point.

Replaceability against Deep Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Replaceability · Layer: Structural Core
Scope of the second
Deep Optimization · Layer: Structural Core
Rule
"replaceability" (structural-core layer) is traded against "Deep Optimization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deep Optimization" and choosing an explicit operating point.

Interchangeability against Specialized Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Interchangeability · Layer: Structural Core
Scope of the second
Specialized Optimization · Layer: Structural Core
Rule
"interchangeability" (structural-core layer) is traded against "Specialized Optimization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Specialized Optimization" and choosing an explicit operating point.

Independence against Coordination Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Independence · Layer: Structural Core
Scope of the second
Coordination Cost · Layer: Structural Core
Rule
"independence" (structural-core layer) is traded against "Coordination Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Cost" and choosing an explicit operating point.

Autonomy against Governance

  • Mechanism: scope-separation
  • Derived from the layers
Details
Scope of the first
Autonomy · Layer: Structural Core
Scope of the second
Governance · Layer: Security Core
Rule
"autonomy" governs the structural-core layer and "Governance" the security-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.

Autonomy against Standardization

  • Mechanism: scope-separation
  • Derived from the layers
Details
Scope of the first
Autonomy · Layer: Structural Core
Scope of the second
Standardization · Layer: Evolution Principles
Rule
"autonomy" governs the structural-core layer and "Standardization" the evolution-principles layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.

Determinism against Runtime Adaptivity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Determinism · Layer: Computation Core
Scope of the second
Runtime Adaptivity · Layer: Computation Core
Rule
"determinism" (computation-core layer) is traded against "Runtime Adaptivity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Adaptivity" and choosing an explicit operating point.

Predictability against Dynamic Runtime Behavior

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Predictability · Layer: Computation Core
Scope of the second
Dynamic Runtime Behavior · Layer: Computation Core
Rule
"predictability" (computation-core layer) is traded against "Dynamic Runtime Behavior" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Runtime Behavior" and choosing an explicit operating point.

Referential Transparency against Stateful IO

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Referential Transparency · Layer: Computation Core
Scope of the second
Stateful IO · Layer: Computation Core
Rule
"referential-transparency" (computation-core layer) is traded against "Stateful IO" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful IO" and choosing an explicit operating point.

Pure Functions against Stateful Operations

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pure Functions · Layer: Computation Core
Scope of the second
Stateful Operations · Layer: Computation Core
Rule
"pure-functions" (computation-core layer) is traded against "Stateful Operations" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful Operations" and choosing an explicit operating point.

Immutability against Allocation Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Immutability · Layer: Computation Core
Scope of the second
Allocation Cost · Layer: Computation Core
Rule
"immutability" (computation-core layer) is traded against "Allocation Cost" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Allocation Cost" and choosing an explicit operating point.

Reproducibility against Continuous Updates

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reproducibility · Layer: Computation Core
Scope of the second
Continuous Updates · Layer: Computation Core
Rule
"reproducibility" (computation-core layer) is traded against "Continuous Updates" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Continuous Updates" and choosing an explicit operating point.

Repeatability against Real-World Variability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Repeatability · Layer: Computation Core
Scope of the second
Real-World Variability · Layer: Computation Core
Rule
"repeatability" (computation-core layer) is traded against "Real-World Variability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Real-World Variability" and choosing an explicit operating point.

Correctness against Delivery Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Correctness · Layer: Computation Core
Scope of the second
Delivery Speed · Layer: Structural Core
Rule
"correctness" (computation-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.

Formal Verification against Cost/Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Formal Verification · Layer: Computation Core
Scope of the second
Cost/Complexity · Layer: Computation Core
Rule
"formal-verification" (computation-core layer) is traded against "Cost/Complexity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Complexity" and choosing an explicit operating point.

Specification-Based Testing against Spec Maintenance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Specification-Based Testing · Layer: Computation Core
Scope of the second
Spec Maintenance · Layer: Computation Core
Rule
"specification-based-testing" (computation-core layer) is traded against "Spec Maintenance" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Spec Maintenance" and choosing an explicit operating point.

Property-Based Testing against Shrinking/Debug Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Property-Based Testing · Layer: Computation Core
Scope of the second
Shrinking/Debug Complexity · Layer: Computation Core
Rule
"property-based-testing" (computation-core layer) is traded against "Shrinking/Debug Complexity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shrinking/Debug Complexity" and choosing an explicit operating point.

Static Analysis against False Positives

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Static Analysis · Layer: Computation Core
Scope of the second
False Positives · Layer: Structural Core
Rule
"static-analysis" (computation-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.

Testability against Encapsulation Extremes

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Testability · Layer: Computation Core
Scope of the second
Encapsulation Extremes · Layer: Computation Core
Rule
"testability" (computation-core layer) is traded against "Encapsulation Extremes" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Encapsulation Extremes" and choosing an explicit operating point.

Validation against Iteration Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Validation · Layer: Computation Core
Scope of the second
Iteration Speed · Layer: Structural Core
Rule
"validation" (computation-core layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.

Verification against Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Verification · Layer: Computation Core
Scope of the second
Cost · Layer: Structural Core
Rule
"verification" (computation-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.

Factory Pattern against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Factory Pattern · Layer: Design Patterns Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"factory-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Factory Method Pattern against Inheritance Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Factory Method Pattern · Layer: Design Patterns Core
Scope of the second
Inheritance Complexity · Layer: Design Patterns Core
Rule
"factory-method-pattern" (design-patterns-core layer) is traded against "Inheritance Complexity" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Inheritance Complexity" and choosing an explicit operating point.

Abstract Factory Pattern against Boilerplate

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Abstract Factory Pattern · Layer: Design Patterns Core
Scope of the second
Boilerplate · Layer: Structural Core
Rule
"abstract-factory-pattern" (design-patterns-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.

Builder Pattern against Boilerplate

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Builder Pattern · Layer: Design Patterns Core
Scope of the second
Boilerplate · Layer: Structural Core
Rule
"builder-pattern" (design-patterns-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.

Prototype Pattern against Copy Semantics

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Prototype Pattern · Layer: Design Patterns Core
Scope of the second
Copy Semantics · Layer: Design Patterns Core
Rule
"prototype-pattern" (design-patterns-core layer) is traded against "Copy Semantics" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Copy Semantics" and choosing an explicit operating point.

Singleton Pattern against Testability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Singleton Pattern · Layer: Design Patterns Core
Scope of the second
Testability · Layer: Computation Core
Rule
"singleton-pattern" (design-patterns-core layer) is traded against "Testability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Testability" and choosing an explicit operating point.

Singleton Pattern against Dependency Injection

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Singleton Pattern · Layer: Design Patterns Core
Scope of the second
Dependency Injection · Layer: Extensibility Core
Rule
"singleton-pattern" (design-patterns-core layer) is traded against "Dependency Injection" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dependency Injection" and choosing an explicit operating point.

Domain-Driven Design (DDD) against Simple CRUD

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Domain-Driven Design (DDD) · Layer: Domain Modeling
Scope of the second
Simple CRUD · Layer: Domain Modeling
Rule
"domain-driven-design" (domain-modeling layer) is traded against "Simple CRUD" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simple CRUD" and choosing an explicit operating point.

Domain Model against Persistence Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Domain Model · Layer: Domain Modeling
Scope of the second
Persistence Simplicity · Layer: Domain Modeling
Rule
"domain-model" (domain-modeling layer) is traded against "Persistence Simplicity" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Persistence Simplicity" and choosing an explicit operating point.

Bounded Context against Cross-Context Reuse

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Bounded Context · Layer: Domain Modeling
Scope of the second
Cross-Context Reuse · Layer: Domain Modeling
Rule
"bounded-context" (domain-modeling layer) is traded against "Cross-Context Reuse" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Context Reuse" and choosing an explicit operating point.

Context Mapping against Documentation Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Context Mapping · Layer: Domain Modeling
Scope of the second
Documentation Overhead · Layer: Domain Modeling
Rule
"context-mapping" (domain-modeling layer) is traded against "Documentation Overhead" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Documentation Overhead" and choosing an explicit operating point.

Anti-Corruption Layer against Mapping Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Anti-Corruption Layer · Layer: Domain Modeling
Scope of the second
Mapping Overhead · Layer: Structural Core
Rule
"anti-corruption-layer" (domain-modeling layer) is traded against "Mapping Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mapping Overhead" and choosing an explicit operating point.

Explicit Boundaries against Cross-Cutting Concerns

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Explicit Boundaries · Layer: Domain Modeling
Scope of the second
Cross-Cutting Concerns · Layer: Structural Core
Rule
"explicit-boundaries" (domain-modeling layer) is traded against "Cross-Cutting Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Cutting Concerns" and choosing an explicit operating point.

Aggregate against Aggregate Size

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Aggregate · Layer: Domain Modeling
Scope of the second
Aggregate Size · Layer: Domain Modeling
Rule
"aggregate" (domain-modeling layer) is traded against "Aggregate Size" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Aggregate Size" and choosing an explicit operating point.

Value Object against Object Count

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Value Object · Layer: Domain Modeling
Scope of the second
Object Count · Layer: Domain Modeling
Rule
"value-object" (domain-modeling layer) is traded against "Object Count" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Object Count" and choosing an explicit operating point.

Entity against Value Object

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Entity · Layer: Domain Modeling
Scope of the second
Value Object · Layer: Domain Modeling
Rule
"entity" (domain-modeling layer) is traded against "Value Object" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Value Object" and choosing an explicit operating point.

Domain Service against Aggregate

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Domain Service · Layer: Domain Modeling
Scope of the second
Aggregate · Layer: Domain Modeling
Rule
"domain-service" (domain-modeling layer) is traded against "Aggregate" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Aggregate" and choosing an explicit operating point.

Defensive Programming against Verbosity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Defensive Programming · Layer: Correctness Core
Scope of the second
Verbosity · Layer: Correctness Core
Rule
"defensive-programming" (correctness-core layer) is traded against "Verbosity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Verbosity" and choosing an explicit operating point.

Fail Fast against Graceful Degradation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fail Fast · Layer: Correctness Core
Scope of the second
Graceful Degradation · Layer: Correctness Core
Rule
"fail-fast" (correctness-core layer) is traded against "Graceful Degradation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Graceful Degradation" and choosing an explicit operating point.

Fail Safe against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fail Safe · Layer: Correctness Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"fail-safe" (correctness-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Fail Secure against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fail Secure · Layer: Correctness Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"fail-secure" (correctness-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Graceful Degradation against Consistency / Feature Completeness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Graceful Degradation · Layer: Correctness Core
Scope of the second
Consistency / Feature Completeness · Layer: Correctness Core
Rule
"graceful-degradation" (correctness-core layer) is traded against "Consistency / Feature Completeness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency / Feature Completeness" and choosing an explicit operating point.

Fault Tolerance against Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fault Tolerance · Layer: Correctness Core
Scope of the second
Cost · Layer: Structural Core
Rule
"fault-tolerance" (correctness-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.

Resilience against Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Resilience · Layer: Correctness Core
Scope of the second
Complexity · Layer: Human Factors
Rule
"resilience" (correctness-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.

Robustness Principle against Strict Validation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Robustness Principle · Layer: Correctness Core
Scope of the second
Strict Validation · Layer: Correctness Core
Rule
"robustness-principle" (correctness-core layer) is traded against "Strict Validation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strict Validation" and choosing an explicit operating point.

Error Handling against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Error Handling · Layer: Correctness Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"error-handling" (correctness-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Error Boundaries against Hidden Errors

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Error Boundaries · Layer: Correctness Core
Scope of the second
Hidden Errors · Layer: Correctness Core
Rule
"error-boundaries" (correctness-core layer) is traded against "Hidden Errors" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Hidden Errors" and choosing an explicit operating point.

Fallback Pattern against Stale/Reduced Results

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fallback Pattern · Layer: Correctness Core
Scope of the second
Stale/Reduced Results · Layer: Correctness Core
Rule
"fallback-pattern" (correctness-core layer) is traded against "Stale/Reduced Results" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stale/Reduced Results" and choosing an explicit operating point.

Retry Pattern against Load Amplification

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Retry Pattern · Layer: Correctness Core
Scope of the second
Load Amplification · Layer: Correctness Core
Rule
"retry-pattern" (correctness-core layer) is traded against "Load Amplification" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Load Amplification" and choosing an explicit operating point.

Timeout Pattern against Slow Operation Tolerance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Timeout Pattern · Layer: Correctness Core
Scope of the second
Slow Operation Tolerance · Layer: Correctness Core
Rule
"timeout-pattern" (correctness-core layer) is traded against "Slow Operation Tolerance" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Slow Operation Tolerance" and choosing an explicit operating point.

Circuit Breaker Pattern against Availability of Degraded Dependency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Circuit Breaker Pattern · Layer: Correctness Core
Scope of the second
Availability of Degraded Dependency · Layer: Correctness Core
Rule
"circuit-breaker-pattern" (correctness-core layer) is traded against "Availability of Degraded Dependency" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability of Degraded Dependency" and choosing an explicit operating point.

Bulkhead Pattern against Resource Utilization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Bulkhead Pattern · Layer: Correctness Core
Scope of the second
Resource Utilization · Layer: Performance Core
Rule
"bulkhead-pattern" (correctness-core layer) is traded against "Resource Utilization" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Resource Utilization" and choosing an explicit operating point.

Backpressure against Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Backpressure · Layer: Correctness Core
Scope of the second
Throughput · Layer: Performance Core
Rule
"backpressure" (correctness-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.

Event-Driven Architecture against Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event-Driven Architecture · Layer: Execution Core
Scope of the second
Debuggability · Layer: Observability
Rule
"event-driven-architecture" (execution-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.

Event-Driven Architecture against Strong Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event-Driven Architecture · Layer: Execution Core
Scope of the second
Strong Consistency · Layer: Execution Core
Rule
"event-driven-architecture" (execution-core layer) is traded against "Strong Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Consistency" and choosing an explicit operating point.

Publish/Subscribe Pattern against Delivery Ordering

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Publish/Subscribe Pattern · Layer: Execution Core
Scope of the second
Delivery Ordering · Layer: Execution Core
Rule
"publish-subscribe-pattern" (execution-core layer) is traded against "Delivery Ordering" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Ordering" and choosing an explicit operating point.

Message Queue against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Message Queue · Layer: Execution Core
Scope of the second
Latency · Layer: Performance Core
Rule
"message-queue" (execution-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

Message Broker against Operational Dependency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Message Broker · Layer: Execution Core
Scope of the second
Operational Dependency · Layer: Execution Core
Rule
"message-broker" (execution-core layer) is traded against "Operational Dependency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Dependency" and choosing an explicit operating point.

Event Bus against Event Storm / Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event Bus · Layer: Execution Core
Scope of the second
Event Storm / Traceability · Layer: Execution Core
Rule
"event-bus" (execution-core layer) is traded against "Event Storm / Traceability" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Event Storm / Traceability" and choosing an explicit operating point.

Event Stream against Storage Volume

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event Stream · Layer: Execution Core
Scope of the second
Storage Volume · Layer: Execution Core
Rule
"event-stream" (execution-core layer) is traded against "Storage Volume" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage Volume" and choosing an explicit operating point.

Event Sourcing against Query Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Event Sourcing · Layer: Execution Core
Scope of the second
Query Complexity · Layer: Execution Core
Rule
"event-sourcing" (execution-core layer) is traded against "Query Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Query Complexity" and choosing an explicit operating point.

CQRS against Eventual Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CQRS · Layer: Execution Core
Scope of the second
Eventual Consistency · Layer: Execution Core
Rule
"command-query-responsibility-segregation" (execution-core layer) is traded against "Eventual Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Eventual Consistency" and choosing an explicit operating point.

Domain Events against Event Granularity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Domain Events · Layer: Execution Core
Scope of the second
Event Granularity · Layer: Execution Core
Rule
"domain-events" (execution-core layer) is traded against "Event Granularity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Event Granularity" and choosing an explicit operating point.

Integration Events against Duplication with Domain Events

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Integration Events · Layer: Execution Core
Scope of the second
Duplication with Domain Events · Layer: Execution Core
Rule
"integration-events" (execution-core layer) is traded against "Duplication with Domain Events" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Duplication with Domain Events" and choosing an explicit operating point.

Asynchronous Communication against Immediate Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Asynchronous Communication · Layer: Execution Core
Scope of the second
Immediate Consistency · Layer: Execution Core
Rule
"asynchronous-communication" (execution-core layer) is traded against "Immediate Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Immediate Consistency" and choosing an explicit operating point.

Service Autonomy against Global Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Autonomy · Layer: Execution Core
Scope of the second
Global Consistency · Layer: Execution Core
Rule
"service-autonomy" (execution-core layer) is traded against "Global Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global Consistency" and choosing an explicit operating point.

Eventual Consistency against User Expectations

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Eventual Consistency · Layer: Execution Core
Scope of the second
User Expectations · Layer: Execution Core
Rule
"eventual-consistency" (execution-core layer) is traded against "User Expectations" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Expectations" and choosing an explicit operating point.

Eventual Consistency against Strong Immediate Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Eventual Consistency · Layer: Execution Core
Scope of the second
Strong Immediate Consistency · Layer: Execution Core
Rule
"eventual-consistency" (execution-core layer) is traded against "Strong Immediate Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Immediate Consistency" and choosing an explicit operating point.

Saga Pattern against Workflow Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Saga Pattern · Layer: Execution Core
Scope of the second
Workflow Complexity · Layer: Execution Core
Rule
"saga-pattern" (execution-core layer) is traded against "Workflow Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Workflow Complexity" and choosing an explicit operating point.

Outbox Pattern against Relay Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Outbox Pattern · Layer: Execution Core
Scope of the second
Relay Complexity · Layer: Execution Core
Rule
"outbox-pattern" (execution-core layer) is traded against "Relay Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Relay Complexity" and choosing an explicit operating point.

Compensating Transaction against Business Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Compensating Transaction · Layer: Execution Core
Scope of the second
Business Complexity · Layer: Execution Core
Rule
"compensating-transaction" (execution-core layer) is traded against "Business Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Business Complexity" and choosing an explicit operating point.

Append-Only Log against Storage Growth

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Append-Only Log · Layer: Execution Core
Scope of the second
Storage Growth · Layer: Execution Core
Rule
"append-only-log" (execution-core layer) is traded against "Storage Growth" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage Growth" and choosing an explicit operating point.

Dead-Letter Queue against Operational Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dead-Letter Queue · Layer: Execution Core
Scope of the second
Operational Overhead · Layer: Resource Core
Rule
"dead-letter-queue" (execution-core layer) is traded against "Operational Overhead" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Overhead" and choosing an explicit operating point.

Idempotent Consumer against State Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Idempotent Consumer · Layer: Execution Core
Scope of the second
State Overhead · Layer: Execution Core
Rule
"idempotent-consumer" (execution-core layer) is traded against "State Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Overhead" and choosing an explicit operating point.

Competing Consumers against Ordering

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Competing Consumers · Layer: Execution Core
Scope of the second
Ordering · Layer: Causality Core
Rule
"competing-consumers" (execution-core layer) is traded against "Ordering" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering" and choosing an explicit operating point.

Self-Describing Architecture against Metadata Drift

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Self-Describing Architecture · Layer: Declarative Core
Scope of the second
Metadata Drift · Layer: Declarative Core
Rule
"self-describing-architecture" (declarative-core layer) is traded against "Metadata Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Drift" and choosing an explicit operating point.

Self-Describing API against Payload Verbosity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Self-Describing API · Layer: Declarative Core
Scope of the second
Payload Verbosity · Layer: Declarative Core
Rule
"self-describing-api" (declarative-core layer) is traded against "Payload Verbosity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Payload Verbosity" and choosing an explicit operating point.

Self-Describing Structures against Size Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Self-Describing Structures · Layer: Declarative Core
Scope of the second
Size Overhead · Layer: Declarative Core
Rule
"self-describing-structures" (declarative-core layer) is traded against "Size Overhead" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Size Overhead" and choosing an explicit operating point.

Metadata-Driven Design against Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Metadata-Driven Design · Layer: Declarative Core
Scope of the second
Debuggability · Layer: Observability
Rule
"metadata-driven-design" (declarative-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.

Declarative Configuration against Dynamic Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Declarative Configuration · Layer: Declarative Core
Scope of the second
Dynamic Complexity · Layer: Declarative Core
Rule
"declarative-configuration" (declarative-core layer) is traded against "Dynamic Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Complexity" and choosing an explicit operating point.

Convention over Configuration against Explicitness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Convention over Configuration · Layer: Declarative Core
Scope of the second
Explicitness · Layer: Declarative Core
Rule
"convention-over-configuration" (declarative-core layer) is traded against "Explicitness" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicitness" and choosing an explicit operating point.

Capability Declaration against Declaration Drift

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Capability Declaration · Layer: Declarative Core
Scope of the second
Declaration Drift · Layer: Declarative Core
Rule
"capability-declaration" (declarative-core layer) is traded against "Declaration Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Declaration Drift" and choosing an explicit operating point.

Manifest-Based Design against Manifest Drift

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Manifest-Based Design · Layer: Declarative Core
Scope of the second
Manifest Drift · Layer: Declarative Core
Rule
"manifest-based-design" (declarative-core layer) is traded against "Manifest Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Manifest Drift" and choosing an explicit operating point.

Homoiconicity against Readability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Homoiconicity · Layer: Declarative Core
Scope of the second
Readability · Layer: Human Factors
Rule
"homoiconicity" (declarative-core layer) is traded against "Readability" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Readability" and choosing an explicit operating point.

Code as Data against Safety/Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Code as Data · Layer: Declarative Core
Scope of the second
Safety/Debuggability · Layer: Declarative Core
Rule
"code-as-data" (declarative-core layer) is traded against "Safety/Debuggability" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Safety/Debuggability" and choosing an explicit operating point.

Metaprogramming against Debuggability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Metaprogramming · Layer: Declarative Core
Scope of the second
Debuggability · Layer: Observability
Rule
"metaprogramming" (declarative-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.

Metaprogramming against Static Analysis

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Metaprogramming · Layer: Declarative Core
Scope of the second
Static Analysis · Layer: Computation Core
Rule
"metaprogramming" (declarative-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.

Metaprogramming against Explicit Handwritten Code

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Metaprogramming · Layer: Declarative Core
Scope of the second
Explicit Handwritten Code · Layer: Declarative Core
Rule
"metaprogramming" (declarative-core layer) is traded against "Explicit Handwritten Code" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicit Handwritten Code" and choosing an explicit operating point.

Reflection against Performance/Safety

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reflection · Layer: Declarative Core
Scope of the second
Performance/Safety · Layer: Declarative Core
Rule
"reflection" (declarative-core layer) is traded against "Performance/Safety" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance/Safety" and choosing an explicit operating point.

Reflection against Static Analysis

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Reflection · Layer: Declarative Core
Scope of the second
Static Analysis · Layer: Computation Core
Rule
"reflection" (declarative-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.

Introspection against Encapsulation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Introspection · Layer: Declarative Core
Scope of the second
Encapsulation · Layer: Structural Core
Rule
"introspection" (declarative-core layer) is traded against "Encapsulation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Encapsulation" and choosing an explicit operating point.

Compile-Time Evaluation against Build Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Compile-Time Evaluation · Layer: Declarative Core
Scope of the second
Build Complexity · Layer: Declarative Core
Rule
"compile-time-evaluation" (declarative-core layer) is traded against "Build Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Build Complexity" and choosing an explicit operating point.

Compile-Time Evaluation against Runtime Dynamic Evaluation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Compile-Time Evaluation · Layer: Declarative Core
Scope of the second
Runtime Dynamic Evaluation · Layer: Declarative Core
Rule
"compile-time-evaluation" (declarative-core layer) is traded against "Runtime Dynamic Evaluation" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Dynamic Evaluation" and choosing an explicit operating point.

Runtime Code Generation against Security/Debugging

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Code Generation · Layer: Declarative Core
Scope of the second
Security/Debugging · Layer: Declarative Core
Rule
"runtime-code-generation" (declarative-core layer) is traded against "Security/Debugging" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security/Debugging" and choosing an explicit operating point.

Runtime Code Generation against Static Safety

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Code Generation · Layer: Declarative Core
Scope of the second
Static Safety · Layer: Correctness Core
Rule
"runtime-code-generation" (declarative-core layer) is traded against "Static Safety" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Safety" and choosing an explicit operating point.

Domain-Specific Language (DSL) against Tooling/Maintenance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Domain-Specific Language (DSL) · Layer: Declarative Core
Scope of the second
Tooling/Maintenance · Layer: Declarative Core
Rule
"domain-specific-language" (declarative-core layer) is traded against "Tooling/Maintenance" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling/Maintenance" and choosing an explicit operating point.

Language-Oriented Programming against Toolchain Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Language-Oriented Programming · Layer: Declarative Core
Scope of the second
Toolchain Complexity · Layer: Declarative Core
Rule
"language-oriented-programming" (declarative-core layer) is traded against "Toolchain Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Toolchain Complexity" and choosing an explicit operating point.

Language-Oriented Programming against One-Size General-Purpose Code

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Language-Oriented Programming · Layer: Declarative Core
Scope of the second
One-Size General-Purpose Code · Layer: Declarative Core
Rule
"language-oriented-programming" (declarative-core layer) is traded against "One-Size General-Purpose Code" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "One-Size General-Purpose Code" and choosing an explicit operating point.

Observability against Cost/Noise

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Observability · Layer: Observability
Scope of the second
Cost/Noise · Layer: Observability
Rule
"observability" (observability layer) is traded against "Cost/Noise" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Noise" and choosing an explicit operating point.

Logging against Noise/PII Leakage

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Logging · Layer: Observability
Scope of the second
Noise/PII Leakage · Layer: Observability
Rule
"logging" (observability layer) is traded against "Noise/PII Leakage" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Noise/PII Leakage" and choosing an explicit operating point.

Monitoring against Alert Noise

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Monitoring · Layer: Observability
Scope of the second
Alert Noise · Layer: Observability
Rule
"monitoring" (observability layer) is traded against "Alert Noise" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Alert Noise" and choosing an explicit operating point.

Alerting against Alert Fatigue

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Alerting · Layer: Observability
Scope of the second
Alert Fatigue · Layer: Observability
Rule
"alerting" (observability layer) is traded against "Alert Fatigue" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Alert Fatigue" and choosing an explicit operating point.

Auditability against Storage/Privacy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auditability · Layer: Observability
Scope of the second
Storage/Privacy · Layer: Observability
Rule
"auditability" (observability layer) is traded against "Storage/Privacy" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage/Privacy" and choosing an explicit operating point.

Audit Logging against Privacy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Audit Logging · Layer: Observability
Scope of the second
Privacy · Layer: Observability
Rule
"audit-logging" (observability layer) is traded against "Privacy" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Privacy" and choosing an explicit operating point.

Traceability against Metadata Propagation Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Traceability · Layer: Observability
Scope of the second
Metadata Propagation Overhead · Layer: Observability
Rule
"traceability" (observability layer) is traded against "Metadata Propagation Overhead" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Propagation Overhead" and choosing an explicit operating point.

Correlation ID against Header/Metadata Management

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Correlation ID · Layer: Observability
Scope of the second
Header/Metadata Management · Layer: Observability
Rule
"correlation-id" (observability layer) is traded against "Header/Metadata Management" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Header/Metadata Management" and choosing an explicit operating point.

Causation ID against Metadata Verbosity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Causation ID · Layer: Observability
Scope of the second
Metadata Verbosity · Layer: Observability
Rule
"causation-id" (observability layer) is traded against "Metadata Verbosity" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Verbosity" and choosing an explicit operating point.

Distributed Tracing against Overhead/Sampling

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Distributed Tracing · Layer: Observability
Scope of the second
Overhead/Sampling · Layer: Observability
Rule
"distributed-tracing" (observability layer) is traded against "Overhead/Sampling" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Overhead/Sampling" and choosing an explicit operating point.

SLO/SLI against Feature Velocity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
SLO/SLI · Layer: Observability
Scope of the second
Feature Velocity · Layer: Observability
Rule
"slo-sli" (observability layer) is traded against "Feature Velocity" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Feature Velocity" and choosing an explicit operating point.

Dashboards against Dashboard Sprawl

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dashboards · Layer: Observability
Scope of the second
Dashboard Sprawl · Layer: Observability
Rule
"dashboards" (observability layer) is traded against "Dashboard Sprawl" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dashboard Sprawl" and choosing an explicit operating point.

Plugin Architecture against Static Analysis

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Plugin Architecture · Layer: Extensibility Core
Scope of the second
Static Analysis · Layer: Computation Core
Rule
"plugin-architecture" (extensibility-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.

Plugin Architecture against Security

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Plugin Architecture · Layer: Extensibility Core
Scope of the second
Security · Layer: Security Core
Rule
"plugin-architecture" (extensibility-core layer) is traded against "Security" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security" and choosing an explicit operating point.

Extension Points against API Surface Growth

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Extension Points · Layer: Extensibility Core
Scope of the second
API Surface Growth · Layer: Extensibility Core
Rule
"extension-points" (extensibility-core layer) is traded against "API Surface Growth" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "API Surface Growth" and choosing an explicit operating point.

Inversion of Control (IoC) against Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Inversion of Control (IoC) · Layer: Extensibility Core
Scope of the second
Traceability · Layer: Observability
Rule
"inversion-of-control" (extensibility-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.

Dependency Injection against Constructor Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dependency Injection · Layer: Extensibility Core
Scope of the second
Constructor Complexity · Layer: Extensibility Core
Rule
"dependency-injection" (extensibility-core layer) is traded against "Constructor Complexity" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Constructor Complexity" and choosing an explicit operating point.

Service Registry against Registry Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Registry · Layer: Extensibility Core
Scope of the second
Registry Availability · Layer: Extensibility Core
Rule
"service-registry" (extensibility-core layer) is traded against "Registry Availability" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Registry Availability" and choosing an explicit operating point.

Registry Pattern against Global State

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Registry Pattern · Layer: Extensibility Core
Scope of the second
Global State · Layer: Extensibility Core
Rule
"registry-pattern" (extensibility-core layer) is traded against "Global State" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global State" and choosing an explicit operating point.

Service Locator Pattern against Testability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Locator Pattern · Layer: Extensibility Core
Scope of the second
Testability · Layer: Computation Core
Rule
"service-locator-pattern" (extensibility-core layer) is traded against "Testability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Testability" and choosing an explicit operating point.

Service Locator Pattern against Dependency Inversion Principle (DIP)

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Locator Pattern · Layer: Extensibility Core
Scope of the second
Dependency Inversion Principle (DIP) · Layer: Structural Core
Rule
"service-locator-pattern" (extensibility-core layer) is traded against "DIP" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "DIP" and choosing an explicit operating point.

Service Locator Pattern against Explicit Dependencies

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Locator Pattern · Layer: Extensibility Core
Scope of the second
Explicit Dependencies · Layer: Extensibility Core
Rule
"service-locator-pattern" (extensibility-core layer) is traded against "Explicit Dependencies" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicit Dependencies" and choosing an explicit operating point.

Feature Toggle against Flag Debt

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Feature Toggle · Layer: Extensibility Core
Scope of the second
Flag Debt · Layer: Extensibility Core
Rule
"feature-toggle" (extensibility-core layer) is traded against "Flag Debt" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flag Debt" and choosing an explicit operating point.

Portability against Platform Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Portability · Layer: Resource Core
Scope of the second
Platform Optimization · Layer: Resource Core
Rule
"portability" (resource-core layer) is traded against "Platform Optimization" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Platform Optimization" and choosing an explicit operating point.

Platform Independence against Native Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Platform Independence · Layer: Resource Core
Scope of the second
Native Optimization · Layer: Resource Core
Rule
"platform-independence" (resource-core layer) is traded against "Native Optimization" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Native Optimization" and choosing an explicit operating point.

Environment Parity against Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Environment Parity · Layer: Resource Core
Scope of the second
Cost · Layer: Structural Core
Rule
"environment-parity" (resource-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.

Containerization against Image Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Containerization · Layer: Resource Core
Scope of the second
Image Complexity · Layer: Resource Core
Rule
"containerization" (resource-core layer) is traded against "Image Complexity" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Image Complexity" and choosing an explicit operating point.

Infrastructure as Code against Tooling Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Infrastructure as Code · Layer: Resource Core
Scope of the second
Tooling Complexity · Layer: Human Factors
Rule
"infrastructure-as-code" (resource-core layer) is traded against "Tooling Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling Complexity" and choosing an explicit operating point.

Standards Compliance against Innovation/Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Standards Compliance · Layer: Resource Core
Scope of the second
Innovation/Flexibility · Layer: Resource Core
Rule
"standards-compliance" (resource-core layer) is traded against "Innovation/Flexibility" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Innovation/Flexibility" and choosing an explicit operating point.

Protocol Independence against Protocol-Specific Features

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Protocol Independence · Layer: Resource Core
Scope of the second
Protocol-Specific Features · Layer: Resource Core
Rule
"protocol-independence" (resource-core layer) is traded against "Protocol-Specific Features" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Protocol-Specific Features" and choosing an explicit operating point.

Configuration Externalization against Config Sprawl

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Configuration Externalization · Layer: Resource Core
Scope of the second
Config Sprawl · Layer: Resource Core
Rule
"configuration-externalization" (resource-core layer) is traded against "Config Sprawl" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Config Sprawl" and choosing an explicit operating point.

Immutable Infrastructure against Deploy Time

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Immutable Infrastructure · Layer: Resource Core
Scope of the second
Deploy Time · Layer: Resource Core
Rule
"immutable-infrastructure" (resource-core layer) is traded against "Deploy Time" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deploy Time" and choosing an explicit operating point.

Runtime Discovery against Predictability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Discovery · Layer: Extensibility Core
Scope of the second
Predictability · Layer: Computation Core
Rule
"runtime-discovery" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.

Runtime Discovery against Static Analysis

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Discovery · Layer: Extensibility Core
Scope of the second
Static Analysis · Layer: Computation Core
Rule
"runtime-discovery" (extensibility-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.

Service Discovery against Operational Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Service Discovery · Layer: Extensibility Core
Scope of the second
Operational Complexity · Layer: Structural Core
Rule
"service-discovery" (extensibility-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.

Auto-Discovery against Startup Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auto-Discovery · Layer: Extensibility Core
Scope of the second
Startup Cost · Layer: Extensibility Core
Rule
"auto-discovery" (extensibility-core layer) is traded against "Startup Cost" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Startup Cost" and choosing an explicit operating point.

Dynamic Binding against Static Safety

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dynamic Binding · Layer: Extensibility Core
Scope of the second
Static Safety · Layer: Correctness Core
Rule
"dynamic-binding" (extensibility-core layer) is traded against "Static Safety" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Safety" and choosing an explicit operating point.

Late Binding against Predictability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Late Binding · Layer: Extensibility Core
Scope of the second
Predictability · Layer: Computation Core
Rule
"late-binding" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.

Runtime Binding against Debugging

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Binding · Layer: Extensibility Core
Scope of the second
Debugging · Layer: Structural Core
Rule
"runtime-binding" (extensibility-core layer) is traded against "Debugging" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debugging" and choosing an explicit operating point.

Dynamic Dispatch against Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dynamic Dispatch · Layer: Extensibility Core
Scope of the second
Traceability · Layer: Observability
Rule
"dynamic-dispatch" (extensibility-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.

Runtime Extensibility against Predictability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Extensibility · Layer: Extensibility Core
Scope of the second
Predictability · Layer: Computation Core
Rule
"runtime-extensibility" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.

Runtime Extensibility against Security

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Runtime Extensibility · Layer: Extensibility Core
Scope of the second
Security · Layer: Security Core
Rule
"runtime-extensibility" (extensibility-core layer) is traded against "Security" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security" and choosing an explicit operating point.

Scalability against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Scalability · Layer: Performance Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"scalability" (performance-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Scalability against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Scalability · Layer: Performance Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"scalability" (performance-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Horizontal Scaling against Distributed Coordination

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Horizontal Scaling · Layer: Performance Core
Scope of the second
Distributed Coordination · Layer: Performance Core
Rule
"horizontal-scaling" (performance-core layer) is traded against "Distributed Coordination" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Coordination" and choosing an explicit operating point.

Vertical Scaling against Cost/Limit

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Vertical Scaling · Layer: Performance Core
Scope of the second
Cost/Limit · Layer: Performance Core
Rule
"vertical-scaling" (performance-core layer) is traded against "Cost/Limit" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Limit" and choosing an explicit operating point.

Elasticity against Warm-Up Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Elasticity · Layer: Performance Core
Scope of the second
Warm-Up Latency · Layer: Performance Core
Rule
"elasticity" (performance-core layer) is traded against "Warm-Up Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Warm-Up Latency" and choosing an explicit operating point.

Load Balancing against Session Affinity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Load Balancing · Layer: Performance Core
Scope of the second
Session Affinity · Layer: Performance Core
Rule
"load-balancing" (performance-core layer) is traded against "Session Affinity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Session Affinity" and choosing an explicit operating point.

Sharding against Cross-Shard Queries

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Sharding · Layer: Performance Core
Scope of the second
Cross-Shard Queries · Layer: Performance Core
Rule
"sharding" (performance-core layer) is traded against "Cross-Shard Queries" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Shard Queries" and choosing an explicit operating point.

Partitioning against Rebalancing Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Partitioning · Layer: Performance Core
Scope of the second
Rebalancing Complexity · Layer: Performance Core
Rule
"partitioning" (performance-core layer) is traded against "Rebalancing Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rebalancing Complexity" and choosing an explicit operating point.

Caching against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Caching · Layer: Performance Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"caching" (performance-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Caching against Always-Fresh Reads

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Caching · Layer: Performance Core
Scope of the second
Always-Fresh Reads · Layer: Performance Core
Rule
"caching" (performance-core layer) is traded against "Always-Fresh Reads" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Always-Fresh Reads" and choosing an explicit operating point.

Statelessness against State Access Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Statelessness · Layer: Performance Core
Scope of the second
State Access Latency · Layer: Performance Core
Rule
"statelessness" (performance-core layer) is traded against "State Access Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Access Latency" and choosing an explicit operating point.

Concurrency against Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Concurrency · Layer: Performance Core
Scope of the second
Complexity · Layer: Human Factors
Rule
"concurrency" (performance-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.

Parallelism against Coordination Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Parallelism · Layer: Performance Core
Scope of the second
Coordination Overhead · Layer: Execution Core
Rule
"parallelism" (performance-core layer) is traded against "Coordination Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Overhead" and choosing an explicit operating point.

Throughput against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Throughput · Layer: Performance Core
Scope of the second
Latency · Layer: Performance Core
Rule
"throughput" (performance-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

Latency against Throughput/Batching

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Latency · Layer: Performance Core
Scope of the second
Throughput/Batching · Layer: Performance Core
Rule
"latency" (performance-core layer) is traded against "Throughput/Batching" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput/Batching" and choosing an explicit operating point.

Performance Engineering against Maintainability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Performance Engineering · Layer: Performance Core
Scope of the second
Maintainability · Layer: Human Factors
Rule
"performance-engineering" (performance-core layer) is traded against "Maintainability" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Maintainability" and choosing an explicit operating point.

Algorithmic Efficiency against Implementation Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Algorithmic Efficiency · Layer: Performance Core
Scope of the second
Implementation Simplicity · Layer: Performance Core
Rule
"algorithmic-efficiency" (performance-core layer) is traded against "Implementation Simplicity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Implementation Simplicity" and choosing an explicit operating point.

Time Complexity against Space Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Time Complexity · Layer: Performance Core
Scope of the second
Space Complexity · Layer: Performance Core
Rule
"time-complexity" (performance-core layer) is traded against "Space Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Space Complexity" and choosing an explicit operating point.

Big O Notation against Constant-Factor Practicality

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Big O Notation · Layer: Performance Core
Scope of the second
Constant-Factor Practicality · Layer: Performance Core
Rule
"big-o-notation" (performance-core layer) is traded against "Constant-Factor Practicality" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Constant-Factor Practicality" and choosing an explicit operating point.

Optimization against Readability/Maintainability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Optimization · Layer: Performance Core
Scope of the second
Readability/Maintainability · Layer: Performance Core
Rule
"optimization" (performance-core layer) is traded against "Readability/Maintainability" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Readability/Maintainability" and choosing an explicit operating point.

Profiling against Measurement Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Profiling · Layer: Performance Core
Scope of the second
Measurement Overhead · Layer: Performance Core
Rule
"profiling" (performance-core layer) is traded against "Measurement Overhead" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Measurement Overhead" and choosing an explicit operating point.

Benchmarking against Environment Drift

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Benchmarking · Layer: Performance Core
Scope of the second
Environment Drift · Layer: Performance Core
Rule
"benchmarking" (performance-core layer) is traded against "Environment Drift" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Environment Drift" and choosing an explicit operating point.

Bottleneck Analysis against Distributed Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Bottleneck Analysis · Layer: Performance Core
Scope of the second
Distributed Complexity · Layer: Performance Core
Rule
"bottleneck-analysis" (performance-core layer) is traded against "Distributed Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Complexity" and choosing an explicit operating point.

Resource Utilization against Over-Provisioning

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Resource Utilization · Layer: Performance Core
Scope of the second
Over-Provisioning · Layer: Performance Core
Rule
"resource-utilization" (performance-core layer) is traded against "Over-Provisioning" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Provisioning" and choosing an explicit operating point.

Rate Limiting against User Experience

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Rate Limiting · Layer: Performance Core
Scope of the second
User Experience · Layer: Human Factors
Rule
"rate-limiting" (performance-core layer) is traded against "User Experience" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Experience" and choosing an explicit operating point.

Memory Efficiency against CPU Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Memory Efficiency · Layer: Performance Core
Scope of the second
CPU Cost · Layer: Performance Core
Rule
"memory-efficiency" (performance-core layer) is traded against "CPU Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "CPU Cost" and choosing an explicit operating point.

CDN / Edge Caching against Cache Invalidation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CDN / Edge Caching · Layer: Performance Core
Scope of the second
Cache Invalidation · Layer: Performance Core
Rule
"cdn-edge-caching" (performance-core layer) is traded against "Cache Invalidation" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cache Invalidation" and choosing an explicit operating point.

Read Replica against Read-Your-Writes Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Read Replica · Layer: Performance Core
Scope of the second
Read-Your-Writes Consistency · Layer: Performance Core
Rule
"read-replica" (performance-core layer) is traded against "Read-Your-Writes Consistency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Read-Your-Writes Consistency" and choosing an explicit operating point.

Queuing Theory against Model Assumptions

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Queuing Theory · Layer: Performance Core
Scope of the second
Model Assumptions · Layer: Performance Core
Rule
"queuing-theory" (performance-core layer) is traded against "Model Assumptions" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Model Assumptions" and choosing an explicit operating point.

Schema Validation against Flexible Input

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Schema Validation · Layer: Contracts Core
Scope of the second
Flexible Input · Layer: Contracts Core
Rule
"schema-validation" (contracts-core layer) is traded against "Flexible Input" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexible Input" and choosing an explicit operating point.

Type Safety against Rapid Scripting

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Type Safety · Layer: Contracts Core
Scope of the second
Rapid Scripting · Layer: Contracts Core
Rule
"type-safety" (contracts-core layer) is traded against "Rapid Scripting" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rapid Scripting" and choosing an explicit operating point.

Canonical Model against Bounded Context Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canonical Model · Layer: Contracts Core
Scope of the second
Bounded Context Autonomy · Layer: Contracts Core
Rule
"canonical-model" (contracts-core layer) is traded against "Bounded Context Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bounded Context Autonomy" and choosing an explicit operating point.

Canonical Data Model against Bounded Context Purity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canonical Data Model · Layer: Contracts Core
Scope of the second
Bounded Context Purity · Layer: Contracts Core
Rule
"canonical-data-model" (contracts-core layer) is traded against "Bounded Context Purity" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bounded Context Purity" and choosing an explicit operating point.

Canonical Data Model against Local Model Autonomy

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canonical Data Model · Layer: Contracts Core
Scope of the second
Local Model Autonomy · Layer: Contracts Core
Rule
"canonical-data-model" (contracts-core layer) is traded against "Local Model Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Model Autonomy" and choosing an explicit operating point.

Canonical Schema against Service-Specific Schemas

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canonical Schema · Layer: Contracts Core
Scope of the second
Service-Specific Schemas · Layer: Contracts Core
Rule
"canonical-schema" (contracts-core layer) is traded against "Service-Specific Schemas" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Service-Specific Schemas" and choosing an explicit operating point.

Canonicalization against Lossless Preservation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canonicalization · Layer: Contracts Core
Scope of the second
Lossless Preservation · Layer: Contracts Core
Rule
"canonicalization" (contracts-core layer) is traded against "Lossless Preservation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lossless Preservation" and choosing an explicit operating point.

Single Source of Truth against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Single Source of Truth · Layer: Contracts Core
Scope of the second
Availability · Layer: Correctness Core
Rule
"single-source-of-truth" (contracts-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Single Source of Truth against Decentralization

  • Mechanism: scope-separation
  • Derived from the layers
Details
Scope of the first
Single Source of Truth · Layer: Contracts Core
Scope of the second
Decentralization · Layer: Execution Core
Rule
"single-source-of-truth" governs the contracts-core layer and "Decentralization" the execution-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.

Semantic Consistency against Polysemy Across Contexts

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Semantic Consistency · Layer: Contracts Core
Scope of the second
Polysemy Across Contexts · Layer: Contracts Core
Rule
"semantic-consistency" (contracts-core layer) is traded against "Polysemy Across Contexts" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Polysemy Across Contexts" and choosing an explicit operating point.

Ubiquitous Language against Cross-Context Terminology

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Ubiquitous Language · Layer: Contracts Core
Scope of the second
Cross-Context Terminology · Layer: Contracts Core
Rule
"ubiquitous-language" (contracts-core layer) is traded against "Cross-Context Terminology" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Context Terminology" and choosing an explicit operating point.

Intent-Revealing Interface against Concise Naming

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Intent-Revealing Interface · Layer: Contracts Core
Scope of the second
Concise Naming · Layer: Contracts Core
Rule
"intent-revealing-interface" (contracts-core layer) is traded against "Concise Naming" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Concise Naming" and choosing an explicit operating point.

Principle of Least Surprise against Clever Abstractions

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Principle of Least Surprise · Layer: Contracts Core
Scope of the second
Clever Abstractions · Layer: Contracts Core
Rule
"principle-of-least-surprise" (contracts-core layer) is traded against "Clever Abstractions" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Clever Abstractions" and choosing an explicit operating point.

Security by Design against Developer Ergonomics

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Security by Design · Layer: Security Core
Scope of the second
Developer Ergonomics · Layer: Security Core
Rule
"security-by-design" (security-core layer) is traded against "Developer Ergonomics" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Developer Ergonomics" and choosing an explicit operating point.

Defense in Depth against Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Defense in Depth · Layer: Security Core
Scope of the second
Complexity · Layer: Human Factors
Rule
"defense-in-depth" (security-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.

Least Privilege against Operational Convenience

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Least Privilege · Layer: Security Core
Scope of the second
Operational Convenience · Layer: Security Core
Rule
"least-privilege" (security-core layer) is traded against "Operational Convenience" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Convenience" and choosing an explicit operating point.

Zero Trust Architecture against Latency/Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Zero Trust Architecture · Layer: Security Core
Scope of the second
Latency/Complexity · Layer: Security Core
Rule
"zero-trust-architecture" (security-core layer) is traded against "Latency/Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Complexity" and choosing an explicit operating point.

Secure by Default against Ease of Initial Use

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Secure by Default · Layer: Security Core
Scope of the second
Ease of Initial Use · Layer: Security Core
Rule
"secure-by-default" (security-core layer) is traded against "Ease of Initial Use" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ease of Initial Use" and choosing an explicit operating point.

Attack Surface Reduction against Feature Exposure

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Attack Surface Reduction · Layer: Security Core
Scope of the second
Feature Exposure · Layer: Security Core
Rule
"attack-surface-reduction" (security-core layer) is traded against "Feature Exposure" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Feature Exposure" and choosing an explicit operating point.

Threat Modeling against Delivery Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Threat Modeling · Layer: Security Core
Scope of the second
Delivery Speed · Layer: Structural Core
Rule
"threat-modeling" (security-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.

Authentication against User Experience

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Authentication · Layer: Security Core
Scope of the second
User Experience · Layer: Performance Core
Rule
"authentication" (security-core layer) is traded against "UX" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "UX" and choosing an explicit operating point.

Authorization against Policy Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Authorization · Layer: Security Core
Scope of the second
Policy Complexity · Layer: Security Core
Rule
"authorization" (security-core layer) is traded against "Policy Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Complexity" and choosing an explicit operating point.

Access Control against Usability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Access Control · Layer: Security Core
Scope of the second
Usability · Layer: Security Core
Rule
"access-control" (security-core layer) is traded against "Usability" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Usability" and choosing an explicit operating point.

RBAC against Role Explosion

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
RBAC · Layer: Security Core
Scope of the second
Role Explosion · Layer: Security Core
Rule
"role-based-access-control" (security-core layer) is traded against "Role Explosion" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Role Explosion" and choosing an explicit operating point.

ABAC against Policy Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
ABAC · Layer: Security Core
Scope of the second
Policy Complexity · Layer: Security Core
Rule
"attribute-based-access-control" (security-core layer) is traded against "Policy Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Complexity" and choosing an explicit operating point.

Input Validation against Input Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Input Validation · Layer: Security Core
Scope of the second
Input Flexibility · Layer: Security Core
Rule
"input-validation" (security-core layer) is traded against "Input Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Input Flexibility" and choosing an explicit operating point.

Output Encoding against Formatting Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Output Encoding · Layer: Security Core
Scope of the second
Formatting Flexibility · Layer: Security Core
Rule
"output-encoding" (security-core layer) is traded against "Formatting Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Formatting Flexibility" and choosing an explicit operating point.

Encryption at Rest against Key Operations

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Encryption at Rest · Layer: Security Core
Scope of the second
Key Operations · Layer: Security Core
Rule
"encryption-at-rest" (security-core layer) is traded against "Key Operations" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Key Operations" and choosing an explicit operating point.

Encryption in Transit against Certificate Management

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Encryption in Transit · Layer: Security Core
Scope of the second
Certificate Management · Layer: Security Core
Rule
"encryption-in-transit" (security-core layer) is traded against "Certificate Management" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Certificate Management" and choosing an explicit operating point.

Secrets Management against Operational Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Secrets Management · Layer: Security Core
Scope of the second
Operational Complexity · Layer: Structural Core
Rule
"secrets-management" (security-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.

Privacy by Design against Analytics/Personalization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Privacy by Design · Layer: Security Core
Scope of the second
Analytics/Personalization · Layer: Security Core
Rule
"privacy-by-design" (security-core layer) is traded against "Analytics/Personalization" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Analytics/Personalization" and choosing an explicit operating point.

Compliance against Delivery Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Compliance · Layer: Security Core
Scope of the second
Delivery Speed · Layer: Structural Core
Rule
"compliance" (security-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.

Governance against Team Velocity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Governance · Layer: Security Core
Scope of the second
Team Velocity · Layer: Security Core
Rule
"governance" (security-core layer) is traded against "Team Velocity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Velocity" and choosing an explicit operating point.

Policy Enforcement against False Positives

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Policy Enforcement · Layer: Security Core
Scope of the second
False Positives · Layer: Structural Core
Rule
"policy-enforcement" (security-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.

Policy as Code against Policy Maintenance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Policy as Code · Layer: Security Core
Scope of the second
Policy Maintenance · Layer: Security Core
Rule
"policy-as-code" (security-core layer) is traded against "Policy Maintenance" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Maintenance" and choosing an explicit operating point.

Risk Management against Speed

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Risk Management · Layer: Security Core
Scope of the second
Speed · Layer: Security Core
Rule
"risk-management" (security-core layer) is traded against "Speed" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Speed" and choosing an explicit operating point.

Continuous Compliance against Pipeline Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Continuous Compliance · Layer: Security Core
Scope of the second
Pipeline Complexity · Layer: Security Core
Rule
"continuous-compliance" (security-core layer) is traded against "Pipeline Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Pipeline Complexity" and choosing an explicit operating point.

CSRF Protection against Client Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
CSRF Protection · Layer: Security Core
Scope of the second
Client Complexity · Layer: Security Core
Rule
"csrf-protection" (security-core layer) is traded against "Client Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Client Complexity" and choosing an explicit operating point.

Parameterized Queries against Dynamic Query Flexibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Parameterized Queries · Layer: Security Core
Scope of the second
Dynamic Query Flexibility · Layer: Security Core
Rule
"parameterized-queries" (security-core layer) is traded against "Dynamic Query Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Query Flexibility" and choosing an explicit operating point.

Session Management against User Convenience

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Session Management · Layer: Security Core
Scope of the second
User Convenience · Layer: Security Core
Rule
"session-management" (security-core layer) is traded against "User Convenience" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Convenience" and choosing an explicit operating point.

Self-Healing Architecture against Automation Risk

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Self-Healing Architecture · Layer: Correctness Core
Scope of the second
Automation Risk · Layer: Correctness Core
Rule
"self-healing-architecture" (correctness-core layer) is traded against "Automation Risk" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Automation Risk" and choosing an explicit operating point.

Autonomous Recovery against False Recovery Actions

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Autonomous Recovery · Layer: Correctness Core
Scope of the second
False Recovery Actions · Layer: Correctness Core
Rule
"autonomous-recovery" (correctness-core layer) is traded against "False Recovery Actions" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Recovery Actions" and choosing an explicit operating point.

Health Checks against False Positives

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Health Checks · Layer: Correctness Core
Scope of the second
False Positives · Layer: Structural Core
Rule
"health-checks" (correctness-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.

Failover against Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Failover · Layer: Correctness Core
Scope of the second
Consistency · Layer: Atomic Boundary
Rule
"failover" (correctness-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.

Redundancy against Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Redundancy · Layer: Correctness Core
Scope of the second
Cost · Layer: Structural Core
Rule
"redundancy" (correctness-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.

Replication against Consistency Lag

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Replication · Layer: Correctness Core
Scope of the second
Consistency Lag · Layer: Correctness Core
Rule
"replication" (correctness-core layer) is traded against "Consistency Lag" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency Lag" and choosing an explicit operating point.

Auto-Scaling against Cost/Cold Start

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auto-Scaling · Layer: Correctness Core
Scope of the second
Cost/Cold Start · Layer: Correctness Core
Rule
"auto-scaling" (correctness-core layer) is traded against "Cost/Cold Start" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Cold Start" and choosing an explicit operating point.

Auto-Scaling against Fixed Capacity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auto-Scaling · Layer: Correctness Core
Scope of the second
Fixed Capacity · Layer: Correctness Core
Rule
"auto-scaling" (correctness-core layer) is traded against "Fixed Capacity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Fixed Capacity" and choosing an explicit operating point.

Auto-Remediation against Unsafe Automation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auto-Remediation · Layer: Correctness Core
Scope of the second
Unsafe Automation · Layer: Correctness Core
Rule
"auto-remediation" (correctness-core layer) is traded against "Unsafe Automation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Unsafe Automation" and choosing an explicit operating point.

Auto-Remediation against Manual Remediation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Auto-Remediation · Layer: Correctness Core
Scope of the second
Manual Remediation · Layer: Correctness Core
Rule
"auto-remediation" (correctness-core layer) is traded against "Manual Remediation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Manual Remediation" and choosing an explicit operating point.

Rollback against Data Migration Compatibility

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Rollback · Layer: Correctness Core
Scope of the second
Data Migration Compatibility · Layer: Correctness Core
Rule
"rollback" (correctness-core layer) is traded against "Data Migration Compatibility" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Data Migration Compatibility" and choosing an explicit operating point.

Blue-Green Deployment against Infrastructure Cost

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Blue-Green Deployment · Layer: Correctness Core
Scope of the second
Infrastructure Cost · Layer: Correctness Core
Rule
"blue-green-deployment" (correctness-core layer) is traded against "Infrastructure Cost" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Infrastructure Cost" and choosing an explicit operating point.

Canary Deployment against Rollout Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Canary Deployment · Layer: Correctness Core
Scope of the second
Rollout Complexity · Layer: Correctness Core
Rule
"canary-deployment" (correctness-core layer) is traded against "Rollout Complexity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rollout Complexity" and choosing an explicit operating point.

Chaos Engineering against Production Risk

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Chaos Engineering · Layer: Correctness Core
Scope of the second
Production Risk · Layer: Correctness Core
Rule
"chaos-engineering" (correctness-core layer) is traded against "Production Risk" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Production Risk" and choosing an explicit operating point.

Graceful Shutdown against Shutdown Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Graceful Shutdown · Layer: Correctness Core
Scope of the second
Shutdown Latency · Layer: Correctness Core
Rule
"graceful-shutdown" (correctness-core layer) is traded against "Shutdown Latency" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shutdown Latency" and choosing an explicit operating point.

RAID Redundancy against Write Amplification

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
RAID Redundancy · Layer: Correctness Core
Scope of the second
Write Amplification · Layer: Correctness Core
Rule
"raid-redundancy" (correctness-core layer) is traded against "Write Amplification" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Write Amplification" and choosing an explicit operating point.

Interface Segregation Principle (ISP) against Interface Proliferation

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Interface Segregation Principle (ISP) · Layer: Structural Core
Scope of the second
Interface Proliferation · Layer: Structural Core
Rule
"interface-segregation" (structural-core layer) is traded against "Interface Proliferation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Interface Proliferation" and choosing an explicit operating point.

Dependency Inversion Principle (DIP) against Runtime Indirection

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dependency Inversion Principle (DIP) · Layer: Structural Core
Scope of the second
Runtime Indirection · Layer: Structural Core
Rule
"dependency-inversion" (structural-core layer) is traded against "Runtime Indirection" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Indirection" and choosing an explicit operating point.

Open/Closed Principle (OCP) against Simplicity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Open/Closed Principle (OCP) · Layer: Structural Core
Scope of the second
Simplicity · Layer: Human Factors
Rule
"open-closed" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.

Liskov Substitution Principle (LSP) against Narrow Specialized Behavior

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Liskov Substitution Principle (LSP) · Layer: Structural Core
Scope of the second
Narrow Specialized Behavior · Layer: Structural Core
Rule
"liskov-substitution" (structural-core layer) is traded against "Narrow Specialized Behavior" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Narrow Specialized Behavior" and choosing an explicit operating point.

Polymorphism against Traceability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Polymorphism · Layer: Structural Core
Scope of the second
Traceability · Layer: Observability
Rule
"polymorphism" (structural-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.

Streaming Architecture against Ordering/State

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Streaming Architecture · Layer: Execution Core
Scope of the second
Ordering/State · Layer: Execution Core
Rule
"streaming-architecture" (execution-core layer) is traded against "Ordering/State" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering/State" and choosing an explicit operating point.

Streaming Architecture against Batch-Only Processing

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Streaming Architecture · Layer: Execution Core
Scope of the second
Batch-Only Processing · Layer: Execution Core
Rule
"streaming-architecture" (execution-core layer) is traded against "Batch-Only Processing" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Batch-Only Processing" and choosing an explicit operating point.

Single-Pass Processing against Global Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Single-Pass Processing · Layer: Execution Core
Scope of the second
Global Optimization · Layer: Execution Core
Rule
"single-pass-processing" (execution-core layer) is traded against "Global Optimization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global Optimization" and choosing an explicit operating point.

Single-Pass Processing against Multi-Pass Full Materialization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Single-Pass Processing · Layer: Execution Core
Scope of the second
Multi-Pass Full Materialization · Layer: Execution Core
Rule
"single-pass-processing" (execution-core layer) is traded against "Multi-Pass Full Materialization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Multi-Pass Full Materialization" and choosing an explicit operating point.

Pipeline Architecture against Error Propagation/Debugging

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pipeline Architecture · Layer: Execution Core
Scope of the second
Error Propagation/Debugging · Layer: Execution Core
Rule
"pipeline-architecture" (execution-core layer) is traded against "Error Propagation/Debugging" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Error Propagation/Debugging" and choosing an explicit operating point.

Lazy Evaluation against Debuggability/Resource Lifetime

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Lazy Evaluation · Layer: Execution Core
Scope of the second
Debuggability/Resource Lifetime · Layer: Execution Core
Rule
"lazy-evaluation" (execution-core layer) is traded against "Debuggability/Resource Lifetime" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability/Resource Lifetime" and choosing an explicit operating point.

Lazy Evaluation against Eager Full Materialization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Lazy Evaluation · Layer: Execution Core
Scope of the second
Eager Full Materialization · Layer: Execution Core
Rule
"lazy-evaluation" (execution-core layer) is traded against "Eager Full Materialization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Eager Full Materialization" and choosing an explicit operating point.

Sequential Access against Lookup Performance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Sequential Access · Layer: Execution Core
Scope of the second
Lookup Performance · Layer: Execution Core
Rule
"sequential-access" (execution-core layer) is traded against "Lookup Performance" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lookup Performance" and choosing an explicit operating point.

Sequential Access against Random Access Requirement

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Sequential Access · Layer: Execution Core
Scope of the second
Random Access Requirement · Layer: Execution Core
Rule
"sequential-access" (execution-core layer) is traded against "Random Access Requirement" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Random Access Requirement" and choosing an explicit operating point.

Forward-Only Processing against Complex Grammar/Global State

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Forward-Only Processing · Layer: Execution Core
Scope of the second
Complex Grammar/Global State · Layer: Execution Core
Rule
"forward-only-processing" (execution-core layer) is traded against "Complex Grammar/Global State" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complex Grammar/Global State" and choosing an explicit operating point.

Forward-Only Processing against Backtracking Algorithm

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Forward-Only Processing · Layer: Execution Core
Scope of the second
Backtracking Algorithm · Layer: Execution Core
Rule
"forward-only-processing" (execution-core layer) is traded against "Backtracking Algorithm" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Backtracking Algorithm" and choosing an explicit operating point.

Dataflow Architecture against State Coordination

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Dataflow Architecture · Layer: Execution Core
Scope of the second
State Coordination · Layer: Execution Core
Rule
"dataflow-architecture" (execution-core layer) is traded against "State Coordination" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Coordination" and choosing an explicit operating point.

Stateless Processing against Stateful Business Rules

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Stateless Processing · Layer: Execution Core
Scope of the second
Stateful Business Rules · Layer: Execution Core
Rule
"stateless-processing" (execution-core layer) is traded against "Stateful Business Rules" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful Business Rules" and choosing an explicit operating point.

Windowing against Late-Data Handling

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Windowing · Layer: Execution Core
Scope of the second
Late-Data Handling · Layer: Execution Core
Rule
"windowing" (execution-core layer) is traded against "Late-Data Handling" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Late-Data Handling" and choosing an explicit operating point.

Fan-out/Fan-in against Coordination Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fan-out/Fan-in · Layer: Execution Core
Scope of the second
Coordination Overhead · Layer: Execution Core
Rule
"fan-out-fan-in" (execution-core layer) is traded against "Coordination Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Overhead" and choosing an explicit operating point.

Fan-out/Fan-in against Serial Item Processing

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Fan-out/Fan-in · Layer: Execution Core
Scope of the second
Serial Item Processing · Layer: Execution Core
Rule
"fan-out-fan-in" (execution-core layer) is traded against "Serial Item Processing" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Serial Item Processing" and choosing an explicit operating point.

Batch-vs-Stream against Operational Duplication

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Batch-vs-Stream · Layer: Execution Core
Scope of the second
Operational Duplication · Layer: Execution Core
Rule
"batch-vs-stream" (execution-core layer) is traded against "Operational Duplication" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Duplication" and choosing an explicit operating point.

Adapter Pattern against Mapping Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Adapter Pattern · Layer: Design Patterns Core
Scope of the second
Mapping Overhead · Layer: Structural Core
Rule
"adapter-pattern" (design-patterns-core layer) is traded against "Mapping Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mapping Overhead" and choosing an explicit operating point.

Facade Pattern against Over-Centralization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Facade Pattern · Layer: Design Patterns Core
Scope of the second
Over-Centralization · Layer: Design Patterns Core
Rule
"facade-pattern" (design-patterns-core layer) is traded against "Over-Centralization" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Centralization" and choosing an explicit operating point.

Proxy Pattern against Transparency / Debugging

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Proxy Pattern · Layer: Design Patterns Core
Scope of the second
Transparency / Debugging · Layer: Design Patterns Core
Rule
"proxy-pattern" (design-patterns-core layer) is traded against "Transparency / Debugging" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Transparency / Debugging" and choosing an explicit operating point.

Bridge Pattern against Indirection

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Bridge Pattern · Layer: Design Patterns Core
Scope of the second
Indirection · Layer: Design Patterns Core
Rule
"bridge-pattern" (design-patterns-core layer) is traded against "Indirection" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Indirection" and choosing an explicit operating point.

Decorator Pattern against Stack Debugging

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Decorator Pattern · Layer: Design Patterns Core
Scope of the second
Stack Debugging · Layer: Design Patterns Core
Rule
"decorator-pattern" (design-patterns-core layer) is traded against "Stack Debugging" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stack Debugging" and choosing an explicit operating point.

Composite Pattern against Type Safety

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Composite Pattern · Layer: Design Patterns Core
Scope of the second
Type Safety · Layer: Contracts Core
Rule
"composite-pattern" (design-patterns-core layer) is traded against "Type Safety" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Type Safety" and choosing an explicit operating point.

Flyweight Pattern against Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Flyweight Pattern · Layer: Design Patterns Core
Scope of the second
Complexity · Layer: Human Factors
Rule
"flyweight-pattern" (design-patterns-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.

Closed Vocabulary against Naming Expressiveness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Closed Vocabulary · Layer: Structural Core
Scope of the second
Naming Expressiveness · Layer: Structural Core
Rule
"closed-vocabulary" (structural-core layer) is traded against "Naming Expressiveness" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Naming Expressiveness" and choosing an explicit operating point.

Bounded Nesting Depth against Tree Compactness

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Bounded Nesting Depth · Layer: Structural Core
Scope of the second
Tree Compactness · Layer: Structural Core
Rule
"bounded-nesting-depth" (structural-core layer) is traded against "Tree Compactness" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tree Compactness" and choosing an explicit operating point.

Idempotency against State Tracking

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Idempotency · Layer: Atomic Boundary
Scope of the second
State Tracking · Layer: Atomic Boundary
Rule
"idempotency" (atomic-boundary layer) is traded against "State Tracking" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Tracking" and choosing an explicit operating point.

Atomicity against Distributed Scalability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Atomicity · Layer: Atomic Boundary
Scope of the second
Distributed Scalability · Layer: Atomic Boundary
Rule
"atomicity" (atomic-boundary layer) is traded against "Distributed Scalability" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Scalability" and choosing an explicit operating point.

ACID against Distributed Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
ACID · Layer: Atomic Boundary
Scope of the second
Distributed Availability · Layer: Atomic Boundary
Rule
"acid" (atomic-boundary layer) is traded against "Distributed Availability" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Availability" and choosing an explicit operating point.

ACID against BASE/Eventual Consistency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
ACID · Layer: Atomic Boundary
Scope of the second
BASE/Eventual Consistency · Layer: Atomic Boundary
Rule
"acid" (atomic-boundary layer) is traded against "BASE/Eventual Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "BASE/Eventual Consistency" and choosing an explicit operating point.

Transaction Boundary against Large Transaction Scope

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Transaction Boundary · Layer: Atomic Boundary
Scope of the second
Large Transaction Scope · Layer: Atomic Boundary
Rule
"transaction-boundary" (atomic-boundary layer) is traded against "Large Transaction Scope" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Large Transaction Scope" and choosing an explicit operating point.

Unit of Work Pattern against Repository Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Unit of Work Pattern · Layer: Atomic Boundary
Scope of the second
Repository Complexity · Layer: Atomic Boundary
Rule
"unit-of-work-pattern" (atomic-boundary layer) is traded against "Repository Complexity" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Repository Complexity" and choosing an explicit operating point.

Consistency against Availability

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Consistency · Layer: Atomic Boundary
Scope of the second
Availability · Layer: Correctness Core
Rule
"consistency" (atomic-boundary layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.

Consistency against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Consistency · Layer: Atomic Boundary
Scope of the second
Latency · Layer: Performance Core
Rule
"consistency" (atomic-boundary layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

Isolation against Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Isolation · Layer: Atomic Boundary
Scope of the second
Throughput · Layer: Performance Core
Rule
"isolation" (atomic-boundary layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.

Concurrency Control against Performance

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Concurrency Control · Layer: Atomic Boundary
Scope of the second
Performance · Layer: Performance Core
Rule
"concurrency-control" (atomic-boundary layer) is traded against "Performance" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance" and choosing an explicit operating point.

Optimistic Locking against Retry Complexity

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Optimistic Locking · Layer: Atomic Boundary
Scope of the second
Retry Complexity · Layer: Atomic Boundary
Rule
"optimistic-locking" (atomic-boundary layer) is traded against "Retry Complexity" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Retry Complexity" and choosing an explicit operating point.

Pessimistic Locking against Deadlocks

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pessimistic Locking · Layer: Atomic Boundary
Scope of the second
Deadlocks · Layer: Atomic Boundary
Rule
"pessimistic-locking" (atomic-boundary layer) is traded against "Deadlocks" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deadlocks" and choosing an explicit operating point.

Pessimistic Locking against Latency

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pessimistic Locking · Layer: Atomic Boundary
Scope of the second
Latency · Layer: Performance Core
Rule
"pessimistic-locking" (atomic-boundary layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.

Pessimistic Locking against Lock-Free Throughput

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Pessimistic Locking · Layer: Atomic Boundary
Scope of the second
Lock-Free Throughput · Layer: Atomic Boundary
Rule
"pessimistic-locking" (atomic-boundary layer) is traded against "Lock-Free Throughput" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lock-Free Throughput" and choosing an explicit operating point.

State Isolation against Data Sharing

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
State Isolation · Layer: Atomic Boundary
Scope of the second
Data Sharing · Layer: Atomic Boundary
Rule
"state-isolation" (atomic-boundary layer) is traded against "Data Sharing" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Data Sharing" and choosing an explicit operating point.

Controlled Side Effects against Performance Optimization

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Controlled Side Effects · Layer: Atomic Boundary
Scope of the second
Performance Optimization · Layer: Atomic Boundary
Rule
"controlled-side-effects" (atomic-boundary layer) is traded against "Performance Optimization" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance Optimization" and choosing an explicit operating point.

Petri Nets against Modeling Overhead

  • Mechanism: irreducible-tradeoff
  • Derived from the layers
Details
Scope of the first
Petri Nets · Layer: Atomic Boundary
Scope of the second
Modeling Overhead · Layer: Atomic Boundary
Rule
"petri-nets" (atomic-boundary layer) is traded against "Modeling Overhead" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Modeling Overhead" and choosing an explicit operating point.
A1The kind taxonomyB1The relation rangesC1The forcesD1The layer topologyE1The membershipF1The resolutions

Documentation is covered by CC BY-SA 4.0 CCBYSA

© 2025 Jay BaleineThe ontology is authored and maintained by Bane's Lab as one canon and published here in full.