8 Subtle Go Language Details You Might Not Know

Go is praised for its simplicity and predictability, yet even seasoned developers can fall into subtle traps. Drawing from Harrison Cramer's classic article, we highlight eight practical Go details that improve code robustness.

1. Direct integer iteration (Go 1.22+)

Since Go 1.22, the range clause can iterate over an integer directly, eliminating the need for a traditional for i := 0; i < n; i++ loop.

for i := range 10 {
    fmt.Println(i) // prints 0 to 9
}

✅ Use case: simplifies loops, especially when initializing slices or launching goroutines. ⚠️ Note: i runs from 0 to n‑1 .

2. Generic ~T constraint: matching underlying types

When defining a constant with a type alias (e.g., an enum), ordinary generics reject it:

type Status string
const Active Status = "active"

// ❌ ordinary generic does not accept Status
func print[T string](s T) { ... }

Using ~T allows any type whose underlying type is T:

func print[T ~string](s T) {
    fmt.Println(s)
}

print(Active) // ✅ works because Status underlying type is string

✅ Applicable scenario: handling custom‑type constants or strong‑typed IDs such as type UserID string .

3. String length ≠ character count: UTF‑8 pitfalls

s := "Hello 世界"
fmt.Println(len(s))               // 11 bytes
fmt.Println(utf8.RuneCountInString(s)) // 8 characters

len(s)

returns the byte count (Chinese characters occupy 3 bytes each in UTF‑8).

Iterate over characters with for _, r := range s where r is a rune.

for i, r := range s {
    fmt.Printf("position %d: %c
", i, r)
}

⚠️ Common mistake: accessing s[i] on a UTF‑8 string yields a raw byte, producing garbled output for multibyte characters.

4. nil interface ≠ nil value

A classic Go pitfall:

var dog *Dog = nil
var animal Animal = dog
fmt.Println(animal == nil) // ❌ prints false

Reason: animal is a non‑nil interface containing (type=*Dog, value=nil).

Correct approach: avoid returning a concrete nil pointer as an interface; return a true nil interface instead.

func getAnimal() Animal {
    var d *Dog = nil
    if someCondition {
        return d // ❌ boxed nil
    }
    return &Cat{}
}

Fix by returning an explicit nil interface:

func getAnimal() Animal {
    if someCondition {
        return nil // ✅ true nil interface
    }
    return &Dog{}
}

5. Calling methods on a nil pointer (as long as fields aren’t accessed)

type Logger struct { prefix string }

func (l *Logger) Info(msg string) {
    // safe if prefix isn’t used
    fmt.Println("INFO:", msg)
}

func main() {
    var l *Logger = nil
    l.Info("hello") // ✅ does not panic
    // l.prefix // ❌ would panic
}

✅ Use case: implementing the Null Object Pattern to avoid pervasive nil checks.

6. time.After with context cancellation: avoid goroutine leaks

time.After

creates an internal timer; if the timer isn’t consumed, the goroutine leaks:

// ❌ dangerous: after context timeout, the time.After goroutine still runs
select {
case res := <-ch:
    handle(res)
case <-time.After(5 * time.Second):
    log.Println("timeout")
}

Correct pattern: use time.NewTimer together with ctx.Done() or context.WithTimeout so the timer can be stopped.

timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
select {
case res := <-ch:
    handle(res)
case <-ctx.Done():
    return ctx.Err()
case <-timer.C:
    log.Println("timeout")
}

ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
// use ctx in place of time.After

7. Empty struct struct{} : zero‑memory semaphore

ch := make(chan struct{})
ch <- struct{}{} // send signal
<-ch               // receive signal

struct{}

occupies 0 bytes of memory.

More lightweight than bool or int.

Commonly used for goroutine synchronization, rate limiting, broadcast notifications, worker‑pool task queues, and graceful shutdown.

8. JSON - tag: safely hide fields

type User struct {
    Name     string `json:"name"`
    Password string `json:"-"` // never appears in JSON
    Email    string `json:"email"`
}

u := User{Name: "Alice", Password: "secret123", Email: "[email protected]"}
data, _ := json.Marshal(u)
fmt.Println(string(data)) // {"name":"Alice","email":"[email protected]"}

✅ Safety tip: always tag sensitive fields (passwords, keys, internal state) with - to prevent accidental exposure.

Conclusion: Simplicity does not mean trivial

Go’s “less is more” philosophy hides depth; true Go expertise means mastering memory, concurrency, and the type system beneath the clean syntax.

Write safer APIs.

Build more efficient concurrent logic.

Achieve clearer error handling.

Remember: Go won’t think for you, but it will faithfully execute every decision you make—right or wrong.