Why Use Go — Senior Level¶

package main

import (
    "fmt"
    "testing"
)

// Benchmark: Go compilation vs runtime performance trade-off
// Go compiles fast but sacrifices some optimizations

func BenchmarkMapAccess(b *testing.B) {
    m := make(map[string]int, 1000)
    for i := 0; i < 1000; i++ {
        m[fmt.Sprintf("key-%d", i)] = i
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = m["key-500"]
    }
}

func BenchmarkSliceAccess(b *testing.B) {
    s := make([]int, 1000)
    for i := 0; i < 1000; i++ {
        s[i] = i
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = s[500]
    }
}

func main() {
    fmt.Println("Run benchmarks with: go test -bench=. -benchmem")
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// Domain layer — pure business logic, no external dependencies
type User struct {
    ID   string
    Name string
}

type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
}

type UserService struct {
    repo UserRepository
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

func (s *UserService) GetUser(ctx context.Context, id string) (*User, error) {
    if id == "" {
        return nil, fmt.Errorf("user id cannot be empty")
    }
    user, err := s.repo.FindByID(ctx, id)
    if err != nil {
        return nil, fmt.Errorf("UserService.GetUser id=%s: %w", id, err)
    }
    return user, nil
}

// Infrastructure layer — implements repository interface
type InMemoryRepo struct {
    users map[string]*User
}

func NewInMemoryRepo() *InMemoryRepo {
    return &InMemoryRepo{
        users: map[string]*User{
            "1": {ID: "1", Name: "Alice"},
            "2": {ID: "2", Name: "Bob"},
        },
    }
}

func (r *InMemoryRepo) FindByID(_ context.Context, id string) (*User, error) {
    user, ok := r.users[id]
    if !ok {
        return nil, fmt.Errorf("user not found: %s", id)
    }
    return user, nil
}

// HTTP handler layer
type Handler struct {
    svc *UserService
}

func (h *Handler) GetUser(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    id := r.URL.Query().Get("id")

    user, err := h.svc.GetUser(ctx, id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }
    fmt.Fprintf(w, `{"id": "%s", "name": "%s"}`, user.ID, user.Name)
}

func main() {
    // Wire dependencies
    repo := NewInMemoryRepo()
    svc := NewUserService(repo)
    handler := &Handler{svc: svc}

    mux := http.NewServeMux()
    mux.HandleFunc("/user", handler.GetUser)

    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
    }

    go func() {
        log.Printf("Starting server on %s", server.Addr)
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
        log.Fatal(err)
    }
    log.Println("Server stopped")
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type Job struct {
    ID   int
    Data string
}

type Result struct {
    JobID    int
    Output   string
    Duration time.Duration
}

func worker(ctx context.Context, id int, jobs <-chan Job, results chan<- Result) {
    for {
        select {
        case <-ctx.Done():
            return
        case job, ok := <-jobs:
            if !ok {
                return
            }
            start := time.Now()
            // Simulate processing
            time.Sleep(50 * time.Millisecond)
            results <- Result{
                JobID:    job.ID,
                Output:   fmt.Sprintf("worker-%d processed: %s", id, job.Data),
                Duration: time.Since(start),
            }
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    const numWorkers = 5
    const numJobs = 20

    jobs := make(chan Job, numJobs)
    results := make(chan Result, numJobs)

    // Start workers
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            worker(ctx, workerID, jobs, results)
        }(i)
    }

    // Send jobs
    for i := 0; i < numJobs; i++ {
        jobs <- Job{ID: i, Data: fmt.Sprintf("task-%d", i)}
    }
    close(jobs) // Signal no more jobs

    // Collect results in a goroutine
    go func() {
        wg.Wait()
        close(results)
    }()

    // Process results
    for r := range results {
        fmt.Printf("Job %d: %s (%v)\n", r.JobID, r.Output, r.Duration)
    }
}

package main

import (
    "errors"
    "fmt"
    "sync"
    "time"
)

type State int

const (
    Closed   State = iota
    Open
    HalfOpen
)

type CircuitBreaker struct {
    mu           sync.Mutex
    state        State
    failures     int
    threshold    int
    timeout      time.Duration
    lastFailTime time.Time
}

func NewCircuitBreaker(threshold int, timeout time.Duration) *CircuitBreaker {
    return &CircuitBreaker{
        state:     Closed,
        threshold: threshold,
        timeout:   timeout,
    }
}

func (cb *CircuitBreaker) Execute(fn func() error) error {
    cb.mu.Lock()
    if cb.state == Open {
        if time.Since(cb.lastFailTime) > cb.timeout {
            cb.state = HalfOpen
        } else {
            cb.mu.Unlock()
            return errors.New("circuit breaker is open")
        }
    }
    cb.mu.Unlock()

    err := fn()

    cb.mu.Lock()
    defer cb.mu.Unlock()

    if err != nil {
        cb.failures++
        cb.lastFailTime = time.Now()
        if cb.failures >= cb.threshold {
            cb.state = Open
        }
        return err
    }

    cb.failures = 0
    cb.state = Closed
    return nil
}

func main() {
    cb := NewCircuitBreaker(3, 5*time.Second)

    // Simulate calls
    for i := 0; i < 5; i++ {
        err := cb.Execute(func() error {
            return errors.New("service unavailable")
        })
        fmt.Printf("Call %d: %v\n", i+1, err)
    }
}

package main

import (
    "fmt"
    "sync"
)

func fanOut(input []int, numWorkers int) []int {
    jobs := make(chan int, len(input))
    results := make(chan int, len(input))

    // Start workers (fan-out)
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- job * job // Process: square the number
            }
        }()
    }

    // Send jobs
    for _, v := range input {
        jobs <- v
    }
    close(jobs)

    // Fan-in: collect results
    go func() {
        wg.Wait()
        close(results)
    }()

    var output []int
    for r := range results {
        output = append(output, r)
    }
    return output
}

func main() {
    input := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := fanOut(input, 3)
    fmt.Println("Squared:", result)
}

package main

import (
    "errors"
    "fmt"
    "time"
)

type ServerConfig struct {
    addr     string
    timeout  time.Duration
    maxConns int
}

type Option func(*ServerConfig) error

func WithAddr(addr string) Option {
    return func(c *ServerConfig) error {
        if addr == "" {
            return errors.New("addr cannot be empty")
        }
        c.addr = addr
        return nil
    }
}

func WithTimeout(d time.Duration) Option {
    return func(c *ServerConfig) error {
        if d <= 0 {
            return errors.New("timeout must be positive")
        }
        c.timeout = d
        return nil
    }
}

func WithMaxConns(n int) Option {
    return func(c *ServerConfig) error {
        if n <= 0 || n > 100000 {
            return fmt.Errorf("maxConns must be 1-100000, got %d", n)
        }
        c.maxConns = n
        return nil
    }
}

func NewServer(opts ...Option) (*ServerConfig, error) {
    cfg := &ServerConfig{
        addr:     ":8080",
        timeout:  30 * time.Second,
        maxConns: 1000,
    }
    for _, opt := range opts {
        if err := opt(cfg); err != nil {
            return nil, fmt.Errorf("invalid option: %w", err)
        }
    }
    return cfg, nil
}

func main() {
    // Valid configuration
    srv, err := NewServer(WithAddr(":9090"), WithTimeout(60*time.Second))
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("Server: %+v\n", srv)

    // Invalid configuration — caught at construction time
    _, err = NewServer(WithMaxConns(-1))
    if err != nil {
        fmt.Println("Validation error:", err)
    }
}

package main

import (
    "context"
    "fmt"
    "time"
)

func fetchFromDB(ctx context.Context, query string) (string, error) {
    select {
    case <-ctx.Done():
        return "", fmt.Errorf("db query cancelled: %w", ctx.Err())
    case <-time.After(200 * time.Millisecond): // Simulate DB latency
        return fmt.Sprintf("result for: %s", query), nil
    }
}

func getUser(ctx context.Context, id string) (string, error) {
    // Add timeout specific to this operation
    ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
    defer cancel()

    result, err := fetchFromDB(ctx, "SELECT * FROM users WHERE id="+id)
    if err != nil {
        return "", fmt.Errorf("getUser: %w", err)
    }
    return result, nil
}

func main() {
    // Parent context with overall request deadline
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    result, err := getUser(ctx, "42")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

// Layering violation — business logic calls infrastructure
type OrderService struct{ db *sql.DB }

// Dependency inversion — depend on abstractions
type OrderRepository interface{ Save(Order) error }
type OrderService    struct{ repo OrderRepository }

package main

import (
    "errors"
    "fmt"
)

type DomainError struct {
    Code       string
    Message    string
    StatusCode int
    Err        error
}

func (e *DomainError) Error() string { return e.Message }
func (e *DomainError) Unwrap() error { return e.Err }

var (
    ErrNotFound     = &DomainError{Code: "NOT_FOUND", Message: "resource not found", StatusCode: 404}
    ErrUnauthorized = &DomainError{Code: "UNAUTHORIZED", Message: "unauthorized", StatusCode: 401}
    ErrInternal     = &DomainError{Code: "INTERNAL", Message: "internal error", StatusCode: 500}
)

func findResource(id string) error {
    if id == "" {
        return fmt.Errorf("findResource: %w", ErrNotFound)
    }
    return nil
}

func main() {
    err := findResource("")
    if err != nil {
        var domainErr *DomainError
        if errors.As(err, &domainErr) {
            fmt.Printf("Status: %d, Code: %s, Message: %s\n",
                domainErr.StatusCode, domainErr.Code, domainErr.Message)
        }
    }
}

package main

import (
    "bytes"
    "fmt"
    "sync"
)

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func processWithPool(data string) string {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufferPool.Put(buf)
    }()
    buf.WriteString("processed: ")
    buf.WriteString(data)
    return buf.String()
}

func processWithoutPool(data string) string {
    buf := new(bytes.Buffer)
    buf.WriteString("processed: ")
    buf.WriteString(data)
    return buf.String()
}

func main() {
    fmt.Println(processWithPool("hello"))
    fmt.Println(processWithoutPool("hello"))
}

package main

import "fmt"

// This allocation escapes to heap — pointer returned
func escapesToHeap() *int {
    x := 42
    return &x // x escapes to heap
}

// This stays on stack — no pointer escapes
func staysOnStack() int {
    x := 42
    return x // x stays on stack
}

func main() {
    fmt.Println(*escapesToHeap())
    fmt.Println(staysOnStack())
    // Check escape analysis: go build -gcflags="-m" main.go
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

// This leaks a goroutine if the HTTP request is cancelled
func leakyFetch(url string) (string, error) {
    ch := make(chan string, 1)
    go func() {
        // If the caller abandons the result, this goroutine is stuck
        resp, err := http.Get(url)
        if err != nil {
            return
        }
        defer resp.Body.Close()
        ch <- "done"
    }()
    return <-ch, nil
}

// Fixed: use context for cancellation
func safeFetch(ctx context.Context, url string) (string, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return "", err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    return "done", nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    result, err := safeFetch(ctx, "https://example.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(result)
}

// Wrong: trying to build a rich domain model in Go
// Go's type system makes complex type hierarchies awkward

// Better: use Go for the service layer, use a different language for complex domain logic
// Or: embrace Go's simplicity and use composition + interfaces instead of type hierarchies

package main

import "fmt"

func main() {
    // Over-engineered: using goroutines for a simple sequential task
    // ch := make(chan int)
    // go func() { ch <- compute() }()
    // result := <-ch

    // Simple: just call the function
    result := compute()
    fmt.Println(result)
}

func compute() int { return 42 }

package main

import "fmt"

type Animal interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }

func main() {
    var a Animal = Dog{}
    fmt.Println(a.Speak()) // "Woof"

    a = Cat{}
    fmt.Println(a.Speak()) // "Meow"

    // The interface variable can hold any type that satisfies the interface
    // Type assertion lets you get the concrete type back
    if cat, ok := a.(Cat); ok {
        fmt.Println("It's a cat:", cat.Speak())
    }
}

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    runtime.GOMAXPROCS(1) // Force single thread for demonstration

    go func() {
        // In Go < 1.14, this infinite loop without function calls
        // would never yield the CPU, starving other goroutines.
        // In Go >= 1.14, the scheduler uses async preemption.
        for i := 0; ; i++ {
            if i%1000000 == 0 {
                runtime.Gosched() // Explicitly yield (needed pre-1.14)
            }
        }
    }()

    time.Sleep(100 * time.Millisecond)
    fmt.Println("Other goroutines can run too")
}

package main

import "fmt"

func buildReport(items []string) string {
    result := ""
    for _, item := range items {
        result += item + "\n"
    }
    return result
}

func main() {
    items := make([]string, 10000)
    for i := range items {
        items[i] = fmt.Sprintf("item-%d", i)
    }
    report := buildReport(items)
    fmt.Println("Report length:", len(report))
}