Go Language Developer Guide: Why Golang is Superior

package main

import (
    "fmt"
    "sync"
)

func processItem(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    // Simulate work
    fmt.Printf("Processing item %d\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go processItem(i, &wg)
    }

    wg.Wait()
    fmt.Println("All items processed")
}

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i // blocks until consumer reads
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for val := range ch { // range over channel until it's closed
        fmt.Println("received:", val)
    }
}

func main() {
    ch := make(chan int) // unbuffered channel
    go producer(ch)
    consumer(ch)
}

ch := make(chan int, 100) // buffer of 100 — send doesn't block until buffer is full

func fanIn(ch1, ch2 <-chan string) <-chan string {
    merged := make(chan string)
    go func() {
        defer close(merged)
        for {
            select {
            case v, ok := <-ch1:
                if !ok { ch1 = nil; continue }
                merged <- v
            case v, ok := <-ch2:
                if !ok { ch2 = nil; continue }
                merged <- v
            }
            if ch1 == nil && ch2 == nil {
                return
            }
        }
    }()
    return merged
}

func fetchUserData(ctx context.Context, userID int) (*User, error) {
    req, err := http.NewRequestWithContext(ctx, "GET",
        fmt.Sprintf("https://api.example.com/users/%d", userID), nil)
    if err != nil {
        return nil, err
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err // returns immediately if ctx was cancelled
    }
    defer resp.Body.Close()

    var user User
    if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
        return nil, err
    }
    return &user, nil
}

// Caller sets a 5-second timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

user, err := fetchUserData(ctx, 42)

// Leak — if no one reads from results, this goroutine blocks forever
func leaky(results chan<- int) {
    go func() {
        result := doExpensiveWork()
        results <- result // blocks if caller has moved on
    }()
}

// Fixed — use context for cancellation
func safe(ctx context.Context, results chan<- int) {
    go func() {
        result := doExpensiveWork()
        select {
        case results <- result:
        case <-ctx.Done(): // caller cancelled — exit cleanly
            return
        }
    }()
}

# Add to your HTTP server
import _ "net/http/pprof"

# Then query the goroutine endpoint
curl http://localhost:6060/debug/pprof/goroutine?debug=2

type Writer interface {
    Write(p []byte) (n int, err error)
}

// Both satisfy Writer — neither declares it
type FileWriter struct{ file *os.File }
func (fw FileWriter) Write(p []byte) (int, error) { return fw.file.Write(p) }

type BufferedWriter struct{ buf bytes.Buffer }
func (bw *BufferedWriter) Write(p []byte) (int, error) { return bw.buf.Write(p) }

// This function accepts anything that satisfies Writer
func writeJSON(w Writer, data any) error {
    return json.NewEncoder(w).Encode(data)
}

package main

import (
    "context"
    "encoding/json"
    "log/slog"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

type Server struct {
    mux    *http.ServeMux
    logger *slog.Logger
}

func NewServer(logger *slog.Logger) *Server {
    s := &Server{mux: http.NewServeMux(), logger: logger}
    s.routes()
    return s
}

func (s *Server) routes() {
    s.mux.HandleFunc("GET /health", s.handleHealth)
    s.mux.HandleFunc("GET /users/{id}", s.handleGetUser)
}

func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
}

func (s *Server) handleGetUser(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id") // Go 1.22+ path parameters
    s.logger.InfoContext(r.Context(), "fetching user", "id", id)
    // ... fetch and return user
}

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

    srv := &http.Server{
        Addr:         ":8080",
        Handler:      NewServer(logger).mux,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    // Graceful shutdown
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        logger.Info("server starting", "addr", srv.Addr)
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            logger.Error("server error", "err", err)
            os.Exit(1)
        }
    }()

    <-quit
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        logger.Error("shutdown error", "err", err)
    }
    logger.Info("server stopped")
}