Seven root causes: why trade-offs exist at all

Here is the one-sentence summary of this whole mechanism:

A hard drive, a flash chip, a memory cell and a magnetic tape all hold bits, and all face the same conflict: "I want writing to be easy, but I want the data to never be lost." These two wishes pull in opposite directions.

This is not an engineering failure, and there is no "universal memory" waiting to be invented. The conflicts are structural. They exist at seven different depths, from "physics forbids it" to "the market did not pay for it." The skill is knowing which depth a trade-off lives at. The deep ones are permanent. The shallow ones can change.

Cause	Comes from	Permanent?	Derived in
0 Stability vs. mutability	Physics (energy barriers)	Yes	Storage media
1 Distance	Geometry and the speed of light	Yes	CPU and memory, the network
2 Low cost forces coarse granularity	Economics of shared machinery	Essentially yes	Storage media
3 Fixed cost per operation	How every mechanism works	Essentially yes	Storage media
4 Order is expensive to maintain	Information theory	Yes	Data structures
5 You must decide before you know	Decisions under uncertainty	Yes	Storage media
6 The market	Industry	No — changes over a decade	Storage media

Cause 0 — Stability versus mutability

To store one bit you need a physical object with two stable states and a hill between them. Retention, write speed, write energy and endurance are not four separate properties. They are one dial. Being non-volatile means resisting change. Being fast to write means being easy to change. (The derivation.)

Cause 1 — Distance: close or big, not both

Bits take up space. More capacity means more volume, so on average the bits are farther from whatever uses them, and signals travel about 15–20 cm per nanosecond. So the memory hierarchy (small and fast near the CPU, big and slow far away) is not a design pattern someone chose. It is a consequence of the fact that capacity needs space and space needs time. (Inside one machine; across a network.)

Cause 2 — Low cost forces coarse granularity

The mechanism is expensive and the medium is cheap, so a low price per bit means many bits share one mechanism, and bits that share a mechanism must be operated on together. The price ladder and the granularity ladder are the same ladder. This cause produces every amplification factor you will ever measure: write amplification in flash, zone rewrites in SMR disks and the small-files problem in object storage are one problem at four price points. (The derivation.)

Cause 3 — Fixed cost per operation: latency versus throughput

Every mechanism has a setup cost that is paid for each operation, whatever its size. So every medium has a natural transfer size, and batching trades latency for throughput. (The derivation.) Latency and throughput are connected by concurrency, not opposed: that is Little's Law.

Cause 4 — Order is expensive to maintain

This one is not physics. It is information.

Writing is easy if you do not care where data lands: add it at the end. Reading needs to know where things are, which needs structure (sorting, an index). And structure must be kept up to date when data changes. So the work of "knowing where things are" is paid at write time, at read time, or in space.

This three-way trade is the RUM conjecture (Read, Update, Memory — you can optimize at most two). It explains why read-optimized and write-optimized designs are opposites, and why every physical layout is a bet on an access pattern: data sorted by user_id is not sorted by timestamp.

Cause 5 — You must decide before you know

Under the read/write tension there is a sharper problem: you place data before you know how it will be read.

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:

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.

What the collector costs

A copying collector reclaims a unit by moving the live records out of it. If a unit is a fraction u live, you move u bytes to free (1 − u) bytes. The cost per byte reclaimed is

RelationshipWrite amplification of garbage collection →

\frac{u}{1 - u} bytes moved per byte freed; 1 + \frac{u}{1 - u} = \frac{1}{1 - u}

u (live fraction of the unit): $v$ — the fraction of its pages that are still valid

Stated in 2 places →Principle: Immutable storage grows indirection →

At u = 0.5: 0.5 ÷ 0.5 = 1 byte moved per byte freed.
At u = 0.9: 0.9 ÷ 0.1 = 9 bytes.
At u = 0.98: 0.98 ÷ 0.02 = 49 bytes.

(Another way to see it: to write one new byte you must also move u/(1−u) old bytes, so total write amplification is 1 + u/(1−u) = 1/(1−u). This is the same formula as SSD write amplification, 1/(1−v).)

The function is hyperbolic. It does not degrade smoothly. It detonates, and it does so near full utilization, which is exactly where operational pressure pushes you.

This single expression is SSD write amplification, LSM space-amplification tuning and the survivor-copy cost of generational garbage collection. It also explains a design rule that looks like waste and is not:

SSD over-provisioning (hidden spare capacity), LSM space-amplification targets, JVM heap headroom and "keep your warehouse tables under X% full" are the same knob with four vocabularies.

So the pattern has a quantitative clause: every immutable substrate grows an indirection layer plus a collector, and that collector costs u/(1−u) per byte reclaimed, so utilization is a price and not a virtue.

Cause 6 — Economics

Chip factories cost tens of billions of dollars and only pay off at huge volume. A technology that is physically better but has no market dies anyway. Intel Optane was excellent, and Intel stopped it in 2022. Meanwhile 3D NAND got cheaper not by better physics but by stacking more layers, which is a manufacturing story.

So some trade-offs depend on today's industry and will change within a decade. Learn to separate them from Causes 0–2, which will not.

Costs are conserved, never removed

Every design that seems to remove a cost has moved it: across time, space, energy, money, complexity, or to someone else (writer vs. reader, device vs. host, build time vs. run time, your team vs. the on-call team).

LSM-trees do not remove write amplification. They move it from the device into background compaction.
Compression does not remove space cost. It turns it into CPU cost.

When you hear "free win", do not ask "is it true?" Ask "which axis absorbed the cost?" If nobody can answer, it is marketing.