golang-coding

Go Coding Standards

Naming Conventions

Element	Convention	Example
Package	lowercase, single word	order, payment, auth
Exported func/type	PascalCase	CreateOrder, OrderService
Unexported	camelCase	validateItems, orderRepo
Interface	-er suffix for single method	Reader, Writer, OrderRepository
Acronyms	All caps	HTTPClient, UserID, APIURL
Receiver	1-2 letter abbreviation	func (s *OrderService) Create(...)

Error Handling

// Good — always check errors explicitly
result, err := repo.FindByID(ctx, id)
if err != nil {
    return fmt.Errorf("find order %d: %w", id, err)
}

// Bad — ignoring errors
result, _ := repo.FindByID(ctx, id)

• Always check err != nil immediately after the call
• Wrap errors with context using fmt.Errorf("context: %w", err)
• Use errors.Is() and errors.As() for error inspection
• Define sentinel errors for expected conditions: var ErrNotFound = errors.New("not found")
• Never use panic for expected errors — only for programmer bugs

Interfaces

• Define interfaces where they are USED, not where they are implemented
• Keep interfaces small — 1-3 methods
• Accept interfaces, return structs
• Use io.Reader, io.Writer from stdlib where possible

// Good — interface at consumer, small
type OrderRepository interface {
    FindByID(ctx context.Context, id int64) (*Order, error)
    Save(ctx context.Context, order *Order) error
}

// Bad — large interface defined at implementation
type OrderStore interface {
    FindByID(...) ...
    FindAll(...) ...
    Save(...) ...
    Delete(...) ...
    Count(...) ...
    // too many methods
}

Context

• First parameter is always context.Context
• Pass context through the entire call chain
• Never store context in structs
• Use context.WithTimeout for external calls

Goroutines and Concurrency

• Always use sync.WaitGroup or errgroup.Group for goroutine lifecycle
• Use channels for communication, mutexes for state protection
• Never start a goroutine without a way to stop it
• Use context.Context for cancellation

g, ctx := errgroup.WithContext(ctx)
for _, item := range items {
    item := item // capture loop variable
    g.Go(func() error {
        return processItem(ctx, item)
    })
}
if err := g.Wait(); err != nil {
    return fmt.Errorf("process items: %w", err)
}

Structs

• Use struct literals with field names: Order{ID: 1, Name: "test"}
• Never rely on positional initialization
• Use pointer receivers for mutating methods, value receivers for read-only
• Prefer composition over embedding

Zero Values

• Design types so zero values are useful
• var buf bytes.Buffer — ready to use
• Use ok pattern for maps: val, ok := m[key]