V8 Internals & Garbage Collection

V8 doesn't treat JavaScript objects as hash maps. Every object gets a hidden class (internally called a Map) describing its shape — property names, order, and memory offsets. Understanding shape transitions, transition trees, and the difference between in-object properties and the backing store is the foundation of V8 performance.

V8 doesn't interpret or compile your JavaScript — it does both, in tiers. Code starts in the Ignition interpreter, gets baseline-compiled by Sparkplug, optimized by Maglev, and peak-optimized by TurboFan. Understanding this pipeline explains why some code is fast immediately and other code needs to 'warm up.'

V8's inline caches speed up property access by remembering object shapes. A monomorphic site (one shape) is blazing fast. Polymorphic (2-4 shapes) is slower. Megamorphic (5+ shapes) falls back to hash lookups. Understanding these states is the key to writing V8-friendly code.

TurboFan optimizes your code based on assumptions about types and shapes. When those assumptions break, V8 deoptimizes — throwing away optimized machine code and falling back to the interpreter. Understanding deoptimization triggers, eager vs lazy deopt, and how closures capture stale assumptions is essential for writing consistently fast JavaScript.

V8 splits the heap into Young and Old generations based on the observation that most objects die young. The Scavenger handles the Young Generation with a fast semi-space copying algorithm. The Old Generation uses Mark-Sweep-Compact with concurrent and incremental techniques to minimize pause times.

High allocation rates create GC pressure — frequent Scavenge cycles, premature promotion, and increased marking work. Object pooling, pre-allocated arrays, and flyweight patterns reduce allocation churn in hot paths. Understanding the trade-offs lets you apply these patterns where they matter without over-engineering cold code.

A ring buffer (circular buffer) uses a fixed-size array with head and tail pointers to store streaming data with zero allocations. Combined with TypedArrays, it's the foundation for GC-free telemetry, animation frame history, event buffering, and real-time audio processing in JavaScript.

JavaScript's garbage collector handles reachability, not intent. Memory leaks happen when objects remain reachable long after they're logically done. This chapter covers the most common leak patterns — forgotten event listeners, closures over large scopes, detached DOM trees, uncleared timers, and growing caches — with heap snapshot techniques to identify each one.

Strong references keep objects alive. Weak references let the garbage collector reclaim them. WeakMap, WeakSet, WeakRef, and FinalizationRegistry give you precise control over object lifetime — if you understand reachability.