Question 1

Can you have a memory leak in a garbage-collected language?

Accepted Answer

Yes, and this surprises people who assume garbage collection makes leaks impossible. It removes one class of leak and leaves another entirely intact.

**What garbage collection actually does.** It reclaims memory that is **unreachable** — objects no code can still get to. It does not reclaim memory that is reachable but useless. If your program holds a reference to something it will never use again, the collector correctly concludes it is still needed and keeps it forever.

So the definition shifts: in a manual-memory language a leak is memory you forgot to free; in a garbage-collected language it is a **reference you forgot to drop**.

**The common causes:**

**Collections that only grow.** A cache, list, map or set that accumulates entries and never evicts. This is by far the most frequent cause in practice. A cache without a bound or a TTL is a leak with a friendly name.

**Event listeners and subscriptions not removed.** Registering a handler creates a reference from the emitter to your object. If the object is discarded but the listener is never unregistered, the emitter keeps it alive — and this is the classic React `useEffect` cleanup bug and the classic DOM leak.

**Closures capturing more than intended.** A closure holds references to everything in its enclosing scope, which can retain far larger structures than the small value you meant to keep.

**Static and global references**, which live for the process lifetime by definition.

**Timers and intervals** never cleared, each holding its callback and its captures.

**Detached DOM nodes** removed from the document but still referenced in JavaScript.

**How to find them:** take **heap snapshots** at two points and compare retained size, then examine the retaining path — the chain of references keeping an object alive. Chrome DevTools, Node's inspector and JVM profilers all support this.

**Weak references** exist for exactly this problem, letting you reference without preventing collection.

Question 2

How does garbage collection actually work?

Accepted Answer

By determining which objects are still reachable from your running program and reclaiming everything else. The key insight is that it does not detect garbage — it detects live data, and treats the

Question 3

What is memory safety, and why does it matter so much?

Accepted Answer

A property of a language or system guaranteeing that a program cannot access memory it should not — no reading past the end of a buffer, no using freed memory, no dereferencing invalid pointers. Its

Question 4

Why is my Node.js application using so much memory?

Accepted Answer

High memory in a long-running process is either legitimate caching, a genuine leak, or garbage collection that has not needed to run yet. Distinguishing them is the first task, because the response

Question 5

How to debug memory leaks in C++?

Accepted Answer

Debugging memory leaks in C++ involves using methods like manual code review, smart pointers, Valgrind, and AddressSanitizer to identify and resolve memory management issues.

Question 6

What are the best C++ memory management techniques?

Accepted Answer

C++ memory management techniques include stack allocation, dynamic memory allocation, smart pointers, memory pooling, and garbage collection. Each has its advantages and trade-offs.

Question 7

What tools can I use to detect memory leaks in C++ applications?

Accepted Answer

C++ memory leak detection tools help identify memory leaks, which can lead to application failures. Tools like Valgrind, ASan, and Visual Studio's tools are effective for this purpose.

Related Questions