Glossary

240 terms, in the sense this mechanism uses them. The platform glossary has every term across all mechanisms.

Absorption point: A deliberate durable buffer where backpressure ends, so it cannot travel further upstream.
Ack (acknowledgement): A reply meaning "I received it" or "I finished it".
Acknowledgement (ack): A small reply that means "I got it" or "I finished it". A nack means "I could not handle it". Almost every reliable protocol uses acks, and almost every bug here is about when an ack is sent and whether it arrives.
Adaptive concurrency limit: A limit that lowers itself when latency rises above the observed no-queue baseline.
Admission control: Declining new work before any resources are committed to it.
AES-NI: CPU instructions that make AES encryption very fast.
Affinity routing (sticky sessions): Sending related requests to the same instance to use its local state or warm cache.
Aging: Raising a waiting task's priority over time to prevent starvation.
Aligned barrier: A checkpoint method where an operator waits for the barrier on all inputs before taking its snapshot.
Anycast: Routing to the nearest of several identical endpoints; a placement mechanism, not a transport.
Application-level keep-alive: Periodic pings sent by the application (HTTP/2 PING, gRPC keepalive) to keep an idle connection open and test it.
Arrival rate (λ): Number of new requests per second entering the system.
Async replication: The primary acknowledges after its own commit, without waiting for replicas; loss window equals replica lag.
At-least-once: Delivery where a message may arrive more than once; arises from processing before acking.
At-most-once: Delivery where a message may be lost but never repeated; arises from acking before processing.
Auto-commit: Periodic automatic offset commit by a consumer client; gives at-most-once if processing is not finished.
Backfill: Running a workflow for past intervals by iterating over the interval key space.1 other meaning →Going back over existing data to fill in or fix a value. Example: a new column exists, and a backfill job computes it for the last three years of rows.
Backpressure: A signal from a consumer, based on its actual state, that makes the producer slow down.If a slow step cannot keep up, it tells the step before it to slow down, and that step tells the one before it, until the source stops reading. We study this in Part 8.
Balls-in-bins variance: The random imbalance that appears when M items are placed at random into N bins.
Barrier: A marker injected into the stream that tells each operator when to snapshot its state.1 other meaning →
Batching: Handling many records per operation to spread a fixed cost; a batch fails as a unit.Doing many small things as one bigger operation, to pay a setup cost only once. Carrying all the shopping in one trip instead of one item per trip.
Binlog / oplog: MySQL's and MongoDB's change logs, equivalent to the PostgreSQL WAL.
Bisect (batch): Retrying the halves of a failed batch to find the one bad record.
Blast radius: The part of the system or the number of users affected when one failure happens.How much damage one mistake or one stolen secret can cause.
Block framing: Writing independently readable blocks, each with a recognizable sync marker, so a binary file can be split at block boundaries.
Bounded-load consistent hashing: Consistent hashing with a cap of (1+ε) × average load per node; overflow goes to the next node.
BREACH / CRIME: Attacks that learn secret content by watching how the size of compressed-then-encrypted data changes.
Broadcast join: A join that copies the small side to every executor so the large side does not move.
Broker: A service that holds records between producers and consumers.A broker (for example Kafka) is a server that stores a stream of messages. A topic is one named stream. Producers append to it. Consumers read from it, each at its own speed, sometimes days later.
Broker-side filtering: The broker evaluates each subscriber's predicate, so the subscriber receives only matching records.
Bufferbloat: Excess latency caused by large buffers that stay full, with no gain in throughput.
Bulk transfer: Moving data as files dropped at a location, picked up later.
Bulkhead: A partition of resources so a failure in one part cannot consume the resources of another.
Cardinality: The number of distinct values a label can take. The series count is the product over all labels.2 other meanings →The number of distinct things in a set. "20 million files" is a statement about cardinality. Metadata size follows cardinality (how many objects), not bytes.
Cell: An independent full copy of a service serving a subset of customers to limit blast radius.
Chandy-Lamport: Algorithm for taking a consistent snapshot of a running distributed system without stopping it.
Change data capture (CDC): Turning a database's changes into a stream of records.A feed of every change (insert, update, delete) made to a database table, delivered as a stream of events.
Check-then-act: Reading state and then acting on it in two steps; a race when two actors do it at once.
Checkpoint: A saved snapshot of all operator state plus source offsets.1 other meaning →A saved snapshot of a job's state plus its position in the input, written to durable storage (storage that survives a crash). After a crash the job loads the last checkpoint and continues from there.
Chunked encoding: HTTP/1.1 framing where the body is sent as chunks, each with its own size, ending with a zero-size chunk.
Circuit breaker: A mechanism that stops calls to a failing dependency (closed, open, half-open).
Co-partitioned join: A join of two streams partitioned by the same key with the same N, done partition by partition.
Codec: An algorithm that compresses and decompresses data (LZ4, Zstd, gzip, Snappy).
CoDel: Controlled delay: drop when the minimum queueing delay stays above a target.
Commit interval: How often a consumer records progress; sets the duplicate blast radius.
Commutative: Two operations give the same result in either order (for example two decrements).A combining operation is associative if grouping does not matter: (a + b) + c = a + (b + c). It is commutative if order does not matter: a + b = b + a. It is invertible if you can undo it: subtract to undo an addition. Sum and count have all three properties. Maximum is associative and commutative but not invertible. Median has none of the three in a useful form. These properties decide how cheaply an aggregate can be computed piece by piece.
Compacted log: A log in which only the newest entry per key is kept.
Composite key: A key made of several fields, e.g. (tenant_id, timestamp), to combine distribution and locality.
Congestion window (cwnd): TCP's estimate of how much the network path can carry.
Consistent hashing: Mapping keys and nodes onto a ring so a membership change moves only about K/N keys.Consistent hashing is a way to map keys onto nodes so that adding or removing a node moves only a small part of the keys. A CRDT (conflict-free replicated data type) is a data structure designed so that copies edited independently can always be merged to the same result. Last-write-wins resolves two conflicting versions by keeping the one with the later timestamp and discarding the other.
Consumer: A program that receives and processes records.A producer is a program that creates data and sends it somewhere. A consumer is a program that receives it and does something with it. A record (or message, or event) is one unit of data: for example, "order 4711 was placed". A broker is a middle service that holds records between producers and consumers (Kafka, RabbitMQ and Amazon SQS are brokers).
Consumer group: A set of consumers that share the partitions of a topic.
Content-based routing: Choosing the destination from the content (fields) of the record.
Control plane: The layer that sends commands and receives status; it moves no data.The data plane is where the real data moves (storage, Spark, the warehouse). The control plane is the layer that only sends commands and receives status. The orchestrator is a control plane.
Credit-based flow control: A scheme where the consumer gives the producer credits for the buffers it can accept.
Custody question: Who holds a record now, who holds the knowledge that it was handled, and what happens if that party disappears.
Data plane: Where the real data is stored and moved.The data plane is where the real data moves (storage, Spark, the warehouse). The control plane is the layer that only sends commands and receives status. The orchestrator is a control plane.
DDL: Statements that change a table's shape (ALTER, DROP, TRUNCATE).DML (data manipulation language) is INSERT, UPDATE, DELETE. DDL (data definition language) changes the shape of the table: ALTER TABLE, DROP COLUMN, TRUNCATE.
Dead-letter queue (DLQ): A holding area for records rejected by validation.A place where a pipeline puts records it could not process or did not accept, so they are kept instead of lost.
Deadline propagation: Passing the remaining time budget of a request down the call chain so each hop can drop expired work.
Dedup window: The time for which deduplication state is kept; duplicates after it are undetectable.
Delayed ACK: A receiver holding its acknowledgment (up to about 40 ms) hoping to send it together with data.
Delimited framing: Message boundaries marked by a delimiter byte such as a newline.
Delivery semantics: How many times the transport hands a record to the consumer.
Dictionary compression: Compression with a pre-trained shared dictionary, which helps small messages that have no history to refer to.
Dimension table: A reference table used to enrich records (for example seller details).
Disk: Durable storage. A write normally sits in the operating system's page cache first and reaches the disk later; fsync forces it there. Data only in the page cache is lost if the machine loses power.When a program writes a file, the operating system usually keeps the data in memory first (the page cache) and writes it to the disk later. A call named fsync forces the data onto the disk and waits until it is there. Data that is only in the page cache is lost if the machine loses power. Replication (copies on other machines) is the other way to survive a crash.
Drop-oldest: A full-policy that discards the oldest record to keep fresh data.
Dual-write: Writing both the old and the new field during expand/contract.
Duplicate blast radius: The amount of work repeated after a crash, set by the commit interval.
Early binding: Checking the format when data is written, so errors appear in the producer.Binding means fixing the structure and meaning of data. Early binding: decide at load time ("this column is the customer's region"). Late binding: store raw facts and decide at read time. Early binding makes reads simple and changes expensive. Late binding makes changes cheap and reads complex.
Effectively-once: At-least-once delivery plus an idempotent or deduplicating consumer.
End-to-end argument: A guarantee that must hold end to end can only be implemented at the endpoints.
End-to-end compression: Compressing once at the producer and decompressing once at the consumer, with intermediaries forwarding the compressed bytes.
Epoch: A number that increases at every leadership change and lets others reject stale leaders.2 other meanings →A whole number that increases each time leadership changes. "Epoch 7" means "the seventh leadership period". Every action is stamped with the epoch, so old leaders can be recognized and ignored.
Exactly-once: Each message's effect happens once; real only within one system's transaction boundary.A processing guarantee that each input affects the result exactly one time, even when machines crash and retry. It is hard; we will only need the two basic ideas (idempotence, and committing a position together with the state) when it appears.
Exhaustion policy: What a connection pool does when no connection is free: block forever, block with a timeout, or reject.
Fail-degraded: Keeping all work and becoming slower.Two ways to react to an error. Fail-fast: stop and report at once. Fail-degraded: continue with reduced quality (for example, show old data with a warning).
Fail-fast: Refusing some work early to stay healthy.Two ways to react to an error. Fail-fast: stop and report at once. Fail-degraded: continue with reduced quality (for example, show old data with a warning).
Fail-open / fail-closed: What a limiter does when its store is down: allow all, or reject all.
Fan-in / fan-out: Many senders to one receiver / one sender to many receivers.
Fixed window counter: A rate limiter that counts per clock window; allows boundary bursts.
Frame: One message plus whatever the receiver needs to find its end in a byte stream.1 other meaning →
Framing: The method that lets a receiver find message boundaries inside a TCP byte stream.
fsync: System call that pushes a file's data and the device cache to durable media.A system call that asks the OS: "push my file's cached data all the way to the device, and ask the device to empty its own cache too." It is the main tool to make data durable. It is also slow, because it waits for the physical device.
Full jitter: Sleeping a random time between 0 and the current backoff cap.
Full-policy: The rule for what a buffer does when it is full.
Goodput: Completed work whose result is still wanted.Throughput is work completed per second. Goodput is work completed per second whose result is still wanted. If a client has already given up (timed out), finishing its request adds throughput but no goodput.
Group commit: Many transactions share one log flush.
Half-open connection: A connection that one side considers alive while the other side has already forgotten it.
Hard / soft affinity: Hard: correctness requires the placement. Soft: placement is a preference and falls back to any node.
Hash function: A function that turns a value into a large, evenly spread number; the same input gives the same output.A function that turns any key (a string, a number) into a number that looks random. The same key always gives the same number. Two different keys can give the same number; this is a collision.
Head-based / tail-based sampling: Deciding to keep a trace at the start, or after seeing its outcome.
Head-of-line blocking: An item at the front of a queue blocking all items behind it.
Heartbeat: A periodic message used to detect whether the other side is alive and working.A timeout is a rule: "if no answer comes within T, assume something is wrong." A heartbeat is a small message a node sends every few hundred milliseconds to say "I am alive". Another node that stops receiving heartbeats starts to suspect the sender.
Highly composite number: A number with many divisors (12, 24, 60, 360), useful as a partition count.
Hotspot: One destination that receives far more load than the rest, e.g. the last range with sequential keys.
Idempotency by replacement: Making a rerun harmless by overwriting a whole partition or swapping a table atomically.
Idempotency key: Unique identifier of an intent, used to make retries safe.
Idempotency-Key header: HTTP header with which a client lets an API deduplicate repeated requests.
Idempotent: Doing it twice has the same effect as doing it once.An operation is idempotent if doing it twice has the same effect as doing it once. "Set the order status to SHIPPED" is idempotent. "Add 1 to the stock counter" is not. Idempotence is the main tool for living with duplicates.
Idempotent producer: A producer whose retries are de-duplicated and order-preserving through broker-tracked sequence numbers.
Identity decoupling: The producer does not know who consumes.
Incremental checkpoint: Continuous flushing so the checkpoint position moves smoothly.
Jitter: Randomness added to waiting times to avoid synchronized clients.
Key skew: One key has far more records than the others; no hash can split it.
kTLS: Kernel TLS: encryption done inside the kernel, which keeps zero-copy possible.
Last-writer-wins: Conflict rule: when two versions arrive, keep the one with the higher version or timestamp.
Late binding: Checking the format only when data is read, so errors appear in the consumer, far from the cause.Binding means fixing the structure and meaning of data. Early binding: decide at load time ("this column is the customer's region"). Late binding: store raw facts and decide at read time. Early binding makes reads simple and changes expensive. Late binding makes changes cheap and reads complex.
Latency: Time one operation takes from request to response.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
Latency bomb: An unbounded queue that makes every record stale before it is processed.
Leaky bucket: A limiter that drains requests at a fixed rate, producing smooth output.
Length-prefixed framing: Each message starts with a header giving its byte length.
Lineage: The map of which assets feed which.A map of what feeds what: table A is read by job J, which writes table B. Following the map shows what would be affected if A changes.
Linger (linger.ms): The time a producer waits to fill a batch before sending it.
Little's Law: L = λW: average items in a system = arrival rate × average time in the system.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
Load shedding: Deliberately dropping work already accepted to keep the rest healthy.
Log (append-only log): A stored ordered sequence of records; consumers track their own offset.An event is a small record: "order 77 placed by user 12 at 12:03:04". A log is an append-only file or service: new events are added at the end, and old events are never changed. A topic is a named log (the word comes from systems like Apache Kafka). Every event has an offset, its position in the log (0, 1, 2, …). A reader remembers "I have read up to offset 5,000", and can go back to offset 3,000 and read again. This ability to replay is the foundation of this whole mechanism. A log keeps events for a configured time (retention), for example 7 days, then deletes the oldest ones.
Logical replication: Replicating row-change events; works across versions and allows filtering.
Logical shard (vnode, slot, bucket): One of a large fixed number of units to which keys map; logical shards are then mapped to physical nodes.
Long polling: A pull request that the broker holds open until data arrives or a timeout expires.
Lost-ack ambiguity: The sender cannot tell "not done" from "done but the reply was lost".
Low watermark: A marker saying no record older than a given time will still arrive.
Maximum frame size: A limit on declared message length, checked before allocating memory, to prevent out-of-memory attacks.
Metastable failure: A failure that persists after its trigger is gone because retries keep the system overloaded.
Micro-batching: Time-based batching with a very short interval (about 100 ms to seconds).
Modulo (%): The remainder after division; used to map a hash to one of N destinations.
mTLS (mutual TLS): TLS where both client and server prove their identity with certificates.
Multicast: One send delivered to many receivers by the network, usually over UDP.
Multiplexing / demultiplexing: Carrying many logical streams over one channel and separating them at the other end.
Nagle's algorithm: Do not send a small segment while an earlier small segment is unacknowledged; coalesces small writes.
Natural idempotency: An operation that is repeatable by construction (upsert, overwrite, PUT).
Offset: A consumer's position in a partition (one integer).An event is a small record: "order 77 placed by user 12 at 12:03:04". A log is an append-only file or service: new events are added at the end, and old events are never changed. A topic is a named log (the word comes from systems like Apache Kafka). Every event has an offset, its position in the log (0, 1, 2, …). A reader remembers "I have read up to offset 5,000", and can go back to offset 3,000 and read again. This ability to replay is the foundation of this whole mechanism. A log keeps events for a configured time (retention), for example 7 days, then deletes the oldest ones.
Outbox (transactional): Table written in the same transaction as the state change, relayed to a broker later.
Overpartitioning: Choosing more partitions than needed now, so consumers can be added later without repartitioning.
Pacing: Spreading sends evenly over time, instead of in bursts.
Page cache: The kernel's cache of file pages.When a program writes a file, the operating system usually keeps the data in memory first (the page cache) and writes it to the disk later. A call named fsync forces the data onto the disk and waits until it is there. Data that is only in the page cache is lost if the machine loses power. Replication (copies on other machines) is the other way to survive a crash.
Partition: One ordered slice of a topic that can be stored and read in parallel.3 other meanings →A topic is a named stream of records ("orders"). Big topics are cut into partitions: separate ordered lists that can be stored and read in parallel. Records in one partition have a fixed order. Across partitions there is no shared order.
Partition skew: Keys spread unevenly across partitions even though no key is large.When some partitions hold much more data than others, work is not shared evenly. The job ends only when the biggest partition ends.
Percentile (p50, p99, p99.9): The value below which that fraction of observations fall.p50 is the median latency, p99 is the latency that 99% of requests beat. The slowest requests are the tail. When one request needs answers from many servers (a fan-out) it must wait for the slowest one. With 100 servers that each have a 1% chance of being slow, the chance that at least one is slow is 1 − 0.99¹⁰⁰ = 63%. So the user-facing tail is much worse than any single server's tail.
Phi-accrual failure detector: A failure detector that outputs a suspicion level from the distribution of heartbeat intervals instead of a fixed timeout.
Physical replication: Replicating bytes or pages exactly; fast but needs identical versions.
Point-to-point: Each record goes to exactly one consumer of a named channel.
Pool exhaustion: The state where all pooled connections are in use.
Prepared transaction: A durable, invisible write waiting for a later commit; it has a timeout.
Primary (leader): The replica that accepts writes and sends them to the followers. Followers apply them a little later (replication lag), so a read from a follower can return older data.A replica is another copy of the same data on another machine. The primary (also leader) accepts writes and sends them to the followers. Followers apply the writes a little later. The delay is replication lag. A read from a follower can therefore return older data than a read from the primary.
Primary key: A unique, non-null identifier for each row.Rules a database can enforce. A primary key says each row has a unique, non-null identifier. A unique constraint says no two rows share a value. A foreign key says a value must exist in another table (for example every orders.customer_id must exist in customers). A check constraint says a row must satisfy a predicate.
Priority inversion: A high-priority task effectively runs at lower priority because it waits for a resource held by a lower one.
Priority routing: Serving high-priority records first, through separate queues, a priority queue, or admission control.
Processing semantics: How many times the effect of a record happens in the world.
Producer: A program that creates and sends records.A producer is a program that creates data and sends it somewhere. A consumer is a program that receives it and does something with it. A record (or message, or event) is one unit of data: for example, "order 4711 was placed". A broker is a middle service that holds records between producers and consumers (Kafka, RabbitMQ and Amazon SQS are brokers).
Pub/sub (publish/subscribe): Producers publish to a topic and every subscriber gets a copy.
Pull: The consumer decides when and how much to fetch.
Push: The broker decides when to deliver.
Queue: A line of work waiting for its turn, like people waiting at a bank counter. A scheduler is the part of a system that decides who is served next.1 other meaning →
QUIC: A transport protocol that makes streams independent, used by HTTP/3.
Quorum: A majority of replicas.A quorum is a group of nodes big enough that its answer counts. The usual quorum is a majority: more than half. With 5 nodes, any 3 form a majority. The key fact: any two majorities of the same set share at least one member. Why? If two groups of 3 from 5 nodes had no member in common, they would need 6 different nodes, but there are only 5. This is the pigeonhole principle. It is arithmetic; it uses no clock and holds however slow the network is. We use it again and again.
Range partitioning: Sending each record to the node that owns its key range; makes a global merge a concatenation.
Rate limiting: A declared hard cap on the accepted rate at a boundary.
RDMA: Remote Direct Memory Access: reading/writing another machine's memory without using its CPU.
Re-sequencing: Buffering out-of-order records at the sink until gaps fill, using sequence numbers.
Reactive pull: The consumer asks for work only when it has capacity, giving backpressure by structure.
read_committed: Kafka consumer setting that hides records of aborted or open transactions.
Rebalance storm: Repeated consumer-group rebalances caused by evictions that are themselves caused by rebalances.
Receive window (rwnd): TCP: the free buffer space the receiver announces.
Reconciliation count: A comparison of record counts at source and sink over a window to detect loss.
Record: One unit of data sent from a producer to a consumer, such as "order 4711 was placed"; also called a message or an event. A broker holds records between the two.A producer is a program that creates data and sends it somewhere. A consumer is a program that receives it and does something with it. A record (or message, or event) is one unit of data: for example, "order 4711 was placed". A broker is a middle service that holds records between producers and consumers (Kafka, RabbitMQ and Amazon SQS are brokers).
Rendezvous (HRW) hashing: Choosing for each key the node with the highest hash(key, node); minimal disruption, O(N) lookup.
Replay: Re-reading records that were already processed.
Replay storm: Overload caused by reprocessing a backlog at full speed after an outage.
Replica: A copy of the same data on another machine. The primary takes writes and the followers apply them a little later, so a follower can lag behind.A replica is another copy of the same data on another machine. The primary (also leader) accepts writes and sends them to the followers. Followers apply the writes a little later. The delay is replication lag. A read from a follower can therefore return older data than a read from the primary.
Replication slot: A bookmark that makes a primary keep log until a consumer has read it.
Reprocess: Running historical data through new code.
Request smuggling: An attack that exploits two hops disagreeing about where an HTTP request ends.
Retention: How long a log keeps records before deleting them.
Retry: If an ack does not arrive within some time, the sender gives up waiting (a timeout) and often sends again (a retry). Retrying is useful, but it can create duplicates, as you will see.
Retry budget: A limit that allows retries only up to a fraction of recent successful requests.
Round trip (RTT): The time for a message to reach the other side and the answer to come back: about 0.2–1 ms inside a datacenter, 70–250 ms between continents, against about 100 ns for a memory read.Latency is how long one operation takes. Throughput is how much work finishes per second. A round trip (RTT, round-trip time) is the time for a message to reach the other side and for the answer to come back. Inside one datacenter an RTT is about 0.2–1 ms. Between continents it is 70–250 ms. A memory read takes about 100 ns, so a network round trip inside a datacenter is roughly 10,000 times slower.
Round-robin: Assigning records to destinations in a repeating cycle; perfect balance, no locality.
RPC: Remote procedure call: calling a function on another machine and waiting for the reply.
RTT (round-trip time): Round-trip time.Machines talk by sending messages over a network. A message may be late, may arrive twice, may arrive out of order, or may never arrive. The round-trip time (RTT) is the time from sending a request until the reply returns. RTT depends strongly on distance:
Saga: Sequence of local transactions with compensators; no atomicity, no isolation.
Salting: Adding a random suffix to a hot key so it splits into k sub-keys.
Scatter-gather: Fanning a request out to N shards and waiting for their answers.To query a dataset split over many machines (shards), a coordinator sends the query to the shards (scatter) and merges the answers (gather). The query is finished only when the slowest shard answers, so the latency of the whole is the maximum over shards. Slow outliers (the "tail", measured by percentiles such as p99, the time that 99% of requests beat) therefore hurt more as you add shards.
Schema: The description of the shape of a record: fields, types, optionality.A description of the shape of a record: which fields (also called columns) exist, what type each has (integer, text, timestamp, ...), and which ones may be missing. Example: a shipment event has shipment_id (text), status (text), weight (number), occurred_at (timestamp).
Semi-synchronous replication: The primary waits until a replica has received the record.
sendfile() / splice(): System calls that move data from the page cache to a socket without copying it through user space.
Serialization: Turning in-memory values into a flat sequence of bytes.Programs hold values in memory (objects, structs, lists). To send them over a network or store them in a file, you must turn them into a flat sequence of bytes. This is serialization; the reverse is deserialization (or decoding). JSON is a serialization format. So are Protocol Buffers (Protobuf), Avro and Thrift.
Service rate (μ): Work a consumer can finish per second.
Session resumption: Reusing earlier TLS handshake state to make a new connection cheaper.
Shard key: The field that decides which shard stores a record.
Sharding: Partitioning applied to stateful storage, where data physically lives on the destination.
Shared commit substrate: The one system that decides whether a commit happened; the boundary of any atomic guarantee.
Side-effect boundary: The point where an effect leaves the system that provides guarantees.
Sliding window counter: A limiter that interpolates between two fixed windows; O(1) memory and no boundary spike.
Sliding window log: A limiter that stores every request timestamp; exact but costly.
SLO: Service level objective, for example "99% of requests under 100 ms".A service level objective is a target such as "99% of requests finish in under 100 ms."
Snapshot-stitch: Combining an initial table copy with subsequent changes without gaps or ordering errors.
Sneakernet: Moving data by physically shipping disks.
Splittability: Whether a reader can start at a random offset and find the next record boundary.
Standing queue: A queue that never drains, as opposed to a short burst.
Starvation: One class of work is never served while the system is otherwise busy.
Sticky partitioner: Kafka producer strategy: random partition choice, but batch-wise, for better batching.
Streaming RPC: An RPC with a long-lived stream of messages and window-based flow control.
Sync marker: A recognizable byte sequence that marks the start of a block in a binary file.
Synthetic idempotency: Idempotency created with an explicit key and dedup state.
TCP: The protocol that gives programs a reliable, ordered stream of bytes over the unreliable internet. Almost all HTTP, database and broker traffic uses it. A connection is one TCP conversation between two programs.
TCP keepalive: Operating-system probes on idle connections; the default delay is 2 hours.
TCP_NODELAY: A socket option that turns off Nagle's algorithm so small writes are sent at once.
Throttling: Graduated slowing under load, a slope instead of a cliff.
Throughput: Work completed per unit of time.Throughput is work finished per second. Latency is how long one operation takes. Little's Law links them to the number of operations in progress: L = λ × W, where λ is the arrival rate (per second), W is the average time one operation spends in the system, and L is how many are inside the system at the same time. Example: 1,000 requests per second, each taking 20 ms (0.02 s), means 1,000 × 0.02 = 20 requests in flight at any moment. This is an identity, not a design choice.
Timeout: The maximum time a caller waits before giving up.A timeout is the longest a caller waits for a reply before giving up. A retry is sending the same request again after a failure or timeout. Retries help when the failure was a rare accident. They add load when the failure is caused by overload.
TLS 0-RTT: TLS 1.3 resumption that sends data in the first flight; the data can be replayed, so use it only for idempotent requests.
TLS termination: The point where encrypted traffic is decrypted; it defines the trust boundary.
Token bucket: A limiter that adds tokens at rate R up to capacity C; allows bursts up to C.
Tombstone: A marker record that says a key was deleted; must outlive every older copy.
Topic: A named stream of records.A topic is a named stream of records ("orders"). Big topics are cut into partitions: separate ordered lists that can be stored and read in parallel. Records in one partition have a fixed order. Across partitions there is no shared order.
Trailer: Metadata sent after the body of a message (for example gRPC status).
Trust boundary: The edge of the network region you trust without further encryption or authentication.
Two Generals problem: The proof that two parties cannot be certain they agree over an unreliable channel.
Two-phase aggregation: Partial aggregation, a shuffle of partials by group key, then a final merge.
Two-phase commit (2PC): Prepare then decide; participants give up the right to abort after voting yes.A way to make a change appear in two places atomically (all or nothing). Phase 1: every participant prepares and promises it can commit. Phase 2: when all have promised, everyone commits. If any participant says no, everyone aborts. Until phase 2, the change stays invisible.
Unaligned barrier: A checkpoint method that snapshots immediately and stores in-flight records.
Upsert: Insert-or-replace by key.A primary key is a column (or set of columns) whose value is unique per row. An upsert means "insert this row, or update it if the key already exists". In SQL: INSERT ... ON CONFLICT (order_id) DO UPDATE ....
Utilization (ρ): The fraction of time a resource is busy.Utilization (ρ, "rho") is the fraction of time a server is busy. For random arrivals, average response time grows like S ÷ (1 − ρ), where S is the service time: 2×S at 50%, 5×S at 80%, 10×S at 90%, 100×S at 99%. Queues are caused by variability meeting load, and the curve has a wall at 100%. The last few percent of utilization cost more than the first eighty.
Validate on borrow: Testing a pooled connection before handing it out.
Version-based application: Applying a record only if its version is higher than the stored one.
Versioned tombstone: A delete marker carrying a version, so a late-arriving older insert cannot resurrect the row.
Virtual node (vnode): Many ring points per physical node so load evens out as 1/√V.
Visibility timeout: The time a delivered message stays hidden before the broker redelivers it if not acked.
Watermark: Declared non-decreasing lower bound on the event times of future arrivals.1 other meaning →Every event carries a timestamp of when it happened (event time), which differs from when the job sees it (processing time). Events arrive late and out of order: a phone with no signal sends its events 5 minutes after they happened. A watermark is a marker flowing through the stream that says "no event with a timestamp earlier than T should arrive any more." It is the job's best guess of how complete the input is. When the watermark passes the end of a time period, the job may treat that period as complete. Watermarks are a guess, and late events can still violate them. The rules of when it is correct to emit a result (event time versus processing time, how late is too late) are a topic of their own. In this mechanism we need only the idea above. We study the machinery that holds data until the watermark allows an answer.
Weakest-link rule: A chain of hops has the semantics of its weakest hop.
Weighted fair queueing: Each priority class gets a guaranteed share of capacity; unused share is redistributed.
Windowing: Assigning records to computation periods by event time; different from batching.
Write-ahead log (WAL): Write-ahead log: ordered, append-only description of changes, forced before commit.Before a database changes its data pages, it first appends a description of the change to a sequential file called the log. If the machine crashes, the database replays the log to recover. Every serious database has one (it may be called WAL, redo log or binlog). Each position in the log has an increasing number, called an LSN (log sequence number; other systems call it SCN or GTID). In this mechanism the key fact is: the log is a complete, ordered record of every change, and it already exists..
Write-Audit-Publish: Write to staging, check with assertions, then atomically publish.
Zero-copy: Sending stored bytes to a socket without copying them through user space.1 other meaning →
Zombie consumer: A replaced consumer that has not noticed and still writes.
Zstd: Modern general-purpose compressor with a fast decoder at every level.
δ-CRDT: A state-based CRDT that ships only the recent change instead of the whole state.