8 Subtle Go Language Details You Might Not Know

“Go looks simple, but the devil is in the details.”

Go is praised for its simplicity, clarity, and predictability, yet even seasoned developers can stumble in edge cases. The following eight subtle details, drawn from Harrison Cramer's classic article, help you write more robust and idiomatic Go code.

1. Direct integer iteration (Go 1.22+)

Since Go 1.22, range 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 starts at 0 and ends at n‑1 .

2. Generic ~T constraint matches underlying types

When defining a constant with a type alias (similar to 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

In UTF‑8, len(s) returns the byte count, while utf8.RuneCountInString(s) returns the number of Unicode code points.

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

len(s)

→ byte count (Chinese characters occupy 3 bytes each).

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

⚠️ Common mistake: accessing a Chinese character via s[i] yields a garbled byte.

4. nil interface ≠ nil value

A classic Go trap: an interface variable holding a typed nil pointer is not itself nil.

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

The interface contains (type=*Dog, value=nil). The safe approach is to avoid returning a concrete typed nil as an interface, and instead return a true nil interface.

func getAnimal() Animal {
    var d *Dog = nil
    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 we don’t touch l.prefix
    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 and 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

An empty struct occupies zero bytes, making it ideal for lightweight signalling.

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

struct{}

uses 0 bytes (more efficient than bool or int).

Commonly used for goroutine synchronization, rate limiting, broadcast notifications.

✅ Typical scenario : implementing worker‑pool task queues or graceful shutdown.

8. JSON - tag: safely hide fields

Using the - tag prevents a struct field from being marshaled.

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]"}

✅ Security advice : hide sensitive fields (passwords, keys, internal state) with - to avoid accidental leakage.

Conclusion: Simplicity does not equal naiveté

Go’s philosophy is “less is more,” but true expertise means mastering memory, concurrency, and the type system beneath the simple syntax.

More secure APIs

More efficient concurrent logic

Clearer error handling

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