Concepts
Mental models and definitions that make the code understandable.
896 published
Page 4 of 9
Flaky Test
A flaky test passes and fails on the same code, eroding trust in the suite and masking real regressions.
Head-Based Sampling
Head-based sampling decides whether to record a trace at its start, before any outcome is known, and propagates that decision down the call graph.
HTTP/2
HTTP/2 multiplexes many requests over one TCP connection using binary framing and header compression, removing head-of-line blocking at the application layer.
HTTP/3
HTTP/3 runs HTTP over QUIC and UDP, eliminating TCP head-of-line blocking so one lost packet does not stall unrelated streams.
Isolation Levels
Isolation levels define how much concurrent transactions may interfere, trading consistency anomalies against concurrency.
Lockfile
A lockfile pins the exact versions and integrity hashes of every dependency, making installs reproducible across machines and time.
Log Sampling
Log sampling keeps a representative subset of log events, preserving patterns and errors while dropping the redundant volume that inflates cost.
Medallion Architecture
Medallion architecture layers a lakehouse into bronze, silver, and gold stages that progressively clean, conform, and aggregate data.
Mutual TLS
Mutual TLS authenticates both ends of a connection with certificates, giving service-to-service identity beyond the transport layer.
Mutex
A mutex is a mutual-exclusion lock that lets only one thread enter a critical section at a time, protecting shared state.
OAuth 2.0
OAuth 2.0 is an authorization framework that lets an application obtain limited, scoped access to a user resources without the password.
OpenTelemetry
OpenTelemetry is a vendor-neutral standard and toolkit for generating, collecting, and exporting traces, metrics, and logs.
Optimistic Locking
Optimistic locking detects conflicting concurrent updates at write time using a version, allowing concurrent readers without locks.
Phantom Read
A phantom read occurs when a transaction re-runs a query and finds new rows inserted by another transaction since its first execution.
Prometheus
Prometheus is a pull-based time-series monitoring system with a query language, built around multi-dimensional metrics and alerting.
Protocol Buffers
Protocol Buffers is a language-neutral schema and binary serialisation format, giving compact, forward-compatible structured messages.
Provenance Attestation
Provenance attestation cryptographically records how a build artefact was produced, enabling verification of supply-chain integrity.
QUIC
QUIC is a UDP-based transport with built-in streams, TLS 1.3, and congestion control that removes TCP head-of-line blocking and speeds handshakes.
Race Condition
A race condition occurs when correctness depends on the unpredictable timing or ordering of concurrent operations accessing shared state.
Read Replica
A read replica is a copy of a database that serves read traffic and scales read capacity, at the cost of replication lag.
Read-Write Lock
A read-write lock allows many concurrent readers or one exclusive writer, raising throughput for read-heavy shared state.
Regression Testing
Regression testing re-runs existing tests after a change to confirm that previously working behaviour still works.
Reproducible Build
A reproducible build produces bit-identical output from the same source, toolchain, and environment, making artefacts verifiable.
SAML
SAML is an XML-based standard for exchanging authentication and authorization assertions between an identity provider and a service provider.
Static Application Security Testing
SAST analyses source code without executing it to find security defects early, trading false positives for speed and shift-left coverage.
Secrets Management
Secrets management is the discipline and tooling for storing, distributing, rotating, and auditing credentials such as keys and tokens.
Semaphore
A semaphore is a counter that limits how many threads or tasks may use a resource concurrently by acquiring and releasing permits.
Smoke Testing
Smoke testing runs a small, fast set of checks to confirm a build is stable enough for deeper testing or release.
Span Links
Span links record causal relationships between spans that are not parent-child, such as batch fan-out or asynchronous follow-up work.
Tail Sampling
Tail sampling decides whether to keep a trace after collecting all its spans, so complete slow or failed traces are retained and routine ones dropped.
Test Coverage Metrics
Test coverage metrics quantify how much of the code a test suite exercises, useful as a signal but dangerous as a target.
Test Double
A test double is any stand-in used in place of a real dependency during a test: a stub, fake, spy, or mock.
Test Fixture
A test fixture is the fixed environment and data a test runs against, set up before and torn down after execution.
Thread Pool
A thread pool reuses a fixed set of worker threads to execute many tasks, bounding concurrency and avoiding per-task thread creation.
TLS Handshake
The TLS handshake authenticates peers and negotiates keys and ciphers, establishing the encrypted channel every HTTPS connection needs.
Trace Sampling
Trace sampling keeps a subset of distributed traces, controlling observability cost while retaining enough data to reason about the system.
Transactional Outbox
The transactional outbox writes messages into the same database transaction as the state change, then relays them reliably.
Tree Shaking
Tree shaking removes code that is never imported, relying on the static import structure of ES modules to drop dead exports.
Vector Search
Vector search retrieves the items whose embeddings are nearest a query vector, turning semantic similarity into an index lookup.
Write-Ahead Log
A write-ahead log records changes before they are applied to data files, giving durability and crash recovery and enabling replication.
A/B Test Statistical Significance
A/B significance is the discipline of separating real effects from noise: fixed hypothesis, pre-computed sample size, guardrail metrics, and no peeking before the planned horizon.
ABA Problem
The ABA problem fools a CAS-based algorithm: the value changed away and back to the expected value, so the swap succeeds even though the intermediate change invalidates the assumption.
Automated Accessibility Testing
Automated a11y testing scans rendered pages for WCAG violations — contrast, labels, heading order, ARIA misuse — catching the mechanical subset of accessibility while manual audit remains mandatory.
Accessibility Tree Testing
Accessibility tree testing asserts against the computed semantics a screen reader receives, not the raw DOM, so tests reflect real assistive technology behaviour.
Actor Model
The actor model structures computation as autonomous actors — private state, asynchronous mailbox, one message at a time — eliminating shared-memory synchronization by construction.
Advisory Locks
Advisory locks are application-defined locks managed by the database, letting code coordinate exclusive access to resources it names itself.
Aggregate Root
An aggregate root is the single entry point to a cluster of objects that must stay consistent together, defining the boundary for atomic changes.
AI Guardrails and Output Validation
Guardrails constrain what a model may do and validate its output, catching unsafe, malformed, or policy-violating responses before they reach users or systems.
Allocation Pressure
Allocation pressure is the rate of memory allocation driving collector frequency and pause distribution — the hidden latency input that GC tuning only treats downstream.
Alt-Svc Header
The Alt-Svc header advertises alternative endpoints for the same origin — such as an HTTP/3 port on a different host — letting clients upgrade transports or migrate mid-connection.
Static Thresholds Versus Anomaly Detection
Static threshold alerts fire on fixed lines — latency over 500ms — while anomaly detection learns baselines and fires on deviations, each with distinct failure modes of noise and blindness.
Anti-Corruption Layer
An anti-corruption layer translates between a legacy or external model and your domain model, preventing foreign concepts from leaking into and degrading your core design.
Anycast Routing
Anycast announces the same IP address from many locations worldwide so routing sends each user to the nearest healthy node, collapsing latency and containing regional failures.
API Composition
API composition aggregates multiple service calls into one response through a composer that fans out in-memory, trading read availability for the weakest link of its providers.
Approval Testing
Approval testing compares actual output against a reviewed, committed baseline, flagging any difference for human confirmation before it is accepted.
Async Assertion Patterns
Async assertions bridge test time and promise time: awaiting results, polling conditions with deadlines, and asserting on settled state — or the suite reports the wrong failure or none at all.
Async Context Propagation
Async context propagation carries request metadata — trace ids, auth, tenants — across task boundaries where thread-locals stop working, via explicit contexts or runtime hooks.
Asynchronous I/O
Asynchronous IO starts an operation and continues without blocking, notifying completion later, which lets one thread service many sockets or file operations.
Atomic Operations
Atomic operations read and modify a value indivisibly, providing lock-free building blocks for counters, flags, and lock-free data structures.
Authenticated Encryption (AEAD)
Authenticated encryption produces ciphertext and a tag that proves integrity and authenticity, so tampering is detected before plaintext is used.
Authorization Testing
Authorization testing systematically verifies every role-against-resource combination — not just that unauthorized requests fail, but that no role gains unintended reach through nested and bulk paths.
Auto-Vectorization
Auto-vectorization lets compilers transform loops into SIMD instructions operating on multiple elements at once — when dependencies, alignment, and aliasing checks allow it to prove safety.
Autovacuum and Dead Tuple Reclamation
Autovacuum reclaims space from dead row versions left by MVCC updates, and tuning its thresholds prevents bloat and transaction ID wraparound.
Backend for Frontend
A backend for frontend is a dedicated server-side layer per client type — web, mobile, TV — that aggregates and shapes services for that experience, decoupling client needs from service contracts.
W3C Baggage Propagation
Baggage propagates arbitrary key-value context alongside the trace context — tenant, flags, experiment cohorts — readable at every hop without carrying it in message payloads or headers by hand.
BBR Congestion Control
BBR models the delivery rate and round-trip time of a path to maximize throughput while keeping queues short, replacing loss-based congestion control that misreads wireless and buffered links.
Back/Forward Cache
The back/forward cache stores a fully live page snapshot on navigation so the back button restores it instantly, unless the page holds unload handlers, open sockets, or other disqualifying state.
Bitmap Index
A bitmap index stores one bit vector per distinct value, enabling instant AND and OR combinations of low-cardinality predicates at the cost of terrible write concurrency.
Bounded Context
A bounded context is an explicit boundary within which a domain model and its language are consistent, preventing one overloaded word from meaning several incompatible things.
Branch Coverage
Branch coverage measures whether every decision outcome is exercised, catching untested else and short-circuit paths that statement coverage overlooks.
Branch Prediction
Branch prediction guesses control flow before it resolves, keeping pipelines full; mispredictions flush the pipeline at 15 to 20 cycles each, making data layout and branch order performance-visible.
Cache Hit Ratio
Cache hit ratio divides served-from-cache responses by total requests; its definition — bytes versus requests, edge versus shield — must be pinned before it means anything.
Cache Key Normalisation
Normalising the cache key collapses requests that are semantically identical but differ in ordering, case, or irrelevant parameters, raising the hit rate.
Cache Partitioning via Consistent Hashing
Cache partitioning spreads keys across nodes with consistent hashing, so adding a node moves only a fraction of keys instead of reshuffling everything.
Web Cache Poisoning
Web cache poisoning tricks a shared cache into storing a malicious response for a normal URL, by supplying unkeyed inputs — headers or parameters the cache ignores — that alter the response.
Cache Preloading and Warming
Cache preloading fills entries before traffic arrives, so users do not pay the latency of a cold cache during a deploy or after an eviction.
Cache Warming
Cache warming pre-populates critical entries before traffic arrives — after deploys, region failovers, and scale events — so first users do not pay cold-cache latency.
Canonical Data Model
A canonical data model defines one shared, system-neutral schema that every integrated system maps to and from, so N systems need 2N mappings instead of N times N point-to-point.
CSS Cascade Layers
Cascade layers let authors order stylesheet rules by an explicit layer order, so specificity conflicts are resolved by layer position instead of selector weight alone.
Characterization Tests
Characterization tests capture what legacy code actually does — including its bugs — as a safety net for refactoring, pinning current behavior before changing it.
Checkpoint Tuning
Checkpoints periodically flush all dirty pages and record a recovery point; tuning their frequency trades steady I/O spread against recovery time and write spikes.
Choreography Versus Orchestration
Choreography lets services react to each other events independently; orchestration centralizes sequencing in a coordinator, trading implicit flow for explicit control.
Chunked Transfer Encoding
Chunked transfer encoding streams a response of unknown length as a sequence of length-prefixed chunks, ending with a zero-size chunk, enabling progressive delivery without buffering.
Document Chunking Strategies
Chunking decides how documents are split before embedding, and the boundary choices determine whether retrieval returns coherent, self-contained passages.
Claim Check Pattern
The claim check pattern stores large payloads externally and passes a reference through the message channel, keeping messages small and channels fast while payloads live in object storage.
Clean Architecture
Clean architecture enforces a dependency rule in which inner entities and use cases know nothing of outer delivery and persistence mechanisms.
Clickjacking
Clickjacking overlays or embeds your page transparently inside an attacker page, so user clicks on visible decoys land on your buttons — transfers, deletes, permission grants.
Clustered Index
A clustered index defines the physical row order of the table itself, so range scans on its key are sequential, but every secondary index must route through it.
Command Injection
Command injection concatenates untrusted input into a shell command string, letting metacharacters append arguments and additional commands that run with the server privileges.
Compare-and-Swap
Compare-and-swap atomically updates a memory location only if it still holds an expected value, enabling lock-free updates through optimistic retry loops.
Competing Consumers
Competing consumers let multiple instances pull from one queue, sharing the work and scaling horizontally — with per-message atomic claim semantics preventing double processing.
GPU Compositing Layers
Compositing layers are independently rasterized surfaces the browser composes on the GPU; promoting animations to transform and opacity on their own layer keeps them off the main thread.
HTTP/2 Connection Coalescing
Connection coalescing lets a browser reuse one HTTP/2 connection for multiple origins when they resolve to the same IP and share a certificate covering both names, collapsing connection counts.
Database Connection Multiplexing
A connection pooler multiplexes many short-lived client connections onto a small set of backend sessions, protecting databases that pay a cost per connection.
Connection Pool Saturation
Connection pool saturation happens when all pooled connections are held longer than requests arrive, queuing callers behind slow queries instead of shedding load cleanly.
Constant-Time Comparison
Constant-time comparison checks equality of secrets by touching every byte with identical operations, removing the early-exit timing signal that leaks prefix matches.
CSS Container Queries
Container queries size a component by its parent's dimensions rather than the viewport, enabling truly reusable responsive components.
Content-Encoding Negotiation
Content-Encoding compresses response bodies with gzip, brotli, or zstd based on client-advertised algorithms, trading CPU for transfer size on compressible text content.
MIME Type Sniffing and nosniff
Browsers may ignore a declared Content-Type and infer a resource's real type from its leading bytes; X-Content-Type-Options: nosniff forces the declared type to be trusted instead.
content-visibility
The content-visibility property skips rendering work for off-screen subtrees while preserving their find-in-page and accessibility semantics, combining containment with viewport awareness.