Why Interviewers Favor These 5 Go Questions—and How to Ace Them

Question 1: Goroutine and Channel usage principles – how to avoid memory leaks

Interview focus: Does the candidate truly understand Go's concurrency model beyond merely writing go func()?

What is a Goroutine? Difference between a coroutine and a thread.

Channel usage patterns: direction‑only, buffered, closing signals.

Controlling Goroutine exit with select and context.

Properly reclaiming Goroutines using sync.WaitGroup.

Typical channel‑leak scenarios: not closing a channel or write blocking.

High‑scoring answer example:

func worker(ctx context.Context, ch <-chan int) {
    for {
        select {
        case <-ctx.Done():
            return
        case val := <-ch:
            fmt.Println("received", val)
        }
    }
}

Preparation tip: Implement a "timeout task scheduler" to demonstrate Goroutine management ability.

Question 2: Traps of interface{} – when to use type switch vs. type assertion

Interview focus: Depth of understanding of Go's type system. interface{} is the empty interface and can hold values of any type.

Differences between a type switch and a type assertion.

Common trap: an interface{} value that is not nil even though the underlying concrete value is nil.

Designing generic interfaces (e.g., for JSON decoding or RPC data conversion).

High‑scoring answer example:

func checkType(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("int:", v)
    case string:
        fmt.Println("string:", v)
    default:
        fmt.Println("unknown")
    }
}

Trap demonstration:

var err error = nil
fmt.Println(err == nil) // false – the interface is not nil, though the underlying value is nil

Question 3: Is Go's map thread‑safe? How to perform concurrent reads and writes?

Interview focus: Awareness of concurrency safety and handling high‑concurrency data scenarios.

Native Go map is not thread‑safe.

Concurrent writes cause a panic.

Correct approaches:

Locking with sync.Mutex.

Using sync.Map (suitable for read‑heavy, write‑light workloads).

High‑scoring answer example:

var m sync.Map
m.Store("key", "value")
val, ok := m.Load("key")

Common mistake to avoid: Claiming that a map can be safely read and written by multiple Goroutines without protection.

Question 4: How does defer execute? Does it affect performance?

Interview focus: Understanding of the underlying mechanism, performance impact, and tuning awareness. defer follows a last‑in‑first‑out (LIFO) order.

Interaction between function return values and defer execution order. defer runs before the function returns, even if a panic occurs.

There is a performance cost; frequent use in hot paths should be avoided.

High‑scoring answer example:

func demo() (res int) {
    defer func() { res++ }()
    return 1 // actual return value becomes 2
}

Derived questions: Execution order of multiple defer statements; can panic + recover be intercepted inside a defer?

Question 5: How does Go manage packages? What is Go Modules?

Interview focus: Familiarity with modern Go project management and teamwork capabilities.

Go Modules replace the old GOPATH mechanism.

Roles of go.mod and go.sum files.

Common commands: go mod tidy, go mod vendor, replace.

Managing multi‑module projects and dependency isolation.

High‑scoring answer example:

go mod init github.com/yourname/project
go get github.com/gin-gonic/gin
go mod tidy

Common mistake to avoid: Saying "I just copy the library into the project" without using modules.

Conclusion

Interviewers ask these five questions because they quickly differentiate candidates who merely write code from those who have engineered solutions, those who have memorized facts from those who truly understand, and those who have solved practice problems from those who can address real‑world issues. To prepare, provide a working code implementation and a concrete scenario for each question, include pitfalls you encountered and optimization thoughts, and present your answers in a systematic way that reflects engineering thinking.