10 Common Go Programming Pitfalls and How to Avoid Them

This article deeply analyzes ten common pitfalls in Go development, covering variable shadowing, string performance, concurrency mistakes, slice and interface usage, and more. It is based on Chapter 16 of "The Way to Go" and is essential for Go interviews and advanced practice.

1. The " := " Conspiracy: Variable Shadowing

Using short variable declaration := inside if or for scopes can unintentionally hide an outer variable.

❌ Bad example:

var remember bool = false
if something {
    remember := true // a new local variable is created
}
// after the if, remember is still false

✅ Best practice: Use assignment = when you intend to modify an existing variable, especially for error variables.

2. String Concatenation: Reject the Performance Killer

Strings in Go are immutable. Using += in a loop creates many temporary strings, causing heavy allocations and GC pressure.

❌ Bad example:

s := ""
for i := 0; i < 10000; i++ {
    s += "data" // each iteration creates a new string
}

✅ Best practice: Use bytes.Buffer or strings.Builder for efficient concatenation.

var b bytes.Buffer
for i := 0; i < 10000; i++ {
    b.WriteString("data")
}
return b.String()

3. defer in Loops: The Hidden Bomb

defer

runs only when the surrounding function returns. Deferring inside a loop keeps file handles open until the function ends, leading to "too many open files" errors.

❌ Bad example:

for _, file := range files {
    f, _ := os.Open(file)
    defer f.Close() // closes only at function exit
    f.Process()
}

✅ Best practice: Close files manually inside the loop or wrap the loop body in an anonymous function.

4. Slice Parameters: No Need for Pointer Indirection

Slices already contain a pointer to the underlying array. Passing a slice by pointer is usually unnecessary.

❌ Bad example:

func process(data *[]int) { ... } // unnecessary pointer

✅ Best practice: Pass the slice directly.

func process(data []int) { ... }

5. Interface Pointer Pitfall

Interfaces already hold type information and a data pointer. A pointer to an interface is rarely useful and can cause compile errors.

❌ Bad example:

func nextFew(n *nexter) { // nexter is an interface type
    n.next() // compile error: *nexter has no method next
}

✅ Best practice: Pass the interface value directly, never a pointer to it.

6. new() vs make(): Clear Distinction

make()

is used only for slices, maps, and channels. It returns a ready‑to‑use reference type. new() allocates memory for arrays, structs, or any value type and returns a pointer to that memory.

7. Concurrency: Closure and Loop Variable Classic Pitfall

Launching goroutines that capture a loop variable often results in all goroutines seeing the final value.

❌ Bad example:

for ix := range values {
    go func() {
        fmt.Print(ix, " ") // all goroutines share the same ix
    }()
}

✅ Best practice: Pass the loop variable as a parameter to the closure.

for ix := range values {
    go func(val int) {
        fmt.Print(val, " ")
    }(ix) // value copy
}

8. Overusing Goroutines: Not Every Task Needs Concurrency

Goroutines are lightweight but not free. For simple or extremely short tasks, the overhead of spawning a goroutine can outweigh the work itself.

✅ Best practice: Use sequential execution when concurrency offers no clear benefit.

9. Error Handling: Reject Boolean Flags

Instead of using a boolean flag to indicate an error, return an error value directly.

❌ Bad example:

var good bool
if !good {
    return errors.New("bad") // unnecessary boolean
}

✅ Best practice: Return the error immediately; consider guard clauses for clearer logic.

10. Value Types vs Pointers: Stack vs Heap Performance

Passing pointers is not always faster. Small structs or basic types are cheap to copy on the stack, while pointers may cause heap allocation and increase GC pressure.

✅ Best practice: Pass values for small data; use pointers only for large structs or when mutation is required.

Conclusion

Go’s philosophy is "less is more," but every line of code deserves careful thought. Mastering these avoidance guidelines helps you ace interviews and write robust, elegant Go programs.