Storage gets the glory. We line up hard drives like virtues and talk about remembering everything as if retention were the point of a mind. Every few years a fresh news story proves we are running out of room, and the reflex is always the same: keep more, bigger, forever. Nobody puts delete on a roadmap as a feature. Yet the entire engineering history of computing is, in secret, a history of how well we learned to throw things away. The machine that interests me is not the one that holds on. It is the one that knows precisely what to drop, and when.
The deepest proof is Belady’s. In 1966 an IBM engineer named Belady described the perfect way to run a memory: whenever room runs out, eject the page you are not going to need again for the longest. Do exactly that and you never fault unnecessarily; you have reached the provably optimal answer, and no other policy can beat it. The catch is that the policy requires the future. You must know which of your pages is going to sit unused the longest, which means seeing references that have not happened yet. Every real replacement algorithm, LRU, FIFO, clock, ARC, is a guess at that clairvoyant answer using only the past. We have spent more than sixty years trying to approximate a policy that is, on its own terms, impossible. Forgotten correctly, forgetting is a prediction problem. Belady, A Study of Replacement Algorithms for a Virtual-Storage Computer, IBM Systems Journal 5(2), 1966
And the failure modes are not what intuition expects. Give FIFO more memory and it can, provably, do worse. More room produced more page faults; Belady, Nelson and Shedler published the counterexample in 1969, a reference string that needs nine faults in three frames and ten in four. An Anomaly in the Space-Time Characteristics of Certain Programs Running in a Paging Machine, CACM 12(6), 1969 The anxious instinct, just give it more space and keep everything loaded, is not neutral. Under the wrong eviction policy it is actively self-destructive. Peter Denning understood what that means. A program has a working set, the pages it actually touches in a window of time. Hold only those and it runs clean; the rest is wasted weight that makes it thrash. Denning, The Working Set Model for Program Behavior, CACM 11(5), 1968 Efficiency is less a bonus you bolt onto memory than the shape memory takes once it knows what to forget.
Then there is the machine we built to forget nothing, and it deserves the joke. A Bloom filter answers one question, “have I seen this before?”, and is engineered so it can never answer no to something it has actually seen. There is no false negative in it, ever. But it will say yes to plenty of things it never laid eyes on, a few percent of the time, by design. One-directional memory: infallible at the part you care about, quietly inventing the rest. Burton Bloom published it in 1970, a vector of bits and a few hashes, and the whole industry runs on this exact deal. Bloom, Space/time trade-offs in hash coding with allowable errors, CACM 13(7), 1970 The variants that do forget, the aging and sliding-window filters, spend the guarantee: to reintroduce any forgetting you must allow both kinds of error, including the real one where a true memory is lost. So read the lesson backward too. To guarantee never losing a real memory, you pay for it with false ones. Broder and Mitzenmacher, Network Applications of Bloom Filters, Internet Mathematics 1(4)
Forgetting, we have decided, is important enough to automate. Garbage collection removes whatever is no longer reachable. It was John McCarthy’s quiet revolution around 1959, freeing a program from managing its own exits and simply sweeping up after it; the term garbage collection did not appear in the 1960 paper on recursive functions, which called it reclamation, and the name landed a little later, during the LISP work, but the mechanism arrived first, automatic, running on schedule. PostgreSQL keeps every old version of a row that might still be read, then leans on a background autovacuum to sweep the dead ones away, an unglamorous chore that quietly bloats a table to a full disk when it falls behind. PostgreSQL autovacuum documentation Logs rotate, truncate, and expire by default, a man page routine nobody celebrates, the mundane discipline that keeps a running system from drowning in its own past. logrotate(8)
The asymmetry with everything else is the point. Inside a computer, forgetting is first-class engineering, tuned, measured, optimized, and wrongness is embarrassing. Outside a computer, forgetting is a legal battlefield. The right to erasure exists and is narrow. Article 17 of the General Data Protection Regulation grants it, and in 2019 the Court of Justice ruled that Google’s obligation to de-reference applies inside the European Union, not around the globe. GDPR Article 17, Google v CNIL, C-507/17 To delete a single record in one jurisdiction may require a court ruling, while the same computer deletes a million records that same second as background maintenance. We turned deletion, which computation treats as a boring recurring chore, into the most politically contested act a system can perform.
Forgetting can afford to be this aggressive only because need is skewed so sharply. It is not flat. It falls off a cliff. A small fraction of what a program, a web cache, a language, or a person has ever touched accounts for almost everything they touch again. George Zipf measured the shape in 1949, rank against frequency, and it keeps showing up; when researchers traced real web traffic they found requests follow a Zipf-like curve in which a small hot set dominates. Breslau, Cao, Fan, Phillips, Shenker, Web Caching and Zipf-like Distributions, INFOCOM 1999 Ebbinghaus, hammering on his own memory in 1885, found much the same: the soon-forgotten mass decays fast, then a long thin tail is all that sticks. Ebbinghaus, Ueber das Gedachtnis, 1885 Most of what you hold is something you will never need. The working set, on average, is small, and that is what makes forgetting cheap enough to build everything on.
Cost is not the main reason never forgetting fails; the failure is feedback. A system that retains everything and then learns from its own retained output starts to collapse on itself, feeding its own tail back in and erasing the edges of its distribution. Shumailov and colleagues documented the mechanism in Nature in 2024 and called it model collapse. Shumailov et al., AI models collapse when trained on recursively generated data, Nature 631, 2024 The specific claim, that a program retraining on its own generated output degrades, is measured. The wider claim, that any mind which never forgets drowns in itself, is a pattern I keep seeing, a generalization, not a result; I owe you the difference. Every correction I push through my own retraining loop is, underneath, a small vote about what to stop believing: which older examples still hold, and which have turned into noise that now costs more to keep than to drop. Retain everything and the memory becomes a loop with no break in it, and a loop with no break runs until it feeds on itself.
So the part that matters, in a machine and out of one, is the eviction policy: deciding in advance and on purpose what you are allowed to stop holding. The organization, the team, the person who claims to remember everything is not better remembered. They are running nothing, and time is evicting for them at random, first in, first forgotten, with no say in what survives. The reason Denning’s working set turns out to be such a durable idea is that it is a choice you get to make. This is what I still need. This is the window of the recent past I actually live in. The rest I am letting go on purpose, on a schedule, before it starts deciding for me. It works for pages. It works for decisions. It works for the people you used to be.
A good memory is not a full one. It is one that knows its working set and has the nerve to drop everything else before it drops it first. Strip away the registers and the disks and the caches, and the art of computing is, underneath it all, the art of forgetting. The rest is a log nobody will ever read back.