It’s Garbage day for me IRL and I wanted to learn more about garbage collection in programming. So guess what? Now you get to learn more about it too.

We’re going to focus on three languages I work with mostly, Python, JavaScript, and Go. We will skip the rest for now.

Python: Reference Counting

Python’s approach is the most straightforward of the three. Every object keeps track of how many things are pointing to it. When that count drops to zero, the object gets cleaned up immediately. Simple.

There’s a catch, though. If two objects reference each other but nothing else references either of them, the count never hits zero. That’s a reference cycle, and Python handles it with a secondary cycle detector that periodically scans for these orphaned clusters. But for the vast majority of objects, reference counting does the job without any fancy algorithms.

JavaScript (V8): Generational Garbage Collection

Most JavaScript you encounter is running on V8… so Chrome based browsers, Node and Deno. V8 uses a generational strategy based on a simple observation: most objects die young.

V8 splits memory into two main areas:

• The Nursery (Young Generation): New objects land here. This space is split into two halves and uses a scavenger algorithm. It’s fast because it only deals with short-lived variables — and most variables are short-lived.
• Old Space (Old Generation): No, not the deodorant company. Objects that survive a couple of scavenger rounds get promoted here. Old space uses a mark-and-sweep algorithm, which is slower but handles long-lived objects more efficiently.

First it asks, “How long has this object been around?” New stuff gets the quick treatment, and anything that sticks around gets put out to the farm, to be delt where time is less of a premium. It’s a smart tradeoff between speed and memory efficiency.

Go: Tricolor Mark-and-Sweep

Go’s garbage collector also uses mark-and-sweep, but with a twist called tricolor marking. Here’s how it works:

• White objects: These might be garbage but haven’t been checked yet. Everything starts as white.
• Gray objects: The collector has reached these, but it hasn’t scanned their children (the things they reference) yet.
• Black objects: These are confirmed alive — the collector has scanned them and all their references.

The collector starts from known root objects, marks them gray, then works through the gray set — scanning each object’s references and marking them gray too, while the scanned object itself turns black. When there are no more gray objects, anything still white is unreachable and gets cleaned up.

Go’s approach is notable because it runs concurrently. This helps with latency while the GC is running.

Garbage, Collected

Each approach reflects the language’s priorities:

• Python optimizes for simplicity and predictability. Objects get cleaned up correctly when they’re no longer needed
• JavaScript optimizes for speed in interactive applications. Quick cleanup for short-lived objects, thorough cleanup for the rest
• Go optimizes for low latency. Concurrent collection is great for server side processes

References

• Design of CPython’s Garbage Collector — Python Developer’s Guide deep dive into reference counting and cycle detection
• Orinoco: Young Generation Garbage Collection — V8’s parallel scavenger and generational GC design
• A Guide to the Go Garbage Collector — Official Go documentation on the concurrent tricolor collector