Distributed Systems Reliability Vocabulary

a relationship between two operations that establishes ordering constraints, such as process, write-read, or real-time dependency

“The audit log had a write-read dependency on the transaction table.”

an operation return indicating the operation definitely did not happen, such as a transaction abort

“The rollback produced a definite error, confirming the transaction never committed.”

an operation return where the outcome is uncertain; the operation may or may not have executed, exemplified by timeouts

“The timeout was an indefinite error — we couldn't tell if the payment had gone through.”

a condition identifying a set of objects rather than a single item, such as all rows matching a WHERE clause

“The query used a predicate to select all orders placed in the last 24 hours.”

a logically single-threaded state machine participating in a distributed system

“Each process maintained its own local view of the shared state.”

a relationship between subsequent operations performed by the same process

“The two writes shared a process dependency, so the second could not precede the first.”

a relationship between operations where one ends before another begins

“The commit established a real-time dependency — the read couldn't have happened before the write completed.”

a relationship where operation A reads a version and operation B writes the next version of the same object

“A read-write dependency chained the cache read to the subsequent database update.”

a relationship between operations within a session performed in total order

“Session dependency guaranteed that a user always saw their own writes in order.”

a specific state an object assumes at a point in time during execution

“Each transaction operated on a snapshot version of the data.”

an ordering over object versions encoding the sequence each object progressed through

“The version order made it possible to detect which writes were overwritten by others.”

a relationship where operation A writes a version that operation B subsequently reads

“A write-read dependency meant the read was only valid after the write had committed.”

a relationship where operation A writes a version that operation B overwrites

“The write-write dependency revealed a potential lost update between two concurrent transactions.”

a set of allowed histories constraining which operations are permissible and their ordering

“Choosing a consistency model involves fundamental tradeoffs between safety and availability.”

ensures all processes observe causally related operations on objects in identical order across the system

“With causal consistency, a reply always appears after the message it responds to.”

after updates cease, sufficient time and messaging ensure every node reaches identical final values

“DNS propagation relies on eventual consistency to spread updates globally.”

a collection of operations performed by a system including process information and timing details

“Analyzing the operation history revealed a subtle ordering violation between two replicas.”

operations appear to execute atomically in a total order consistent with real-time ordering on single objects

“Linearizability is the gold standard for correctness in distributed registers.”

strengthens read committed by requiring that once a transaction observes another's effects, it observes all of them

“Monotonic atomic view prevents seeing half of a batch write across two reads.”

each process observes a monotonically advancing system view; once a write is observed, it remains visible

“Monotonic reads prevent a user from seeing a post disappear after they have already seen it.”

if a single process performs two writes, all other processes observe them in that same order

“Monotonic writes ensure version 2 never appears before version 1 on any replica.”

ensures atomic visibility of transaction updates; either all or none of a transaction's writes are observed

“Read atomic prevents seeing a funds debit without the corresponding credit.”

a consistency level that prohibits dirty writes, aborted reads, intermediate reads, and cyclic information flow

“Read committed is the default isolation level in PostgreSQL and many other SQL databases.”

one of the weakest consistency models; prohibits only dirty writes but permits dirty reads and other phenomena

“Read uncommitted is rarely used in production due to its extreme permissiveness.”

if a process writes a value, its subsequent reads must observe the effects of that write

“Read your writes guarantees a user sees the profile update they just submitted.”

strengthens read committed by additionally prohibiting single-object anti-dependency cycles

“With repeatable read, querying the same row twice in a transaction always returns the same value.”

all transactions appear to execute in some total serial order, prohibiting dirty writes, dirty reads, and anti-dependency cycles

“Serializability is required for correct execution of concurrent bank transfers.”

operations appear in a total order consistent with each process's order but not necessarily real-time order

“Sequential consistency was the memory model targeted by early shared-memory multiprocessors.”

each transaction receives an isolated snapshot of the database; it commits only if no concurrent writes exist to the same keys

“Snapshot isolation prevents most anomalies but still allows write skew.”

a broad term covering models including sequential, linearizable, and serializable consistency

“Strong consistency sacrifices availability during network partitions per the CAP theorem.”

strengthens serializability by requiring the apparent transaction order to match real-time order

“Strong serializability combines linearizability with serializability for the strictest correctness.”

strengthens serializability by additionally prohibiting session phenomena within each process

“Strong session serializability ensures a process always observes its own prior committed transactions.”

strengthens snapshot isolation by additionally prohibiting real-time phenomena

“Strong snapshot isolation prevents a transaction from appearing to commit before a real predecessor.”

reading a value seals the past; later writes must take effect after the writes that were observed

“Writes follow reads ensures a process cannot undermine causality by overwriting what it observed.”

an inconsistently defined term meaning either majority availability or total availability depending on context

“The SLA promised high availability, but the fine print defined it as majority-quorum operations only.”

every non-faulty node executes any operation even in the presence of node or network failures

“A totally available system continues serving reads even when a network partition occurs.”

operations execute when nodes comprise a majority and can communicate with one another

“Raft achieves majority availability: operations proceed as long as a quorum is reachable.”

a client receives a response if executing against state that reflects its past transactions, even during failures

“Sticky availability guarantees a shopping cart session remains consistent on the same server.”

a transaction observes part but not all of another transaction's writes, producing an inconsistent view

“Read skew caused the balance report to show funds debited but not yet credited.”

two transactions each write different objects, with each failing to observe the other's writes

“Write skew allowed two doctors to simultaneously go off-call, violating the one-on-call rule.”

one transaction writes two objects; another reads the current version of one but an older version of the other

“A fractured read made the invoice total inconsistent with its line items.”

transactions overwrite one another forming a cycle linked purely by write-write dependencies (G0)

“Dirty writes are prohibited by virtually every isolation level, including read uncommitted.”

an aborted transaction's write is visible to a committed transaction (G1a)

“An aborted read exposed a rolled-back price change to the billing system.”

a transaction reads a version from the middle of another transaction rather than its final committed write (G1b)

“An intermediate read showed a record in an inconsistent half-updated state.”

transactions observe or overwrite each other's writes in a cyclic pattern (G1c)

“Cyclic information flow was detected when two transactions each depended on the other's uncommitted data.”

a database returns an object version not produced by any write, often from corruption or race conditions

“A garbage read returned zeros for a record that had never been written to that address.”

a committed transaction's effects are lost due to another transaction's concurrent write to the same object (P4)

“Two users editing a wiki page simultaneously caused a lost update, discarding one set of changes.”

one transaction reads data written by another before that transaction has completed (P1)

“Dirty reads allowed seeing a password hash mid-update, exposing an invalid intermediate value.”

a transaction modifies data that another ongoing transaction previously read (P2)

“A non-repeatable read caused the reservation system to double-book a seat.”

one transaction modifies rows matching a predicate that another ongoing transaction had read (P3)

“A phantom appeared when a row matching the WHERE clause was inserted mid-transaction.”

an operation begins after another ends but appears to execute before the prior operation

“The replica returned a stale read — it had not yet received the leader's latest committed update.”

a node forgets information; total amnesia means forgetting everything, partial amnesia occurs after crashes

“After a cold restart with no persistent storage, the node suffered total amnesia.”

gradual storage corruption from cosmic rays, thermal stress, or media degradation over time

“The archival drive suffered bit rot after sitting unpowered in a warm closet for years.”

a node takes arbitrary actions including malicious ones; requires more than two-thirds loyal nodes for consensus

“Byzantine fault tolerance is essential in blockchain consensus protocols where nodes may be adversarial.”

a node stops executing code until it is restarted

“The primary crashed during the write, triggering an automatic failover to the replica.”

a failure model where a node stops executing and never recovers

“Crash-stop models simplify analysis because failed nodes are assumed permanently gone.”

a failure model where a node stops executing code and later restarts from durable state

“With crash-recover semantics, the node replayed its write-ahead log on restart.”

the difference in rates at which clocks advance, causing clock skew to increase over time

“Clock drift caused timestamps to diverge across nodes by hundreds of milliseconds per day.”

the instantaneous difference between clocks on different processes; affects correctness of systems relying on wall clocks

“Clock skew invalidated the TLS certificate check on the newly provisioned server.”

a storage fault where disk sectors are damaged and the error is detected or reported on read

“The RAID array flagged a latent sector error during its weekly integrity scrub.”

a storage system informs the layer above that a write occurred when it actually has not

“A lost write caused the database to believe a record was saved when the disk had silently dropped it.”

a storage system stores only part of a requested write, leaving data in a partially updated state

“A power failure mid-write produced a torn write, corrupting the file header.”

data read from memory differs from what was written, caused by cosmic rays or hardware defects

“ECC RAM detects and corrects single-bit memory corruption automatically.”

an arriving message differs from the sent message due to cable degradation or electromagnetic interference

“The checksum caught message corruption on the noisy industrial network.”

the time for a message to travel from sender to recipient; unbounded in asynchronous networks

“An unexpected message delay made the leader falsely suspect the follower had crashed.”

a single message arrives multiple times due to routers, retries, or log replays

“Idempotent operations protect against message duplication in at-least-once delivery systems.”

messages arrive in a different order from their sending due to variable latency in asynchronous networks

“Message reordering caused the follower to apply an update before its prerequisite arrived.”

a message is sent but never received; indistinguishable from infinite delay in asynchronous systems

“Message omission during the partition caused the replica to fall silently behind.”

a pattern of message omission where a network link loses all messages between two sets of nodes

“A network partition split the cluster into two halves that could not communicate.”

a process halts for some duration then resumes; in asynchronous systems, pauses can be indefinitely long

“A JVM garbage collection pause caused the leader to miss heartbeats and be dethroned.”

a storage device silently returns incorrect data for reads without signaling any error

“Storage corruption went undetected for weeks until a checksum mismatch surfaced.”

data is written to the wrong storage location, overwriting unrelated existing data

“A firmware bug caused a misdirected write that silently overwrote another table's page.”

a storage device returns data from the wrong location rather than the address requested

“A misdirected read returned a neighboring record's bytes instead of the requested block.”

tests that execute multiple logical operations simultaneously across system nodes to expose race conditions

“Concurrent testing exposed a race condition invisible to sequential test runs.”

encodes an operation history as a constraint problem for a SAT solver to find a legal interpretation

“Constraint programming verified that no valid serialization existed for the observed history.”

searches for dependency cycles in an operation history to demonstrate consistency violations

“Cycle detection in the dependency graph revealed a G2 anti-dependency anomaly.”

simulation testing using deterministic simulated layers, enabling exact reproduction of failures

“Deterministic simulation testing let engineers replay the exact sequence that crashed production.”

writing specific inputs with expected specific outputs, contrasting with generative property-based testing

“Example-based testing confirmed the known edge case was fixed, but missed the new one.”

deliberately injecting failures during a test to verify the system does not violate its invariants

“Fault injection tests confirmed the cluster recovered correctly after any single-node crash.”

submitting random inputs and verifying that specified properties hold across all of them

“Fuzz testing the parser uncovered a crash triggered by a specific Unicode sequence.”

generative testing that chooses interesting inputs using system feedback through oracles

“Guided search quickly found the rare interleaving that triggered the deadlock.”

a generative technique that transforms a test input and verifies the output's relationship to the original

“Metamorphic testing checked that sorting an already-sorted list produced the identical result.”

a component that provides information determining test correctness, such as detecting crashes or comparing to a reference

“The test oracle compared the distributed system's output to a single-node reference implementation.”

generates random inputs, applies them to the system, and verifies that a specified property always holds

“Property-based testing found an edge case where serialization failed for negative zero.”

a property-based testing technique that reduces a large failing input to the smallest case that still reproduces the failure

“Shrinking reduced a 10,000-operation failing trace to a minimal 3-step reproducer.”

simulates system components rather than using real hardware, networks, and operating systems

“Simulation testing allowed engineers to inject network partitions and clock skew deterministically.”