go-rust-systems

Go & Rust Systems Programming

When to Use Which

Use Case	Go	Rust
Web services, APIs	✅ Excellent	✅ Good
CLI tools	✅ Excellent	✅ Excellent
Systems programming	✅ Good	✅ Excellent
Memory-critical apps	⚠️ GC overhead	✅ Zero-cost
Concurrency	✅ Goroutines	✅ Fearless
Learning curve	✅ Easy	⚠️ Steeper

Go Quick Reference

Essential Commands

go mod init <module>          # Initialize new module
go mod tidy                   # Add missing, remove unused
go test -race ./...          # Run with race detector
go test -cover ./...         # Show coverage
golangci-lint run            # Run all linters
govulncheck ./...            # Check vulnerabilities

Go Code Quality Signals

Use golangci-lint as the primary aggregated lint gate. Pin its version, commit its configuration, and enable linters deliberately. For full CI diagnostics, disable the default output caps:

issues:
  max-issues-per-linter: 0
  max-same-issues: 0

The caps affect how many findings are displayed; they are not quality thresholds. A clean run complements rather than replaces gofmt, go vet, go test -race, coverage evidence, and govulncheck.

Use function-level CRAP analysis only when complexity plus low coverage would help prioritize test and refactoring work. Configure a reviewed threshold and treat the result as a hotspot signal, not a project health score or correctness proof.

Do not use a single letter grade or /100 score as a required quality gate. The hosted Go Report Card service is retired. gocode-score and codescore are experimental advisory tools with limited adoption, so do not add them by default. Never weaken checks or add unjustified suppressions merely to improve a score.

Critical Patterns

// 1. Always check errors
result, err := someFunc()
if err != nil {
    return fmt.Errorf("operation failed: %w", err)  // Wrap with context
}

// 2. Use context for cancellation
func processData(ctx context.Context, data []string) error {
    for _, item := range data {
        select {
        case <-ctx.Done():
            return ctx.Err()  // Respect cancellation
        default:
            // Process item
        }
    }
    return nil
}

// 3. Defer cleanup immediately
file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer file.Close()  // Defer right after open

// 4. Table-driven tests
func TestAdd(t *testing.T) {
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"positive", 1, 2, 3},
        {"negative", -1, -2, -3},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add() = %v, want %v", got, tt.want)
            }
        })
    }
}