Memory Management and Garbage Collection
Stack vs heap, how garbage collection actually works, generational GC in V8, memory leak patterns and detection, and preventing the leaks that crash production tabs after 30 minutes.
How JavaScript organizes memory at runtime. The stack stores execution frames and primitives with LIFO discipline. The heap stores objects and closures with dynamic allocation. Understanding this split explains why closures are expensive and why stack overflows happen.
Primitives are copied by value — you get an independent copy. Objects are copied by reference — you get a pointer to the same data. This single distinction causes more bugs than any other JavaScript concept. Master it with shallow copy, deep copy, and structural sharing.
The garbage collector's only question: can this object be reached from any root? If yes, it lives. If no, it dies. Understand mark-and-sweep, the root set, why reference counting fails for circular structures, and how to reason about what the GC can and cannot reclaim.
V8 splits the heap into Young and Old generations based on a powerful observation: most objects die young. The Scavenger collects the Young Generation with a fast semi-space copying algorithm. Objects that survive get promoted to the Old Generation, where Mark-Sweep-Compact handles long-lived data.
Stop-the-world pauses kill user experience. V8 fights back with incremental marking (break work into chunks), concurrent marking (run on background threads), parallel scavenging (multiple threads for copying), and tri-color marking (track progress safely). Understand the techniques that keep GC pauses under 5ms.
The 5 classic memory leaks in JavaScript: forgotten event listeners, detached DOM trees, closures over large scopes, unbounded collections, and forgotten timers. Real production code for each pattern, with the exact fix. These are the leaks that crash browser tabs after 30 minutes.
Weak references don't prevent garbage collection. WeakMap stores metadata about objects without leaking them. WeakSet tracks membership without ownership. WeakRef builds caches that automatically evict. FinalizationRegistry provides cleanup hooks. Master the tools for GC-friendly data structures.
When JavaScript's automatic memory management isn't enough. ArrayBuffer gives you raw binary access. Typed arrays (Uint8Array, Float32Array) give you views into that binary data. SharedArrayBuffer enables multi-threaded memory sharing. Master the primitives for binary protocols, image processing, audio, WebAssembly interop, and high-performance computation.
Proactive memory management: set budgets per component, pool objects in hot paths, clean up subscriptions with useEffect returns and AbortController, and build architecture that prevents leaks by construction. The practices that separate apps that run for 30 minutes from apps that run for 30 hours.
7 real-world code snippets with hidden memory leaks. Identify the leak, explain why it happens at the GC level, and provide the fix. Each scenario tests a different leak pattern from the module. Detailed explanations reveal the full retaining path.