Glossary

Plain-English definitions of the terms used across the simulators — grows as new topics land.

Acknowledgement deadline: Acknowledgement deadline: the window a consumer has to acknowledge a delivered message before the broker assumes the delivery failed and redelivers it. On Google Cloud Pub/Sub it defaults to 10 seconds; AWS SQS calls its equivalent the visibility timeout (30 seconds by default).
Admission control: Admission control: deciding whether to accept a request at the very edge, before parsing or routing it — the cheapest place to shed, so rejected work never consumes capacity.
Allowed lateness: Allowed lateness: a grace period after a window fires during which a late event still updates it and re-emits a corrected result, before the window finally closes and drops stragglers.
Amdahl's law: Amdahl's law: the speedup from more cores is capped by the part of the work that can't be parallelized. If 10% is serial, even infinite cores cap you at 10× — and uneven splits leave cores idle well before that.
At-least-once delivery: At-least-once delivery: a message or change is delivered one or more times, never zero. The sender redelivers whenever it cannot confirm a copy was handled, so a consumer can see the same item twice and handlers must be idempotent.
Availability: Whether the system can still respond to requests, even during failures. Often traded off against consistency when the network splits (partition).
Backpressure: Backpressure: signalling a fast sender to slow down instead of silently accepting more work than you can finish — a full bounded queue pushing resistance back upstream. TCP flow control is the classic example.
Base32 (geohash): Geohash's 32-character alphabet 0123456789bcdefghjkmnpqrstuvwxyz. It drops a, i, l and o so no two characters look alike; each character carries 5 bits.
Big-O notation: Big-O notation describes how an operation's cost grows as the input grows. It ignores constants and focuses on the shape: does doubling the data double the work, or barely change it?
Bit interleaving: Weaving two bit streams together — one longitude bit, then one latitude bit, alternating — so a single string narrows both coordinates as it grows.
Block index: A small in-memory map: 'the block starting at key X lives at byte offset Y'. It lets a read jump straight to the right block instead of scanning the file.
Blocking I/O: When a task waits on I/O (disk, network) and holds onto its core while doing nothing useful. Async/non-blocking I/O instead yields the core so other ready tasks can run — the core stays busy.
Bloom filter: A compact bit array that answers 'is this key DEFINITELY not here?' in memory. If it says no, we skip reading the file entirely. It can say 'maybe' wrongly (a false positive) but never misses a key that exists.
Byte offset: A byte offset is the distance (in bytes) from the start of the file. Offset 0 is the very first byte; a section at offset 48 starts 48 bytes in.
Candidate pair: Candidate pair: two items that shared a bucket in at least one band, marking them as likely near-duplicates worth a full comparison. LSH narrows a whole collection down to just these pairs.
Centroid: A centroid is a running mean of nearby values plus a count of how many it stands for. A t-digest keeps a small set of them instead of the raw numbers; each one is a compressed stand-in for the points that landed near it.
Change data capture (CDC): Change data capture (CDC): reading a database's write-ahead log and turning every committed insert, update, and delete into an ordered event on a stream, so other systems can follow the changes without the database calling them.
Column chunk: A column chunk: the slice of one column belonging to one row group. It is the unit a columnar reader fetches and decodes.
Column projection: Column projection: reading only the columns a query selects. A row store must read whole rows, so it pays for columns it never uses.
Columnar storage: Columnar storage: a table stored one column at a time instead of one row at a time. An analytical query reads only the columns it needs and skips the rest.
Compaction: Background merge of SSTables: combines overlapping tables, keeps only the newest value per key, and drops tombstoned data at the bottom level. This reclaims space and speeds up reads.
Compression (δ): Compression δ: the accuracy dial. It sets each centroid's size cap (about 4·N·q·(1−q)/δ), so a larger δ keeps more, finer centroids and tightens the estimate, while a smaller δ lets centroids grow fat and coarsens it. The centroid count is bounded by δ, not by N.
Concurrency: Dealing with many tasks over the same period by interleaving them — switching between them so they all make progress. On a single core only one runs at any instant; they take turns. Concurrency is a structure for managing work, not a guarantee that work runs simultaneously.
Consensus: Getting a group of machines to agree on a single value despite failures and message delays. Hard problem; Raft and Paxos are consensus algorithms.
Consistency: Whether all replicas show the same data at the same time. Strong consistency = every read sees the latest write; weaker models trade that for speed/availability.
Constant time — O(1): O(1), 'constant time': the operation takes the same time no matter how big the data is. A hash-table lookup is O(1) — finding 1 key among a billion costs the same as among ten.
Constant-time compare: Comparing two hashes in the same amount of time regardless of where they differ, so the reject latency leaks nothing about the secret.
Context switch: Saving one task's state and loading another's so a core can switch between them. It's what makes interleaving possible — and it isn't free; too many switches waste time on bookkeeping instead of work.
Core: An independent processor that can execute one stream of instructions at a time. N cores can run N tasks truly simultaneously; a single core can only interleave.
Count-Min Sketch: Count-Min Sketch: a grid of counters, d rows by w columns, one hash function per row. Adding an item increments one cell in each row; estimating its count reads those cells and returns the smallest. Collisions only ever inflate a counter, so the minimum is an overestimate that never falls below the true count.
CRDT: Conflict-free Replicated Data Type: a structure whose replicas can be updated independently and always merge to the same state, because the merge is commutative, associative, and idempotent.
Cuckoo false-positive rate: The false-positive-rate bound of a cuckoo filter, about 2b/2^f for b slots per bucket and f fingerprint bits. Add fingerprint bits to shrink it; for a target rate use about log2(2b/rate) bits.
Cuckoo filter: Cuckoo filter: an approximate membership test that stores a short fingerprint of each key in a table of buckets. Each key has two candidate buckets; if both are full, an existing fingerprint is kicked to its alternate bucket to make room. Unlike a Bloom filter, you can delete a key by clearing its fingerprint.
Daily active users: Daily active users: the count of distinct people who use the product in a day. Almost every capacity estimate starts from this one assumed number.
Data block: Records are grouped into fixed-size blocks (pages). The engine reads one whole block at a time from disk, not one record.
Data shard: Data shard: one of the k equal slices the object is split into. Because the code is systematic, data shards hold the raw object, so a healthy read just concatenates them with no decoding.
Dead-letter queue: Dead-letter queue: a side channel a message copy is moved to once it has failed more times than the retry budget allows, so a poison message is parked for inspection instead of redelivering forever.
Dictionary encoding: Dictionary encoding: each distinct value is stored once in a small dictionary, and the column becomes a list of short integer codes that point into it.
Dirty page: Dirty page: a cached page whose RAM copy is newer than the copy on disk, because a write landed in memory and has not been written back yet. It must be flushed to disk before its frame can be reused, or the write would be lost.
Dirty read: Dirty read: reading a value another transaction has written but not committed. If it rolls back, you acted on data that never existed. Prevented at Read Committed and above.
Disk total: Total bytes across ALL files on disk — the WAL plus every SSTable. This is larger than any single SSTable, and briefly includes the WAL before it's truncated after a flush.
Doubly-linked list: A linked list where each node points to both the next AND previous node. This lets you remove any node in O(1) once you have it — the trick behind an O(1) LRU cache.
Durability: A guarantee that once a write is acknowledged, it survives crashes — usually by writing to disk (a WAL) before confirming. The 'D' in ACID.
Egress: Bytes leaving a system onto the network. At streaming scale it usually dominates the bill, and cutting it is what a delivery network exists for.
Embedding: A vector of numbers a model produces from text, an image, or other input, positioned so that similar things sit close together in the space.
Erasure coding: Erasure coding: split an object into k data shards, compute m parity shards, and store all n = k+m. Any k of them rebuild the object, so up to m can be lost with no data loss — the durability of m+1 replicas at only n/k times the storage.
Event time: Event time: the timestamp of when an event actually happened, stamped at the source. Windowing groups by this, not by arrival order, so counts stay correct when data is late or out of order.
False-positive probability: False-positive probability: the chance the filter says 'maybe present' for a key that was never added. It rises as the filter fills up; you lower it by adding more bits per key. Formula: (1 − e^(−k·n/m))^k, for k hashes, n keys, m bits.
Fan-out: Fan-out: turning one published message into one independent copy per subscription, so a single event can drive many consumers at once without the producer knowing they exist.
Fill ratio: Fraction of the bit array that is set to 1. Bloom filters only ever set bits (never clear them), so this climbs with every ADD. Around 50% full is the sweet spot for the optimal hash count.
Fingerprint: A few bits of a key's hash, stored in place of the key. The filter compares fingerprints, never keys, so it stays tiny; two keys sharing a fingerprint in a candidate bucket is the one source of false positives.
Geohash: A short base32 string that encodes a latitude/longitude point. Built by interleaving the two coordinates' bits and reading them five at a time; nearby points share a leading prefix.
Ground truth: The exact per-item counts, tracked here only so you can compare the estimate to the truth. A real Count-Min Sketch never stores the items or their counts, and that is the memory it saves.
Ground truth: The exact set of keys actually inserted, tracked here only so you can compare the filter's answer to the truth. A real cuckoo filter never stores the keys — only their fingerprints.
Ground truth: The exact quantiles of the raw values, kept here only so you can compare the estimate to the truth. A real t-digest never stores the raw values, and that is the memory it saves.
Happened-before: Happened-before: event X happened before Y if X could have influenced Y — same node in order, or a send and its receive, chained through messages. Two events with no such chain are concurrent.
Hash table: A structure that stores key→value pairs and finds any key in O(1) by hashing the key to a slot. The workhorse behind caches, indexes, and dictionaries.
High-water mark: High-water mark: the offset up to which every in-sync replica has copied the log (the smallest log-end offset across the ISR). A consumer can only read below it, so it never sees a record that isn't fully replicated.
HNSW: Hierarchical Navigable Small World: a layered graph index for approximate nearest-neighbour search. You enter at a sparse top layer and hop greedily to the closest neighbour, descending layers to the answer.
Hostname: A human-readable name for a machine, like example.com. It must be translated to an IP address (via DNS) before a connection can be made.
Hotspot: A shard carrying far more than its fair share of data or traffic. Range partitioning on a rising key creates one; so does a single very popular key under any scheme.
Idempotent: Idempotent: applying the same operation twice has the same effect as applying it once. A CRDT merge is idempotent, so re-merging a state you already folded in changes nothing.
In-sync replica set (ISR): In-sync replica set (ISR): the replicas of a partition currently keeping up with the leader — the leader plus every follower that has fetched recently enough. Only ISR members count toward the high-water mark and are eligible to become leader.
Inverted index: A dictionary mapping each term to its posting list: the sorted document ids that contain the term. It flips a documents-to-words view into a words-to-documents one, so a search reads one short list instead of scanning every document.
IP address: IP address: the numeric address of a machine on a network, like 93.184.216.34. Computers route messages by IP, not by human-readable names.
Isolation level: Isolation level: a database setting that promises which concurrency anomalies you will never observe. Weaker levels allow more anomalies but more parallelism; stronger levels forbid more at the cost of blocking or aborts.
Jaccard similarity: Jaccard similarity: the size of two sets' intersection divided by the size of their union. It runs from 0 for disjoint sets to 1 for identical ones, and it is the similarity MinHash estimates.
Key-derivation function: Key-derivation function: a deliberately slow hash (bcrypt, scrypt, Argon2, PBKDF2) used to store passwords or derive keys, tuned so each evaluation is expensive to compute.
Lamport clock: A single per-node counter: bump it on a local event, and on receive take the larger of the two values plus one. It gives a consistent order but can't tell concurrent events from causal ones.
Latency: How long one request takes to get a response — the delay. Measured in milliseconds. Lower is better. Distinct from throughput.
Leader: In a replicated cluster, the one node that accepts writes and tells the others what to do. If it dies, the cluster elects a new leader (see Raft).
Leader epoch: Leader epoch: a version number for a partition's leadership that increases on every election. Records are stamped with it and followers reject requests carrying a stale epoch, fencing an old leader that wrongly thinks it's still in charge.
Level (LSM): SSTables are organized into levels. L0 holds freshly-flushed tables (key ranges can overlap). Deeper levels (L1, L2…) are larger, sorted, and non-overlapping. Reads check newer levels first.
Linear time — O(n): O(n), 'linear time': the work grows in step with the data — twice the data, twice the work. Scanning every item in a list is O(n).
Linked list: A chain of nodes where each node points to the next. Inserting or removing a node is cheap (just repoint neighbors) but finding the Nth item means walking the chain.
Little's Law: Little's Law: L = λ·W. The average number of items in a system (L) equals the arrival rate (λ) times the average time each spends inside (W). It ties concurrency, throughput, and latency together with no assumptions about the workload.
Load factor: Filled slots as a fraction of a table's capacity. Past a threshold — about 0.75 for a hash table, ~0.95 for a cuckoo filter — collisions or eviction chains grow, so the structure grows or starts rejecting inserts.
Load shedding: Load shedding: rejecting excess requests fast under overload, before doing real work, so the requests you accept stay responsive. A quick rejection beats a slow response nobody is still waiting for.
Log sequence number (LSN): Log sequence number (LSN): a monotonically increasing position in the write-ahead log. Every committed change gets one, so the LSN both orders the changes and names the exact spot a reader can resume from.
Log-end offset (LEO): Log-end offset (LEO): the next offset a replica will write — how many records it currently holds. The leader's LEO is furthest ahead; a follower's trails by how far behind it is.
Logarithmic time — O(log n): O(log n), 'logarithmic time': the work grows very slowly — doubling the data adds just one more step. Binary search and balanced trees are O(log n).
LSH banding: LSH banding: split each signature into b bands of r rows, hash every band to a bucket, and treat two items as a candidate pair if they share a bucket in any band. Similar items collide often and dissimilar ones rarely, so only promising pairs get a full comparison.
Memtable: An in-memory sorted table holding the newest writes. Fast to update. When it fills past its threshold, it's frozen and written to disk as an SSTable.
MinHash: MinHash: a way to estimate how similar two sets are from small signatures. For each of k fixed hash functions, keep the smallest hash over a set's elements. The chance two sets share a given minimum equals their Jaccard similarity, so the fraction of matching signature slots estimates that similarity.
MinHash signature: MinHash signature: the k minimum-hash values that stand in for a whole set. Comparing two signatures slot by slot, the fraction that match estimates the sets' Jaccard similarity, and the estimate tightens as k grows.
Network partition: A network split: some machines can't talk to others, though each side is still alive. Systems must choose how to behave — stay consistent or stay available.
Nines (availability): Availability expressed as a count of leading 9s: 'three nines' = 99.9% uptime. Each extra nine cuts allowed downtime ~10×: 99.9% ≈ 8.8 h/year, 99.99% ≈ 53 min/year, 99.999% ≈ 5 min/year.
No false negatives: A Bloom filter never has false negatives: if a key was added, every one of its k bits is 1, so a query for it always returns 'maybe present'. It can only be wrong in the other direction — a false positive.
Node: One element of a structure (list, tree, graph) — it holds a value plus links to other nodes. Also used to mean one machine in a distributed cluster.
Non-repeatable read: Non-repeatable read: reading the same row twice in one transaction and getting two different values, because another transaction committed a change in between. Prevented at Repeatable Read and above.
Overestimate (one-sided error): Count-Min only overcounts, never undercounts (for non-negative streams). The overcount is bounded by a fraction of the total stream size, so widening the grid tightens the bound.
Packet: A small chunk of data sent across a network. A big message is split into many packets, each routed independently and reassembled at the other end.
Page cache: Page cache: a pool of RAM the operating system uses to hold recently-used file pages, so most reads and writes hit memory instead of disk. It uses spare RAM and gives it back when programs need memory.
Page fault: Page fault: what happens when a program touches a page that is not resident in RAM. The kernel reads the page from disk into a free frame, then resumes the access — turning a cache miss into a disk read.
Parallelism: Actually running tasks at the same instant, which requires multiple cores (or machines). Parallelism needs concurrency to organize the work, but concurrency does not need parallelism — one core can be concurrent without ever being parallel.
Parity shard: Parity shard: one of the m redundant shards computed from all k data shards. It holds no readable data — only the coded redundancy that lets a survivor rebuild a lost shard.
Partial-key cuckoo hashing: Partial-key cuckoo hashing: a key's two buckets are i1 = hash(key) and i2 = i1 XOR hash(fingerprint). Because exclusive-or is its own inverse, the alternate bucket of a stored fingerprint can be computed from the fingerprint alone — no key needed — which is what lets the filter relocate entries.
Peak factor: How much busier the busy hour is than the daily average. Traffic clusters while people are awake, so multiply an average rate by two to five to get the rate the system must survive.
Pepper (password hashing): A secret value added to every password hash and kept outside the database (app config or a hardware module), so a database-only leak still cannot be cracked.
Phantom read: Phantom read: re-running the same range query in one transaction and finding new rows another transaction inserted and committed in between. Prevented at Snapshot Isolation and above.
Port: A number (0–65535) that identifies which program on a machine should receive a message. Web servers usually listen on port 80 (HTTP) or 443 (HTTPS).
Posting list: The sorted list of document ids that contain a given term. A single-term search returns one posting list; a multi-term AND intersects two of them with a two-pointer walk.
Predicate pushdown: Predicate pushdown: pushing a query's WHERE filter down to the storage layer so it can skip data that cannot match, instead of reading everything and filtering afterward.
Probe: One of the k hash functions maps the key to a bit position. ADD sets all k bits; QUERY checks them — a single 0 bit is enough to prove the key is absent.
Processing time: Processing time: the time the server reads off its own clock when it handles an event. Cheaper to bucket by, but wrong whenever events arrive late or reordered.
Publish / subscribe: Publish/subscribe: a messaging pattern where a producer publishes a message once to a named topic and the broker delivers an independent copy to every attached subscription. Producers and consumers never reference each other, only the topic.
QPS: Queries per second: how many requests a system handles each second. An estimate quotes the peak, not the average, because the peak is what the system has to survive.
Quorum: A majority agreement. With N replicas, requiring a quorum (more than half) to confirm a write or read guarantees any two quorums overlap — so they can't disagree.
Rainbow table: A precomputed lookup from common passwords to their hashes, letting an unsalted hash be reversed by lookup. A unique per-user salt makes it worthless.
Read amplification: Read amplification: how many data blocks a single GET had to read. A key in a deep level (or a missing key) may touch several SSTables — bloom filters keep this low.
Reading a quantile: To read quantile q, multiply q by N to get a target rank, walk the centroids adding up their counts, and interpolate between the means of the two whose cumulative counts straddle that rank.
Recall: The fraction of queries for which a search returns the true nearest neighbours. Exact search has recall 1; an approximate index like HNSW trades a little recall for a large speed-up.
Reed-Solomon code: Reed-Solomon code: the standard erasure code. Parity shards are computed as independent weighted mixes of the data over a finite field (GF(256)), so any k of the n shards recover the original. It is optimal (MDS): an (n,k) code survives exactly n−k losses.
Replica: A copy of the data kept on another machine. Replicas give you fault tolerance (one dies, others serve) and let reads spread across machines.
Resharding: Changing the shard count on a live cluster. Its cost is how many keys must be copied to a new machine — nearly everything under plain hash-mod, only a small slice under consistent hashing or fixed buckets.
Round-trip: One full there-and-back trip: request out, response back. Each network round-trip adds latency, so cutting round-trips is a common optimization.
Row group: A row group: a fixed horizontal slice of a table (a batch of rows) stored together. Each column is cut along the same row-group boundaries, and each group carries its own min/max summary. Parquet calls it a row group; ORC calls it a stripe.
Run-length encoding: Run-length encoding: a stretch of identical values is stored once with a count, so a column of repeats shrinks to a few entries.
Salt: A unique random value added to each password before hashing, so identical passwords produce different stored hashes and precomputed tables are useless. It is stored in plaintext next to the hash; its job is uniqueness, not secrecy.
Scheduler: The component that decides which ready task runs on which core next. Round-robin gives each task a fixed turn (quantum) in rotation so no task is starved.
Serializable: Serializable: the strongest isolation level. Transactions behave as if run one at a time, so every anomaly including write skew is prevented, usually by detecting read-write dependency cycles and aborting one transaction.
Session window: Session window: a window with no fixed size that grows with activity and closes after a gap of inactivity. Two nearby events can merge into one session.
Shard key: The field a sharded system routes on — user id, account id, whatever you look rows up by. A function turns it into a shard number. Chosen once and hard to change, since it decides where every row lives.
Side output: Side output: a separate stream that receives events too late to count (their window already closed), so the amount of dropped data can be measured rather than lost silently.
Significant figure: The leading digit that carries a number's size. Rounding an estimate to one significant figure (17,361 becomes 20,000) keeps the arithmetic mental and adds far less error than the assumptions already contain.
SLA: Service Level Agreement: a contractual promise about a metric (e.g. 99.9% availability) with penalties if missed. The externally-committed number.
Sliding window: Sliding window: fixed-size windows that open every slide step and overlap, so one event can belong to several at once. Used for rolling metrics like a moving average.
SLO: Service Level Objective: an internal target you operate to (often stricter than the SLA) so you have headroom before breaching the contract.
Snapshot Isolation: Snapshot Isolation: each transaction reads from a frozen snapshot of the whole database taken when it began, so it sees no dirty reads, non-repeatable reads, or phantoms. It still allows write skew.
SSTable: Sorted String Table: an immutable file of key→value records sorted by key. Once written it's never modified — only merged into a new one during compaction.
SSTable footer: A fixed-size 20-byte trailer at the very end of the file. It stores four numbers — the byte offset and length of the index section, and of the bloom section — plus a 4-byte magic number ('LSMT') to verify the file. A reader opens the file by reading these last 20 bytes first, which tell it where everything else lives.
Storage overhead: Storage overhead: total storage as a multiple of the raw data, n/k for an erasure code. RS(6,3) is 1.5×, versus 3× for three-way replication at similar durability.
Stream total (N): N: the total of every increment fed to the sketch. The guaranteed overcount bound is a fraction of this, so error grows with the whole stream, not with any one item's count.
Strong eventual consistency: Strong eventual consistency: any two replicas that have received the same set of updates are in the same state — no coordination needed, and merges can arrive in any order.
Subscription: A named attachment to a topic that receives its own copy of every published message and tracks that copy's delivery state (pending, in-flight, acknowledged, or dead-lettered) independently of every other subscription.
Take the minimum: The estimate is the minimum of the item's d cells. Each cell was incremented on every add of the item, so each is at least the true count; collisions only add more. The smallest cell is the least-polluted upper bound, so the minimum is the tightest honest answer.
The footprint: The number of centroids the digest stores — its whole memory. It is bounded by the compression, not by how many values you add, so a few hundred centroids can summarize billions of numbers.
Throughput: How many requests a system handles per unit of time (e.g. 10,000 requests/second). A system can have high throughput but still high latency per request.
Tombstone: A delete doesn't erase data — it writes a 'tombstone' marker that shadows older copies in lower levels. The data is actually removed later, during compaction.
Tree: A structure of nodes branching from a root, each node having children. Lookups follow one path from the root, so balanced trees search in O(log n).
Trie (prefix tree): Prefix tree: strings that share a prefix share the same path of nodes. A prefix lookup costs only as much as the prefix length — not the dictionary size — which is what makes it the structure behind autocomplete.
TTL (Time To Live): Time To Live: how long a cached answer stays valid before it must be looked up again. A DNS record with TTL 300 may be reused for 300 seconds.
Tumbling window: Tumbling window: fixed-size, back-to-back, non-overlapping buckets of event time. Every event belongs to exactly one, used for clean per-period reports.
Utilization: The fraction of available core-time actually spent doing useful work. Idle or blocked cores drag it down; low utilization is why adding cores often fails to speed things up proportionally.
Vector clock: A logical clock with one counter per node. Comparing two vectors element by element tells happened-before from concurrent exactly, which a single counter cannot.
Watermark: Watermark: a moving estimate that event time has certainly advanced past T, so no earlier events are still expected. Computed as the highest event time seen minus a fixed lag, it only moves forward and decides when a window fires.
Work factor: A tunable cost on a slow hash that sets how many times it folds. Raising it multiplies the time every hash takes, throttling an attacker's guessing while a single login barely notices.
Working set: The slice of the data actually being read right now. Roughly 80% of traffic lands on 20% of the data, and it is that fifth, not the whole dataset, that has to fit in memory.
Write amplification: Write amplification: total bytes written to disk ÷ bytes you actually wrote. Compaction re-writes data, so this is >1. The price LSM trees pay for fast writes.
Write skew: Write skew: two transactions each read overlapping rows, each write a different row based on what they read, and both commit, together breaking a rule neither broke alone. Allowed by Snapshot Isolation; prevented by Serializable.
Write-Ahead Log (WAL): Write-Ahead Log: every write is appended here on disk first. If the server crashes before the in-memory data is saved, it's replayed from this log so nothing is lost. It's cleared once the memtable it protects is safely flushed to an SSTable.
Writeback: Writeback: flushing dirty pages from RAM down to disk and marking them clean again. It runs in the background on a timer, and on demand when a program calls fsync to make a write durable.
Zone map: A zone map: the smallest and largest value of a column within one row group, kept as tiny metadata. A query compares its predicate against this min/max to skip whole groups without reading them.