Pile contre tas, simplement

Every value in your program lives somewhere in memory. Mojo uses two regions: the stack and the heap. 🧠

The stack is a fast, orderly pile of memory. Local variables go here, and they vanish automatically when a function returns.

The stack is fast because its size is known and it grows and shrinks in a simple last-in, first-out order, like a stack of plates.

The heap is a larger, flexible pool of memory. You use it when a value's size is not known until the program is actually running.

A list that grows, a long string, or anything sized at runtime lives on the heap, since the stack needs fixed, known sizes.

A simple Int or Float has a fixed, tiny size, so Mojo can keep it right on the stack for the fastest possible access.

A List can grow without limit, so its elements live on the heap while a small handle to them sits on the stack.

The heap is more flexible but slower to manage than the stack. Reaching for heap memory has a real cost you should respect.

Stack values clean themselves up at the end of their scope. Mojo also tracks heap values so they are freed at the right time for you.

Most of the time Mojo decides stack or heap based on the type. Knowing the difference simply helps you reason about speed.

Picture the stack as a quick scratchpad and the heap as deep storage. Fast and small versus large and flexible.

Let us see where a growable value lives.

The stack is fast and fixed-size; the heap is flexible for runtime-sized data. Knowing both helps you reason about speed. 🎯