Zero Values — Find the Bug¶

package main

import "fmt"

type Counter struct {
    counts map[string]int
}

func (c *Counter) Increment(key string) {
    c.counts[key]++
}

func (c *Counter) Get(key string) int {
    return c.counts[key]
}

func main() {
    var c Counter
    c.Increment("hits")
    fmt.Println(c.Get("hits"))
}

package main

import "fmt"

type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}

func validateAge(age int) error {
    var err *AppError
    if age < 0 {
        err = &AppError{Code: 400, Message: "age cannot be negative"}
    }
    if age > 150 {
        err = &AppError{Code: 400, Message: "age is unrealistically large"}
    }
    return err  // BUG
}

func main() {
    err := validateAge(25)
    if err != nil {
        fmt.Printf("ERROR: %v\n", err)  // This prints! But 25 is valid!
    } else {
        fmt.Println("Valid age")
    }
}

package main

import "fmt"

type User struct {
    Name  string
    Email string
    Admin *Role
}

type Role struct {
    Name        string
    Permissions []string
}

func (u *User) HasPermission(perm string) bool {
    for _, p := range u.Admin.Permissions {  // BUG
        if p == perm {
            return true
        }
    }
    return false
}

func main() {
    user := User{Name: "Alice", Email: "alice@example.com"}
    // Admin is nil (zero value for pointer)
    fmt.Println(user.HasPermission("read"))
}

package main

import "fmt"

func processItems(items []string) {
    if items == nil {
        fmt.Println("Error: no items to process")
        return
    }
    for _, item := range items {
        fmt.Println("Processing:", item)
    }
}

func collectItems(data []string) []string {
    var result []string
    for _, d := range data {
        if len(d) > 3 {
            result = append(result, d)
        }
    }
    return result  // may return nil
}

func main() {
    data := []string{"hi", "ok"}
    items := collectItems(data)
    processItems(items)
    // Output: "Error: no items to process" even though this is valid behavior
}

package main

import "fmt"

type Cache struct {
    data map[string][]byte
}

func (c *Cache) GetOrLoad(key string, loader func() []byte) []byte {
    // Check if in cache
    if val, ok := c.data[key]; ok {  // safe read from nil map
        return val
    }
    // Load and store
    val := loader()
    c.data[key] = val  // BUG: c.data is still nil!
    return val
}

func main() {
    var c Cache
    result := c.GetOrLoad("config", func() []byte {
        return []byte("loaded-config")
    })
    fmt.Println(string(result))
}

package main

import "fmt"

type Config struct {
    Host    string
    Port    int
    Tags    []string
    Options map[string]string
}

func isZeroConfig(c Config) bool {
    return c == Config{}  // BUG
}

func main() {
    c := Config{Host: "localhost", Port: 8080}
    fmt.Println(isZeroConfig(c))  // false — correct

    zero := Config{}
    fmt.Println(isZeroConfig(zero))  // compile error or unexpected behavior
}

package main

import "fmt"

type EventProcessor struct {
    OnSuccess func(event string)
    OnError   func(err error)
    OnRetry   func(attempt int) bool
}

func (ep *EventProcessor) Process(event string) {
    defer func() {
        if r := recover(); r != nil {
            ep.OnError(fmt.Errorf("panic: %v", r))  // BUG: OnError may be nil
        }
    }()

    // Process event
    if event == "" {
        ep.OnError(fmt.Errorf("empty event"))  // BUG: OnError may be nil
        return
    }

    ep.OnSuccess(event)  // BUG: OnSuccess may be nil
}

func main() {
    var ep EventProcessor
    ep.Process("user.login")
}

package main

import (
    "fmt"
    "sync"
)

type SafeCounter struct {
    mu    sync.Mutex
    value int
}

func (c *SafeCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func cloneCounter(c SafeCounter) SafeCounter {  // BUG: copies mutex!
    return c
}

func main() {
    var original SafeCounter
    original.Increment()
    original.Increment()

    clone := cloneCounter(original)  // copies the mutex by value!
    clone.Increment()

    fmt.Println("Original:", original.Value())  // 2
    fmt.Println("Clone:", clone.Value())         // 1... but mutex is corrupted
}

package main

import (
    "encoding/json"
    "fmt"
)

type Player struct {
    Name     string `json:"name"`
    Score    int    `json:"score"`
    Level    int    `json:"level"`
    Deaths   int    `json:"deaths"`
    IsActive bool   `json:"is_active"`
}

func newPlayer(name string) Player {
    return Player{Name: name}
}

func main() {
    player := newPlayer("Alice")
    // Player just created: Score=0, Level=0, Deaths=0, IsActive=false

    b, _ := json.Marshal(player)
    fmt.Println(string(b))
    // Output: {"name":"Alice","score":0,"level":0,"deaths":0,"is_active":false}

    // Problem: Client receives level=0 and thinks player is level 0
    // But we want level=1 for new players
    // Also: deaths=0 looks weird in JSON when player hasn't played yet
    // Also: is_active=false makes player look inactive when they just registered
}

package main

import (
    "encoding/json"
    "fmt"
)

type SearchResult struct {
    Query   string   `json:"query"`
    Results []string `json:"results"`
    Total   int      `json:"total"`
}

func search(query string, items []string) SearchResult {
    var matches []string  // nil slice

    for _, item := range items {
        if len(item) > 0 && item[0] == query[0] {
            matches = append(matches, item)
        }
    }

    return SearchResult{
        Query:   query,
        Results: matches,  // BUG: nil when no results
        Total:   len(matches),
    }
}

func main() {
    items := []string{"apple", "banana", "avocado", "cherry"}

    // Search with results:
    r1 := search("a", items)
    b1, _ := json.Marshal(r1)
    fmt.Println(string(b1))
    // {"query":"a","results":["apple","avocado"],"total":2}

    // Search with NO results:
    r2 := search("z", items)
    b2, _ := json.Marshal(r2)
    fmt.Println(string(b2))
    // {"query":"z","results":null,"total":0}  ← BUG: should be []
    // API clients expect [] for empty, not null!
}

package main

import (
    "fmt"
    "time"
)

type Event struct {
    ID          int
    Name        string
    ScheduledAt time.Time  // zero value is 0001-01-01 00:00:00
    CompletedAt time.Time  // zero value is 0001-01-01 00:00:00
}

func scheduleEvent(name string, when time.Time) Event {
    return Event{
        Name:        name,
        ScheduledAt: when,
        // CompletedAt uses zero value — event not completed yet
    }
}

func isCompleted(e Event) bool {
    return e.CompletedAt != time.Time{}  // BUG: verbose and fragile
}

func isPastDue(e Event) bool {
    return e.ScheduledAt.Before(time.Now())  // works, but...
}

func main() {
    event := scheduleEvent("meeting", time.Now().Add(time.Hour))

    fmt.Println("Completed:", isCompleted(event))
    fmt.Println("Scheduled at:", event.ScheduledAt)
    fmt.Println("CompletedAt zero:", event.CompletedAt.IsZero())
}

package main

import (
    "fmt"
    "time"
)

func producer(done <-chan struct{}) <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        for i := 0; ; i++ {
            select {
            case <-done:
                return
            case ch <- i:
            }
        }
    }()
    return ch
}

func main() {
    done := make(chan struct{})
    nums := producer(done)

    // BUG: trying to merge with a "disabled" nil channel
    var extra <-chan int = nil  // intentionally nil

    timeout := time.After(100 * time.Millisecond)
    count := 0

    for {
        select {
        case n, ok := <-nums:
            if !ok {
                fmt.Println("nums closed")
                goto done
            }
            count++
            _ = n
        case n, ok := <-extra:  // BUG: this is fine (nil ignored), but...
            if !ok {
                extra = nil  // BUG: redundant, already nil, but would work
            }
            _ = n
        case <-timeout:
            close(done)
        }
    }
done:
    fmt.Println("Received", count, "values")
}

package main

import (
    "errors"
    "fmt"
)

type NotFoundError struct {
    Resource string
    ID       int
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s with id %d not found", e.Resource, e.ID)
}

func findUser(id int) (*User, error) {
    var nfe *NotFoundError
    if id <= 0 {
        nfe = &NotFoundError{Resource: "user", ID: id}
    }
    // Simulate: return error if not found
    if id > 1000 {
        nfe = &NotFoundError{Resource: "user", ID: id}
    }
    return nil, nfe  // BUG: always returns non-nil error!
}

type User struct{ ID int }

func main() {
    user, err := findUser(42)
    if err != nil {
        fmt.Println("Error:", err)  // BUG: prints even for valid user
        return
    }
    _ = user
    fmt.Println("Found user!")

    // The correct error check:
    var nfe *NotFoundError
    if errors.As(err, &nfe) {
        fmt.Println("Not found:", nfe)
    }
}