Golang Pro

Golang Pro is a community skill for writing production-quality Go code with idiomatic patterns, covering error handling, concurrency design, interface composition, testing strategies, and performance optimization for Go applications.

What Is This?

Overview

Golang Pro provides patterns and practices for building reliable Go applications. It covers error handling that wraps and propagates errors with context using the standard errors package and sentinel error patterns, concurrency design that structures goroutine lifecycles with proper cancellation, synchronization, and channel patterns, interface composition that defines small focused interfaces and composes them for flexible dependency injection, testing strategies that write table-driven tests, use test helpers, and organize test fixtures following Go conventions, and performance optimization that profiles CPU and memory usage to identify allocation hotspots and reduce garbage collection pressure. The skill enables developers to write Go code that is maintainable, testable, and efficient in production.

Who Should Use This

This skill serves Go developers building production services, backend engineers adopting Go for new projects, and teams establishing Go coding standards and review guidelines.

Why Use It?

Problems It Solves

Error handling in Go becomes inconsistent when developers mix different wrapping styles and lose context about where errors originate. Goroutine leaks occur when concurrent code lacks proper cancellation and lifecycle management. Overly broad interfaces create tight coupling between packages that reduces testability. Tests become fragile and verbose without table-driven patterns and shared test helpers.

Core Highlights

Error wrapper adds context to errors at each call boundary while preserving the original error chain. Goroutine manager handles lifecycle, cancellation, and error collection for concurrent workers. Interface designer composes single-method interfaces for flexible dependency boundaries. Test builder creates table-driven tests with reusable fixtures and assertions.

How to Use It?

Basic Usage

// Error handling patterns
package service

import (
  "errors"
  "fmt"
)

var (
  ErrNotFound = errors.New(
    "not found")
  ErrForbidden = errors.New(
    "forbidden")
)

type UserService struct {
  repo UserRepository
}

func (s *UserService) Get(
  id string,
) (*User, error) {
  user, err := s.repo\
    .FindByID(id)
  if err != nil {
    return nil,
      fmt.Errorf(
        "get user %s: %w",
        id, err)
  }
  return user, nil
}

func (s *UserService)\
  Delete(
  id string,
) error {
  _, err := s.Get(id)
  if errors.Is(
    err, ErrNotFound) {
    return nil
  }
  if err != nil {
    return fmt.Errorf(
      "delete user: %w",
      err)
  }
  return s.repo.Delete(id)
}

Real-World Examples

// Concurrency with errgroup
package worker

import (
  "context"
  "golang.org/x/sync"
    "/errgroup"
)

type Task struct {
  ID   string
  Data []byte
}

type Processor struct {
  workers int
}

func (p *Processor) Run(
  ctx context.Context,
  tasks []Task,
) error {
  g, ctx := errgroup\
    .WithContext(ctx)
  ch := make(
    chan Task,
    p.workers)

  g.Go(func() error {
    defer close(ch)
    for _, t :=\
        range tasks {
      select {
      case ch <- t:
      case <-ctx.Done():
        return ctx.Err()
      }
    }
    return nil
  })

  for i := 0;\
      i < p.workers;\
      i++ {
    g.Go(func() error {
      for t :=\
          range ch {
        if err :=\
            process(
              ctx, t,
            ); err != nil {
          return err
        }
      }
      return nil
    })
  }
  return g.Wait()
}

Advanced Tips

Use context values sparingly and prefer explicit function parameters for data that affects behavior since context should carry deadlines and cancellation signals rather than business data. Profile memory allocations with pprof to find functions that create garbage collection pressure through excessive heap allocations. Prefer sync.Pool for frequently allocated temporary objects in hot paths.

When to Use It?

Use Cases

Establish error handling conventions for a Go service with consistent wrapping and sentinel errors. Build a concurrent worker pipeline with proper cancellation and error propagation. Write comprehensive table-driven tests for a Go package with shared test fixtures.

Related Topics

Go programming, error handling, concurrency, goroutines, testing, interfaces, and performance profiling.

Important Notes

Requirements

Go 1.21 or newer for latest standard library features. Go modules for dependency management. The errgroup package from golang.org/x/sync for concurrent error handling patterns.

Usage Recommendations

Do: wrap errors with context at each call boundary using fmt.Errorf with the %w verb. Keep interfaces small with one or two methods and compose them where needed. Use race detector during testing with go test -race.

Don't: ignore errors with blank identifier assignments unless the consequence is documented. Share mutable state between goroutines without synchronization primitives. Create interfaces with many methods that mirror concrete struct APIs since this defeats interface segregation.

Limitations

Go error handling verbosity is inherent to the language and cannot be fully eliminated through patterns alone. Channel-based concurrency adds complexity that may exceed mutex-based approaches for simple shared state scenarios. Generics support in Go is still maturing and some patterns require type assertions as workarounds.