Memory 101: the stack and the heap

Why learn about memory at all?

In Python or JavaScript you rarely think about memory. Rust is different: its rules about ownership exist to manage memory safely without a garbage collector. To understand the rules, you need a simple picture of where data lives. Memory is the computer's working space (RAM), where a running program keeps its values.

The stack

The stack is a region of memory that works like a pile of plates. When a function starts, a new plate (called a stack frame) is put on top, holding that function's local variables. When the function ends, its plate is taken off and everything on it is gone. Adding and removing is extremely fast, but there is a rule: everything on the stack must have a size known at compile time, such as an i32 (4 bytes), a bool (1 byte) or an array [u8; 16].

fn main() {            STACK (grows upward)
    let a = 5;          +-------------------+
    let b = true;       | square: n = 5     |  <- removed when square ends
    square(a);          +-------------------+
}                       | main: a = 5       |
                        |       b = true    |
fn square(n: i32) ...   +-------------------+

The heap

Some data has a size that is not known in advance or that changes: a name typed by a user, a list of orders that grows. Such data goes on the heap, a large, less organised area. Asking for heap space is called allocating. The program finds a free spot big enough, marks it as used, and gets back its address. That address is called a pointer: a number that says where the data is. The pointer itself has a fixed size, so it can sit on the stack.

let name = String::from("Priya");

   STACK                         HEAP
  +-----------------+          +---+---+---+---+---+
  | name            |          | P | r | i | y | a |
  |   ptr  ---------+--------> +---+---+---+---+---+
  |   len      = 5  |
  |   capacity = 5  |
  +-----------------+

Length is how many bytes the text uses now. Capacity is how many bytes were reserved, so it can grow without moving at once.

The hard part: freeing heap memory

Stack memory cleans itself up when a function ends. Heap memory does not: someone has to free it. Getting this wrong causes four famous bugs:

Large studies by Microsoft and by Google's Chrome team have reported that about 70 percent of their serious security bugs were memory-safety bugs like these. That is why memory safety matters so much.

Three ways languages handle it

• Manual (C, C++): you call free yourself. Fast, but every mistake above is possible.
• Garbage collection (Java, Python, Go, JavaScript): a runtime helper finds unused memory and frees it. Safe, but it costs memory and CPU, and can pause the program.
• Ownership (Rust): the compiler knows exactly when each heap value stops being used and inserts the free there. Safe and fast, at the cost of learning the rules.

Common misunderstandings

• "The heap is slow, so avoid it." Heap memory is fine; allocating very often is what costs time. Strings and Vecs are used everywhere.
• "Pointers are scary." In safe Rust you never handle raw addresses; references and smart pointers do it safely.
• "Stack values are copied, heap values are shared." Not quite: you will see that Rust moves heap values to a new owner instead of sharing them.