EN
RU
Introduction: Why Go Seems Simple but Hides Pitfalls
Go (Golang) is a compiled, statically typed language created at Google. It is often praised for its simple syntax, built-in concurrency support, and high performance. However, this apparent simplicity often plays a cruel trick on beginners coming from dynamic languages (Python, JavaScript) or even C++.
Many developers, when starting to write in Go, make the same typical mistakes. In this article, we will break down the top 5 most common problems that beginner Go developers face and show how to fix them with clear code examples.
1. Ignoring Returned Errors (Error Handling)
The Problem
Go has no exceptions (try-catch). An error is simply a value that a function returns as the last argument. The most common beginner mistake is to assign the result to a variable but ignore the error using the underscore _.
// BAD: error is swallowedresult, _ := doSomething()fmt.Println(result)Why is this bad?
The program will continue working with incorrect data, which can lead to panics, memory leaks, or logical bugs that are hard to catch.
How to do it correctly
Always check the error. Use the idiomatic pattern:
// GOOD: error is handledresult, err := doSomething()if err != nil { log.Printf("Error executing doSomething: %v", err) return // or panic, or other logic}fmt.Println(result)Tip: Write your code so that if err != nil becomes your reflex. Don't be afraid of early returns — it makes the code cleaner.
2. Confusion with nil and Empty Slices/Maps
The Problem
In Go, nil is not an "empty object". It is the zero value for pointers, slices, maps, channels, and interfaces. Beginners often try to write data into a nil map or slice, causing a panic.
// BAD: panic when writing to a nil mapvar m map[string]intm["key"] = 42 // panic: assignment to entry in nil mapHow to do it correctly
Always initialize maps and slices before use:
// GOOD: initialization via makem := make(map[string]int)m["key"] = 42
// Or via a literalm2 := map[string]int{}m2["key"] = 42The situation with slices is trickier: you can read from a nil slice (it returns an empty slice), but you cannot write to it by index. Use append:
var s []ints = append(s, 1) // OK, creates a new slice// s[0] = 1 // panic: runtime error: index out of range [0] with length 03. Incorrect Use of Goroutines and Data Race
The Problem
Goroutines are lightweight threads. Beginners often launch goroutines forgetting to synchronize access to shared data. This leads to a data race — undefined program behavior.
// BAD: data racevar counter intfor i := 0; i < 1000; i++ { go func() { counter++ // unsafe! }()}time.Sleep(time.Second)fmt.Println(counter) // result is unpredictableHow to do it correctly
Use mutexes (sync.Mutex) or channels for synchronization:
// GOOD: using a mutexvar ( counter int mu sync.Mutex)for i := 0; i < 1000; i++ { go func() { mu.Lock() counter++ mu.Unlock() }()}// Wait for completion (better to use sync.WaitGroup)time.Sleep(time.Second)fmt.Println(counter) // 1000Important: Always check your code for races using the -race flag: go run -race main.go.