The papers, distilled

Data as time-varying n-ary relations queried by predicate calculus, so programs survive changes in storage, indexes, and access paths.

The B-tree: a page-sized, always-balanced ordered index that stays cheap to search and to update on disc.

A candid engineering retrospective on building INGRES: what a working relational DBMS actually cost, and which design choices were mistakes.

Names atomicity, consistency and durability as the transaction's defining properties, then shows exactly where nested and long-lived transactions break them.

A retrospective walk through eight Jim Gray papers that built the transaction abstraction, from two-phase locking to Paxos Commit.

A retrospective on Berkeley Postgres, showing how one extensible object-relational design seeded PostgreSQL and a generation of database systems.

The first working shared-nothing parallel database: one processor per disk, every relation partitioned, queries run as self-scheduling dataflow.

Shared-nothing hardware plus partitioned data and a split/merge dataflow runtime give relational queries near-linear speedup and scaleup.

ARIES made crash recovery correct and fast under record-level locking by repeating history, then undoing losers with redo-only compensation records.

The CUBE operator: one SQL clause that computes every group-by over N dimensions at once, and returns it as a relation.

A disk index that defers and batches inserts into cascading sorted merges, cutting disk-arm cost by nearly two orders of magnitude.

Paxos: a majority-quorum protocol that keeps replicated logs consistent through crashes and lost messages, and progresses when the network settles.

A plain-English derivation of Paxos, showing fault-tolerant consensus follows almost unavoidably from wanting a majority of acceptors to agree.

The definitive restatement of CAP: not pick two of three, but the impossibility of safety plus liveness on an unreliable network.

A cluster file system that makes commodity failure routine, files enormous, and concurrent append a first-class atomic operation.

A programming model that hides parallelization, fault tolerance, locality and load balancing behind two user-written functions: map and reduce.

A read-optimized column store built from overlapping sorted projections, compressed columns, and a hybrid write store with snapshot isolation.

The engineering post-mortem of C-Store: which column-store research ideas survived seven years of paying customers, and which were dropped.

A production store that fused Dynamo's leaderless ring with Bigtable's column families to absorb billions of writes a day.

A SQL-like warehouse over Hadoop: HiveQL compiles into map-reduce DAGs, backed by a catalog, partitions, buckets and pluggable SerDes.

Resilient distributed datasets: cached, lineage-recoverable collections that let clusters reuse a working set in memory across many operations.

A distributed commit log for high-volume event data: partitioned append-only segments, pull-based consumers holding their own offsets, zero-copy delivery.

The first database to give globally distributed transactions external consistency, by exposing clock uncertainty in the time API and waiting it out.

Order transactions deterministically before executing them, and a partitioned database can drop two-phase commit entirely.

One adaptive distributed SQL engine that serves sub-second dashboards and multi-hour ETL over dozens of pluggable data sources.

Eight years of running RocksDB at Facebook scale, and how that moved its optimization target from write amplification to space to CPU.

A leader-based consensus algorithm designed for understandability, equivalent to multi-Paxos in safety and efficiency but teachable and implementable.

Split a warehouse into blob storage, ephemeral compute clusters and a shared metadata brain, making elasticity an architectural property.

ACID tables on plain cloud object stores, built from a Parquet-checkpointed write-ahead log that needs no always-on metadata service.

A blueprint for running warehouse-grade transactions, indexing and SQL performance directly over open Parquet files in cloud object storage.

An in-process SQL engine that brings vectorized OLAP execution to the embedded niche SQLite left empty.

Serializable ACID transactions at NoSQL scale, built by unbundling the database and proving every feature correct in deterministic simulation.

Flink 2.0 makes remote storage the primary home of streaming state, hiding its latency with asynchronous, out-of-order record execution.