5. Memory Management

Stack Memory

The stack stores function call frames, including local variables and return addresses. It is managed automatically: when a function is called, a frame is pushed; when it returns, the frame is popped. Stack allocation is fast but limited in size and lifetime.

Heap Memory

The heap is a larger, more flexible area of memory used for dynamic allocations. Objects that outlive a single function call are typically stored on the heap. Managing heap memory is more complex and can be manual or automatic depending on the language.

In low‑level languages, you may explicitly choose where to allocate. In higher‑level languages, the runtime handles most of this, but understanding the distinction helps explain performance and lifetime behavior.

Garbage collection (GC) automatically frees memory that is no longer in use. The runtime tracks references to objects and periodically reclaims those that cannot be reached from active variables.

GC simplifies programming by removing the need for manual deallocation, reducing certain classes of bugs like double frees. However, GC introduces overhead and potential pauses, which must be considered in latency-sensitive systems.

Common strategies include mark‑and‑sweep, generational GC, and reference counting. Each has trade‑offs between throughput, pause times, and memory overhead.

Memory optimization focuses on using less memory or using it more efficiently. Techniques include choosing appropriate data structures, reusing objects, pooling resources, and avoiding unnecessary copies.

Often there is a trade‑off between speed and memory. Caching may speed up computations but increase memory usage. Optimization involves understanding where memory is truly a bottleneck and targeting those areas.

Effective optimization requires measurement. Memory profilers show what is allocated, how long it lives, and where. Decisions should be based on real data rather than guesswork.

A memory leak occurs when a program allocates memory but never releases it, even though it no longer needs it. Over time, leaks can cause memory usage to grow until the system slows down or crashes.

In manual memory management, leaks often come from missing free/delete calls. In garbage‑collected environments, leaks can arise from lingering references (e.g., storing objects in global collections and never removing them).

To prevent leaks, follow consistent allocation/deallocation patterns, use smart pointers or RAII in manual environments, and avoid unnecessary global references in GC environments. Tools like leak detectors and profilers help find problematic allocations.