Computer Science & Algorithms
Section 1
Core Idea
LRU (Least Recently Used) is a cache eviction policy: when the cache is full, evict the item that was used longest ago. It assumes temporal locality—recently used items are more likely to be used again. Simple to implement (e.g. doubly linked list + hash map) and often near-optimal in practice for request sequences with locality. Belady's algorithm (evict the page used farthest in the future) is optimal but unrealisable without a crystal ball; LRU is a practical heuristic that performs well when the workload has recency. Used everywhere: CPU caches, CDNs, in-memory caches, and any bounded buffer where you must choose what to keep.
Free playbook
Get The Business Model Playbook
58 business models, one visual page each: how the money flows, the metrics that matter, and who runs it. Free when you join the Faster Than Normal email.
Free. No spam. Unsubscribe anytime.
Section 2
How to See It
Deciding & Judging
You're seeing Least Recently Used when a system with limited capacity (cache, queue, attention) drops or deprioritises whatever hasn't been touched lately—"use it or lose it" by recency. Prioritisation is effectively LRU when the rule is "keep the recently active, drop the rest."
Section 3
How to Use It
When you have a fixed-size store and must evict something, LRU is the default when recency predicts future use. Implement with O(1) lookup and move-to-front on access. If the workload has different locality (e.g. scan-heavy), consider variants (LRU-K, adaptive) or a different policy. In decisions: "what have we not looked at lately?" often identifies candidates to deprioritise or drop.
Decision filter
"Do we have a bounded resource and a stream of requests? If recency predicts future need, evict least recently used. If the access pattern is different, choose or adapt the policy accordingly."
As a founder
Backlogs, feature lists, and partner pipelines are caches: limited slots, constant churn. LRU thinking—deprioritise or drop what hasn't been touched recently—keeps focus on what's active. Avoid hoarding "someday" items; if it hasn't been used lately, it's a candidate to evict.
Section 5
Founders & Leaders
Jensen HuangCo-founder & CEO, NVIDIA
Huang built NVIDIA around high-throughput memory hierarchies and caching at scale. LRU and its variants are central to GPU memory management and data pipelines—what to keep in fast memory, what to evict. Founders can take the lesson: bounded capacity means eviction policy; recency is a strong default when the future resembles the recent past.
Section 7
Connected Models
Reinforces
Belady's Algorithm
Belady's algorithm is the optimal offline eviction policy (evict the page used farthest in the future). LRU is a practical online approximation; when locality holds, LRU performs close to Belady. Same problem, different information.
Tension
Scheduling & Prioritization
Scheduling orders work by priority or due date; LRU orders eviction by recency. The tension: scheduling is about "what to do next"; LRU is "what to drop." Both allocate scarce capacity under a simple rule.
Leads-to
Binary Search
Caches make search fast by keeping hot data in a small, fast store. LRU decides what stays in that store. Binary search assumes sorted data; caching (with LRU) assumes locality. Together they reduce cost of repeated access.
Section 8
One Key Quote
— Classic systems literature"LRU exploits temporal locality: the assumption that recently referenced items are more likely to be referenced again." When that holds, it's simple and effective; when it doesn't, adapt or switch policy.
Section 11
Summary & Further Reading
LRU evicts the least recently used item when capacity is full. It assumes temporal locality and is easy to implement with O(1) operations. Use it for caches and any bounded buffer where recency predicts future use; tune or replace when the access pattern differs.
01
Book
Covers cache policies, amortised analysis, and data structures for LRU-style eviction.
02
Book
Applies caching and LRU to human attention, storage, and prioritisation.
03