Chapter 8: Tools & Ecosystem

1 Go Command Toolchain

Go ships with an all-in-one toolchain. Unlike most languages, you rarely need external build tools — go handles compilation, testing, formatting, and dependency management.

# Initialize a new module
go mod init github.com/user/myproject

# Add a dependency (automatically updates go.mod)
go get github.com/gin-gonic/gin@latest

# Build for current platform
go build -o myapp .

# Run directly without creating a binary
go run .

# Format all files in project
go fmt ./...

# Run static analysis
go vet ./...

# Clean module cache
go clean -modcache

# List all dependencies
go list -m all

2 Testing

Go has a built-in testing package and go test command. Test files end with _test.go and test functions start with Test. No external framework needed.

Basic Test

package math

func Add(a, b int) int {
    return a + b
}

func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

package math

import "testing"

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5
    if got != want {
        t.Errorf("Add(2, 3) = %d, want %d", got, want)
    }
}

func TestDivide(t *testing.T) {
    _, err := Divide(10, 0)
    if err == nil {
        t.Error("expected error for division by zero")
    }
}

Table-Driven Tests

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -1, -2, -3},
        {"zero", 0, 0, 0},
        {"mixed", -1, 5, 4},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.expected {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}

Benchmarks

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(100, 200)
    }
}

// Run benchmarks:
// go test -bench=. -benchmem

Running Tests

# Run all tests
go test ./...

# Run with verbose output
go test -v ./...

# Run specific test by name
go test -run TestAdd ./...

# Run with coverage report
go test -cover ./...

# Generate HTML coverage report
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

# Run benchmarks
go test -bench=. -benchmem ./...

3 Code Quality

Go enforces code quality through built-in tools. gofmt eliminates style debates, while go vet and golangci-lint catch bugs and anti-patterns.

go vet — Built-in Static Analysis

# Catches common mistakes like:
# - Printf format string mismatches
# - Unreachable code
# - Incorrect struct tags
# - Copying locks by value

go vet ./...

gofmt & goimports

# gofmt — canonical code formatting (built-in)
gofmt -w .

# goimports — gofmt + auto-manage import statements
go install golang.org/x/tools/cmd/goimports@latest
goimports -w .

golangci-lint — Comprehensive Linter

# Install
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Run all default linters
golangci-lint run

# Run specific linters
golangci-lint run --enable errcheck,govet,staticcheck

# Fix auto-fixable issues
golangci-lint run --fix

golangci-lint bundles 50+ linters. Key ones include:

4 Popular Third-Party Libraries

While Go's standard library is powerful, these third-party libraries have become de facto standards in the ecosystem.

🌐 Web Frameworks

r := gin.Default()
r.GET("/users/:id", getUser)
r.POST("/users", createUser)
r.Run(":8080")

e := echo.New()
e.GET("/users/:id", getUser)
e.POST("/users", createUser)
e.Start(":8080")

app := fiber.New()
app.Get("/users/:id", getUser)
app.Post("/users", createUser)
app.Listen(":8080")

🗄️ ORM & Database

db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
db.AutoMigrate(&User{})
db.Create(&User{Name: "Alice"})

var user User
db.First(&user, 1)
db.Where("age > ?", 18).Find(&users)

db := sqlx.MustConnect("mysql", dsn)

var users []User
db.Select(&users, "SELECT * FROM users WHERE age > ?", 18)

db.NamedExec("INSERT INTO users (name, email) VALUES (:name, :email)", user)

🔧 Utilities

5 Build & Deployment

Go compiles to a single static binary with no runtime dependencies. This makes deployment exceptionally simple — just copy the binary to the target machine.

Cross-Compilation

# Build for Linux (from macOS/Windows)
GOOS=linux GOARCH=amd64 go build -o myapp-linux .

# Build for Windows
GOOS=windows GOARCH=amd64 go build -o myapp.exe .

# Build for macOS ARM (Apple Silicon)
GOOS=darwin GOARCH=arm64 go build -o myapp-mac .

# Common GOOS/GOARCH combinations:
# linux/amd64    — most cloud servers
# linux/arm64    — ARM servers, AWS Graviton
# darwin/arm64   — macOS Apple Silicon
# darwin/amd64   — macOS Intel
# windows/amd64  — Windows 64-bit

Static Linking & Build Flags

# Fully static binary (no CGO dependencies)
CGO_ENABLED=0 go build -o myapp .

# Strip debug info for smaller binary
go build -ldflags="-s -w" -o myapp .

# Embed version info at build time
go build -ldflags="-X main.version=1.2.3 -X main.buildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)" -o myapp .

Docker Multi-Stage Build

# Dockerfile
FROM golang:1.24-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /app/server .

# Final image — from scratch (no OS, ~5MB total)
FROM scratch
COPY --from=builder /app/server /server
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
ENTRYPOINT ["/server"]

6 VS Code and gopls imports guide

In daily Go work, the VS Code Go extension and gopls connect editor behavior with the Go toolchain. Organizing imports on save, removing unused imports, and adding missing imports are mostly controlled by source.organizeImports and the default formatter setting.

For exact configuration, read VS Code gopls organize imports.

6 Chapter Summary