Golang Expert

Expert guidance for writing clean, idiomatic, maintainable Go code.

Table of Contents

1. [Core Principles](#core-principles)
2. [Quick Reference](#quick-reference)
3. [Detailed Guides](#detailed-guides)

Core Principles

The Go Philosophy

1. Simplicity over cleverness - Readable beats clever
2. Explicit over implicit - No magic, clear data flow
3. Composition over inheritance - Small interfaces, embed structs
4. Errors are values - Handle them, don't ignore them

KISS - Keep It Simple

// BAD - over-engineered
type ProcessorFactory interface {
    CreateProcessor(config Config) Processor
}

// GOOD - direct and simple
func Process(data []byte) (Result, error) {
    // Direct implementation
}

DRY - Don't Repeat Yourself

// BAD - duplicated logic
func ParseUserDate(s string) time.Time { /*...*/ }
func ParseOrderDate(s string) time.Time { /*...*/ } // Same code!

// GOOD - single source of truth
func ParseDate(s string) (time.Time, error) {
    return time.Parse(time.RFC3339, s)
}

Functional Principles

1. No global mutable state - Use dependency injection
2. Immutability - Return new values, don't mutate inputs
3. Pure functions - Same input = same output, no side effects
4. Constants over variables - Use const when possible

// BAD - global state
var logger *Logger
func SetLogger(l *Logger) { logger = l }

// GOOD - dependency injection
type Service struct {
    logger Logger
}
func NewService(logger Logger) *Service {
    return &Service{logger: logger}
}

Quick Reference

Interface Design

// Small, focused interfaces (Interface Segregation)
type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// Compose when needed
type ReadWriter interface {
    Reader
    Writer
}

// Accept interfaces, return structs
func Process(r Reader) *Result { /*...*/ }

Error Handling

// Wrap errors with context
if err != nil {
    return fmt.Errorf("process user %d: %w", id, err)
}

// Sentinel errors for expected conditions
var ErrNotFound = errors.New("not found")

// Check with errors.Is/As
if errors.Is(err, ErrNotFound) { /*...*/ }

Table-Driven Tests

func TestParse(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        want    Result
        wantErr bool
    }{
        {"valid input", "abc", Result{Value: "abc"}, false},
        {"empty input", "", Result{}, true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := Parse(tt.input)
            if (err != nil) != tt.wantErr {
                t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if got != tt.want {
                t.Errorf("Parse() = %v, want %v", got, tt.want)
            }
        })
    }
}

Concurrency

// Always use context for cancellation
func Process(ctx context.Context) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    case result := <-work():
        return handle(result)
    }
}

// Use errgroup for parallel work
g, ctx := errgroup.WithContext(ctx)
for _, item := range items {
    item := item // capture loop variable
    g.Go(func() error { return process(ctx, item) })
}
return g.Wait()

Detailed Guides

Load these references as needed:

Code Review Workflow

When reviewing Go code:

1. Read [code-review-checklist.md](references/code-review-checklist.md)
2. Check for KISS/DRY violations
3. Verify error handling is complete
4. Assess interface design
5. Review test coverage and quality
6. Flag concurrency issues
7. Identify performance concerns

Refactoring Workflow

When refactoring:

1. Ensure tests exist before changes
2. Apply KISS - Remove unnecessary abstractions
3. Apply DRY - Extract duplicated code
4. Improve interfaces - Make them smaller
5. Add DI - Remove global state
6. Run tests after each change