- read

Interview Questions for a Go Developer. Part 5: Runtime

Aleksandr Gladkikh 131

In the fifth part of our series of articles on Go, we will delve into key aspects of memory management and code execution in this programming language. We will explore important concepts such as the stack and heap, the memory model, escape analysis, garbage collector, and the keyword defer. We will discuss how these elements interact in Go to ensure efficient resource management and program execution safety.

1. What do the stack and heap represent in the context of the Go programming language, and how do they differ from each other?

The stack and heap are two fundamental memory areas used in programming. In the context of Go:

  • Stack: It is a memory area used for storing local function variables, call parameters, and return addresses. The stack operates on a “Last In, First Out” (LIFO) principle, and its size is usually fixed, making push and pop operations fast.
  • Heap: It is a memory area designed for dynamic memory allocation during program execution. The heap stores objects that can be created and destroyed at different times. Memory management in the heap is more flexible but also more time-consuming than in the stack.

2. How Does the Stack Work?

he memory stack is a special type of memory used by computers to manage program execution and store local data within functions. The stack operates on the “Last-In-First-Out” (LIFO) principle, meaning that the last added element will be the first one to be removed.

Here’s how it works:

  • Stack Creation: When a program starts, the system allocates a small area of memory for the stack. This memory area is shared among different execution threads (e.g., different functions in the program).
  • Stack Frames: Each function called in the program creates its own “stack frame.” A stack frame contains the function’s local variables, parameters, return address (the address of the next instruction after the function completes), and other control data.
  • Adding Data: When a new function is called, its stack frame is added to the top of the stack. This means that the new function starts executing, and its local variables and parameters are placed within this stack frame.
  • Removing Data: When a function completes its execution, its stack frame is removed from the top of the stack. This restores the execution state of the previous function, which is located lower in the stack.
  • Stack Overflows: It’s crucial to monitor the stack depth because its size is limited. If too many nested functions are called, a stack overflow can occur, leading to a program crash.
  • Recursion: Recursive functions, which call themselves, use the stack to maintain the state of each call.

The memory stack is crucial for program operation and maintaining the order of execution. It also plays a vital role in managing local variables and transferring control between functions.

3. What types of data are typically stored in the stack, and what types are stored in the heap?

The stack typically stores local variables, pointers to return addresses, and values of basic data types such as integers and booleans. The heap stores dynamically allocated objects, such as strings, slices, maps, and user-defined structures.

4. How Does the Heap Work?

In programming, the heap is a memory area used for dynamic memory allocation and management during program execution. It differs from the stack, which is used for storing local variables and managing function calls.

Key characteristics of the heap:

  • Dynamic Memory Allocation: Memory in the heap is allocated during runtime using operations like malloc (in C/C++) or new (in Go and other languages). This allows programs to request memory at runtime to store data whose size is not known in advance or may change.
  • Manual Memory Management: In most cases, the program is responsible for releasing memory allocated in the heap when it’s no longer needed. If not done correctly, this can lead to memory leaks, where unused memory remains occupied and cannot be used for other purposes.
  • Unordered Organization: The heap is not organized as data structures with a specific order, unlike data structures such as arrays or lists. This means that accessing elements in the heap is not as efficient as with arrays.
  • Addressing via Pointers: Pointers are typically used to work with data in the heap. Variables that store addresses in the heap are called pointers. Using pointers allows efficient traversal of heap memory and data manipulation.
  • Dynamic Size: The size of the heap can dynamically increase as needed. This allows programs to manage memory for data of varying sizes depending on the context.

Examples of languages that use the heap for dynamic memory management include C, C++, Go, Java, and Python (for objects).

It’s important to manage heap memory correctly to avoid memory leaks and undefined program behavior due to improper use of pointers and memory allocation/deallocation. Many modern programming languages provide mechanisms for automatic memory management (e.g., garbage collection) to ease this process.

5. What memory management mechanism is used for stack data, and how is it related to functions?

Data on the stack is managed automatically using “Automatic Memory Management.” When a function is called, a fixed amount of memory is allocated for storing local variables and context. Upon function completion, the allocated memory is automatically released.

6. Which is faster: stack or heap?

The question of whether the stack or heap is faster doesn’t have a straightforward answer because it depends on the specific situation and usage context.


  • Operations on the stack (push, pop) are typically more efficient and faster than operations in the heap because they work with local memory.
  • Stack data usually has more predictable and faster access times because the Last-In-First-Out (LIFO) structure allows for efficient use of processor caches.
  • The size of the stack is often limited, and it is suitable for storing local data and managing function calls.


  • Accessing data in the heap is less efficient because it relies on addressing through pointers. This can slow down program execution.
  • Dynamic memory allocation and management in the heap require additional operations, which can increase overhead.
  • The heap is used for storing dynamically sized data and objects with lifetimes not limited to function scope.

Overall, the choice between the stack and heap depends on specific tasks and program needs. For managing function calls, local variables, and small data, the stack can be faster and more efficient. However, for storing large amounts of data, dynamic memory allocation, and managing the lifecycle of objects, the heap is more suitable.

7. What is the memory model in Go, and how does it differ from the memory model of other programming languages?

The Go memory model provides guarantees regarding parallel execution (goroutines) and data exchange between them. Unlike some other languages, the Go memory model provides “sequentially consistent” guarantees, meaning that operations will be observed in the order they were performed in the program.

8. How to understand when a variable leaks into the heap, and when it remains on the stack? What is the Go command for this?

In the Go programming language, variables can be stored in both the stack and the heap, depending on their type and how they are created. Here are some basic rules:

Variables in the Stack:

  • Primitive data types such as integers, floating-point numbers, booleans, and pointers are typically stored in the stack.
  • Local function variables and function parameters are also typically stored in the stack.
  • Variables in the stack have a limited lifetime and are destroyed when the function exits.

Variables in the Heap:

  • Slices, maps, channels, and user-defined data structures are typically stored in the heap.
  • Variables in the heap have a longer lifespan and are retained until they are explicitly garbage collected.

To explicitly allocate memory in the heap in Go, you can use the `new` keyword or the `make` function depending on the data type:

  • To allocate memory for a pointer to a type, use `new`:
var x *int
x = new(int)
  • To create slices, maps, and channels, use `make`:
slice := make([]int, 10)
myMap := make(map[string]int)
ch := make(chan int)

If you create variables using `new` or `make`, they will be stored in the heap. Otherwise, variables are typically stored in the stack.

It’s important to note that in Go, developers don’t need to explicitly manage memory in the heap, as Go includes a built-in garbage collector that automatically frees memory when it’s no longer in use.

9. How do goroutines affect the memory model and data exchange between them?

Goroutines can run concurrently, and for proper data exchange between them, Go provides synchronization primitives such as channels (`chan`) and mutexes (`sync.Mutex`). These primitives ensure safe access to data and prevent race conditions.

10. How does the Go memory model ensure safe operation with concurrent goroutines?

The Go memory model ensures safety by using synchronization primitives and visibility guarantees. The sequentially consistent guarantee ensures that operations are observed in the order they were performed, helping to avoid race conditions.

11. What is escape analysis in Go, and how does it help manage memory?

Escape analysis is a process where the compiler analyzes the scope and lifetime of objects to determine if they can be placed on the stack instead of the heap. This helps reduce overhead in memory management and avoids memory leaks.

12. Which variables and objects can “escape” from a function, and how does it affect their storage (stack or heap)?

Variables and objects “escape” from a function if the compiler determines that they are used outside the function’s scope, such as when they are returned to the calling function via a return value or through pointers. If a variable escapes, it is typically allocated on the heap to ensure accessibility beyond the function’s scope.

13. What practices can help reduce memory leaks in Go applications?

  • Use local variables and short-lived object lifetimes to keep them on the stack.
  • Properly use pointers and pass data by value or through channels.
  • Manually release resources such as files and network connections using deferred calls (`defer`).

14. What is the garbage collector in Go, and how does it work?

The garbage collector is a mechanism that automatically removes unused objects from memory to free up occupied space. In Go, the garbage collector runs in the background and automatically identifies objects that are no longer reachable through the program.

15. What algorithm does the garbage collector implement in Go?

In Go, the garbage collector implements the “tri-color concurrent mark-sweep” algorithm. This algorithm performs garbage collection with minimal program stoppage and can run concurrently with the execution of the program.

Here’s a brief overview of this algorithm:

Three Colors:

  • Objects in memory can be marked with one of three colors: white, black, or gray.
  • Initial marking: All objects are white (unscanned), except for root objects, which are considered black.

Phases of the Algorithm:

  • Marking Phase: This is the main phase where marking begins from root objects, and the process propagates marking from black objects to their children. Objects become gray when their children have not been fully marked yet.
  • Sweeping Phase: After marking is complete, the garbage collector goes through objects in memory and reclaims memory occupied by white (unmarked) objects.


  • Garbage collection is performed concurrently with the program’s execution. This helps minimize pause times due to garbage collection.
  • During the marking and sweeping phases, the garbage collector can work concurrently with goroutines, ensuring multitasking.

Garbage collection in Go is automatic, and developers do not need to manually manage memory. However, it’s important to understand the general principles of how the garbage collector works to avoid memory leaks and optimize your code’s performance. Refer to the Go documentation for the most up-to-date information, as technologies and algorithms may evolve over time.

16. Which types of objects are considered “garbage” and can be collected by the garbage collector?

The garbage collector collects objects that have no active references from the program. These can be objects that are no longer accessible through variables or data structures, such as when a reference to an object is lost or overwritten.

17. What is `stop the world` and how many times is it executed?

“Stop-the-world” is a term used in the context of garbage collection and refers to a period of time during which the execution of a program is completely halted (paused) so that the garbage collector can free up unused memory and address memory leaks.

In many garbage collection systems, there are two main types of pauses:

  • Generational: In many modern garbage collectors, including the one used in Go, an effort is made to minimize the duration of “stop-the-world” pauses by dividing the heap into several generations. Typically, there is a young generation (containing recently created objects) and an old generation (containing long-lived objects). Most objects become garbage quickly, so garbage collection in the young generation can be fast and have a lesser impact on performance. The old generation is collected less frequently, but the pauses for collection can be longer.
  • Full (Major) Garbage Collection: This is a broader form of garbage collection where the entire heap is analyzed to find garbage. Full garbage collection typically involves longer “stop-the-world” pauses because the entire process can take a significant amount of time.

The frequency of “stop-the-world” events depends on the specific garbage collector implementation, the type of application, the overall data volume, and architectural decisions. In modern garbage collection systems, efforts are made to minimize pause durations and conduct them in parallel with program execution to reduce their impact on performance.

18. What measures can be taken to optimize the performance of the garbage collector and reduce garbage collection overhead?

  • Avoid frequent creation of temporary objects when possible.
  • Use slices instead of arrays where appropriate, as slices are managed more efficiently by the garbage collector.
  • When working with large data sets, consider manually releasing resources using deferred calls (`defer`).

19. How many resources does garbage collector require?

The resource requirements of a garbage collector (GC) can vary widely depending on several factors, including the type of GC, the algorithm used, runtime configuration, the volume of data and program structures, and more.

Here are some general aspects that influence the resource consumption by a garbage collector:

  • Type of Garbage Collector: Different types of garbage collectors have different resource requirements. For example, real-time garbage collectors may consume more resources compared to those that work with pauses.
  • Garbage Collection Algorithm: Different algorithms may consume different amounts of resources. For instance, algorithms that divide the heap into multiple generations may consume fewer resources for the young generation but more resources for the older generation.
  • Data Size: The volume of data that your application works with impacts the amount of memory and time needed for garbage collection.
  • Garbage Collection Tuning: Configuring parameters for garbage collection, such as the frequency and duration of pauses, can affect resource consumption. For example, reducing the frequency of garbage collection may decrease overhead but may also lead to higher memory usage. In Go, the GOGC environment variable controls garbage collection parameters.
  • Concurrency: Some garbage collectors work in parallel with program execution, which may consume additional resources (e.g., CPU time) but minimizes the impact on overall performance.
  • Architecture and Platform: Different architectures and platforms can also influence resource consumption. For example, mobile devices with limited resources may place a greater emphasis on memory management.

So, there’s no one-size-fits-all answer to the question of how many resources a garbage collector requires. Properly configuring and optimizing garbage collection parameters, as well as selecting the appropriate algorithm, depend on the specifics of your application and its performance requirements.

20. What are deferred calls in Go, and what are they used for?

Deferred calls are a mechanism that allows postponing the execution of a function until the current function is about to return. They can be useful for releasing resources, logging, performing deferred functions before returning from a function, and more.

21. What is the order of the `defer` call?

In the Go programming language, the `defer` statement is used to defer the execution of a function until the surrounding function returns or the surrounding block (if used within a block) exits. When multiple `defer` statements are used within a single function, they are executed in a last-in, first-out (LIFO) order, meaning that the most recently added `defer` statement is executed first, and the first one added is executed last.

Here’s an example that demonstrates the order of execution of `defer` statements:

package main

import "fmt"

func main() {

defer fmt.Println("Deferred 1")
defer fmt.Println("Deferred 2")
defer fmt.Println("Deferred 3")


In this example, when the program is executed, the output will be as follows:

Deferred 3
Deferred 2
Deferred 1

You can use the `defer` statement to ensure certain actions, such as closing files or releasing resources, are performed before exiting a function. It’s important to remember that `defer` defers the execution of a function until the current function returns or the current block exits, so the order of execution of `defer` statements can be crucial, especially when working with resources.

22. In what order are deferred calls executed when a function completes?

Deferred calls are executed in reverse order, meaning the last added deferred call will be executed first, and the first added deferred call will be executed last.

23. What is variable capturing in defer?

In Go, the `defer` statement captures the values of variables at the time the `defer` is called, not at the time the deferred function is executed. This can lead to some non-obvious results, especially if variables are modified after the `defer` is called.

Here’s an example that illustrates this aspect:

package main

import "fmt"

func main() {
x := 42
defer fmt.Println("Value of x:", x)
x = 99
fmt.Println("End of main function")

In this example, even though the value of `x` is changed to `99` after the `defer` is called, the value captured by `defer` remains `42`. Therefore, the output will be:

End of main function
Value of x: 42

If you want to capture the current value of a variable in `defer`, you can use an anonymous function to create a closure:

func main() {
x := 42
defer func() {
fmt.Println("Value of x:", x)
x = 99
fmt.Println("End of main function")

In this case, the value of `x` will be captured as a closure, and the result will be:

End of main function
Value of x: 99

Please note that using closures with `defer` can potentially lead to memory leaks if variables are captured in loops or other long-lived data structures because they may hold references to memory longer than expected.

24. What usage scenarios for deferred calls can help ensure proper and safe resource cleanup?

  • Releasing open files or network connections.
  • Freeing memory or resources allocated during function execution.
  • Logging information about function execution or error handling before returning from it.

25. How do I return an error inside defer? (not just logging)

In Go, you can return an error from a function that uses `defer` by simply returning the error inside the deferred function, and then use the returned values to propagate the error up the call stack.

Here’s an example:

package main

import (

func main() {
err := doSomething()
if err != nil {
fmt.Println("Error:", err)

func doSomething() error {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered:", r)

fmt.Println("Doing something...")
return errors.New("An error occurred")

In this example, the `doSomething` function returns an error, and inside the deferred function, we attempt to call the `recover()` function to “catch” any panics that may occur due to returning an error within the deferred function. Then, the error is passed up to `main`, where we check for its presence and handle it.

Note the use of the `recover()` function to “catch” any panic that might occur as a result of returning an error within the deferred function. It’s also important to remember that the `defer` statement will be executed after the function’s execution completes, even if the function returns an error.

In this article, we have explored an essential aspect of the Go programming language related to runtime management in applications. We have discussed key concepts such as memory management, garbage collection, and deferred functions. Understanding these mechanisms plays a crucial role in the development of efficient and reliable applications in Go.

In the next article, we will dive deeper into the world of application development in Go. We will explore practical aspects, including error handling, Context, and the go mod package manager.

Don’t miss the upcoming article, where we will delve into these topics that may be of interest to Go developers and interviewers during technical interviews. Stay tuned for updates and continue learning with us!

Thank you for reading until the end. Please consider following the writer and this publication. Visit Stackademic to find out more about how we are democratizing free programming education around the world.