Glossary

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

A (atomic write unit): The largest write a device applies all-or-nothing across a power loss.
Ack (acknowledgement): A reply meaning "I received it" or "I finished it".
Adaptive flushing: Continuous background flushing whose rate follows checkpoint age (InnoDB).
Amplification: Extra bytes read, written or stored compared with what was logically needed.If you ask for 200 bytes and the system must move 4,096 bytes, the amplification is about 20. Read amplification means extra bytes read. Write amplification means extra bytes written. Space amplification means extra bytes stored. It is the hidden cost behind most slow systems.
Analysis pass: First ARIES recovery pass: rebuilds the dirty page table and active transaction list.
Append-only: A file or log where data is only added at the end.A store where you only add new rows and never change old ones in place. Most analytical stores work this way, because rewriting data in place is expensive on large files.
ARIES: A recovery algorithm for databases: analysis, redo of history, then undo with logged compensation.
Asynchronous replication: The primary acknowledges before any replica has the data.
Backup: A copy decoupled from production in time and authority, protecting against the data being wrong (not only a lost copy).
Barrier: A marker injected into the stream that tells each operator when to snapshot its state.1 other meaning →
Base + log: The pattern "a starting image plus the changes since": checkpoints, PITR, LSM, event sourcing.
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: The unit compressed independently; sets ratio, read amplification, blast radius and parallelism.1 other meaning →Storage hardware and databases do not read single bytes. They read fixed-size chunks called pages (or blocks), typically 4 KiB to 16 KiB on a local disk. To read one 200-byte row you must read its whole page.
Buffer manager: The component that caches pages in memory and decides when to write them.
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.
Checkpoint age: How far the log head is ahead of the oldest unflushed change.
Checksum: A small value computed from data, used to detect changes or corruption.
CLR (compensation log record): A log record describing an undo step, so that recovery never undoes the same change twice.
Compound transaction: A batch of filesystem changes committed together in the journal.
Copy-on-write: Writing a new copy of a unit and swapping a pointer instead of changing the old bytes.Two ways to handle a delete or update in immutable storage. Copy-on-write: rewrite the whole data file without the deleted rows. Merge-on-read: write a small side file (a delete vector or tombstone, a note that says "row 17 of file X is deleted") and let every reader apply it. Copy-on-write makes writes costly and reads clean. Merge-on-read makes writes cheap and every read does extra work.
Correlated failure: Failures that happen together because of a common cause (same rack, batch, software).
Crash: Any sudden stop: a process killed, the operating system (OS) failing (a kernel panic), a power cut. A crash gives no warning and can happen between any two instructions.
Crash-consistent: The state a power loss would produce; recoverable by the system's normal recovery.
Crypto-shredding: Deleting data by destroying its key.
Delayed allocation: A filesystem postponing disk-block choice until writeback.
Detection lag: Time between corruption happening and someone being alerted.
Device write cache: Volatile RAM inside a disk or SSD.Many disks and SSDs have their own small RAM cache. A device can say "done" when data reaches this cache, before it reaches the permanent medium.
Dirty page: A page changed in memory but not yet written to disk.A database stores tables in files, cut into fixed-size pages (typically 8 KB; do not confuse them with 4 KB virtual-memory pages). A buffer pool is the database's own area of RAM that holds copies of such pages. Each slot in the pool is a frame. A hit means the page is already in a frame. A miss means it must be read from disk. The hit rate is hits ÷ accesses. A page changed in memory but not yet written to disk is dirty. The working set is the set of pages the workload keeps coming back to.
Double-write buffer: Writing each page first to a scratch area, then to its home, so a torn page can be repaired.
Durability ladder: The rungs from client memory to verified multi-domain copies.
Erasure coding (EC): Splitting data into k chunks plus m parity chunks so that any k of n rebuild it.
Failure domain: A set of components that can fail together.A set of components that fail together: machines in one rack share a switch and a power feed; machines in one AZ share a building; every machine running the same buggy deployment shares that bug. When we say two replicas fail "independently", we mean they are in different failure domains.
fdatasync: Like fsync, but skips metadata not needed to read the data.
Fencing token: A growing number issued with a lock or lease; the resource rejects requests with an older number.An epoch is a number that only goes up, for example "this is leadership term 7". A fencing token is such a number attached to every request, so that a storage system can refuse a request carrying an older number than one it has already seen.
Fixed cost per operation (F): The cost paid for each request whatever its size.Most mechanisms charge a setup cost per operation, whatever its size. A flush to disk costs about the same for 1 byte or 100 KB. So doing many things in one operation (batching) is cheaper per item. The price of batching: the first item waits for the last.
Force (policy): Writing all of a transaction's data pages at commit.
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.
FUA: Force Unit Access: this write must reach the media before being acknowledged.
Fuzzy checkpoint: A checkpoint taken without stopping writes; consistent at no single instant.
Garbage collection (GC): Runtime component that finds unreachable objects and reclaims their memory.In Java, Go, C# and similar languages you never call free. A background component, the garbage collector, finds objects that nothing refers to any more and reclaims their memory. A tracing collector does this by starting from known roots (variables) and following every reference to mark the objects that are still live. The live set is the total size of all live objects. A generational collector splits the heap into a young generation (new objects, collected often and cheaply) and an old generation (objects that survived several collections). Pauses are moments when the program is stopped so the collector can work.
Group commit: Many transactions share one log flush.
History list length: InnoDB's count of old row versions waiting to be purged.
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.
Immutable (object-lock) retention: A copy that cannot be changed or deleted for a period, protecting against deletion by attackers or mistakes.
In-doubt window: Time between issuing a durable commit and learning its outcome.
Incremental / differential backup: A copy of only what changed since a reference point.
Incremental checkpoint: Continuous flushing so the checkpoint position moves smoothly.
Indirection: An extra lookup layer between a name and a physical location.A lookup layer between "the name you use" and "where the thing really is", like a phone book or a URL redirect. It lets you move things without telling everyone.
Journaling: A filesystem logging its metadata changes before applying them.
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.
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.
Log compaction: Keeping only the last record per key.
Logging, physical / logical / physiological: Recording bytes / operations / page-level bytes with operations inside the page.
Logical error: A wrong but valid operation (bad UPDATE, DROP TABLE) as opposed to hardware failure.
Lost write: A write that was acknowledged but never performed.
LRC (local reconstruction code): An erasure code with local parities to cut repair reads.
LSN: Log Sequence Number: the position of a record in the log.
Merkle tree: A tree of hashes used to find which ranges of two datasets differ.
Misdirected write: A write that lands intact at the wrong address.
MTTDL: Mean time to data loss.
MVCC: Keeping old versions so readers do not block writers and writers do not block readers.A technique where an update does not overwrite a row but creates a new version, so that readers who started earlier can still see the old one. Each reader works on a consistent snapshot. Old versions are removed later by a cleanup job (called vacuum in Postgres).
Nagle's algorithm: Do not send a small segment while an earlier small segment is unacknowledged; coalesces small writes.
Nested top action: A structural change committed independently of the transaction that caused it.
No-force / force: Commit does not / does write the data pages.
No-steal / steal: Pages of uncommitted transactions may not / may reach disk.
Non-volatile: Volatile memory (RAM) forgets everything when power is lost. Non-volatile storage (SSD, hard disk) keeps data without power. "Durable" means: stored so that it is still there after a crash.
O_DIRECT / O_DSYNC: Flags: bypass the page cache / make each write durable before returning.
Page: The fixed-size unit (commonly 4-16 KiB) read and written by storage and databases.3 other meanings →Storage hardware and databases do not read single bytes. They read fixed-size chunks called pages (or blocks), typically 4 KiB to 16 KiB on a local disk. To read one 200-byte row you must read its whole page.
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.
pageLSN: The LSN of the last record applied to a page.
PITR: Point-in-time recovery: base backup plus log replay to a chosen moment.
PLP (power-loss protection): Capacitors that let an SSD finish writes when power fails.
Purge / vacuum: Background removal of old row versions.
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.
Random I/O: Reading or writing blocks scattered across storage rather than next to each other. Each access pays a fixed setup cost (a seek, a flash read, a network round trip), so it costs far more per byte than sequential I/O.Reading pages that sit next to each other is sequential and cheap per page. Reading pages scattered around is random and costs more per page, because each read pays a fixed setup cost (a disk seek, a flash read, a network round trip). The ratio of the two costs is the key number of Part 1. Call the cost of one sequential page read s and one random page read r.
Re-basing (synthetic full): Building a new full image from an old base plus increments.
Recovery: Rebuilding a correct state from what survived a crash.
recoveryLSN: The LSN of the oldest change of a page that may not be on disk.
Redo: Re-applying logged changes during recovery.
Repair amplification: Data read to rebuild lost data (k reads per lost chunk in EC).
Replication slot: A bookmark that makes a primary keep log until a consumer has read it.
RPO: Recovery Point Objective: how much recent work may be lost.Two numbers every recovery plan states.
Rto: Recovery Time Objective: how long until service returns.1 other meaning →Two numbers every recovery plan states.
Savepoint: A deliberately taken, stable, self-contained checkpoint owned by the operator of the job.1 other meaning →
Scrubbing: Reading all data on a schedule to verify checksums.
Semi-synchronous replication: The primary waits until a replica has received the record.
Sequencer: Component that puts transactions into one agreed global order.
Sequential: Reading or writing one place after another, like appending to a file. It avoids the per-access cost of jumping around, so it is far cheaper than random I/O, especially on spinning disks.Sequential means writing one place after another (like appending to a file). Random means jumping between different places. On a hard disk, each jump costs a mechanical move of about 5–10 ms. On flash, random writes are also more costly. Sequential is much cheaper.
Sharp checkpoint: A stop-the-world checkpoint with a fully consistent image.
Silent corruption: Wrong data returned with no error.
Snapshot: A frozen consistent view of the database at one moment.1 other meaning →A lock makes other transactions wait while you use a row. A snapshot is a frozen, consistent view of the database as it was at one moment; with it, readers do not need locks, because they read old versions while writers create new ones. This second idea is called MVCC (multi-version concurrency control): the database keeps several versions of each row. Both are mechanisms. This mechanism is about the promises they are used to keep.
Synchronous replication: The primary waits until a replica has made the record durable.
T10 DIF/PI: A standard adding per-sector guard, reference tag and application tag.
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.
Tiered storage: Placing hot data on a small fast medium and cold data on a large slow one.
Tombstone: A marker record that says a key was deleted; must outlive every older copy.
Torn page / torn write: A page that is part old, part new after a crash.
Transaction: A group of operations executed as one all-or-nothing unit.A group of reads and writes that the database treats as one unit: either all of it takes effect, or none of it does. In SQL you mark it with BEGIN ... COMMIT (make it permanent) or ROLLBACK (throw it away). Example: moving 30 from Anna's wallet to Ben's wallet.
Truncation point: The log position before which the log may be deleted.
Undo: Reversing changes of uncommitted transactions.
Volatile: Volatile memory (RAM) forgets everything when power is lost. Non-volatile storage (SSD, hard disk) keeps data without power. "Durable" means: stored so that it is still there after a crash.
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-ahead rule: Log first: redo before commit, undo before the page write.
ZFS: A filesystem with copy-on-write snapshots and parent-pointer checksums.