Go language interview questions

How Go interviews usually run

For Go backend roles you typically meet: a screening call, one or two coding rounds (often allowed in Go), a round on Go concepts and concurrency, and for experienced roles a system design round. Interviewers care less about trivia and more about whether you can explain WHY Go behaves as it does. Below are the questions that come up again and again, with answers you should be able to give in your own words.

1. What is a slice internally? What happens on append?

A slice is a small header: a pointer to an underlying array, a length and a capacity. Slicing shares the array. append writes into the existing array if there is spare capacity; otherwise it allocates a bigger array, copies the elements and returns a header pointing to the new array. That is why you must use append's return value, and why two slices can unexpectedly change each other.

s := []int{1, 2, 3}
t := s[:2]        // len 2, cap 3, shares s's array
t = append(t, 4)  // fits in capacity: overwrites s[2]
fmt.Println(s)    // [1 2 4]

2. Are maps ordered? Are they safe for concurrent use?

No and no. Iteration order is unspecified and randomised on purpose. Concurrent writes (or a write with a concurrent read) are a data race and can crash the program with "concurrent map writes". Protect a shared map with a sync.Mutex or RWMutex; sync.Map suits only special cases. Reading a missing key returns the zero value; use v, ok := m[k] to check presence. Writing to a nil map panics.

3. Value receiver or pointer receiver?

A value receiver gets a copy, so changes are lost; a pointer receiver works on the original. Use pointers when the method mutates, when the struct is large, or when it contains a mutex; keep a type's receivers consistent. Method sets matter for interfaces: methods with pointer receivers belong only to *T, so only *T satisfies an interface that needs them.

4. Why can an error be non-nil when it holds a nil pointer?

An interface value is a pair (dynamic type, value). It is nil only when both are empty. Returning a nil *MyError as an error gives (type *MyError, value nil), which is not equal to nil. Fix: return a literal nil on success.

5. In what order do deferred calls run? When are arguments evaluated?

for i := 0; i < 3; i++ {
	defer fmt.Print(i)           // prints 210: LIFO, i copied at defer time
}

for i := 0; i < 3; i++ {
	defer func() { fmt.Print(i) }() // Go 1.22+: 210 (each round has its own i)
}                                   // before Go 1.22: 333 (one shared i)

6. How do you handle errors in Go? What are %w, errors.Is and errors.As?

Errors are values returned as the last result and checked right away. Wrap with fmt.Errorf("context: %w", err) to add context while keeping the original. errors.Is(err, target) checks the chain for a specific value (a sentinel such as sql.ErrNoRows); errors.As(err, &target) finds an error of a specific type and gives you its fields. Panic is for bugs, not for expected failures.

7. make versus new

new(T) allocates a zeroed T and returns *T; it works for any type. make is only for slices, maps and channels: it initialises their internal structure and returns the value itself (not a pointer). var m map[string]int is nil and cannot be written; make(map[string]int) can.

8. How does Go's garbage collector work, briefly?

Go uses a concurrent, tri-colour mark-and-sweep collector. Most of the work runs alongside your goroutines, with very short stop-the-world pauses. The compiler's escape analysis keeps many values on the stack, which costs the GC nothing. You can tune it with GOGC (how much the heap may grow between collections, default 100) and GOMEMLIMIT (a soft memory limit, Go 1.19+). To reduce GC work, allocate less: reuse buffers, pre-size slices, avoid needless pointers.

More quick ones