Why Go Is Fast: 5 Key Language Features Explained

Introduction

David Cheney, a long‑time Go contributor, presented at Gocon 2014 about the language features that make Go fast. The talk covers memory layout, concurrency primitives, escape analysis, inlining, and goroutine scheduling.

Why Choose Go?

Three primary reasons people adopt Go are its lightweight concurrency primitives, ease of deployment, and raw execution speed.

1. Efficient Value Handling

Go stores simple values compactly. For example, an int consumes four bytes, similar to Java, but unlike Python which adds significant overhead for type information and reference counting.

Custom structs such as a Location type occupy only 24 bytes, allowing an array of 1,000 locations to use just 24 KB, which fits well in CPU caches.

2. Inlining

Function calls have inherent costs: creating a stack frame, saving registers, and jumping to the callee address. Inlining removes the call overhead by embedding the callee’s body into the caller, at the expense of larger binaries.

Only small, frequently called functions are inlined; complex functions are left as calls.

3. Escape Analysis

Escape analysis determines whether a value can be allocated on the stack instead of the heap. Stack‑allocated values avoid garbage‑collection overhead and improve cache locality.

Example: Sum computes the sum of 1‑100; the slice it creates does not escape the function, so it lives on the stack.

Sum

4. Goroutine Scheduling

Goroutines are lightweight, cooperatively scheduled user‑level threads. The runtime multiplexes many goroutines onto a small set of OS threads, performing context switches only at defined points such as channel operations, syscalls, or GC pauses.

Blocking channel send/receive

Explicit go statement

Blocking I/O syscalls

After a GC stop

5. Dynamic Stack Management

Go stacks start small (a few kilobytes) and grow on demand. When a function needs more stack space, the runtime allocates a larger segment, copies the existing stack, and continues execution, eliminating the need for protected guard pages.

This design avoids the “hot split” problem where recursive calls cause frequent stack segment switches.

Conclusion

The five features—compact value representation, inlining, escape analysis, efficient goroutine scheduling, and growable stacks—work together to give Go its performance edge. They are interdependent: inlining reduces stack checks, escape analysis improves cache locality, and lightweight goroutine scheduling relies on the dynamic stack model.

For further reading, see Cheney’s related posts on Go performance, goroutine stack size, and runtime environment variables.