go-development

Go Development

Production patterns and idioms for Go programming, covering project structure, error handling, concurrency, interfaces, testing, and module management.

When to Use This Skill

• Starting or structuring a Go project
• Writing idiomatic Go error handling
• Working with goroutines and channels
• Designing interfaces and composable packages
• Writing tests with go test
• Managing dependencies with Go modules
• Using context for cancellation and propagation

Core Concepts

1. Project Layout

myapp/
├── cmd/
│   └── myapp/
│       └── main.go          # Entry point
├── internal/                 # Private packages (not importable externally)
│   ├── handler/
│   │   └── handler.go
│   ├── service/
│   │   └── service.go
│   └── repository/
│       └── repository.go
├── pkg/                      # Public reusable packages
│   └── httputil/
│       └── response.go
├── go.mod
├── go.sum
├── Makefile
└── README.md

2. Key Principles

Principle	Go Idiom
Error handling	Return error as last value, check immediately
Composition	Embed interfaces, not structs
Concurrency	Share memory by communicating (channels)
Simplicity	Fewer abstractions, explicit over implicit
Zero values	Design types so zero value is useful

Quick Start

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

# Add dependencies
go get github.com/gin-gonic/gin@latest

# Tidy dependencies
go mod tidy

# Build and run
go build -o myapp ./cmd/myapp
go run ./cmd/myapp

# Run tests
go test ./...
go test -v -race -count=1 ./...

Patterns

Pattern 1: Error Handling

package service

import (
    "errors"
    "fmt"
)

// Define sentinel errors for comparison
var (
    ErrNotFound     = errors.New("not found")
    ErrUnauthorized = errors.New("unauthorized")
)

// Custom error type with context
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
}

// Wrap errors with context using %w
func GetUser(id string) (*User, error) {
    user, err := db.Find(id)
    if err != nil {
        return nil, fmt.Errorf("GetUser(%s): %w", id, err)
    }
    if user == nil {
        return nil, fmt.Errorf("GetUser(%s): %w", id, ErrNotFound)
    }
    return user, nil
}

// Check wrapped errors with errors.Is and errors.As
func HandleRequest(id string) error {
    user, err := GetUser(id)
    if err != nil {
        if errors.Is(err, ErrNotFound) {
            return writeNotFound()
        }
        var validErr *ValidationError
        if errors.As(err, &validErr) {
            return writeBadRequest(validErr.Field, validErr.Message)
        }
        return fmt.Errorf("handling request: %w", err)
    }
    return writeJSON(user)
}