What Are Stack and Heap?

The article explains the concepts of stack and heap memory in Go programming, describing how memory allocation works, growth directions, and performance implications.

It begins by noting that programming largely involves manipulating memory, and understanding memory allocation enables writing more efficient code. The discussion then covers that both stack and heap are memory blocks with different usage patterns; stack grows downward (toward lower addresses) following LIFO, while heap grows upward via dynamic allocation.

Using Go as an example, the article shows that simple variables like a := 1 are allocated on the stack, whereas a slice s := []int{1,2,3} consists of a pointer (allocated on stack) pointing to underlying array data stored on the heap.

It explains that the compiler determines stack frame size at compile time; only data with unknown or variable size at compile time (e.g., slice backing array) must go on the heap. Stack allocation is efficient, requiring only pointer adjustments and no GC involvement, while heap allocation triggers Go's garbage collector, which can cause stop‑the‑world pauses affecting performance.

The concept of heap escape is introduced: when a variable’s lifetime extends beyond its function (e.g., returning a pointer to a local variable), the variable escapes to the heap. An example demonstrates this:

func main() { c := call() }

func call() *int { x := 2 return &x }

Running go run -gcflags "-m -l" main.go yields the output ./main.go:8:2: moved to heap: x , confirming the escape.

The article concludes by advising developers to favor stack allocation or minimize heap allocations to improve performance and reduce GC pressure.