Glossary¶

Complete alphabetical index of all concepts.

A¶

Absence of Global Time - Distributed Fundamentals (Tier 1)
Abstract Data Type vs. Concrete Implementation - Data Structures (Tier 0)
Abstraction - Software Architecture (Tier 2)
Abstraction Layering - Programming Paradigms (Tier 0)
ACID Properties as Transaction Guarantees - Data Modeling & Persistence (Tier 1)
Alert Fatigue: The Attention Depletion Problem - Observability (Tier 3)
Alert on Symptoms, Not Causes - Observability (Tier 3)
Algebraic Data Types - Type Systems & Memory (Tier 0)
Amdahl's Law - Performance Optimization (Tier 3)
Amortization of I/O Overhead - Storage & I/O Foundations (Tier 0)
Amortized Analysis - Algorithmic Thinking (Tier 0)
Amortized Analysis - Algorithm Patterns (Tier 0)
Amortized Analysis and Cost Distribution - Data Structures (Tier 0)
Approximation and Heuristics - Algorithm Patterns (Tier 0)
Approximation as Strategy - Algorithmic Thinking (Tier 0)
Architectural Boundaries - Software Architecture (Tier 2)
Architecture as Decision Management - Software Architecture (Tier 2)
Arrange-Act-Assert Structure - Testing Strategies (Tier 2)
Asymptotic Analysis - Algorithmic Thinking (Tier 0)
Asynchronous Execution Pattern - Concurrency & Parallelism (Tier 1)
Atomic Operations - Concurrency & Parallelism (Tier 1)
Authentication vs. Authorization (Identity vs. Permission) - Security Patterns (Tier 2)

B¶

Backpressure - Distributed Patterns (Tier 1)
Backtracking and Pruning - Algorithm Patterns (Tier 0)
Backward Compatibility as Trust Contract - API Design (Tier 2)
Batching to Amortize Overhead - Performance Optimization (Tier 3)
Behavior Testing vs. Implementation Testing - Testing Strategies (Tier 2)
Blameless Post-Mortems: Learning Over Punishment - Observability (Tier 3)
Blocking vs. Non-Blocking I/O - Storage & I/O Foundations (Tier 0)
Borrowing and Temporary Access - Type Systems & Memory (Tier 0)
Bottleneck-First Optimization - Performance Optimization (Tier 3)
Bounded Context - Software Architecture (Tier 2)
Branch Prediction and Speculative Execution - Compute & Memory Foundations (Tier 0)
Buffering and Batching - Storage & I/O Foundations (Tier 0)
Bulkhead Isolation - Distributed Patterns (Tier 1)

C¶

Cache Invalidation Problem - Performance Optimization (Tier 3)
Cache-Conscious Design - Compute & Memory Foundations (Tier 0)
Caching as Space-Time Trade-off - Performance Optimization (Tier 3)
CAP Theorem - Distributed Fundamentals (Tier 1)
CAP Theorem and Consistency Models - Data Modeling & Persistence (Tier 1)
Cardinality as Observability's Resource Constraint - Observability (Tier 3)
Chaos Engineering: Proactive Failure Injection - Observability (Tier 3)
Circuit Breaker Pattern - Distributed Patterns (Tier 1)
Code Coverage Limitations - Testing Strategies (Tier 2)
Cohesion - Software Architecture (Tier 2)
Command-Query Separation - Software Design (Tier 2)
Comparison-Based Sorting Lower Bound - Algorithm Patterns (Tier 0)
Complete Mediation - Security Patterns (Tier 2)
Complexity Classes - Algorithmic Thinking (Tier 0)
Composition Over Inheritance - Programming Paradigms (Tier 0)
Composition Over Inheritance - Software Design (Tier 2)
Compression Trade-off - Performance Optimization (Tier 3)
Concurrency vs. Parallelism Distinction - Concurrency & Parallelism (Tier 1)
Connection-Oriented vs. Connectionless Communication - Networking Foundations (Tier 1)
Consensus Problem - Distributed Fundamentals (Tier 1)
Consistent Hashing - Distributed Patterns (Tier 1)
Context Propagation: Causality Across Boundaries - Observability (Tier 3)
Contiguous vs. Linked Memory Layout - Data Structures (Tier 0)
Contract Testing - Testing Strategies (Tier 2)
Contract-First Design - API Design (Tier 2)
Coupling - Software Architecture (Tier 2)
CPU-Bound vs. I/O-Bound Distinction - Compute & Memory Foundations (Tier 0)
CQRS: Command Query Responsibility Segregation - Data Modeling & Persistence (Tier 1)
Crash Consistency - Storage & I/O Foundations (Tier 0)

D¶

Deadlock and the Coffman Conditions - Concurrency & Parallelism (Tier 1)
Declarative Expression - Programming Paradigms (Tier 0)
Deep Modules - Software Architecture (Tier 2)
Deep vs. Shallow Modules - Software Design (Tier 2)
Defense in Depth - Security Patterns (Tier 2)
Delivery Guarantee Levels - Networking Foundations (Tier 1)
Denormalization as Calculated Trade-off - Data Modeling & Persistence (Tier 1)
Dependency Direction - Software Architecture (Tier 2)
Dependency Injection as Inversion of Control - Software Design (Tier 2)
Dependency Inversion Principle - Software Design (Tier 2)
Design Patterns as Named Solutions - Software Design (Tier 2)
Diminishing Returns of Optimization - Performance Optimization (Tier 3)
Divide and Conquer - Algorithm Patterns (Tier 0)
Divide-and-Conquer Paradigm - Algorithmic Thinking (Tier 0)
Document Model and Hierarchical Data - Data Modeling & Persistence (Tier 1)
Durability Guarantees and Fsync - Storage & I/O Foundations (Tier 0)
Dynamic Programming - Algorithm Patterns (Tier 0)
Dynamic Programming Thinking - Algorithmic Thinking (Tier 0)

E¶

Economy of Mechanism - Security Patterns (Tier 2)
Encapsulation - Software Architecture (Tier 2)
Encapsulation (Information Hiding) - Programming Paradigms (Tier 0)
Error Budgets: Quantifying Acceptable Failure - Observability (Tier 3)
Error Design as First-Class Concern - API Design (Tier 2)
Event Sourcing as Append-Only State - Data Modeling & Persistence (Tier 1)
Eventual Consistency - Distributed Patterns (Tier 1)
Exponential Backoff with Jitter - Distributed Patterns (Tier 1)

F¶

Fail Securely - Security Patterns (Tier 2)
Fail-Fast Principle - Software Design (Tier 2)
Failure Mode Spectrum - Distributed Fundamentals (Tier 1)
Fallacies of Distributed Computing - Distributed Fundamentals (Tier 1)
FIFO Semantics (Queue Discipline) - Data Structures (Tier 0)
Flaky Tests - Testing Strategies (Tier 2)
Floating-Point Arithmetic Pitfalls - Compute & Memory Foundations (Tier 0)
Floating-Point Representation Limits - Compute & Memory Foundations (Tier 0)
Flow Control vs. Congestion Control - Networking Foundations (Tier 1)
FLP Impossibility - Distributed Fundamentals (Tier 1)
Functional Dependency and Normalization - Data Modeling & Persistence (Tier 1)

G¶

Garbage Collection as Automatic Lifetime Management - Type Systems & Memory (Tier 0)
Granularity of Parallelism - Concurrency & Parallelism (Tier 1)
Graph Model for Relationship-Centric Data - Data Modeling & Persistence (Tier 1)
Graph Representation Trade-offs - Data Structures (Tier 0)
Graph Traversal Strategies - Algorithm Patterns (Tier 0)
Greedy Strategy - Algorithmic Thinking (Tier 0)
Greedy Strategy and Its Limits - Algorithm Patterns (Tier 0)

H¶

Head-of-Line Blocking - Networking Foundations (Tier 1)
Heap Property and Partial Ordering - Data Structures (Tier 0)
Higher-Order Abstraction (Functions as Values) - Programming Paradigms (Tier 0)
HTTP Semantics: Method Idempotency and Safety - Networking Foundations (Tier 1)
Hypermedia as Engine of Application State (HATEOAS) - API Design (Tier 2)

I¶

I/O Multiplexing - Storage & I/O Foundations (Tier 0)
I/O Scheduling and Prioritization - Storage & I/O Foundations (Tier 0)
Idempotency - Distributed Patterns (Tier 1)
Idempotency as Fundamental Requirement - Distributed Fundamentals (Tier 1)
Idempotency as Reliability Foundation - API Design (Tier 2)
Immutability - Programming Paradigms (Tier 0)
Immutability as Concurrency Strategy - Concurrency & Parallelism (Tier 1)
Index as Read-Write Trade-off - Data Modeling & Persistence (Tier 1)
Inductive Reasoning in Algorithms - Algorithmic Thinking (Tier 0)
Information Hiding - Software Architecture (Tier 2)
Information Hiding - Software Design (Tier 2)
Input Validation at Boundaries (Never Trust External Data) - Security Patterns (Tier 2)
Instruction Pipelining - Compute & Memory Foundations (Tier 0)
Integer Overflow and Representation - Compute & Memory Foundations (Tier 0)
Interface Segregation Principle - Software Design (Tier 2)

L¶

Latency Components - Networking Foundations (Tier 1)
Latency Numbers Intuition - Compute & Memory Foundations (Tier 0)
Latency vs. Throughput Trade-off - Performance Optimization (Tier 3)
Law of Demeter (Principle of Least Knowledge) - Software Design (Tier 2)
Layered Architecture - Software Architecture (Tier 2)
Lazy Evaluation - Programming Paradigms (Tier 0)
Lazy Evaluation - Performance Optimization (Tier 3)
Leader-Follower Replication - Distributed Patterns (Tier 1)
Least Privilege Principle - Security Patterns (Tier 2)
LIFO Semantics (Stack Discipline) - Data Structures (Tier 0)
Liskov Substitution Principle - Software Design (Tier 2)
Load Shedding - Distributed Patterns (Tier 1)
Load Testing and Capacity Planning - Performance Optimization (Tier 3)
Locality Principles (Temporal and Spatial) - Compute & Memory Foundations (Tier 0)
Lock-Free and Wait-Free Progress Guarantees - Concurrency & Parallelism (Tier 1)
Logical Time and Causality - Distributed Fundamentals (Tier 1)
Loop Invariants - Algorithmic Thinking (Tier 0)

M¶

Measure Before Optimizing - Performance Optimization (Tier 3)
Memoization - Performance Optimization (Tier 3)
Memory Hierarchy - Compute & Memory Foundations (Tier 0)
Memory Safety as Invariant Preservation - Type Systems & Memory (Tier 0)
Memory Visibility and Ordering - Concurrency & Parallelism (Tier 1)
Memory-Mapped I/O - Compute & Memory Foundations (Tier 0)
Message Passing (Object Communication) - Programming Paradigms (Tier 0)
Message Passing and Channel-Based Coordination - Concurrency & Parallelism (Tier 1)
Minimum Spanning Tree Property - Algorithm Patterns (Tier 0)
Mitigation Before Root Cause - Observability (Tier 3)
Modular Decomposition - Software Architecture (Tier 2)
Monitoring vs. Observability: Known-Unknowns vs. Unknown-Unknowns - Observability (Tier 3)
Multiplexing Independent Streams - Networking Foundations (Tier 1)
Mutation Testing - Testing Strategies (Tier 2)
Mutual Exclusion and Critical Sections - Concurrency & Parallelism (Tier 1)

N¶

Name Resolution as Indirection - Networking Foundations (Tier 1)
Null Safety and Option Types - Type Systems & Memory (Tier 0)

O¶

Open/Closed Principle - Software Design (Tier 2)
Outbox Pattern - Distributed Patterns (Tier 1)
Ownership and Single-Owner Lifetime Management - Type Systems & Memory (Tier 0)

P¶

PACELC Extension - Distributed Fundamentals (Tier 1)
Page-Based Memory Management - Compute & Memory Foundations (Tier 0)
Pagination as Bounded Response Pattern - API Design (Tier 2)
Parametric Polymorphism (Generics) - Type Systems & Memory (Tier 0)
Partial Failure - Distributed Fundamentals (Tier 1)
Pattern Matching and Preprocessing - Algorithm Patterns (Tier 0)
Persistent vs. Ephemeral Structures - Data Structures (Tier 0)
Polymorphism (Substitutability) - Programming Paradigms (Tier 0)
Ports and Adapters - Software Architecture (Tier 2)
Postel's Law (Robustness Principle) - API Design (Tier 2)
Pre-conditions and Post-conditions - Algorithmic Thinking (Tier 0)
Precomputation - Performance Optimization (Tier 3)
Prefix-Based Organization (Tries) - Data Structures (Tier 0)
Probabilistic Data Structures - Data Structures (Tier 0)
Problem Reduction - Algorithmic Thinking (Tier 0)
Property-Based Testing - Testing Strategies (Tier 2)
Protocol Layering - Networking Foundations (Tier 1)

Q¶

Query Flexibility vs. Server Optimization Trade-off - API Design (Tier 2)
Quorum Systems - Distributed Fundamentals (Tier 1)

R¶

Race Condition - Concurrency & Parallelism (Tier 1)
Randomized Algorithms - Algorithm Patterns (Tier 0)
Rate Limiting as Resource Protection - API Design (Tier 2)
Read vs. Write Asymmetry - Storage & I/O Foundations (Tier 0)
Recursive Decomposition - Algorithmic Thinking (Tier 0)
Referential Integrity and Constraints - Data Modeling & Persistence (Tier 1)
Referential Transparency (Pure Functions) - Programming Paradigms (Tier 0)
Relational Model as Set-Theoretic Foundation - Data Modeling & Persistence (Tier 1)
Reliability Through Acknowledgment and Retransmission - Networking Foundations (Tier 1)
Replication Trade-offs - Distributed Fundamentals (Tier 1)
Request-Response Pattern - Networking Foundations (Tier 1)
Resource as Primary Abstraction - API Design (Tier 2)
Resource Pooling - Performance Optimization (Tier 3)
Richardson Maturity Model as Capability Spectrum - API Design (Tier 2)
Runbooks: Codified Incident Response - Observability (Tier 3)

S¶

Saga Pattern - Distributed Patterns (Tier 1)
Sampling: Trading Completeness for Feasibility - Observability (Tier 3)
Schema-on-Write vs. Schema-on-Read - Data Modeling & Persistence (Tier 1)
Seams - Testing Strategies (Tier 2)
Search Space Reduction (Binary Search Principle) - Algorithm Patterns (Tier 0)
Secrets Management - Security Patterns (Tier 2)
Secure by Default - Security Patterns (Tier 2)
Security Logging and Audit Trails - Security Patterns (Tier 2)
Separation of Concerns - Programming Paradigms (Tier 0)
Separation of Concerns - Software Architecture (Tier 2)
Separation of Duties - Security Patterns (Tier 2)
Sequential vs. Random Access - Storage & I/O Foundations (Tier 0)
Service Level Hierarchy: SLI, SLO, SLA - Observability (Tier 3)
Sharding and Partitioning - Distributed Patterns (Tier 1)
Shared Mutable State as Root Hazard - Concurrency & Parallelism (Tier 1)
Shortest Path Problem Structure - Algorithm Patterns (Tier 0)
Side Effect Isolation - Programming Paradigms (Tier 0)
SIMD and Data Parallelism - Compute & Memory Foundations (Tier 0)
Single Responsibility Principle - Software Design (Tier 2)
Split Brain and Fencing - Distributed Fundamentals (Tier 1)
Stack vs. Heap Allocation - Type Systems & Memory (Tier 0)
State Machines as Design Tool - Software Design (Tier 2)
Stateless Protocol Design - Networking Foundations (Tier 1)
Statelessness as Scalability Enabler - API Design (Tier 2)
Static vs. Dynamic Type Checking - Type Systems & Memory (Tier 0)
Storage Media Characteristics - Storage & I/O Foundations (Tier 0)
Streaming and Push Patterns - Networking Foundations (Tier 1)
Structure Selection Heuristics - Data Structures (Tier 0)
Structured Logging: Machine-Parseable Events - Observability (Tier 3)
Subtyping and Substitutability - Type Systems & Memory (Tier 0)
Synchronization Primitive Semantics - Concurrency & Parallelism (Tier 1)

T¶

Temporal Data and Bi-temporal Modeling - Data Modeling & Persistence (Tier 1)
Test Brittleness - Testing Strategies (Tier 2)
Test Doubles Taxonomy - Testing Strategies (Tier 2)
Test Isolation - Testing Strategies (Tier 2)
Test Pyramid - Testing Strategies (Tier 2)
Test-Driven Development as Design Technique - Testing Strategies (Tier 2)
Testing as Design Feedback - Testing Strategies (Tier 2)
The File Abstraction - Storage & I/O Foundations (Tier 0)
The Hashing Principle - Data Structures (Tier 0)
The I/O Cost Model - Storage & I/O Foundations (Tier 0)
The Indexing Principle - Data Structures (Tier 0)
The Storage Hierarchy - Storage & I/O Foundations (Tier 0)
The Three Pillars: Complementary System State Representations - Observability (Tier 3)
Thread Confinement and Ownership - Concurrency & Parallelism (Tier 1)
Threat Modeling - Security Patterns (Tier 2)
Time-Space Trade-off Principle - Algorithmic Thinking (Tier 0)
Timeout Design - Distributed Patterns (Tier 1)
Topological Ordering and Dependency Resolution - Algorithm Patterns (Tier 0)
Tractability Boundaries - Algorithmic Thinking (Tier 0)
Transaction Isolation Levels - Data Modeling & Persistence (Tier 1)
Transport Security as a Layer - Networking Foundations (Tier 1)
Tree Balance and Guaranteed Bounds - Data Structures (Tier 0)
Trust Boundaries - Security Patterns (Tier 2)
Two Generals Problem - Distributed Fundamentals (Tier 1)
Type Abstraction - Programming Paradigms (Tier 0)
Type Inference - Type Systems & Memory (Tier 0)
Type Safety as Error Prevention - Type Systems & Memory (Tier 0)
Type-Level Encoding of Invariants - Type Systems & Memory (Tier 0)

U¶

Uniform Interface Principle - API Design (Tier 2)

V¶

Value vs. Reference Semantics - Type Systems & Memory (Tier 0)
Versioning as Change Management - API Design (Tier 2)
Virtual Memory Abstraction - Compute & Memory Foundations (Tier 0)

W¶

Write-Ahead Logging (WAL) - Storage & I/O Foundations (Tier 0)

Z¶

Zero Trust Architecture - Security Patterns (Tier 2)