What is the difference between a heap and a stack?

Stack and heap are two different memory management methods in programming, including in Go.

Stack is a memory area where local variables of functions and information about function calls (return address, parameters) are stored. It operates on a LIFO (last-in, first-out) principle. The stack is quickly allocated and freed as control automatically occurs when entering and exiting functions. The size of the stack is usually limited and small.

Heap is a memory area for dynamic allocation, where objects live longer than the execution time of a single function. Memory in the heap is allocated and freed manually or with the help of a garbage collector. The heap allows creating objects with a dynamic lifespan and arbitrary size.

In Go, the stack is used for local variables and function calls, while the heap is for objects that need to live longer (for example, when passing pointers). The Go compiler automatically decides where to place a variable (on the stack or in the heap) through escape analysis.

Example:

func foo() *int {
    x := 10       // local variable
    return &x     // returning a pointer, x "escapes" to the heap
}

func main() {
    p := foo()    // p points to memory in the heap
    fmt.Println(*p)
}

Here, the variable x will be placed in the heap because its address is returned from the function.