Algorithms for Life: Sorting & Caching

In 1959, two mathematicians named Lester Ford Jr. and Selmer Johnson published a short paper about a tournament problem — how to rank contestants using the fewest possible head-to-head comparisons (Ford, L.R. & Johnson, S.M. (1959). A Tourn…). It seemed like a tidy little puzzle. But sixty-five years later, the problem they opened remains unsolved. We still don't know whether their algorithm is truly optimal. And buried inside that unresolved question is one of the most practically useful ideas in all of computer science: there is a hard, mathematical floor on how much work it takes to put things in order.

The proof is elegant enough to explain over coffee. If you have n items to sort, there are n! (n factorial) possible orderings they could be in. Every time you compare two items — "Is A more important than B?" — you get exactly one bit of information: yes or no. To distinguish among all n! possible arrangements, you need at least log₂(n!) comparisons, which grows as n log n (Knuth, D.E. (1998). The Art of Computer Pr…). This isn't a limitation of any particular algorithm. It's an information-theoretic boundary. The universe itself doesn't contain a shortcut.

Donald Knuth, in his landmark The Art of Computer Programming, formalized this lower bound and showed that even the cleverest comparison-based sorting algorithm cannot consistently beat it (Knuth, D.E. (1998). The Art of Computer Pr…). The Ford-Johnson algorithm comes remarkably close — achieving the theoretical minimum for small input sizes — but for larger sets, no one has proven whether it's optimal (Ford, L.R. & Johnson, S.M. (1959). A Tourn…).

What does this mean for the rest of us? Every time you sit down to rank your priorities, reorganize your files, or sort through a backlog, you are running up against the same constraint. Ranking requires comparisons. Comparisons take time. And the cost grows faster than linearly — which means that doubling the number of things you're trying to organize more than doubles the effort required. The mathematical floor isn't just an abstract curiosity. It's the reason your Sunday evening "get organized" ritual takes three hours instead of thirty minutes.

But here's where it gets interesting. That n log n bound applies only to comparison-based sorting — systems where all you can do is ask "Is A bigger than B?" In computer science, there are non-comparison sorts like radix sort and bucket sort that sidestep the bound entirely by exploiting the structure of the data (Knuth, D.E. (1998). The Art of Computer Pr…). A hospital emergency room does the same thing: triage doesn't rank patients against each other. It classifies them by symptom pattern into categories — critical, urgent, stable — using domain knowledge rather than pairwise comparisons (Triage protocols in emergency medicine (20…). Classification is cheaper than ranking. And that principle transfers directly to human life: the more domain expertise you bring to an organizational problem, the less sorting you actually need to do.

Jeff Dean and Peter Norvig at Google once compiled a table that every programmer knows by heart: the latency numbers for different layers of computer memory (Dean, J. & Norvig, P. Latency Numbers Ever…). An L1 cache reference takes half a nanosecond. Reading from main memory takes a hundred nanoseconds — two hundred times slower. A disk seek? Ten million nanoseconds. The performance difference between having data in the right place and having to go fetch it is not ten percent or even ten-fold. It is orders of magnitude.

Someone once had the idea to multiply all those durations by a billion, scaling nanoseconds up to human-comprehensible time (Dean, J. & Norvig, P. Latency Numbers Ever…). The result is one of the best analogies in all of computer science education. At human scale, an L1 cache hit is a single heartbeat — half a second. An L2 cache reference is a long yawn, about seven seconds. Main memory is brushing your teeth: a minute and forty seconds. But a disk seek? That's sixteen and a half weeks. A semester at university. Just to retrieve one piece of information.

Your physical and cognitive life follows the same hierarchy. The pen on your desk is L1 cache — instant access, zero retrieval cost. The filing cabinet across the room is main memory. The storage unit across town is cold storage. And the insight from computer architecture is this: the system's overall speed is determined not by how fast the fastest layer is, but by how well you manage what goes where (Dean, J. & Norvig, P. Latency Numbers Ever…).

Cognitive science mirrors this architecture remarkably well. Working memory — the mental workspace where you hold and manipulate information — has a capacity of roughly seven plus or minus two items, as George Miller famously established (Neural mechanisms of working memory (2022)…). That's your L1 cache. It's fast but brutally small. Long-term memory, by contrast, has essentially unlimited capacity, but transfer between the two requires effortful encoding — what psychologists call rehearsal and elaboration (Neural mechanisms of working memory (2022)…). The latency gap between "I know this instantly" and "I know I know this but can't quite access it" is the human equivalent of a cache miss.

Research on tip-of-the-tongue states — that maddening sensation of knowing you know something but being unable to retrieve it — confirms this mapping. A 2020 study in Cognition and Emotion found that these states are associated with increased prefrontal cortex activity, suggesting the brain is actively searching through its own index, burning cognitive resources on what amounts to a slow disk read (Neural activity during tip-of-the-tongue s…).

Thomas Malone's pioneering 1983 study of how people organize their desks revealed that workers naturally create physical memory hierarchies without being taught to (Malone, T.W. (1983). How Do People Organiz…). Items used frequently migrated to desk surfaces (hot storage). Items used occasionally ended up in drawers (warm storage). Items used rarely were filed in cabinets or closets (cold storage). The pile on your desk isn't a sign of disorganization — it's a spatially instantiated LRU cache, where visibility serves as the recency signal.

The UK's National Archives has formalized this same principle at institutional scale. Their "Lakehouse" architecture uses Bronze, Silver, and Gold data layers mapped onto explicit temperature tiers: hot streaming storage on SSDs for active processing, warm object storage for the broader accessible dataset, and cold offline archives — some maintained at literal sub-freezing temperatures to preserve fragile film stock (UK National Archives (TNA). Lakehouse arch…). NARA in the United States manages over 13.5 billion pages of federal records using a similar tiered approach, with the "Capstone" method sorting emails not by content but by the organizational role of the sender — a heuristic that dramatically reduces classification overhead (National Archives and Records Administrati…).

For decades, the productivity industry has operated on an unexamined premise: that organizing information into folders, categories, and hierarchies is inherently superior to leaving things in piles. The research tells a very different story.

Personal Information Management (PIM) research has identified a persistent split in how people handle information: filers invest effort upfront to classify items into structured hierarchies, while pilers accept apparent disorder and rely on recency, spatial cues, or search to retrieve what they need (CiteSeerX PIM Research. Premature filing a…). The intuition is that filers should outperform pilers at retrieval. But a key finding from PIM research is that "premature filing" — sorting items before you know whether you'll ever need them again — is frequently wasted work (CiteSeerX PIM Research. Premature filing a…). You pay the cost of classification on every item, but you only recoup that cost on the small fraction you actually retrieve later.

Malone's 1983 ACM study found something even more counterintuitive: hierarchical classification systems tend to have overlapping and ambiguous categories, which means that diligent filers often can't find what they filed because they can't remember which of several plausible folders they chose (Malone, T.W. (1983). How Do People Organiz…). The folder structure that seemed logical at filing time becomes opaque at retrieval time. As Malone put it, the problem isn't that filers are disorganized — it's that hierarchical classification has an inherent ambiguity cost.

Microsoft Research's work on keeping behaviors confirmed this finding in the digital realm, observing that even when folder structures exist, users frequently bypass them in favor of filename search or location-based retrieval (Microsoft Research. Keeping behaviors and…). The tension, researchers found, is between organizing for current use versus organizing for re-use — and most people optimize for the former.

Gmail's architectural decision to use labels instead of folders is an engineering response to exactly this research. A single message can carry multiple labels — functioning as multiple secondary indexes — while search remains the primary retrieval mechanism (Gmail Interface — Labels vs. Folders archi…). As one widely circulated explanation puts it: "Google is all about the search — even in Gmail" (AskLeo.com. How Gmail Labels Relate to Fol…). This is the computational equivalent of saying: don't pay the cost of perfect sorting upfront; invest instead in fast retrieval.

When the UK government redesigned its GOV.UK digital portal, extensive user research revealed that search-first design works beautifully for "known-item" queries — a user searching for "how do I book my driving theory test?" But search utterly fails for exploratory queries where the user lacks domain vocabulary (GOV.UK UX Research. Search vs. taxonomy de…). Citizens seeking financial assistance who didn't know the legal name of benefit programs couldn't form a useful search query. The solution was a hybrid: taxonomy for browsing, search for direct retrieval (GOV.UK UX Research. Search vs. taxonomy de…). Neither pure sorting nor pure searching alone was sufficient.

The warehouse logistics literature provides the most striking confirmation. A Management Science study on "chaotic storage" — deliberately storing dissimilar items together rather than sorting them into product categories — found that order-fulfillment productivity could increase by approximately 5% when chaotic placement was combined with good system-supported lookup (Chaotic Storage, Worker Learning & Order F…). Meanwhile, a separate study using simulated annealing for storage assignment found that when demand patterns were stable enough, optimized "sorted" placement could reduce retrieval time by 21% compared to frequency-based assignment (Simulated Annealing Storage Assignment. Wh…). The reconciliation is clear: sorting pays off only when the demand signal is stable enough that your sort order stays valid. When the environment is volatile, approximate organization plus fast search beats meticulous filing every time.

In 2002, a software engineer named Tim Peters sat down to write a sorting algorithm for the Python programming language. What he created — Timsort — is now used in Python, Java SE 7, Android, GNU Octave, V8 (the engine behind Chrome and Node.js), and Swift (Peters, T. (2002). Timsort algorithm. Pyth…). It powers a substantial fraction of all the sorting that happens on planet Earth. And its central insight is, in a word, laziness.

Timsort doesn't start from scratch. It scans the data looking for subsequences that are already in order — what Peters called "natural runs" — and then merges those runs together (Peters, T. (2002). Timsort algorithm. Pyth…). The philosophy, drawn from Peter McIlroy's 1993 paper on "optimistic sorting," is that real-world data almost always contains pre-existing structure, and a smart algorithm should exploit that structure rather than ignoring it (McIlroy, P. (1993). Optimistic Sorting and…). As McIlroy put it, when a method gets significantly below the information-theoretic limit of log₂(n!), it's either astronomically lucky or it's finding exploitable structure in the data (McIlroy, P. (1993). Optimistic Sorting and…).

This is a profound reframe of the sorting problem. The classical question was: "Given a random pile of items, how do I sort them most efficiently?" Timsort's question is: "Given items that are probably already partially sorted, how do I finish the job with minimal additional work?" The difference matters enormously, because in practice, data is almost never truly random. Your email inbox arrives roughly in chronological order. Your bookshelf has clusters of related titles. Your to-do list has items that naturally group by project.

The human analogue is the difference between a full reorganization and a tidy-up. Marie Kondo asks you to pull every item you own onto the floor and sort from scratch — a comparison sort on the full dataset. Timsort would say: scan for the order that already exists, identify the runs, and merge them. Don't disrupt what's already working.

This connects to a deeper principle in both computer science and cognitive science: the value of exploiting environmental structure. Gerd Gigerenzer's research program on "fast-and-frugal heuristics" demonstrated that simple decision rules — ones that deliberately ignore information — can outperform complex statistical models precisely because they're adapted to the structure of real environments (Gigerenzer, G., Todd, P.M. & ABC Research…). The key empirical finding: heuristics like "Take The Best," which uses a single cue rather than weighing all available evidence, can match or beat regression models in prediction accuracy (Gigerenzer, G., Todd, P.M. & ABC Research…). This works not because ignoring information is inherently smart, but because in uncertain, noisy environments, the extra information adds more noise than signal.

Timsort is the algorithmic embodiment of Gigerenzer's insight. It works better than theoretically optimal algorithms in practice because it's adapted to the structure of real data — just as fast-and-frugal heuristics work better than optimal statistical models because they're adapted to the structure of real environments. The unified principle: in complex real-world settings, exploiting structure beats chasing optimality.

Here is the episode's strongest claim, and it's worth pausing to show why the evidence is so unusually robust. The principle that "good enough" organization beats perfect organization is not supported by a single study or a single tradition. It is independently verified from four distinct intellectual lineages that had no reason to converge — and did anyway.

The first tradition is computer science complexity theory. As we've discussed, the n log n lower bound proves that ranking has irreducible costs (Knuth, D.E. (1998). The Art of Computer Pr…). But beyond that, the field of approximation algorithms has shown that for many optimization problems, guaranteed near-optimal solutions can be computed in polynomial time, while finding the true optimum is NP-hard (Knuth, D.E. (1998). The Art of Computer Pr…). The practical translation: in many real-world problems, the jump from 95% optimal to 100% optimal costs more than the entire rest of the computation.

The second tradition is behavioral economics. Herbert Simon's work on bounded rationality — for which he won the Nobel Prize in Economics in 1978 — established that human decision-makers operate under constraints of limited time, limited information, and limited computational capacity (Simon, H.A. Bounded rationality and satisf…). Simon coined the term "satisficing" — a portmanteau of "satisfy" and "suffice" — to describe the strategy of searching for a solution that meets a threshold of acceptability rather than continuing to search for the optimum (Simon, H.A. Bounded rationality and satisf…). His argument was not that people are irrational for failing to optimize. It was that optimizing is itself irrational when the cost of finding the optimum exceeds the value of having it.

The third tradition is Gigerenzer's cognitive psychology. The ABC Research Group's program on ecological rationality demonstrated that simple heuristics don't just perform "acceptably" — they can actually outperform complex optimization procedures in environments characterized by uncertainty and noise (Gigerenzer, G., Todd, P.M. & ABC Research…). The mechanism is what statisticians call the bias-variance tradeoff: a simpler model with higher bias but lower variance often predicts better out of sample than a complex model with lower bias but higher variance. Ignoring information isn't just cheaper — in noisy environments, it's more accurate.

The fourth tradition is industrial operations research. The chaotic warehouse storage study we discussed earlier — dissimilar items stored together, supported by system-aided lookup — showed that approximate placement combined with good search infrastructure can match or exceed the performance of carefully sorted placement (Chaotic Storage, Worker Learning & Order F…). And a hospital workflow study on RF sponge-detection technology found that adopting a better retrieval system reduced search time by approximately 79.6% (University of Iowa IRO. The Effect of Radi…), confirming that investment in retrieval speed dominates investment in placement precision.

The convergence is the story. Four fields, four methodologies, four sets of researchers who likely never read each other's work — all arriving at the same conclusion. In complex, uncertain, real-world environments, the returns to perfect organization diminish faster than the costs rise. Good enough, supported by good retrieval, beats perfect almost every time.

Of all the ideas in computer science, cache eviction may be the one with the most underappreciated implications for human life. A cache eviction policy is the set of rules that determines what gets removed from fast memory when that memory fills up. And the central insight — counterintuitive, uncomfortable, and deeply important — is that what you choose to throw away matters as much as what you choose to keep.

The most famous eviction policy is LRU — Least Recently Used — which discards whatever you haven't accessed in the longest time (Megiddo, N. & Modha, D. (2003). ARC: A Sel…). It's simple and surprisingly effective. But it has a critical vulnerability: if you sequentially scan through a large dataset once (reading every file in a folder, scrolling through an entire archive), LRU will fill the cache with items you'll never access again, evicting the things you actually use daily. Computer scientists call this "cache pollution."

In 2003, Nimrod Megiddo and Dharmendra Modha at IBM's Almaden Research Center published ARC — the Adaptive Replacement Cache — which addressed exactly this problem (Megiddo, N. & Modha, D. (2003). ARC: A Sel…). ARC maintains not just a cache but a "ghost cache" — a memory of what it recently evicted. When evicted items are requested again, the algorithm learns from its mistakes and recalibrates the balance between recency and frequency (Megiddo, N. & Modha, D. (2003). ARC: A Sel…). The person who keeps a "someday/maybe" list in David Allen's Getting Things Done system is implementing a ghost cache: you've evicted the item from your active work, but you remember having evicted it, and that memory informs future decisions (Allen, D. (2001). Getting Things Done: The…).

The CLOCK algorithm, used in most operating systems, takes a different approach — one that maps even more directly to human practice (CLOCK and Clock-Pro algorithm documentatio…). Rather than maintaining a perfect recency-ordered list (computationally expensive), CLOCK does a periodic sweep through memory, checking each item for a "recently used" flag. Items that have been accessed get their flag set; items that haven't are evicted. This is exactly what a GTD weekly review does: sweep through your commitments, mark what's still active, and discard what isn't (Allen, D. (2001). Getting Things Done: The…).

But the most provocative application of eviction logic comes from organizational psychology. A 2018 study in Frontiers in Psychology on "intentional forgetting in organizations" found that organizations implementing new routines often fail not because employees can't learn the new way, but because they can't forget the old way (Intentional Forgetting in Organizations (2…). The retrieval cues for old behaviors — the familiar interface, the habitual workflow, the muscle memory — keep pulling people back. The study's recommendation: don't just teach the new behavior; actively remove the cues that trigger retrieval of the old one. That's not just change management — it's cache eviction.

The regulatory world has arrived at the same principle from a completely different direction. GDPR Article 17 — the "Right to Erasure," commonly known as the "right to be forgotten" — gives individuals the legal power to issue what amounts to a mandatory cache invalidation request (GDPR Article 17 — Right to Erasure ('Right…). Organizations must delete personal data when it's no longer necessary for its original purpose, effectively imposing a time-to-live on every stored record. But this collides with statutory retention requirements: healthcare records under HIPAA must be kept for minimum periods, financial records have regulatory holds, and litigation preserves data indefinitely (Usercentrics.com. GDPR data retention and…). The result is a complex eviction policy that looks remarkably like ARC's dual-cache architecture: data can be removed from the "active cache" of marketing databases and customer portals, but preserved in restricted cold archives for compliance (Usercentrics.com. GDPR data retention and…).

Document retention and destruction policies at organizations like OASIS formalize this as institutional eviction rules: what gets kept, what gets destroyed, when destruction must be suspended for litigation holds — a system of TTLs and compliance constraints that mirrors cache management precisely (OASIS Open. Document Retention and Destruc…).

The Masicampo and Baumeister study from 2011 adds a cognitive dimension. They found that simply making a concrete plan for when and how you'll address an unfulfilled goal reduces its cognitive burden — neutralizing the Zeigarnik effect without actually completing the task (Masicampo, E.J. & Baumeister, R.F. (2011)…). Writing something down and filing it appropriately sends a signal to working memory: "You can let go. This is handled." That's a cache eviction with a ghost entry — the item leaves active processing but remains accessible if needed.

However, there's a tension here that the productivity industry rarely acknowledges. Research on cognitive offloading — the practice of using external tools to reduce memory demands — has found that while offloading reduces stress, it also reduces intentional memory engagement (Cognitive offloading literature (multiple…). People who routinely write things down and rely on external systems show lower memory performance for the offloaded content (Cognitive offloading literature (multiple…). The productivity system as a cache is excellent. The productivity system as a replacement for memory formation is a trap. You can cache to your inbox, but you must still promote items to long-term memory intentionally.

Merlin Mann coined the term "Inbox Zero" in 2006, and it immediately became one of the most misunderstood ideas in the productivity canon (Mann, M. (2006). Inbox Zero. 43folders.com…). Most people interpreted it as a moral imperative: your inbox should be empty, and if it isn't, you're failing. But Mann's actual framework was algorithmic, not aspirational. The inbox is a bounded buffer — a cache of finite size — and every item in it needs to be processed through a finite-state machine: reply, archive, defer, delegate, or delete (Missive. Inbox Zero Procedural Guidance. m…). The point was never to achieve and maintain emptiness. The point was to run an eviction policy.

The Missive team's modern procedural guidance makes this explicit: when you open an email, do something with it — one of those five actions — which prevents the inbox from becoming unbounded (Missive. Inbox Zero Procedural Guidance. m…). This is a single-pass streaming algorithm. Each message is processed exactly once, classified, and routed. The inbox stays small not through discipline but through architecture.

The deeper insight comes from mapping this to computer science terminology. Your inbox is the hot cache. Your archive is cold storage. Filters and rules are prefetch and automatic classification. "Process each message once" is a single-pass streaming algorithm. "Keep inbox near-empty" is a bounded cache size (Missive. Inbox Zero Procedural Guidance. m…). Once you see the mapping, the emotional charge disappears. A full inbox isn't a personal failing — it's a cache overflow event. And the solution isn't to "try harder" but to adjust the eviction policy.

The GTD weekly review, as described by David Allen, is effectively a rebuild-heap or re-score operation over your task set (Allen, D. (2001). Getting Things Done: The…). If you never run it, your priority queue becomes garbage — filled with items whose priorities have shifted but whose scores haven't been updated. The Software Recommendations community explicitly describes wanting task apps that function as priority queues, automatically surfacing the next most important item without manual re-sorting (Software Recommendations StackExchange. Pr…).

The Japanese 5S methodology — Sort, Set in order, Shine, Standardize, Sustain — embodies a parallel philosophy from a different cultural tradition (Japanese 5S Methodology (2019). Journal of…). The first step, Seiri (Sort), is explicitly about separating necessary from unnecessary items and removing the unnecessary. It's a cache eviction pass. The second step, Seiton (Set in order), arranges the surviving items for efficient retrieval. The methodology's insight is that organization begins with removal, not arrangement.

Mise en place — the culinary practice of staging all ingredients and tools before cooking begins — is another instantiation of the same principle (Oklahoma CareerTech. Mise en Place Kitchen…). It's human prefetching: you build a working set containing only what you'll need for the current session, placed for minimum retrieval latency. Everything else stays in cold storage. The practice exists because chefs discovered empirically what computer architects proved theoretically: the cost of fetching the wrong thing at the wrong time dominates all other costs.

France recognized a version of this principle in labor law when it introduced the "El Khomri" law in 2017, establishing the right to disconnect for companies with 50 or more employees (France El Khomri Law (Law no. 2016-1088)…). Spain followed with a universal right to disconnect in 2018, and Belgium extended the right to private-sector companies with 20 or more employees in 2023 (Belgium Labour Deal Act (2023). Right to D…). The European Agency for Safety and Health at Work has documented that task-switching — the cognitive equivalent of cache thrashing — takes an average of 23 minutes to recover from (23-minute task-switching refocus statistic…). These laws are, at their core, regulatory protection against human cache overflow: legislating the right to close the buffer, flush the cache, and allow cognitive recovery.

If your inbox exceeds 30 items, treat it as a cache overflow event — not a backlog management problem. The difference matters because the solutions are different. A backlog requires you to work faster. A cache overflow requires you to adjust the eviction policy: tighten filters, batch-process at scheduled intervals, and aggressively route items to cold storage.

Let's translate everything we've covered into a concrete protocol — a set of specific, actionable steps grounded in the evidence, not in productivity folklore.

Week 1: Audit your memory hierarchy. Walk through your physical and digital environment and identify what's in each tier. Your desk surface, phone home screen, and browser bookmarks bar are L1 cache. Your filing cabinet, app folders, and email archive are main memory. Your storage unit, cloud backup, and "someday" lists are cold storage. For each tier, ask: does the content match the access frequency? If you're keeping rarely-used items in hot storage (desktop icons you never click, bookmarks you never visit), you have a cache placement problem (Dean, J. & Norvig, P. Latency Numbers Ever…).

Week 2: Run a classification pass, not a sorting pass. Instead of trying to rank all your commitments in linear order — which, as we've established, has n log n cost — classify them into three or four buckets (Knuth, D.E. (1998). The Art of Computer Pr…). Emergency-room triage, not Olympic judging. A useful classification: "Active this week," "Active this month," "Someday/maybe," "Archive." This is radix sorting applied to life: you exploit the categorical structure of your commitments to avoid the cost of pairwise comparison.

Week 3: Implement a single-pass inbox protocol. Choose your primary inbox — email, Slack, physical mail, whatever generates the most inflow — and process it using the five-action finite-state machine: reply (if under two minutes), delegate, defer to a specific calendar block, archive, or delete (Missive. Inbox Zero Procedural Guidance. m…). The goal is not an empty inbox. The goal is a bounded inbox, processed at defined intervals (research suggests twice daily is sufficient for most knowledge workers) (Mann, M. (2006). Inbox Zero. 43folders.com…).

Week 4: Run your first eviction sweep. This is your CLOCK algorithm pass. Go through every active commitment, project, and subscription. Mark each as "recently accessed" or not. Anything not marked gets evicted — not deleted necessarily, but moved to cold storage with its retrieval cues removed (CLOCK and Clock-Pro algorithm documentatio…) (Intentional Forgetting in Organizations (2…). Remember the intentional forgetting research: to truly disengage from old commitments, you need to remove the cues that trigger re-engagement. Unsubscribe from the newsletter. Remove the shortcut. Close the tab.

Ongoing: Schedule a weekly rebuild. The GTD weekly review is a heap-rebuild operation (Allen, D. (2001). Getting Things Done: The…). Without it, your priorities degrade over time as circumstances change but your system doesn't. Block 30 minutes weekly — same day, same time — to sweep all active commitments, update classifications, and evict what's no longer relevant.

The meta-principle threading through all of this is the episode's core finding: the productivity question is almost never "How do I organize this better?" It's "Should I be organizing this at all?" Sorting is a bet on future retrieval. If the future is uncertain, invest in search and retrieval speed, not in upfront classification. If the future is predictable, invest in structure. And in all cases, run regular eviction — because a system that only adds and never removes will, eventually, collapse under its own weight.