Immutable storage grows indirection
An immutable substrate grows an indirection layer plus a collector.
What it is
With perfect knowledge of all future queries, most trade-offs would disappear. You would put each byte in the perfect place. The trade-off exists because you decide with incomplete information. The alternative is to delay the decision, and delay costs an indirection layer that records what you decided later.
This is why one architecture appears again and again, at every scale:
immutable storage → indirection layer → garbage collector
Every medium that cannot update in place grew it: the FTL on flash, zone mapping on SMR disks, manifests on object storage (the table).
Each buys the freedom to place data late, and pays with a lookup table plus a cleanup process. And in each case the garbage collector eventually becomes the operational problem, because delayed decisions pile up.
From Physical Substrate & Performance Laws › Seven root causes
Any strategy that does not overwrite must grow two organs: an indirection layer, so readers can find the current version, and a collector, so the dead can be reclaimed. This convergence appears in SSD translation layers, in LSM trees and in table-format manifests, because it is a root cause below every layer. Its collector has one cost law everywhere: it moves u/(1−u) live bytes for every byte it frees, a price that explodes near full utilization. For a table, that makes the fill target a write-amplification decision, not housekeeping.
From Storage: Physical Organization › Deletes and versions
Where it appears
In 17 mechanisms. Each says what the mechanism is about, then how this principle shows up there, in its own words.
- Physical Substrate & Performance Laws
Why do trade-offs exist at all?
immutable storage → indirection layer → garbage collector
Read it inSeven root causes: why trade-offs exist at allDisk and flashNVMe, persistent memory, tape and object storage
- Storage: Physical Organization
What should sit next to what, given that I must decide at write time and find out at read time?
The LSM tree is not a data structure someone chose.
Read it inObject storage and the lakehouse
- Persistence & Durability
When a system says "yes, your data is safe", what exactly has it promised, and what did it have to do to keep that promise?
For durability it is the first instance of a pattern this mechanism meets again and again: every storage that cannot update in place grows an indirection layer and a cleaner, and the cleaner's progress is held back by the oldest reader (Log truncation and retention policies).
Read it inUndo loggingSnapshots: full, incremental, copy-on-write
- Core Data Structures
How do we choose a data structure when the real cost is set by the hardware, not by Big-O?
A layout that cannot be updated in place grows an indirection layer plus a collector.
Read it inThe big picture: a data structure is a betBit vectors and rank/select
- Indexing
When does a separate "where is it?" structure pay for itself, and what does it cost to keep it true?
Anything that relocates forces a choice between indirection and invalidation.
Read it inPrimary versus secondary: identity is not locationSet membership: inverted indexes
- Transactions & Concurrency Control
What happens when many users change the same data at the same time, and how do we keep the result correct?
Immutable storage grows an indirection layer plus a collector, and the collector falls behind in exactly the conditions that produce the most garbage (heavy updates plus long readers).
Read it inMultiversion concurrency control (MVCC)
- Consistency & Isolation Models
When many users, many objects and many copies exist at once, which histories does the system promise never to show, and who writes the code for the histories it does show?
A CRDT removes coordination from the write path and reinstates it in the collector.
- Query Planning & Optimization
How does a system choose a plan for a question when the facts that decide the best plan are unknown until the plan has run?
The indirection keeps producing capabilities that nobody bought it for.
Read it inResult-set caching
- Memory & Resource Management
Who is allowed to hold how much memory, for how long, and what happens to the work when the answer is less than it asked for?
The uncomfortable form of the lesson: you can choose the granularity, never the structure.
Read it inGC tuning versus manual managementOff-heap memory managementPinning and unpinning: where residency meets correctness
- Caching
What happens when we deliberately keep a second copy of data that no protocol forces to be correct?
It has the same failure mode: the collector falls behind exactly when most garbage is produced.
Read it inVersioned keys are MVCC, and the bill goes somewhere newMetadata caching: the one place where the inequality is not close
- Fault Tolerance & Delivery Semantics
What is the cheapest thing that can be safely done twice?
Every storage design that never overwrites ends up with an indirection layer and a garbage collector.
Read it inCheckpoints and lineage: save the state or the recipe
- Cost Mechanics
What is metered, and what is the smallest increment you are charged for?
Put the listing in a file and read it in one request.
Read it inLIST cost and manifests
- Time & Temporal Semantics
When am I allowed to act on data that may still be incomplete, and what do I owe the reader if I was wrong?
So TTL (time-to-live) is the collector of this mechanism, the second half of "immutable storage plus a collector".
Read it inTTL and expiry
- Streaming
What does it cost to remember, when the input never ends?
Keyed state is a compacted log (key → latest value), and a compacted log materializes to exactly that table.
Read it inChangelogs and table-stream dualityIncremental checkpoints and recovery time
- Change Data Capture & Incremental Processing
What does it cost to know what changed, and is that cheaper than not needing to know?
In one line: a versioned table is a change log with a garbage collector, and your cursor is racing it.
Read it inSnapshot-diff incrementality
- Data Modeling
What does one row mean, who is allowed to change that answer, and what breaks downstream when they do?
This is the immutable-store law again, with the same missing collector.
Read it inData VaultEvent sourcing and activity schemaAs-was or as-is: the slowly changing dimension types
- Metadata, Catalog & Lineage
What can a system prove about its data without reading the data, and how does it know that proof is still true?
Metadata now scales like data, because it is data on the same storage.
Read it inManifest and snapshot treesVersioning, branches and tags
Related
Made on the same pages most often.