Best Practices

Writing idiomatic Go code makes it readable, maintainable, and professional. In this final lesson, you'll learn Go's best practices, common idioms, and patterns used by experienced Go developers.

Code Style and Formatting

Use gofmt

# Format all Go files
gofmt -w .

# Or use goimports (also organizes imports)
go install golang.org/x/tools/cmd/goimports@latest
goimports -w .

Naming Conventions

// ✅ Good names
var userCount int
var maxRetries = 3
type UserService struct{}
func GetUserByID(id int) (*User, error)

// ❌ Bad names
var usrCnt int           // Unclear abbreviation
var MAX_RETRIES = 3      // Not Go style (use maxRetries)
type user_service struct{} // Use camelCase
func get_user_by_id(id int) // Use camelCase

// Acronyms
var userID int    // ✅ ID, not Id
var httpServer    // ✅ HTTP, not Http
var urlPath       // ✅ URL, not Url

Error Handling Patterns

Check Errors Immediately

// ✅ Good - check immediately
file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer file.Close()

// ❌ Bad - delayed check
file, err := os.Open("file.txt")
// ... other code ...
if err != nil {  // Too late!
    return err
}

Wrap Errors with Context

// ✅ Good - add context
user, err := db.GetUser(id)
if err != nil {
    return fmt.Errorf("failed to get user %d: %w", id, err)
}

// ❌ Bad - lose context
user, err := db.GetUser(id)
if err != nil {
    return err  // What failed? Which user?
}

Don't Panic

// ✅ Good - return error
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// ❌ Bad - panic for expected errors
func divide(a, b float64) float64 {
    if b == 0 {
        panic("division by zero")  // Don't panic!
    }
    return a / b
}

// ✅ OK - panic only for programmer errors
func mustCompile(pattern string) *regexp.Regexp {
    re, err := regexp.Compile(pattern)
    if err != nil {
        panic(err)  // OK in init or must* functions
    }
    return re
}

Interface Best Practices

Accept Interfaces, Return Structs

// ✅ Good - accept interface
func ProcessData(r io.Reader) error {
    // Works with files, network, strings, etc.
}

// ❌ Bad - accept concrete type
func ProcessData(f *os.File) error {
    // Only works with files
}

// ✅ Good - return concrete type
func NewUser(name string) *User {
    return &User{Name: name}
}

// ❌ Bad - return interface (usually)
func NewUser(name string) UserInterface {
    return &User{Name: name}
}

Keep Interfaces Small

// ✅ Good - small, focused interfaces
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
}

// ❌ Bad - large interface
type DataStore interface {
    GetUser(id int) (*User, error)
    SaveUser(user *User) error
    DeleteUser(id int) error
    GetProduct(id int) (*Product, error)
    SaveProduct(product *Product) error
    // ... 20 more methods
}

Concurrency Patterns

Use Context for Cancellation

// ✅ Good - use context
func ProcessWithTimeout(ctx context.Context, data []int) error {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    for _, item := range data {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            process(item)
        }
    }
    return nil
}

// ❌ Bad - no cancellation
func Process(data []int) error {
    for _, item := range data {
        process(item)  // Can't cancel!
    }
    return nil
}

Don't Start Goroutines Without Knowing When They Stop

// ✅ Good - controlled lifecycle
func StartWorker(ctx context.Context) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                return  // Clean shutdown
            default:
                doWork()
            }
        }
    }()
}

// ❌ Bad - goroutine leak
func StartWorker() {
    go func() {
        for {
            doWork()  // Never stops!
        }
    }()
}

Package Organization

Package Names

// ✅ Good package names
package user
package http
package json

// ❌ Bad package names
package user_service  // No underscores
package utils         // Too generic
package helpers       // Too generic
package common        // Too generic

Avoid Package-Level State

// ❌ Bad - global state
package database

var DB *sql.DB

func init() {
    DB, _ = sql.Open("postgres", "...")
}

// ✅ Good - explicit dependencies
package database

type Store struct {
    db *sql.DB
}

func NewStore(connStr string) (*Store, error) {
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        return nil, err
    }
    return &Store{db: db}, nil
}

Performance Best Practices

Preallocate Slices

// ✅ Good - preallocate
users := make([]User, 0, 100)
for i := 0; i < 100; i++ {
    users = append(users, User{ID: i})
}

// ❌ Slow - grows dynamically
var users []User
for i := 0; i < 100; i++ {
    users = append(users, User{ID: i})
}

Use strings.Builder for Concatenation

// ✅ Good - efficient
var sb strings.Builder
for i := 0; i < 100; i++ {
    sb.WriteString("x")
}
result := sb.String()

// ❌ Slow - creates many strings
result := ""
for i := 0; i < 100; i++ {
    result += "x"
}

Avoid Unnecessary Allocations

// ✅ Good - reuse
var buf bytes.Buffer
for _, item := range items {
    buf.Reset()
    buf.WriteString(item)
    process(buf.Bytes())
}

// ❌ Bad - allocates every time
for _, item := range items {
    buf := bytes.NewBuffer(nil)
    buf.WriteString(item)
    process(buf.Bytes())
}

Code Organization Tips

Group Related Code

// ✅ Good - grouped by feature
user/
  user.go          // User type and core logic
  repository.go    // Database operations
  service.go       // Business logic
  handler.go       // HTTP handlers

// ❌ Bad - grouped by type
models/
  user.go
  product.go
repositories/
  user_repository.go
  product_repository.go
services/
  user_service.go
  product_service.go

Documentation

// ✅ Good - clear documentation
// Package user provides user management functionality.
package user

// User represents a user in the system.
// Users have a unique ID and email address.
type User struct {
    ID    int
    Email string
}

// GetByEmail retrieves a user by their email address.
// It returns ErrNotFound if the user doesn't exist.
func GetByEmail(email string) (*User, error) {
    // ...
}

// ❌ Bad - no documentation
package user

type User struct {
    ID    int
    Email string
}

func GetByEmail(email string) (*User, error) {
    // ...
}

Testing Best Practices

Go Proverbs

Essential Go Tools

# Format code
gofmt -w .
goimports -w .

# Lint code
go install golang.org/x/lint/golint@latest
golint ./...

# Static analysis
go vet ./...

# Security check
go install github.com/securego/gosec/v2/cmd/gosec@latest
gosec ./...

# Detect race conditions
go test -race ./...

# Generate documentation
godoc -http=:6060

🎉 Congratulations!

What's Next?

Recommended Resources

• Official Go Website
• A Tour of Go
• Go by Example
• Go Wiki
• GopherAcademy Videos

Summary