Go Command — Find the Bug¶

Practice finding and fixing bugs in Go code related to the go command, build process, module management, and common toolchain issues.

How to Use¶

1. Read the buggy code carefully
2. Try to find the bug without looking at the hint
3. Write the fix yourself before checking the solution
4. Understand why the bug happens — not just how to fix it

Difficulty Levels¶

Bug 1: Missing module initialization 🟢¶

What the code should do: Compile and print "Hello, World!"

// main.go — in a new directory with no go.mod
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

go build -o hello main.go

Expected output:

$ ./hello
Hello, World!

Actual output:

go: cannot find main module; see 'go help modules'

# Fix: initialize the module first
go mod init hello
go build -o hello main.go
./hello

Bug 2: Running a multi-file package incorrectly 🟢¶

What the code should do: Print "Sum: 15"

// main.go
package main

import "fmt"

func main() {
    result := Sum(1, 2, 3, 4, 5)
    fmt.Printf("Sum: %d\n", result)
}

// math.go
package main

func Sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

go run main.go

Expected output:

Sum: 15

Actual output:

./main.go:6:13: undefined: Sum

# Option 1: Run the whole package
go run .

# Option 2: Specify all files
go run main.go math.go

Bug 3: Wrong go get usage for installing tools 🟢¶

What the code should do: Install golangci-lint as a CLI tool.

# Inside a project directory with go.mod
go get github.com/golangci/golangci-lint/cmd/golangci-lint@latest

Expected result: golangci-lint binary available in PATH.

Actual result: The dependency is added to go.mod but no binary is installed. Running golangci-lint gives "command not found."

# Correct: use go install for CLI tools
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Make sure $GOPATH/bin or $GOBIN is in your PATH
export PATH=$PATH:$(go env GOPATH)/bin

Bug 4: Version injection with const instead of var 🟡¶

What the code should do: Print the injected version when built with -ldflags.

package main

import "fmt"

const version = "dev"

func main() {
    fmt.Printf("Version: %s\n", version)
}

go build -ldflags="-X main.version=1.2.3" -o server
./server

Expected output:

Version: 1.2.3

Actual output:

Version: dev

package main

import "fmt"

// Must be var, not const, for -ldflags -X to work
var version = "dev"

func main() {
    fmt.Printf("Version: %s\n", version)
}

Bug 5: Test cache hiding a broken test 🟡¶

What the code should do: Test that always passes.

// main_test.go
package main

import (
    "os"
    "testing"
)

func TestFileExists(t *testing.T) {
    _, err := os.Stat("/tmp/test-data.txt")
    if err != nil {
        t.Fatal("test data file not found")
    }
}

# First, create the file
echo "data" > /tmp/test-data.txt

# Run test — PASS
go test -v ./...

# Delete the file
rm /tmp/test-data.txt

# Run test again — still PASS!
go test -v ./...

Expected output after file deletion:

FAIL — test data file not found

Actual output after file deletion:

ok  mypackage  (cached)

# Option 1: Disable test cache
go test -count=1 -v ./...

# Option 2: The test itself should create its own data (better design)

func TestFileExists(t *testing.T) {
    // Create test data as part of the test — don't rely on external state
    tmpFile := t.TempDir() + "/test-data.txt"
    if err := os.WriteFile(tmpFile, []byte("data"), 0644); err != nil {
        t.Fatal(err)
    }

    _, err := os.Stat(tmpFile)
    if err != nil {
        t.Fatal("test data file not found")
    }
}

Bug 6: Build tag syntax error (silent failure) 🟡¶

What the code should do: Only compile debug.go when the debug tag is provided.

// debug.go
// +build debug

package main

import "log"

func init() {
    log.Println("DEBUG MODE ENABLED")
}

go build -tags debug -o server
./server
# Expected: "DEBUG MODE ENABLED" appears in output
# Actual: No debug message — file was silently excluded

// debug.go
//go:build debug

package main

import "log"

func init() {
    log.Println("DEBUG MODE ENABLED")
}

Bug 7: go mod tidy removing needed test dependency 🟡¶

What the code should do: Tests import a testing utility, but go mod tidy removes it.

// main.go
package main

func main() {}

// main_test.go
package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestSomething(t *testing.T) {
    assert.Equal(t, 42, 42)
}

go mod tidy
go test ./...
# Error: cannot find module providing package github.com/stretchr/testify/assert

# Fix: run go mod tidy AFTER writing all code
# Step 1: Write all code including tests
# Step 2: Then tidy
go mod tidy

# Or explicitly add the dependency
go get github.com/stretchr/testify

# Then verify
go test ./...

Bug 8: Data race not caught without -race flag 🔴¶

What the code should do: Safely increment a counter from multiple goroutines.

package main

import (
    "fmt"
    "sync"
)

var counter int

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter++
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", counter)
}

go run main.go
# Output: Counter: 987 (or some number close to 1000, appears to work)

Expected output:

Counter: 1000

Actual output:

Counter: 987 (varies, sometimes 1000, sometimes less)

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var counter atomic.Int64

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Add(1) // atomic increment
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", counter.Load())
}

Bug 9: CGO binary fails in scratch container 🔴¶

What the code should do: Run a Go HTTP server in a Docker scratch container.

FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN go build -o server ./cmd/server

FROM scratch
COPY --from=builder /app/server /server
ENTRYPOINT ["/server"]

docker build -t myserver .
docker run myserver

Expected output:

Server listening on :8080

Actual output:

standard_init_linux.go:228: exec user process caused: no such file or directory

FROM golang:1.22 AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o server ./cmd/server

FROM scratch
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /app/server /server
ENTRYPOINT ["/server"]

Bug 10: Cross-compilation silently uses wrong architecture 🔴¶

What the code should do: Build a Linux ARM64 binary on an AMD64 machine.

GOOS=linux GOARCH=arm64 go build -o server-arm64 ./cmd/server
file server-arm64
# Expected: ELF 64-bit LSB executable, ARM aarch64

// cmd/server/main.go
package main

/*
#include <stdio.h>
void greet() { printf("Hello from C!\n"); }
*/
import "C"

import "fmt"

func main() {
    C.greet()
    fmt.Println("Server starting...")
}

Expected output:

ELF 64-bit LSB executable, ARM aarch64

Actual output:

# command-line-arguments
/usr/bin/ld: cannot find -lc
collect2: error: ld returned 1 exit status

# Option 1: Remove CGO dependency (preferred)
# Remove the import "C" and C code, use pure Go alternatives

# Option 2: Provide a cross-compiler
CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc \
    GOOS=linux GOARCH=arm64 \
    go build -o server-arm64 ./cmd/server

# Option 3: Build inside a Docker container matching the target
docker buildx build --platform linux/arm64 -t myserver .

Bug 11: go:embed path not found 🔴¶

What the code should do: Embed all HTML templates.

package main

import (
    "embed"
    "fmt"
)

//go:embed ../templates/*.html
var templates embed.FS

func main() {
    entries, _ := templates.ReadDir("templates")
    for _, e := range entries {
        fmt.Println(e.Name())
    }
}

go build
# pattern ../templates/*.html: invalid pattern syntax

// Move the embed directive to a package at or above the templates directory
// Or restructure your project so templates are within the package:
//
// cmd/server/
// ├── main.go
// └── templates/
//     ├── index.html
//     └── about.html

//go:embed templates/*.html
var templates embed.FS

func main() {
    entries, _ := templates.ReadDir("templates")
    for _, e := range entries {
        fmt.Println(e.Name())
    }
}

Score Card¶

Rating:¶

• 11/11 without hints → Senior-level Go toolchain expertise
• 8-10/11 → Solid Go middle-level understanding
• 5-7/11 → Good junior, keep practicing
• < 5/11 → Review the topic fundamentals first