Glossary

A to C

ACK frame

A QUIC frame that acknowledges packet number ranges and carries explicit congestion notification counts. Section 1.1.

Activity

In durable execution, a recorded step whose result is journaled, so replay returns it instead of executing again. Section 9.4.

AF_XDP

A socket type that receives packets from an XDP program through memory shared with the kernel. Section 1.2.

Ambient mode

A service mesh topology that splits layer 4 into a per-node proxy and layer 7 into an optional per-namespace proxy. Section 5.1.

Anti-entropy

Background reconciliation between replicas, usually by comparing Merkle trees. Section 3.3.

ARIES

The recovery design of write-ahead logging, repeating history during redo, and logging undo actions. Section 3.1.

Backpressure

A signal travelling from a slow consumer to a fast producer, telling it to slow down. Section 5.4.

Bulkhead

A per-dependency resource pool that stops one slow dependency consuming every thread. Section 5.2.

Burn rate

The multiple of error budget consumption that exhausts the budget exactly at the end of the window. Section 8.4.

Chunked prefill

Splitting a long prompt into pieces interleaved with decode steps, so no prefill monopolizes the accelerator. Section 9.1.

Commit wait

Spanner's delay until the clock uncertainty interval passes the commit timestamp, which buys external consistency. Section 2.3.

Connection identifier

A QUIC field that names a connection independently of the address and port tuple, which is what enables migration. Section 1.1.

Consistent hashing

A key-to-node mapping that remaps only the keys of a departed node when membership changes. Section 3.2.

Continuous batching

Admitting new inference requests into freed batch slots at every decode step. Section 9.1.

Control plane

The component that computes configuration and distributes it to data plane proxies. Section 5.1.

Cooperative rebalancing

A consumer group protocol that revokes only the partitions that move, over two short rounds. Section 4.1.

CRDT

A type whose merge is commutative, associative, and idempotent, so replicas converge with no coordination. Section 3.3.

Crypto shredding

Encrypting a subject's data with a per-subject key and deleting the key to satisfy an erasure request. Section 4.2.

D to I

Dead letter queue

A topic that holds records a consumer failed to process, with enough context to diagnose and replay. Section 4.4.

Deterministic execution

Replicas executing the same transactions in the same order with no external inputs, so no agreement on the outcome is needed. Section 2.4.

DiskANN

A graph vector index whose edges live on NVMe, trading latency for orders of magnitude less memory. Section 9.3.

DPDK

A user-space poll mode driver that removes the kernel from the packet path entirely. Section 1.2.

Durable execution

A workflow engine that journals every step so a run resumes from where it stopped. Section 9.4.

EPaxos

A leaderless consensus protocol that commits non-interfering commands in one round trip from the nearest replica. Section 2.2.

Error budget

The allowed shortfall from a service level objective, which is one minus the objective. Section 8.4.

Event sourcing

Storing the sequence of changes as the source of truth, with current state as a fold over them. Section 4.2.

Exactly-once semantics

A guarantee that the visible effect happens once, whatever fails. Not the same as delivering a message once. Section 4.3.

Filtered traversal

Evaluating a predicate during a vector index walk, continuing through non-matching nodes for connectivity. Section 9.3.

Flexible Paxos

The observation that the two Paxos phases need quorums that intersect each other, not themselves. Section 2.2.

Goodput

Throughput restricted to the work that met its latency target. Section 9.1.

Grouped query attention

Sharing one key and value head across several query heads, to shrink the key and value cache. Section 9.1.

Head-of-line blocking

A stall in which one lost or slow item blocks unrelated items behind it. Section 1.1.

Hedged request

A second copy of a request sent after a delay, taking whichever answer arrives first. Section 8.3.

HNSW

A layered proximity graph for approximate nearest neighbor search. Section 9.3.

Hybrid logical clock

A timestamp with a physical component and a logical counter, preserving causality and human meaning. Section 2.3.

Idempotent producer

A producer that attaches a sequence number per partition so the broker discards retry duplicates. Section 4.3.

Informer

A Kubernetes client component that lists once, watches, and maintains an indexed local cache. Section 7.2.

J to Q

Joint consensus

A transitional cluster configuration requiring majorities in both the old and the new set. Section 2.1.

Last stable offset

The offset of the earliest still-open transaction, beyond which a read-committed consumer cannot advance. Section 4.3.

Latch crabbing

Releasing a parent node's latch as soon as the child is known safe during a tree descent. Section 3.1.

Leader epoch

A mapping from epoch to start offset that lets a returning replica truncate at exactly the right place. Section 4.1.

Level-driven reconciliation

A controller that reads current state and acts, rather than processing a delta. Section 7.2.

Linearizability

Every operation appears to take effect at one instant between invocation and response, respecting real time. Section 2.3.

Log Matching Property

If two Raft logs hold an entry with the same index and term, the entries and all preceding entries are identical. Section 2.1.

MSG_ZEROCOPY

A socket flag that transmits from pinned user pages, with completion reported on the error queue. Section 1.2.

MVCC

Keeping several row versions so readers never block writers. Section 3.4.

No-op entry

An empty log entry a new Raft leader appends so it can commit entries from earlier terms safely. Section 2.1.

Outbox pattern

Writing an event to a table in the same transaction as the state change, then relaying it. Section 2.4.

PagedAttention

Managing the key and value cache in fixed-size blocks with a per-sequence block table. Section 9.1.

Path validation

A QUIC challenge and response proving that an endpoint can receive at a claimed new address. Section 1.1.

Pipeline bubble

The idle fraction in pipeline parallelism, equal to p minus 1 over m plus p minus 1. Section 9.2.

pivot_root

A system call that replaces the root mount and detaches the old one, unlike chroot. Section 7.1.

Power of two random choices

Sampling two backends and sending to the less loaded, which cuts maximum load exponentially. Section 5.2.

Prefix caching

Sharing key and value cache blocks between sequences with a common prefix, by reference count. Section 9.1.

Product quantization

Compressing a vector by splitting it into sub-vectors and replacing each with a codebook index. Section 9.3.

R to Z

Reciprocal rank fusion

Combining ranked lists by summing one over k plus rank, needing no score normalization. Section 9.3.

Rendezvous hashing

Picking the node with the highest hash of key combined with node identifier, with no ring structure. Section 3.2.

Request coalescing

Sending one origin request for a key and fanning the response out to every waiting client. Section 6.2.

Retry budget

A hard cap on retries as a fraction of total requests, which keeps the amplification loop below gain one. Section 5.2.

RoCE

RDMA over converged Ethernet, which needs a near-lossless fabric with priority flow control. Section 1.2.

RUM conjecture

A structure optimizes at most two of read overhead, update overhead, and memory overhead. Section 3.1.

Saga

A sequence of local transactions with compensating business actions, replacing a distributed transaction. Section 2.4.

Seccomp

A BPF program evaluated on every system call, returning allow, error, kill, trap, log, or notify. Section 7.1.

sendfile

A system call that moves bytes from a file descriptor to a socket without entering user space. Section 1.2.

Session ticket key

The server key that encrypts session tickets, which takes back the handshake's forward secrecy until rotated. Section 1.4.

Speculative decoding

Using a draft model to propose tokens and the full model to accept or reject them in one pass. Section 9.1.

SPIFFE

A workload identity standard with URI-named identities carried in short-lived documents. Section 5.1.

Stale-while-revalidate

Serving a stale cached response immediately while fetching a fresh one in the background. Section 6.2.

Surrogate key

A label attached to cached responses so that one purge invalidates every response carrying it. Section 6.2.

Tail sampling

Deciding whether to keep a trace after it completes, so errors and slow traces are kept. Section 8.1.

Tied request

Two copies of a request sent at once, each able to cancel the other once one starts work. Section 8.3.

Tiered storage

Moving closed log segments to object storage while keeping recent segments local. Section 4.1.

Token bucket

A limiter with tokens refilling at a rate up to a capacity, permitting a burst and no sustained overload. Section 6.1.

Token translation

Validating an external credential at the edge and minting a short-lived narrowly scoped internal one. Section 6.3.

TrueTime

A clock that returns an interval rather than an instant, with a guarantee that true time lies inside it. Section 2.3.

Upcasting

Converting an old event version into the current one at load time. Section 4.2.

Vector clock

One counter per node, which distinguishes happened-before from concurrent. Section 2.3.

Virtual node

Many ring positions per physical node, which flattens a consistent hashing distribution. Section 3.2.

Waypoint proxy

The optional per-namespace layer 7 proxy in an ambient mesh. Section 5.1.

Wide event

One arbitrarily wide structured record per unit of work, with context injected at write time. Section 8.1.

Write skew

Two transactions read overlapping rows, write disjoint rows, both commit, and break a shared invariant. Section 3.4.

XDP

An eBPF hook inside the network driver, before socket buffer allocation. Section 1.2.

ZeRO

Sharding optimizer state, gradients, and parameters across a data-parallel group. Section 9.2.

ztunnel

The per-node layer 4 proxy in an ambient mesh. Section 5.1.