Leaks in a garbage-collected language

Retention, not “forgetting to free”

From lesson 01: the GC keeps everything reachable from a root, because reachability over-approximates liveness. A leak in a garbage-collected language is the over-approximation biting back — an object you are logically done with stays reachable through some reference you did not intend to keep. The GC is correct to retain it; the bug is in your reference graph, not in the collector.

So leak hunting is never “where did I forget to free?” It is “what is the retainer path?” — the chain of references from a root down to the leaked object. Cut any link on that path and the object becomes unreachable and gets collected. The fix is always severing a reference, never freeing.

This builds directly on closures pinning their Context (05-closures-scope/02-closure-memory): a closure is one of the commonest accidental retainers, because it keeps its whole captured environment alive for as long as the closure itself is reachable.

A field guide to real retainers

1. Timers and intervals that are never cleared. setInterval keeps its callback reachable forever from the runtime’s timer table; the callback’s closure keeps everything it captured alive.

function startPolling(bigState) {
  setInterval(() => check(bigState), 1000);  // bigState pinned forever
}
// fix: const id = setInterval(...); clearInterval(id) on teardown

2. Event listeners never removed. el.addEventListener('x', handler) makes the target retain handler, and handler’s closure retains whatever it captured. On SPA route changes this accumulates.

window.addEventListener('resize', onResize);  // retains onResize + its closure
// fix: window.removeEventListener('resize', onResize) on unmount

3. Unbounded caches — Map/array/Set used as a cache that only grows. The container is module-scoped (a root), so every entry is retained until removed. Without a cap or TTL, it grows monotonically.

const cache = new Map();
function memo(key, compute) {
  if (!cache.has(key)) cache.set(key, compute(key));  // never evicted
  return cache.get(key);
}
// fix: LRU with a max size, or a TTL, or WeakMap if keyed by an object

4. Closures sharing a Context that pins a big variable. Multiple closures from the same scope share one Context object; if any closure is long-lived, the whole Context — including a huge variable only another closure used — stays alive. (See 05-closures-scope/02-closure-memory.)

5. Detached DOM nodes still referenced from JS. You remove a node from the document, but a JS variable, array, or closure still references it. The node — and its entire subtree — cannot be collected. In browsers this also keeps detached windows/iframes alive, a heavy leak.

6. SlicedString pinning a huge parent. huge.slice(0, 10) in V8 can produce a SlicedString that references the original string rather than copying 10 chars, so a tiny substring keeps a multi-megabyte parent alive. Force a copy when you keep a small slice of a large string.

7. Global accumulation. Anything hung off globalThis / window (or a module-level singleton) is rooted for the process lifetime. An accidental global (x = 1 without declaration in sloppy mode) is a classic.

8. “Collected but not returned to the OS.” Sometimes the object is collected but RSS does not drop: the heap was fragmented, so V8 holds the pages. This is not a JS-level leak — it is fragmentation (lesson 03’s compaction territory), diagnosed differently (RSS high, heapUsed low).

What unites all eight patterns: each one is an unintended root-to-object path. Without it the GC would collect freely; with it the GC is merely doing its job. When you see RSS climb on a production service, mentally trace the chain — container → closure → object — until you find the link that does not belong.

Weak references: let the GC win the tie

When you need to associate data with an object without keeping that object alive, use a weak reference, which the GC ignores when computing reachability:

• WeakMap / WeakSet — keys (WeakMap) or values (WeakSet) are held weakly. When the only remaining references to a key object are weak, the entry is collectible automatically. Perfect for per-object metadata caches keyed by the object itself — no manual eviction, no leak.
• WeakRef — a weak reference to a single object; .deref() returns the object or undefined if it has been collected. For caches where you want the value to disappear under memory pressure.
• FinalizationRegistry — register a cleanup callback that may run after an object is collected. Use sparingly: finalizers are not guaranteed to run, run at an unspecified time, and must never be relied on for correctness — only for best-effort cleanup of external resources.

const meta = new WeakMap();          // keyed by DOM node, say
meta.set(node, { lastSeen: now });   // does NOT keep `node` alive
// when `node` is removed and otherwise unreferenced, the entry vanishes