Go Interview Questions with Answers

// Hello World in Go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

// Data Types in Go
package main

import "fmt"

func main() {
    var age int = 25
    var salary float64 = 50000.50
    var pi float64 = 3.14159265358979
    var grade rune = 'A'
    var isActive bool = true
    var name string = "Alice"
    var price float64 = 99.99
    
    fmt.Printf("Age: %d\n", age)
    fmt.Printf("Salary: %.2f\n", salary)
    fmt.Printf("Pi: %f\n", pi)
    fmt.Printf("Grade: %c\n", grade)
    fmt.Printf("Active: %t\n", isActive)
    fmt.Printf("Name: %s\n", name)
    fmt.Printf("Price: %.2f\n", price)
}

// Variables and Constants in Go
package main

import "fmt"

func main() {
    var x int = 10
    const PI float64 = 3.14159
    val := 3.14
    str := "Hello"
    var counter int = 0
    
    fmt.Printf("x = %d\n", x)
    fmt.Printf("PI = %f\n", PI)
    fmt.Printf("val = %f\n", val)
    fmt.Printf("str = %s\n", str)
    fmt.Printf("counter = %d\n", counter)
}

// Arrays and Slices in Go
package main

import "fmt"

func main() {
    // Array (fixed size)
    var arr [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Printf("arr[0] = %d\n", arr[0])
    fmt.Printf("arr[2] = %d\n", arr[2])
    
    // Slice (dynamic size)
    slice := []int{1, 2, 3, 4, 5}
    slice = append(slice, 6, 7)
    fmt.Printf("Slice: %v\n", slice)
    
    // Slice operations
    slice2 := slice[1:4]
    fmt.Printf("Slice2: %v\n", slice2)
    
    // 2D Slice
    matrix := [][]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }
    fmt.Printf("matrix[1][1] = %d\n", matrix[1][1])
}

// Functions in Go
package main

import "fmt"

// Basic function
func add(a int, b int) int {
    return a + b
}

// Function with multiple return values
func divide(a, b int) (int, int) {
    return a / b, a % b
}

// Function with named return values
func getMinMax(nums []int) (min int, max int) {
    min = nums[0]
    max = nums[0]
    for _, v := range nums {
        if v < min {
            min = v
        }
        if v > max {
            max = v
        }
    }
    return
}

// Variadic function
func sum(nums ...int) int {
    total := 0
    for _, v := range nums {
        total += v
    }
    return total
}

func main() {
    fmt.Printf("Add: %d\n", add(10, 20))
    quotient, remainder := divide(20, 10)
    fmt.Printf("Quotient: %d, Remainder: %d\n", quotient, remainder)
    
    min, max := getMinMax([]int{5, 2, 8, 1, 9})
    fmt.Printf("Min: %d, Max: %d\n", min, max)
    
    fmt.Printf("Sum: %d\n", sum(1, 2, 3, 4, 5))
}

// Recursion in Go
package main

import "fmt"

// Factorial
func factorial(n int) int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n-1)
}

// Fibonacci
func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

// Sum of array
func sumArray(arr []int, n int) int {
    if n <= 0 {
        return 0
    }
    return arr[n-1] + sumArray(arr, n-1)
}

func main() {
    fmt.Printf("Factorial 5: %d\n", factorial(5))
    fmt.Printf("Fibonacci 8: %d\n", fibonacci(8))
    fmt.Printf("Sum [1,2,3,4,5]: %d\n", sumArray([]int{1, 2, 3, 4, 5}, 5))
}

// Maps in Go
package main

import "fmt"

func main() {
    // Map declaration
    scores := map[string]int{
        "Alice": 95,
        "Bob":   87,
        "Carol": 92,
    }
    
    // Access values
    fmt.Printf("Alice: %d\n", scores["Alice"])
    fmt.Printf("Bob: %d\n", scores["Bob"])
    
    // Add new key-value
    scores["Dave"] = 88
    
    // Check if key exists
    val, exists := scores["Eve"]
    if exists {
        fmt.Printf("Eve: %d\n", val)
    } else {
        fmt.Println("Eve not found")
    }
    
    // Iterate map
    for key, value := range scores {
        fmt.Printf("%s: %d\n", key, value)
    }
    
    // Delete key
    delete(scores, "Bob")
    fmt.Printf("After delete: %v\n", scores)
}

// Structs in Go
package main

import "fmt"

// Struct definition
type Person struct {
    Name  string
    Age   int
    Email string
}

// Struct with methods
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Struct with pointer receiver
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

func main() {
    // Create struct
    person1 := Person{Name: "Alice", Age: 25, Email: "alice@email.com"}
    person2 := Person{Name: "Bob", Age: 30}
    
    fmt.Printf("Person1: %+v\n", person1)
    fmt.Printf("Person2: %+v\n", person2)
    
    rect := Rectangle{Width: 4.0, Height: 6.0}
    fmt.Printf("Area: %.2f\n", rect.Area())
    fmt.Printf("Perimeter: %.2f\n", rect.Perimeter())
    
    rect.Scale(2.0)
    fmt.Printf("After scaling: %+v\n", rect)
}

// Interfaces in Go
package main

import "fmt"
import "math"

// Interface definition
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Circle implementation
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// Rectangle implementation
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Interface as parameter
func printShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    shapes := []Shape{
        Circle{Radius: 5.0},
        Rectangle{Width: 4.0, Height: 6.0},
    }
    
    for _, s := range shapes {
        printShapeInfo(s)
    }
}

// Pointers in Go
package main

import "fmt"

func swap(a, b *int) {
    *a, *b = *b, *a
}

func increment(val *int) {
    *val++
}

func main() {
    x := 10
    y := 20
    
    fmt.Printf("Before swap: x=%d, y=%d\n", x, y)
    swap(&x, &y)
    fmt.Printf("After swap: x=%d, y=%d\n", x, y)
    
    z := 5
    fmt.Printf("Before increment: z=%d\n", z)
    increment(&z)
    fmt.Printf("After increment: z=%d\n", z)
    
    // Pointer to struct
    person := &Person{Name: "Alice", Age: 25}
    person.Age = 26 // Equivalent to (*person).Age = 26
    fmt.Printf("Person: %+v\n", person)
}

// Goroutines in Go
package main

import (
    "fmt"
    "time"
)

func printNumbers(prefix string) {
    for i := 1; i <= 5; i++ {
        fmt.Printf("%s: %d\n", prefix, i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // Start goroutines
    go printNumbers("Goroutine 1")
    go printNumbers("Goroutine 2")
    
    // Give goroutines time to run
    time.Sleep(2 * time.Second)
    fmt.Println("Main function finished")
}

// Channels in Go
package main

import "fmt"

func sum(nums []int, ch chan int) {
    sum := 0
    for _, v := range nums {
        sum += v
    }
    ch <- sum
}

func main() {
    // Unbuffered channel
    ch := make(chan int)
    
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    go sum(nums[:5], ch)
    go sum(nums[5:], ch)
    
    result1 := <-ch
    result2 := <-ch
    
    fmt.Printf("Sum1: %d, Sum2: %d, Total: %d\n", result1, result2, result1+result2)
    
    // Buffered channel
    ch2 := make(chan string, 3)
    ch2 <- "Hello"
    ch2 <- "World"
    ch2 <- "Go"
    
    fmt.Println(<-ch2)
    fmt.Println(<-ch2)
    fmt.Println(<-ch2)
}

// Select Statement in Go
package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "Message from ch1"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "Message from ch2"
    }()
    
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("Timeout")
        }
    }
}

// Error Handling in Go
package main

import (
    "errors"
    "fmt"
)

// Custom error
type ValidationError struct {
    Field string
    Value interface{}
}

func (e ValidationError) Error() string {
    return fmt.Sprintf("validation failed for field '%s' with value '%v'", e.Field, e.Value)
}

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

// Function with custom error
func validateAge(age int) error {
    if age < 0 {
        return ValidationError{Field: "age", Value: age}
    }
    if age > 150 {
        return ValidationError{Field: "age", Value: age}
    }
    return nil
}

func main() {
    // Basic error handling
    result, err := divide(10, 2)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Result: %.2f\n", result)
    }
    
    result2, err2 := divide(10, 0)
    if err2 != nil {
        fmt.Printf("Error: %v\n", err2)
    } else {
        fmt.Printf("Result: %.2f\n", result2)
    }
    
    // Custom error
    err3 := validateAge(200)
    if err3 != nil {
        fmt.Printf("Error: %v\n", err3)
    }
}

// Defer, Panic, Recover in Go
package main

import "fmt"

func deferExample() {
    defer fmt.Println("Deferred: This runs last")
    fmt.Println("Regular: This runs first")
}

func panicExample() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from: %v\n", r)
        }
    }()
    
    fmt.Println("Before panic")
    panic("Something went wrong!")
    fmt.Println("After panic") // This won't run
}

func main() {
    deferExample()
    fmt.Println()
    panicExample()
    fmt.Println("Program continues after panic recovery")
}

// Packages in Go
package main

import (
    "fmt"
    "math/rand"
    "time"
)

// Internal package functions
func add(a, b int) int {
    return a + b
}

func main() {
    rand.Seed(time.Now().UnixNano())
    randomNumber := rand.Intn(100)
    fmt.Printf("Random number: %d\n", randomNumber)
    fmt.Printf("Add: %d\n", add(10, 20))
}

// JSON in Go
package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email,omitempty"`
}

func main() {
    // Marshal to JSON
    person := Person{Name: "Alice", Age: 25, Email: "alice@email.com"}
    jsonData, err := json.Marshal(person)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("JSON: %s\n", jsonData)
    
    // Pretty print
    jsonDataPretty, _ := json.MarshalIndent(person, "", "  ")
    fmt.Printf("Pretty JSON:\n%s\n", jsonDataPretty)
    
    // Unmarshal from JSON
    jsonString := `{"name":"Bob","age":30}`
    var person2 Person
    err = json.Unmarshal([]byte(jsonString), &person2)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Person2: %+v\n", person2)
}

// File I/O in Go
package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // Write to file
    file, err := os.Create("example.txt")
    if err != nil {
        fmt.Printf("Error creating file: %v\n", err)
        return
    }
    defer file.Close()
    
    _, err = file.WriteString("Hello, World!\n")
    if err != nil {
        fmt.Printf("Error writing: %v\n", err)
        return
    }
    fmt.Println("File written successfully")
    
    // Read from file
    file2, err := os.Open("example.txt")
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    defer file2.Close()
    
    scanner := bufio.NewScanner(file2)
    for scanner.Scan() {
        fmt.Printf("Read: %s\n", scanner.Text())
    }
    
    if err := scanner.Err(); err != nil {
        fmt.Printf("Error reading: %v\n", err)
    }
}

// HTTP Server in Go
package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func greetHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "Guest"
    }
    fmt.Fprintf(w, "Hello, %s!", name)
}

func main() {
    http.HandleFunc("/", helloHandler)
    http.HandleFunc("/greet", greetHandler)
    
    fmt.Println("Server starting on port 8080...")
    http.ListenAndServe(":8080", nil)
}

// Testing in Go
// math_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
    result := add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Expected %d, got %d", expected, result)
    }
}

func TestSubtract(t *testing.T) {
    result := subtract(5, 3)
    expected := 2
    if result != expected {
        t.Errorf("Expected %d, got %d", expected, result)
    }
}

// Benchmarks
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        add(2, 3)
    }
}

// Example test
func ExampleAdd() {
    result := add(2, 3)
    fmt.Println(result)
    // Output: 5
}

// Empty Interface in Go
package main

import "fmt"

func printValue(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)
}

func main() {
    printValue(42)
    printValue("Hello")
    printValue(3.14)
    printValue(true)
    printValue([]int{1, 2, 3})
}

// Type Assertion in Go
package main

import "fmt"

func main() {
    var i interface{} = "Hello"
    
    // Type assertion
    s, ok := i.(string)
    if ok {
        fmt.Printf("String: %s\n", s)
    }
    
    // Type switch
    switch v := i.(type) {
    case int:
        fmt.Printf("Int: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

// Context in Go
package main

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

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker stopped")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(200 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()
    
    go worker(ctx)
    
    time.Sleep(2 * time.Second)
    fmt.Println("Main function finished")
}

// Sync Package in Go
package main

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex
var wg sync.WaitGroup

func increment() {
    mutex.Lock()
    counter++
    mutex.Unlock()
    wg.Done()
}

func main() {
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment()
    }
    
    wg.Wait()
    fmt.Printf("Counter: %d\n", counter)
}

// Atomic Operations in Go
package main

import (
    "fmt"
    "sync/atomic"
)

var counter int32

func increment() {
    atomic.AddInt32(&counter, 1)
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    
    // Wait for goroutines to finish
    // (In real code, use WaitGroup)
    fmt.Printf("Counter: %d\n", atomic.LoadInt32(&counter))
}

// WaitGroup in Go
package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    
    wg.Wait()
    fmt.Println("All workers completed")
}

// Once in Go
package main

import (
    "fmt"
    "sync"
)

var once sync.Once
var instance *Singleton

type Singleton struct {
    Data string
}

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{Data: "Initialized"}
        fmt.Println("Singleton created")
    })
    return instance
}

func main() {
    for i := 0; i < 5; i++ {
        go func() {
            inst := GetInstance()
            fmt.Printf("Instance: %p\n", inst)
        }()
    }
    
    // Wait for goroutines
    var wg sync.WaitGroup
    wg.Add(1)
    wg.Wait()
}

// Timer and Ticker in Go
package main

import (
    "fmt"
    "time"
)

func main() {
    // Timer
    timer := time.NewTimer(2 * time.Second)
    <-timer.C
    fmt.Println("Timer expired")
    
    // Ticker
    ticker := time.NewTicker(500 * time.Millisecond)
    go func() {
        for t := range ticker.C {
            fmt.Printf("Tick at %v\n", t)
        }
    }()
    
    time.Sleep(2 * time.Second)
    ticker.Stop()
    fmt.Println("Ticker stopped")
}

// Mutex in Go
package main

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

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func main() {
    counter := Counter{}
    
    for i := 0; i < 100; i++ {
        go counter.Increment()
    }
    
    time.Sleep(time.Second)
    fmt.Printf("Counter: %d\n", counter.Value())
}

// RWMutex in Go
package main

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

type SafeMap struct {
    mu   sync.RWMutex
    data map[string]int
}

func (s *SafeMap) Set(key string, value int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.data[key] = value
}

func (s *SafeMap) Get(key string) (int, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    val, ok := s.data[key]
    return val, ok
}

func main() {
    sm := SafeMap{data: make(map[string]int)}
    
    for i := 0; i < 10; i++ {
        go func(i int) {
            sm.Set(fmt.Sprintf("key%d", i), i)
        }(i)
    }
    
    time.Sleep(time.Second)
    
    for i := 0; i < 10; i++ {
        val, ok := sm.Get(fmt.Sprintf("key%d", i))
        if ok {
            fmt.Printf("key%d: %d\n", i, val)
        }
    }
}

// Context With Cancel in Go
package main

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

func longRunningTask(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Task cancelled")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    
    go longRunningTask(ctx)
    
    time.Sleep(2 * time.Second)
    cancel()
    
    time.Sleep(1 * time.Second)
    fmt.Println("Main done")
}

// Context With Value in Go
package main

import (
    "context"
    "fmt"
)

type key string

func main() {
    ctx := context.WithValue(context.Background(), key("userID"), "12345")
    ctx = context.WithValue(ctx, key("requestID"), "req-abc-123")
    
    processRequest(ctx)
}

func processRequest(ctx context.Context) {
    userID := ctx.Value(key("userID"))
    requestID := ctx.Value(key("requestID"))
    
    fmt.Printf("UserID: %v, RequestID: %v\n", userID, requestID)
}

// Custom Errors in Go
package main

import (
    "fmt"
)

type AppError struct {
    Code    int
    Message string
    Err     error
}

func (e *AppError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("error %d: %s: %v", e.Code, e.Message, e.Err)
    }
    return fmt.Sprintf("error %d: %s", e.Code, e.Message)
}

func (e *AppError) Unwrap() error {
    return e.Err
}

func doSomething() error {
    return &AppError{
        Code:    404,
        Message: "Resource not found",
        Err:     fmt.Errorf("resource with ID 123 not found"),
    }
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if appErr, ok := err.(*AppError); ok {
            fmt.Printf("Code: %d\n", appErr.Code)
        }
    }
}

// Build Tags in Go
// +build linux,amd64

package main

import "fmt"

func main() {
    fmt.Println("Linux AMD64 build")
}

// Embedding in Go
package main

import "fmt"

type Writer interface {
    Write(data []byte) (int, error)
}

type Logger struct{}

func (l Logger) Write(data []byte) (int, error) {
    fmt.Printf("Writing: %s\n", string(data))
    return len(data), nil
}

type FileWriter struct {
    Logger // Embedding
    FileName string
}

func main() {
    fw := FileWriter{
        Logger:   Logger{},
        FileName: "test.txt",
    }
    fw.Write([]byte("Hello, World!"))
}

// Generics in Go (1.18+)
package main

import "fmt"

// Generic function
func Sum[T int | float64](a, b T) T {
    return a + b
}

// Generic struct
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

func main() {
    fmt.Printf("Sum int: %d\n", Sum[int](5, 3))
    fmt.Printf("Sum float: %.2f\n", Sum[float64](3.14, 2.5))
    
    intStack := Stack[int]{}
    intStack.Push(10)
    intStack.Push(20)
    val, _ := intStack.Pop()
    fmt.Printf("Stack pop: %d\n", val)
}

// Reflection in Go
package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
    Age  int
}

func inspectStruct(v interface{}) {
    t := reflect.TypeOf(v)
    fmt.Printf("Type: %s\n", t.Name())
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("  Field %d: %s (%s)\n", i, field.Name, field.Type)
    }
}

func main() {
    user := User{Name: "Alice", Age: 25}
    inspectStruct(user)
    
    // Dynamic field access
    v := reflect.ValueOf(user)
    nameField := v.FieldByName("Name")
    if nameField.IsValid() {
        fmt.Printf("Name: %s\n", nameField.String())
    }
}

// iota in Go
package main

import "fmt"

const (
    StatusPending = iota
    StatusProcessing
    StatusShipped
    StatusDelivered
    StatusCancelled
)

const (
    _ = iota // skip first
    KB = 1 << (10 * iota)
    MB
    GB
    TB
)

func main() {
    fmt.Printf("StatusPending: %d\n", StatusPending)
    fmt.Printf("StatusProcessing: %d\n", StatusProcessing)
    fmt.Printf("StatusShipped: %d\n", StatusShipped)
    fmt.Printf("StatusDelivered: %d\n", StatusDelivered)
    fmt.Printf("StatusCancelled: %d\n", StatusCancelled)
    
    fmt.Printf("1 KB = %d bytes\n", KB)
    fmt.Printf("1 MB = %d bytes\n", MB)
    fmt.Printf("1 GB = %d bytes\n", GB)
    fmt.Printf("1 TB = %d bytes\n", TB)
}

// Flag Package in Go
package main

import (
    "flag"
    "fmt"
)

func main() {
    var name string
    var age int
    var active bool
    
    flag.StringVar(&name, "name", "Guest", "user name")
    flag.IntVar(&age, "age", 0, "user age")
    flag.BoolVar(&active, "active", false, "is user active")
    
    flag.Parse()
    
    fmt.Printf("Name: %s\n", name)
    fmt.Printf("Age: %d\n", age)
    fmt.Printf("Active: %t\n", active)
    fmt.Printf("Args: %v\n", flag.Args())
}

// Logging in Go
package main

import (
    "log"
    "os"
)

func main() {
    // Basic log
    log.Println("This is a log message")
    
    // Log with prefix
    log.SetPrefix("ERROR: ")
    log.Println("This is an error message")
    
    // Log with flags
    log.SetFlags(log.LstdFlags | log.Lshortfile)
    log.Println("Log with file and line")
    
    // Log to file
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    log.SetOutput(file)
    log.Println("This will go to the log file")
}

// Environment Variables in Go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Get environment variable
    home := os.Getenv("HOME")
    fmt.Printf("HOME: %s\n", home)
    
    // Set environment variable
    os.Setenv("MY_VAR", "Hello World")
    fmt.Printf("MY_VAR: %s\n", os.Getenv("MY_VAR"))
    
    // Get all environment variables
    env := os.Environ()
    for _, e := range env[:5] {
        fmt.Println(e)
    }
    
    // Lookup environment variable
    val, exists := os.LookupEnv("PATH")
    if exists {
        fmt.Printf("PATH exists: %s\n", val)
    }
}

// Command Line Arguments in Go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Get arguments
    args := os.Args
    
    fmt.Printf("Number of arguments: %d\n", len(args))
    
    for i, arg := range args {
        fmt.Printf("Argument %d: %s\n", i, arg)
    }
    
    // Check arguments
    if len(args) > 1 {
        fmt.Printf("First argument: %s\n", args[1])
    }
}

// OS Signal Handling in Go
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // Create channel for signals
    sigs := make(chan os.Signal, 1)
    
    // Register signals
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
    
    fmt.Println("Waiting for signal...")
    
    // Block until signal received
    sig := <-sigs
    fmt.Printf("Received signal: %s\n", sig)
    fmt.Println("Exiting...")
}

// HTTP Client in Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // GET request
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("GET Response: %s\n", string(body))
    
    // POST request
    data := map[string]interface{}{
        "title":  "My Post",
        "body":   "This is my post",
        "userId": 1,
    }
    jsonData, _ := json.Marshal(data)
    
    resp2, err := http.Post("https://jsonplaceholder.typicode.com/posts", 
        "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp2.Body.Close()
    
    body2, _ := ioutil.ReadAll(resp2.Body)
    fmt.Printf("POST Response: %s\n", string(body2))
}

// HTTP Client with Timeout in Go
package main

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

func main() {
    client := &http.Client{
        Timeout: 5 * time.Second,
    }
    
    resp, err := client.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Printf("Status: %s\n", resp.Status)
}

// Custom HTTP Client in Go
package main

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

func main() {
    transport := &http.Transport{
        MaxIdleConns:    10,
        IdleConnTimeout: 30 * time.Second,
    }
    
    client := &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second,
    }
    
    req, err := http.NewRequest("GET", "https://api.example.com/data", nil)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    req.Header.Set("User-Agent", "Go-Client")
    req.Header.Set("Authorization", "Bearer token123")
    
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Printf("Status: %s\n", resp.Status)
}

// HTTP Server with Routing in Go
package main

import (
    "fmt"
    "net/http"
)

func main() {
    // Serve static files
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))
    
    // API routes
    http.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case "GET":
            fmt.Fprintf(w, "GET users")
        case "POST":
            fmt.Fprintf(w, "POST users")
        default:
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        }
    })
    
    http.HandleFunc("/api/users/", func(w http.ResponseWriter, r *http.Request) {
        id := r.URL.Path[len("/api/users/"):]
        fmt.Fprintf(w, "User ID: %s\n", id)
    })
    
    fmt.Println("Server starting on port 8080...")
    http.ListenAndServe(":8080", nil)
}

// Middleware in Go
package main

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

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("Started %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        log.Printf("Completed in %v", time.Since(start))
    })
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    })
    
    // Apply middleware
    handler := loggingMiddleware(authMiddleware(mux))
    
    http.ListenAndServe(":8080", handler)
}

// WebSocket in Go
package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Print("Upgrade failed:", err)
        return
    }
    defer conn.Close()
    
    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Read failed:", err)
            break
        }
        
        fmt.Printf("Received: %s\n", message)
        
        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("Write failed:", err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, "index.html")
    })
    
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// gRPC Server in Go
package main

import (
    "context"
    "log"
    "net"
    
    "google.golang.org/grpc"
    pb "path/to/proto"
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + req.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    
    log.Println("Server listening on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

// gRPC Client in Go
package main

import (
    "context"
    "log"
    "time"
    
    "google.golang.org/grpc"
    pb "path/to/proto"
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()
    
    client := pb.NewGreeterClient(conn)
    
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    
    resp, err := client.SayHello(ctx, &pb.HelloRequest{Name: "World"})
    if err != nil {
        log.Fatalf("Could not greet: %v", err)
    }
    log.Printf("Greeting: %s", resp.Message)
}

// Database Connection in Go
package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    // Connect to database
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer db.Close()
    
    // Test connection
    err = db.Ping()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Println("Connected to database")
    
    // Query
    rows, err := db.Query("SELECT id, name, age FROM users")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer rows.Close()
    
    for rows.Next() {
        var id int
        var name string
        var age int
        err = rows.Scan(&id, &name, &age)
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            return
        }
        fmt.Printf("ID: %d, Name: %s, Age: %d\n", id, name, age)
    }
}

// ORM in Go with GORM
package main

import (
    "fmt"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

type User struct {
    gorm.Model
    Name  string
    Email string
    Age   int
}

func main() {
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // Auto migrate
    db.AutoMigrate(&User{})
    
    // Create
    db.Create(&User{Name: "Alice", Email: "alice@email.com", Age: 25})
    
    // Read
    var user User
    db.First(&user, 1)
    fmt.Printf("User: %+v\n", user)
    
    // Update
    db.Model(&user).Update("Age", 26)
    
    // Delete
    db.Delete(&user)
}

// MongoDB in Go
package main

import (
    "context"
    "fmt"
    "time"
    
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

type User struct {
    Name  string
    Email string
    Age   int
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer client.Disconnect(ctx)
    
    collection := client.Database("test").Collection("users")
    
    // Insert
    user := User{Name: "Alice", Email: "alice@email.com", Age: 25}
    result, err := collection.InsertOne(ctx, user)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Inserted ID: %v\n", result.InsertedID)
}

// Redis in Go
package main

import (
    "context"
    "fmt"
    "github.com/go-redis/redis/v8"
)

func main() {
    ctx := context.Background()
    
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })
    
    // Set
    err := rdb.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // Get
    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Value: %s\n", val)
    
    // Incr
    rdb.Incr(ctx, "counter")
    rdb.Incr(ctx, "counter")
    counter, _ := rdb.Get(ctx, "counter").Int()
    fmt.Printf("Counter: %d\n", counter)
}

// Testing with Testify in Go
package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestAdd(t *testing.T) {
    result := add(2, 3)
    assert.Equal(t, 5, result, "Add should return sum")
    
    result2 := add(-1, 1)
    assert.Equal(t, 0, result2)
}

func TestDivide(t *testing.T) {
    result, err := divide(10, 2)
    require.NoError(t, err)
    assert.Equal(t, 5, result)
    
    _, err = divide(10, 0)
    assert.Error(t, err)
}

func TestMain(m *testing.M) {
    // Setup
    println("Setup")
    
    code := m.Run()
    
    // Teardown
    println("Teardown")
    
    os.Exit(code)
}

// Benchmarks in Go
package main

import (
    "testing"
)

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        add(2, 3)
    }
}

func BenchmarkSubtract(b *testing.B) {
    for i := 0; i < b.N; i++ {
        subtract(5, 3)
    }
}

// Run benchmarks:
// go test -bench=.
// go test -bench=BenchmarkAdd -benchmem

// Dependency Injection in Go
package main

import "fmt"

// Logger interface
type Logger interface {
    Log(message string)
}

// ConsoleLogger implementation
type ConsoleLogger struct{}

func (l ConsoleLogger) Log(message string) {
    fmt.Printf("[LOG] %s\n", message)
}

// Service with dependency injection
type UserService struct {
    logger Logger
}

func NewUserService(logger Logger) *UserService {
    return &UserService{logger: logger}
}

func (s *UserService) CreateUser(name string) {
    s.logger.Log(fmt.Sprintf("Creating user: %s", name))
    fmt.Printf("User created: %s\n", name)
}

func main() {
    logger := ConsoleLogger{}
    service := NewUserService(logger)
    service.CreateUser("Alice")
}

// Dependency Injection with Interface in Go
package main

import "fmt"

// Database interface
type Database interface {
    Save(data string) error
    Get(id int) (string, error)
}

// Mock Database for testing
type MockDB struct{}

func (m MockDB) Save(data string) error {
    fmt.Printf("Mock saving: %s\n", data)
    return nil
}

func (m MockDB) Get(id int) (string, error) {
    return fmt.Sprintf("Mock data for ID: %d", id), nil
}

// Real Database
type RealDB struct{}

func (r RealDB) Save(data string) error {
    fmt.Printf("Real saving: %s\n", data)
    return nil
}

func (r RealDB) Get(id int) (string, error) {
    return fmt.Sprintf("Real data for ID: %d", id), nil
}

type Repository struct {
    db Database
}

func NewRepository(db Database) *Repository {
    return &Repository{db: db}
}

func main() {
    // Use mock for testing
    mockRepo := NewRepository(MockDB{})
    mockRepo.db.Save("test data")
    
    // Use real for production
    realRepo := NewRepository(RealDB{})
    realRepo.db.Save("real data")
}

// Functional Options Pattern in Go
package main

import "fmt"

type Server struct {
    host string
    port int
    timeout int
    maxConns int
}

type ServerOption func(*Server)

func WithHost(host string) ServerOption {
    return func(s *Server) {
        s.host = host
    }
}

func WithPort(port int) ServerOption {
    return func(s *Server) {
        s.port = port
    }
}

func WithTimeout(timeout int) ServerOption {
    return func(s *Server) {
        s.timeout = timeout
    }
}

func WithMaxConns(maxConns int) ServerOption {
    return func(s *Server) {
        s.maxConns = maxConns
    }
}

func NewServer(opts ...ServerOption) *Server {
    // Default values
    s := &Server{
        host: "localhost",
        port: 8080,
        timeout: 30,
        maxConns: 100,
    }
    
    // Apply options
    for _, opt := range opts {
        opt(s)
    }
    return s
}

func main() {
    server1 := NewServer()
    fmt.Printf("Server1: %+v\n", server1)
    
    server2 := NewServer(
        WithHost("0.0.0.0"),
        WithPort(9090),
        WithTimeout(60),
        WithMaxConns(200),
    )
    fmt.Printf("Server2: %+v\n", server2)
}

// Builder Pattern in Go
package main

import "fmt"

type Person struct {
    Name string
    Age int
    Email string
    Address string
    Phone string
}

type PersonBuilder struct {
    person Person
}

func NewPersonBuilder() *PersonBuilder {
    return &PersonBuilder{person: Person{}}
}

func (b *PersonBuilder) WithName(name string) *PersonBuilder {
    b.person.Name = name
    return b
}

func (b *PersonBuilder) WithAge(age int) *PersonBuilder {
    b.person.Age = age
    return b
}

func (b *PersonBuilder) WithEmail(email string) *PersonBuilder {
    b.person.Email = email
    return b
}

func (b *PersonBuilder) WithAddress(address string) *PersonBuilder {
    b.person.Address = address
    return b
}

func (b *PersonBuilder) WithPhone(phone string) *PersonBuilder {
    b.person.Phone = phone
    return b
}

func (b *PersonBuilder) Build() Person {
    return b.person
}

func main() {
    person := NewPersonBuilder().
        WithName("Alice").
        WithAge(25).
        WithEmail("alice@email.com").
        WithAddress("123 Main St").
        WithPhone("555-1234").
        Build()
    
    fmt.Printf("Person: %+v\n", person)
}

// Singleton Pattern in Go
package main

import (
    "fmt"
    "sync"
)

type Database struct {
    connected bool
}

var (
    instance *Database
    once sync.Once
)

func GetDatabase() *Database {
    once.Do(func() {
        fmt.Println("Creating database connection...")
        instance = &Database{connected: true}
    })
    return instance
}

func (db *Database) Query(sql string) {
    fmt.Printf("Executing query: %s\n", sql)
}

func main() {
    db1 := GetDatabase()
    db2 := GetDatabase()
    
    db1.Query("SELECT * FROM users")
    db2.Query("SELECT * FROM orders")
    
    fmt.Printf("db1 == db2: %v\n", db1 == db2)
    fmt.Printf("db1 address: %p\n", db1)
    fmt.Printf("db2 address: %p\n", db2)
}

// Factory Pattern in Go
package main

import "fmt"

// Product interface
type Product interface {
    Use() string
}

// Concrete products
type Chair struct{}

func (c Chair) Use() string {
    return "Sitting on a chair"
}

type Table struct{}

func (t Table) Use() string {
    return "Placing items on a table"
}

type Sofa struct{}

func (s Sofa) Use() string {
    return "Sitting on a sofa"
}

// Factory
type FurnitureFactory struct{}

func (f FurnitureFactory) CreateProduct(productType string) (Product, error) {
    switch productType {
    case "chair":
        return Chair{}, nil
    case "table":
        return Table{}, nil
    case "sofa":
        return Sofa{}, nil
    default:
        return nil, fmt.Errorf("unknown product type: %s", productType)
    }
}

func main() {
    factory := FurnitureFactory{}
    
    products := []string{"chair", "table", "sofa"}
    for _, p := range products {
        product, err := factory.CreateProduct(p)
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            continue
        }
        fmt.Printf("%s: %s\n", p, product.Use())
    }
}

// Strategy Pattern in Go
package main

import "fmt"

// Strategy interface
type SortStrategy interface {
    Sort(data []int) []int
}

// Bubble sort
type BubbleSort struct{}

func (b BubbleSort) Sort(data []int) []int {
    result := make([]int, len(data))
    copy(result, data)
    n := len(result)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if result[j] > result[j+1] {
                result[j], result[j+1] = result[j+1], result[j]
            }
        }
    }
    return result
}

// Quick sort
type QuickSort struct{}

func (q QuickSort) Sort(data []int) []int {
    result := make([]int, len(data))
    copy(result, data)
    quickSortHelper(result, 0, len(result)-1)
    return result
}

func quickSortHelper(arr []int, low, high int) {
    if low < high {
        pi := partition(arr, low, high)
        quickSortHelper(arr, low, pi-1)
        quickSortHelper(arr, pi+1, high)
    }
}

func partition(arr []int, low, high int) int {
    pivot := arr[high]
    i := low - 1
    for j := low; j < high; j++ {
        if arr[j] < pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

// Context
type Sorter struct {
    strategy SortStrategy
}

func (s *Sorter) SetStrategy(strategy SortStrategy) {
    s.strategy = strategy
}

func (s *Sorter) Sort(data []int) []int {
    return s.strategy.Sort(data)
}

func main() {
    data := []int{64, 34, 25, 12, 22, 11, 90}
    
    sorter := Sorter{}
    
    sorter.SetStrategy(BubbleSort{})
    result1 := sorter.Sort(data)
    fmt.Printf("Bubble Sort: %v\n", result1)
    
    sorter.SetStrategy(QuickSort{})
    result2 := sorter.Sort(data)
    fmt.Printf("Quick Sort: %v\n", result2)
}

// Observer Pattern in Go
package main

import "fmt"

// Observer interface
type Observer interface {
    Update(message string)
}

// Subject interface
type Subject interface {
    Register(observer Observer)
    Unregister(observer Observer)
    Notify(message string)
}

// Concrete Subject
type NewsPublisher struct {
    observers []Observer
}

func (n *NewsPublisher) Register(observer Observer) {
    n.observers = append(n.observers, observer)
}

func (n *NewsPublisher) Unregister(observer Observer) {
    for i, obs := range n.observers {
        if obs == observer {
            n.observers = append(n.observers[:i], n.observers[i+1:]...)
            break
        }
    }
}

func (n *NewsPublisher) Notify(message string) {
    for _, observer := range n.observers {
        observer.Update(message)
    }
}

// Concrete Observers
type EmailSubscriber struct {
    name string
}

func (e EmailSubscriber) Update(message string) {
    fmt.Printf("Email to %s: %s\n", e.name, message)
}

type SMSSubscriber struct {
    phone string
}

func (s SMSSubscriber) Update(message string) {
    fmt.Printf("SMS to %s: %s\n", s.phone, message)
}

func main() {
    publisher := NewsPublisher{}
    
    emailSub := EmailSubscriber{name: "Alice"}
    smsSub := SMSSubscriber{phone: "555-1234"}
    
    publisher.Register(emailSub)
    publisher.Register(smsSub)
    
    publisher.Notify("Breaking News: Go 1.18 released!")
    
    publisher.Unregister(emailSub)
    publisher.Notify("Update: Go 1.19 coming soon!")
}

// Pipeline Pattern in Go
package main

import (
    "fmt"
    "sync"
)

func generator(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func filter(in <-chan int, predicate func(int) bool) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            if predicate(n) {
                out <- n
            }
        }
        close(out)
    }()
    return out
}

func merge(chans ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    
    for _, ch := range chans {
        go func(c <-chan int) {
            for n := range c {
                out <- n
            }
            wg.Done()
        }(ch)
    }
    
    go func() {
        wg.Wait()
        close(out)
    }()
    
    return out
}

func main() {
    // Pipeline: generate -> square -> filter
    nums := generator(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    squares := square(nums)
    evens := filter(squares, func(n int) bool { return n%2 == 0 })
    
    // Fan-out: multiple workers
    workers := 3
    chans := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        chans[i] = filter(squares, func(n int) bool { return n%2 == 0 })
    }
    
    // Fan-in: merge results
    results := merge(chans...)
    
    for result := range results {
        fmt.Printf("Result: %d\n", result)
    }
}

// Worker Pool Pattern in Go
package main

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

type Job struct {
    ID int
}

type Result struct {
    JobID int
    Output string
}

func worker(id int, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job.ID)
        time.Sleep(time.Second) // Simulate work
        results <- Result{JobID: job.ID, Output: fmt.Sprintf("Job %d processed by worker %d", job.ID, id)}
    }
}

func main() {
    numJobs := 10
    numWorkers := 3
    
    jobs := make(chan Job, numJobs)
    results := make(chan Result, numJobs)
    
    var wg sync.WaitGroup
    
    // Start workers
    for i := 1; i <= numWorkers; i++ {
        wg.Add(1)
        go worker(i, jobs, results, &wg)
    }
    
    // Send jobs
    for i := 1; i <= numJobs; i++ {
        jobs <- Job{ID: i}
    }
    close(jobs)
    
    // Wait for workers to finish
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // Collect results
    for result := range results {
        fmt.Printf("Result: %s\n", result.Output)
    }
}

// Rate Limiting in Go
package main

import (
    "fmt"
    "time"
)

// Token bucket rate limiter
type RateLimiter struct {
    tokens chan struct{}
    ticker *time.Ticker
}

func NewRateLimiter(rate int) *RateLimiter {
    rl := &RateLimiter{
        tokens: make(chan struct{}, rate),
        ticker: time.NewTicker(time.Second / time.Duration(rate)),
    }
    
    // Refill tokens
    go func() {
        for range rl.ticker.C {
            select {
            case rl.tokens <- struct{}{}:
            default:
                // Token bucket full
            }
        }
    }()
    
    // Initialize tokens
    for i := 0; i < rate; i++ {
        rl.tokens <- struct{}{}
    }
    
    return rl
}

func (rl *RateLimiter) Allow() bool {
    select {
    case <-rl.tokens:
        return true
    default:
        return false
    }
}

func (rl *RateLimiter) Stop() {
    rl.ticker.Stop()
}

func main() {
    limiter := NewRateLimiter(3) // 3 requests per second
    defer limiter.Stop()
    
    for i := 0; i < 10; i++ {
        if limiter.Allow() {
            fmt.Printf("Request %d allowed at %v\n", i, time.Now())
        } else {
            fmt.Printf("Request %d denied at %v\n", i, time.Now())
        }
        time.Sleep(200 * time.Millisecond)
    }
}

// Circuit Breaker Pattern in Go
package main

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

type CircuitBreaker struct {
    mu sync.Mutex
    state string // "closed", "open", "half-open"
    failureCount int
    maxFailures int
    timeout time.Duration
    lastFailureTime time.Time
}

func NewCircuitBreaker(maxFailures int, timeout time.Duration) *CircuitBreaker {
    return &CircuitBreaker{
        state: "closed",
        maxFailures: maxFailures,
        timeout: timeout,
    }
}

func (cb *CircuitBreaker) Call(fn func() error) error {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    
    // Check if circuit is open
    if cb.state == "open" {
        if time.Since(cb.lastFailureTime) > cb.timeout {
            cb.state = "half-open"
            fmt.Println("Circuit: half-open")
        } else {
            return errors.New("circuit breaker is open")
        }
    }
    
    // Execute the function
    err := fn()
    
    if err != nil {
        cb.failureCount++
        cb.lastFailureTime = time.Now()
        
        if cb.failureCount >= cb.maxFailures {
            cb.state = "open"
            fmt.Println("Circuit: open")
        }
        return err
    }
    
    // Success - reset
    cb.failureCount = 0
    if cb.state == "half-open" {
        cb.state = "closed"
        fmt.Println("Circuit: closed")
    }
    
    return nil
}

func main() {
    cb := NewCircuitBreaker(3, 2*time.Second)
    
    // Simulate a failing service
    failCount := 0
    for i := 0; i < 10; i++ {
        err := cb.Call(func() error {
            failCount++
            if failCount <= 3 {
                return errors.New("service error")
            }
            return nil
        })
        
        if err != nil {
            fmt.Printf("Call %d: Error - %v\n", i+1, err)
        } else {
            fmt.Printf("Call %d: Success\n", i+1)
        }
        time.Sleep(500 * time.Millisecond)
    }
}

// Retry Pattern in Go
package main

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

type RetryConfig struct {
    MaxAttempts int
    InitialDelay time.Duration
    MaxDelay time.Duration
    Multiplier float64
}

func DefaultRetryConfig() RetryConfig {
    return RetryConfig{
        MaxAttempts: 3,
        InitialDelay: 100 * time.Millisecond,
        MaxDelay: 2 * time.Second,
        Multiplier: 2.0,
    }
}

func Retry(fn func() error, config RetryConfig) error {
    var lastErr error
    delay := config.InitialDelay
    
    for attempt := 0; attempt < config.MaxAttempts; attempt++ {
        err := fn()
        if err == nil {
            return nil
        }
        
        lastErr = err
        
        if attempt < config.MaxAttempts-1 {
            fmt.Printf("Attempt %d failed: %v, retrying in %v\n", attempt+1, err, delay)
            time.Sleep(delay)
            delay = time.Duration(float64(delay) * config.Multiplier)
            if delay > config.MaxDelay {
                delay = config.MaxDelay
            }
        }
    }
    
    return fmt.Errorf("all %d attempts failed: %w", config.MaxAttempts, lastErr)
}

func main() {
    attemptCount := 0
    err := Retry(func() error {
        attemptCount++
        if attemptCount < 3 {
            return errors.New("temporary error")
        }
        return nil
    }, DefaultRetryConfig())
    
    if err != nil {
        fmt.Printf("Failed: %v\n", err)
    } else {
        fmt.Printf("Success after %d attempts\n", attemptCount)
    }
}

// Timeout Pattern in Go
package main

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

func slowOperation() string {
    time.Sleep(2 * time.Second)
    return "Operation complete"
}

func withTimeout(timeout time.Duration) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    resultCh := make(chan string, 1)
    errCh := make(chan error, 1)
    
    go func() {
        result := slowOperation()
        select {
        case resultCh <- result:
        case <-ctx.Done():
            // Operation completed but context was cancelled
        }
    }()
    
    select {
    case result := <-resultCh:
        return result, nil
    case <-ctx.Done():
        return "", fmt.Errorf("operation timed out after %v", timeout)
    }
}

func main() {
    // Test with timeout that's too short
    result, err := withTimeout(1 * time.Second)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Result: %s\n", result)
    }
    
    // Test with sufficient timeout
    result2, err2 := withTimeout(3 * time.Second)
    if err2 != nil {
        fmt.Printf("Error: %v\n", err2)
    } else {
        fmt.Printf("Result: %s\n", result2)
    }
}

// Semaphore Pattern in Go
package main

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

type Semaphore struct {
    ch chan struct{}
}

func NewSemaphore(maxConcurrency int) *Semaphore {
    return &Semaphore{
        ch: make(chan struct{}, maxConcurrency),
    }
}

func (s *Semaphore) Acquire() {
    s.ch <- struct{}{}
}

func (s *Semaphore) Release() {
    <-s.ch
}

func main() {
    sem := NewSemaphore(3) // Max 3 concurrent operations
    var wg sync.WaitGroup
    
    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            sem.Acquire()
            defer sem.Release()
            
            fmt.Printf("Task %d started at %v\n", id, time.Now())
            time.Sleep(1 * time.Second)
            fmt.Printf("Task %d completed at %v\n", id, time.Now())
        }(i)
    }
    
    wg.Wait()
    fmt.Println("All tasks completed")
}

// Graceful Shutdown in Go
package main

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

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    })
    
    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }
    
    // Start server in goroutine
    go func() {
        fmt.Println("Server starting on :8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            fmt.Printf("Server error: %v\n", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    fmt.Println("Shutting down server...")
    
    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        fmt.Printf("Server shutdown error: %v\n", err)
    }
    
    fmt.Println("Server stopped")
}

// CORS Middleware in Go
package main

import (
    "fmt"
    "net/http"
)

func corsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, `{"message": "CORS enabled"}`)
    })
    
    handler := corsMiddleware(mux)
    fmt.Println("Server starting on :8080")
    http.ListenAndServe(":8080", handler)
}

// JWT Authentication in Go
package main

import (
    "fmt"
    "time"
    "github.com/golang-jwt/jwt"
)

var secretKey = []byte("my-secret-key")

type Claims struct {
    Username string `json:"username"`
    jwt.StandardClaims
}

func GenerateToken(username string) (string, error) {
    expirationTime := time.Now().Add(1 * time.Hour)
    claims := &Claims{
        Username: username,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: expirationTime.Unix(),
            IssuedAt:  time.Now().Unix(),
            Issuer:    "my-app",
        },
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(secretKey)
}

func ValidateToken(tokenString string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
        return secretKey, nil
    })
    
    if err != nil {
        return nil, err
    }
    
    if claims, ok := token.Claims.(*Claims); ok && token.Valid {
        return claims, nil
    }
    
    return nil, fmt.Errorf("invalid token")
}

func main() {
    // Generate token
    token, err := GenerateToken("alice")
    if err != nil {
        fmt.Printf("Error generating token: %v\n", err)
        return
    }
    fmt.Printf("Token: %s\n", token)
    
    // Validate token
    claims, err := ValidateToken(token)
    if err != nil {
        fmt.Printf("Error validating token: %v\n", err)
        return
    }
    fmt.Printf("Valid token for user: %s\n", claims.Username)
}

// Metrics and Monitoring in Go
package main

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

type Metrics struct {
    requests int
    errors int
    totalDuration time.Duration
}

var metrics Metrics

func metricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        duration := time.Since(start)
        
        metrics.requests++
        metrics.totalDuration += duration
    })
}

func metricsHandler(w http.ResponseWriter, r *http.Request) {
    avgDuration := metrics.totalDuration / time.Duration(metrics.requests)
    fmt.Fprintf(w, "Requests: %d\n", metrics.requests)
    fmt.Fprintf(w, "Errors: %d\n", metrics.errors)
    fmt.Fprintf(w, "Avg Duration: %v\n", avgDuration)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(100 * time.Millisecond)
        fmt.Fprintf(w, "API response")
    })
    mux.HandleFunc("/metrics", metricsHandler)
    
    handler := metricsMiddleware(mux)
    http.ListenAndServe(":8080", handler)
}

// Profiling in Go
package main

import (
    "fmt"
    "os"
    "runtime/pprof"
    "time"
)

func expensiveOperation() {
    sum := 0
    for i := 0; i < 1000000; i++ {
        sum += i
    }
}

func main() {
    // CPU profiling
    f, err := os.Create("cpu.prof")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer f.Close()
    
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()
    
    // Run operations
    for i := 0; i < 10; i++ {
        expensiveOperation()
        time.Sleep(10 * time.Millisecond)
    }
    
    // Memory profiling
    f2, err := os.Create("mem.prof")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer f2.Close()
    
    pprof.WriteHeapProfile(f2)
    fmt.Println("Profiling complete")
}

// Tracing in Go
package main

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

type Trace struct {
    name string
    start time.Time
    end time.Time
    children []*Trace
}

func StartTrace(name string) *Trace {
    return &Trace{
        name: name,
        start: time.Now(),
        children: []*Trace{},
    }
}

func (t *Trace) End() {
    t.end = time.Now()
}

func (t *Trace) AddChild(child *Trace) {
    t.children = append(t.children, child)
}

func (t *Trace) Duration() time.Duration {
    return t.end.Sub(t.start)
}

func (t *Trace) Print(indent int) {
    prefix := ""
    for i := 0; i < indent; i++ {
        prefix += "  "
    }
    fmt.Printf("%s%s: %v\n", prefix, t.name, t.Duration())
    for _, child := range t.children {
        child.Print(indent + 1)
    }
}

func operation1(ctx context.Context, trace *Trace) {
    child := StartTrace("operation1")
    defer child.End()
    trace.AddChild(child)
    
    time.Sleep(100 * time.Millisecond)
    operation2(ctx, child)
}

func operation2(ctx context.Context, trace *Trace) {
    child := StartTrace("operation2")
    defer child.End()
    trace.AddChild(child)
    
    time.Sleep(50 * time.Millisecond)
    operation3(ctx, child)
}

func operation3(ctx context.Context, trace *Trace) {
    child := StartTrace("operation3")
    defer child.End()
    trace.AddChild(child)
    
    time.Sleep(25 * time.Millisecond)
}

func main() {
    ctx := context.Background()
    root := StartTrace("main")
    defer root.End()
    
    operation1(ctx, root)
    
    root.Print(0)
}

// Feature Flags in Go
package main

import (
    "fmt"
    "sync"
)

type FeatureFlags struct {
    mu sync.RWMutex
    flags map[string]bool
}

func NewFeatureFlags() *FeatureFlags {
    return &FeatureFlags{
        flags: make(map[string]bool),
    }
}

func (ff *FeatureFlags) SetFlag(name string, enabled bool) {
    ff.mu.Lock()
    defer ff.mu.Unlock()
    ff.flags[name] = enabled
}

func (ff *FeatureFlags) IsEnabled(name string) bool {
    ff.mu.RLock()
    defer ff.mu.RUnlock()
    return ff.flags[name]
}

func (ff *FeatureFlags) GetFlags() map[string]bool {
    ff.mu.RLock()
    defer ff.mu.RUnlock()
    result := make(map[string]bool)
    for k, v := range ff.flags {
        result[k] = v
    }
    return result
}

func main() {
    ff := NewFeatureFlags()
    
    ff.SetFlag("new-feature", true)
    ff.SetFlag("experimental-api", false)
    
    if ff.IsEnabled("new-feature") {
        fmt.Println("New feature is enabled")
    }
    
    if !ff.IsEnabled("experimental-api") {
        fmt.Println("Experimental API is disabled")
    }
}

// Configuration Management in Go
package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
)

type Config struct {
    Server struct {
        Host string `json:"host"`
        Port int    `json:"port"`
    } `json:"server"`
    Database struct {
        Host     string `json:"host"`
        Port     int    `json:"port"`
        Username string `json:"username"`
        Password string `json:"password"`
        Name     string `json:"name"`
    } `json:"database"`
    Logging struct {
        Level  string `json:"level"`
        Output string `json:"output"`
    } `json:"logging"`
}

func LoadConfig(path string) (*Config, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    data, err := ioutil.ReadAll(file)
    if err != nil {
        return nil, err
    }
    
    var config Config
    err = json.Unmarshal(data, &config)
    if err != nil {
        return nil, err
    }
    
    // Environment variable overrides
    if host := os.Getenv("DB_HOST"); host != "" {
        config.Database.Host = host
    }
    if port := os.Getenv("DB_PORT"); port != "" {
        fmt.Sscanf(port, "%d", &config.Database.Port)
    }
    
    return &config, nil
}

func main() {
    // Create sample config file
    sampleConfig := Config{
        Server: struct {
            Host string `json:"host"`
            Port int    `json:"port"`
        }{Host: "localhost", Port: 8080},
        Database: struct {
            Host     string `json:"host"`
            Port     int    `json:"port"`
            Username string `json:"username"`
            Password string `json:"password"`
            Name     string `json:"name"`
        }{Host: "localhost", Port: 5432, Username: "user", Password: "pass", Name: "db"},
        Logging: struct {
            Level  string `json:"level"`
            Output string `json:"output"`
        }{Level: "info", Output: "stdout"},
    }
    
    data, _ := json.MarshalIndent(sampleConfig, "", "  ")
    ioutil.WriteFile("config.json", data, 0644)
    
    // Load config
    config, err := LoadConfig("config.json")
    if err != nil {
        fmt.Printf("Error loading config: %v\n", err)
        return
    }
    
    fmt.Printf("Server: %s:%d\n", config.Server.Host, config.Server.Port)
    fmt.Printf("Database: %s:%d/%s\n", config.Database.Host, config.Database.Port, config.Database.Name)
}

// Environment Variables Configuration in Go
package main

import (
    "fmt"
    "os"
    "strconv"
)

type AppConfig struct {
    Port int
    DatabaseURL string
    LogLevel string
    MaxConnections int
}

func LoadConfigFromEnv() AppConfig {
    config := AppConfig{
        Port: 8080,
        DatabaseURL: "postgres://localhost:5432",
        LogLevel: "info",
        MaxConnections: 10,
    }
    
    if port := os.Getenv("PORT"); port != "" {
        if p, err := strconv.Atoi(port); err == nil {
            config.Port = p
        }
    }
    
    if dbURL := os.Getenv("DATABASE_URL"); dbURL != "" {
        config.DatabaseURL = dbURL
    }
    
    if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "" {
        config.LogLevel = logLevel
    }
    
    if maxConn := os.Getenv("MAX_CONNECTIONS"); maxConn != "" {
        if m, err := strconv.Atoi(maxConn); err == nil {
            config.MaxConnections = m
        }
    }
    
    return config
}

func main() {
    os.Setenv("PORT", "9090")
    os.Setenv("LOG_LEVEL", "debug")
    
    config := LoadConfigFromEnv()
    fmt.Printf("Port: %d\n", config.Port)
    fmt.Printf("DatabaseURL: %s\n", config.DatabaseURL)
    fmt.Printf("LogLevel: %s\n", config.LogLevel)
    fmt.Printf("MaxConnections: %d\n", config.MaxConnections)
}

// Versioning in Go
package main

import (
    "fmt"
    "runtime"
)

// Build information (set by ldflags)
var (
    Version   = "dev"
    BuildTime = "unknown"
    GitCommit = "unknown"
)

func main() {
    fmt.Printf("Application: %s\n", Version)
    fmt.Printf("Build Time: %s\n", BuildTime)
    fmt.Printf("Git Commit: %s\n", GitCommit)
    fmt.Printf("Go Version: %s\n", runtime.Version())
    fmt.Printf("OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH)
}

// Docker Integration in Go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Check if running in container
    if _, err := os.Stat("/.dockerenv"); err == nil {
        fmt.Println("Running in Docker container")
    }
    
    // Get container ID from cgroup
    if data, err := os.ReadFile("/proc/self/cgroup"); err == nil {
        fmt.Printf("Cgroup: %s\n", string(data[:100]))
    }
    
    // Container environment variables
    hostname, _ := os.Hostname()
    fmt.Printf("Hostname: %s\n", hostname)
    
    fmt.Println("Application running")
}

// Health Check Endpoint in Go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type HealthStatus struct {
    Status string `json:"status"`
    Timestamp string `json:"timestamp"`
    Uptime string `json:"uptime"`
    Services map[string]string `json:"services"`
}

var startTime = time.Now()

func healthHandler(w http.ResponseWriter, r *http.Request) {
    status := HealthStatus{
        Status: "healthy",
        Timestamp: time.Now().Format(time.RFC3339),
        Uptime: time.Since(startTime).String(),
        Services: map[string]string{
            "database": "healthy",
            "cache": "healthy",
            "api": "healthy",
        },
    }
    
    // Check services (simplified)
    // In real app, check actual service health
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(status)
}

func readinessHandler(w http.ResponseWriter, r *http.Request) {
    // Check if application is ready to serve traffic
    ready := true
    if !ready {
        http.Error(w, "Not ready", http.StatusServiceUnavailable)
        return
    }
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status": "ready"}`))
}

func livenessHandler(w http.ResponseWriter, r *http.Request) {
    // Check if application is alive
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status": "alive"}`))
}

func main() {
    http.HandleFunc("/health", healthHandler)
    http.HandleFunc("/ready", readinessHandler)
    http.HandleFunc("/live", livenessHandler)
    
    fmt.Println("Server starting on :8080")
    http.ListenAndServe(":8080", nil)
}

// Graceful Restart in Go
package main

import (
    "fmt"
    "net"
    "os"
    "os/exec"
    "syscall"
)

func main() {
    fmt.Printf("PID: %d\n", os.Getpid())
    
    // Check if this is a restart
    if len(os.Args) > 1 && os.Args[1] == "restart" {
        fmt.Println("Restarting...")
        cmd := exec.Command(os.Args[0])
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        cmd.Stdin = os.Stdin
        cmd.SysProcAttr = &syscall.SysProcAttr{
            Pdeathsig: syscall.SIGTERM,
        }
        cmd.Start()
        fmt.Printf("New process started: %d\n", cmd.Process.Pid)
        return
    }
    
    // Listen on port
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer listener.Close()
    
    fmt.Println("Server running on :8080")
    
    // Keep running
    select {}
}

// Service Discovery in Go
package main

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

type ServiceInstance struct {
    ID string
    Name string
    Address string
    Port int
    HealthCheckURL string
    LastSeen time.Time
}

type ServiceRegistry struct {
    mu sync.RWMutex
    services map[string][]ServiceInstance
}

func NewServiceRegistry() *ServiceRegistry {
    return &ServiceRegistry{
        services: make(map[string][]ServiceInstance),
    }
}

func (sr *ServiceRegistry) Register(service ServiceInstance) {
    sr.mu.Lock()
    defer sr.mu.Unlock()
    
    service.LastSeen = time.Now()
    sr.services[service.Name] = append(sr.services[service.Name], service)
    fmt.Printf("Registered service: %s (ID: %s)\n", service.Name, service.ID)
}

func (sr *ServiceRegistry) Deregister(name, id string) {
    sr.mu.Lock()
    defer sr.mu.Unlock()
    
    instances := sr.services[name]
    for i, svc := range instances {
        if svc.ID == id {
            sr.services[name] = append(instances[:i], instances[i+1:]...)
            fmt.Printf("Deregistered service: %s (ID: %s)\n", name, id)
            return
        }
    }
}

func (sr *ServiceRegistry) GetInstances(name string) []ServiceInstance {
    sr.mu.RLock()
    defer sr.mu.RUnlock()
    
    // Remove stale services
    var active []ServiceInstance
    for _, svc := range sr.services[name] {
        if time.Since(svc.LastSeen) < 30*time.Second {
            active = append(active, svc)
        }
    }
    return active
}

func main() {
    registry := NewServiceRegistry()
    
    // Register services
    registry.Register(ServiceInstance{
        ID: "1",
        Name: "user-service",
        Address: "localhost",
        Port: 8081,
    })
    registry.Register(ServiceInstance{
        ID: "2",
        Name: "user-service",
        Address: "localhost",
        Port: 8082,
    })
    registry.Register(ServiceInstance{
        ID: "3",
        Name: "order-service",
        Address: "localhost",
        Port: 8083,
    })
    
    // Get instances
    userServices := registry.GetInstances("user-service")
    fmt.Printf("User services: %v\n", userServices)
    
    orderServices := registry.GetInstances("order-service")
    fmt.Printf("Order services: %v\n", orderServices)
}

// Circuit Breaker with Metrics in Go
package main

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

type Metrics struct {
    totalRequests int64
    successRequests int64
    failureRequests int64
}

type CircuitBreakerWithMetrics struct {
    metrics Metrics
    state int32 // 0=closed, 1=open, 2=half-open
    failureThreshold int64
    timeout time.Duration
    lastFailure time.Time
    mu sync.Mutex
}

func NewCircuitBreakerWithMetrics(threshold int64, timeout time.Duration) *CircuitBreakerWithMetrics {
    return &CircuitBreakerWithMetrics{
        failureThreshold: threshold,
        timeout: timeout,
    }
}

func (cb *CircuitBreakerWithMetrics) Call(fn func() error) error {
    atomic.AddInt64(&cb.metrics.totalRequests, 1)
    
    cb.mu.Lock()
    if cb.state == 1 { // open
        if time.Since(cb.lastFailure) > cb.timeout {
            cb.state = 2 // half-open
            cb.mu.Unlock()
            fmt.Println("Circuit: half-open")
        } else {
            cb.mu.Unlock()
            atomic.AddInt64(&cb.metrics.failureRequests, 1)
            return errors.New("circuit breaker is open")
        }
    } else {
        cb.mu.Unlock()
    }
    
    err := fn()
    
    cb.mu.Lock()
    defer cb.mu.Unlock()
    
    if err != nil {
        atomic.AddInt64(&cb.metrics.failureRequests, 1)
        cb.lastFailure = time.Now()
        
        if cb.metrics.failureRequests >= cb.failureThreshold {
            cb.state = 1 // open
            fmt.Println("Circuit: open")
        }
        return err
    }
    
    atomic.AddInt64(&cb.metrics.successRequests, 1)
    if cb.state == 2 {
        cb.state = 0 // closed
        fmt.Println("Circuit: closed")
    }
    
    return nil
}

func (cb *CircuitBreakerWithMetrics) GetMetrics() Metrics {
    return cb.metrics
}

func main() {
    cb := NewCircuitBreakerWithMetrics(3, 2*time.Second)
    
    for i := 0; i < 10; i++ {
        err := cb.Call(func() error {
            if i < 4 {
                return errors.New("service error")
            }
            return nil
        })
        
        if err != nil {
            fmt.Printf("Call %d: Error - %v\n", i+1, err)
        } else {
            fmt.Printf("Call %d: Success\n", i+1)
        }
        time.Sleep(500 * time.Millisecond)
    }
    
    metrics := cb.GetMetrics()
    fmt.Printf("Metrics: Total=%d, Success=%d, Failure=%d\n",
        metrics.totalRequests, metrics.successRequests, metrics.failureRequests)
}

// Distributed Tracing in Go
package main

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

type Span struct {
    ID string
    ParentID string
    Name string
    Start time.Time
    End time.Time
    Tags map[string]string
}

type Tracer struct {
    spans []*Span
}

func NewTracer() *Tracer {
    return &Tracer{
        spans: []*Span{},
    }
}

func (t *Tracer) StartSpan(ctx context.Context, name string) (*Span, context.Context) {
    span := &Span{
        ID: fmt.Sprintf("%d", len(t.spans)+1),
        Name: name,
        Start: time.Now(),
        Tags: make(map[string]string),
    }
    
    // Get parent ID from context
    if parent, ok := ctx.Value("span").(*Span); ok {
        span.ParentID = parent.ID
    }
    
    t.spans = append(t.spans, span)
    ctx = context.WithValue(ctx, "span", span)
    return span, ctx
}

func (t *Tracer) EndSpan(span *Span) {
    span.End = time.Now()
}

func (t *Tracer) AddTag(span *Span, key, value string) {
    span.Tags[key] = value
}

func (t *Tracer) PrintSpans() {
    for _, span := range t.spans {
        duration := span.End.Sub(span.Start)
        parent := "root"
        if span.ParentID != "" {
            parent = span.ParentID
        }
        fmt.Printf("Span: %s, Parent: %s, Duration: %v, Tags: %v\n",
            span.Name, parent, duration, span.Tags)
    }
}

func main() {
    tracer := NewTracer()
    ctx := context.Background()
    
    // Root span
    span1, ctx := tracer.StartSpan(ctx, "main")
    tracer.AddTag(span1, "service", "api-gateway")
    
    // Child span
    span2, ctx := tracer.StartSpan(ctx, "database-query")
    tracer.AddTag(span2, "table", "users")
    time.Sleep(50 * time.Millisecond)
    tracer.EndSpan(span2)
    
    // Another child span
    span3, ctx := tracer.StartSpan(ctx, "external-api")
    tracer.AddTag(span3, "endpoint", "/api/data")
    time.Sleep(100 * time.Millisecond)
    tracer.EndSpan(span3)
    
    tracer.EndSpan(span1)
    tracer.PrintSpans()
}

// API Versioning in Go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strings"
)

type UserV1 struct {
    ID int `json:"id"`
    Name string `json:"name"`
}

type UserV2 struct {
    ID int `json:"id"`
    Name string `json:"name"`
    Email string `json:"email"`
    Age int `json:"age"`
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    path := r.URL.Path
    version := "v1"
    
    // Extract version from path
    if strings.Contains(path, "/v2/") {
        version = "v2"
    }
    
    // Also check header
    if v := r.Header.Get("API-Version"); v != "" {
        version = v
    }
    
    switch version {
    case "v1":
        users := []UserV1{
            {ID: 1, Name: "Alice"},
            {ID: 2, Name: "Bob"},
        }
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    case "v2":
        users := []UserV2{
            {ID: 1, Name: "Alice", Email: "alice@email.com", Age: 25},
            {ID: 2, Name: "Bob", Email: "bob@email.com", Age: 30},
        }
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    default:
        http.Error(w, "Unsupported version", http.StatusBadRequest)
    }
}

func main() {
    http.HandleFunc("/api/v1/users", apiHandler)
    http.HandleFunc("/api/v2/users", apiHandler)
    http.HandleFunc("/api/users", apiHandler)
    
    fmt.Println("Server starting on :8080")
    http.ListenAndServe(":8080", nil)
}

// Pagination in Go
package main

import (
    "fmt"
    "math"
    "strconv"
)

type Pagination struct {
    Page int `json:"page"`
    PerPage int `json:"per_page"`
    Total int `json:"total"`
    TotalPages int `json:"total_pages"`
}

func Paginate(items []string, page, perPage int) ([]string, Pagination) {
    total := len(items)
    totalPages := int(math.Ceil(float64(total) / float64(perPage)))
    
    if page < 1 {
        page = 1
    }
    if perPage < 1 {
        perPage = 10
    }
    
    start := (page - 1) * perPage
    end := start + perPage
    
    if start >= total {
        return []string{}, Pagination{
            Page: page,
            PerPage: perPage,
            Total: total,
            TotalPages: totalPages,
        }
    }
    
    if end > total {
        end = total
    }
    
    pagination := Pagination{
        Page: page,
        PerPage: perPage,
        Total: total,
        TotalPages: totalPages,
    }
    
    return items[start:end], pagination
}

func main() {
    items := make([]string, 0)
    for i := 1; i <= 100; i++ {
        items = append(items, fmt.Sprintf("Item %d", i))
    }
    
    page := 2
    perPage := 10
    
    result, pagination := Paginate(items, page, perPage)
    
    fmt.Printf("Page %d of %d\n", pagination.Page, pagination.TotalPages)
    fmt.Printf("Items: %v\n", result)
    fmt.Printf("Pagination: %+v\n", pagination)
}

// Sorting and Filtering in Go
package main

import (
    "fmt"
    "sort"
    "strings"
)

type User struct {
    ID int
    Name string
    Age int
    Email string
}

type UserFilter struct {
    NameContains string
    MinAge int
    MaxAge int
    SortBy string
    SortDesc bool
}

func FilterUsers(users []User, filter UserFilter) []User {
    result := make([]User, 0)
    
    for _, user := range users {
        // Filter by name
        if filter.NameContains != "" && !strings.Contains(strings.ToLower(user.Name), strings.ToLower(filter.NameContains)) {
            continue
        }
        
        // Filter by age
        if filter.MinAge > 0 && user.Age < filter.MinAge {
            continue
        }
        if filter.MaxAge > 0 && user.Age > filter.MaxAge {
            continue
        }
        
        result = append(result, user)
    }
    
    // Sort
    if filter.SortBy != "" {
        sort.Slice(result, func(i, j int) bool {
            var less bool
            switch filter.SortBy {
            case "name":
                less = result[i].Name < result[j].Name
            case "age":
                less = result[i].Age < result[j].Age
            case "id":
                less = result[i].ID < result[j].ID
            default:
                less = result[i].ID < result[j].ID
            }
            
            if filter.SortDesc {
                return !less
            }
            return less
        })
    }
    
    return result
}

func main() {
    users := []User{
        {ID: 3, Name: "Carol", Age: 22, Email: "carol@email.com"},
        {ID: 1, Name: "Alice", Age: 25, Email: "alice@email.com"},
        {ID: 4, Name: "Dave", Age: 35, Email: "dave@email.com"},
        {ID: 2, Name: "Bob", Age: 30, Email: "bob@email.com"},
    }
    
    filter := UserFilter{
        NameContains: "a",
        MinAge: 20,
        MaxAge: 30,
        SortBy: "name",
        SortDesc: false,
    }
    
    result := FilterUsers(users, filter)
    for _, user := range result {
        fmt.Printf("%+v\n", user)
    }
}

// Search in Go
package main

import (
    "fmt"
    "strings"
)

type Document struct {
    ID int
    Title string
    Content string
}

type SearchResult struct {
    Document Document
    Score int
}

func Search(documents []Document, query string) []SearchResult {
    results := make([]SearchResult, 0)
    query = strings.ToLower(query)
    queryWords := strings.Fields(query)
    
    for _, doc := range documents {
        score := 0
        content := strings.ToLower(doc.Title + " " + doc.Content)
        
        for _, word := range queryWords {
            if strings.Contains(content, word) {
                score++
            }
        }
        
        if score > 0 {
            results = append(results, SearchResult{Document: doc, Score: score})
        }
    }
    
    // Sort by score (descending)
    for i := 0; i < len(results); i++ {
        for j := i + 1; j < len(results); j++ {
            if results[j].Score > results[i].Score {
                results[i], results[j] = results[j], results[i]
            }
        }
    }
    
    return results
}

func main() {
    documents := []Document{
        {ID: 1, Title: "Go Programming", Content: "Go is a programming language designed for simplicity"},
        {ID: 2, Title: "Web Development", Content: "Web development with Go is fast and efficient"},
        {ID: 3, Title: "Database Systems", Content: "Go has excellent database drivers and ORM support"},
    }
    
    results := Search(documents, "go programming")
    
    fmt.Println("Search results:")
    for _, result := range results {
        fmt.Printf("Doc %d: %s (Score: %d)\n", 
            result.Document.ID, result.Document.Title, result.Score)
    }
}

// Caching in Go
package main

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

type CacheItem struct {
    Value interface{}
    Expiration time.Time
}

type Cache struct {
    mu sync.RWMutex
    items map[string]CacheItem
    defaultTTL time.Duration
    cleanupInterval time.Duration
}

func NewCache(defaultTTL, cleanupInterval time.Duration) *Cache {
    cache := &Cache{
        items: make(map[string]CacheItem),
        defaultTTL: defaultTTL,
        cleanupInterval: cleanupInterval,
    }
    
    // Start cleanup goroutine
    go cache.cleanup()
    
    return cache
}

func (c *Cache) Set(key string, value interface{}, ttl ...time.Duration) {
    expiration := time.Now().Add(c.defaultTTL)
    if len(ttl) > 0 {
        expiration = time.Now().Add(ttl[0])
    }
    
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = CacheItem{Value: value, Expiration: expiration}
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    item, exists := c.items[key]
    c.mu.RUnlock()
    
    if !exists {
        return nil, false
    }
    
    if time.Now().After(item.Expiration) {
        c.Delete(key)
        return nil, false
    }
    
    return item.Value, true
}

func (c *Cache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.items, key)
}

func (c *Cache) cleanup() {
    ticker := time.NewTicker(c.cleanupInterval)
    defer ticker.Stop()
    
    for range ticker.C {
        c.mu.Lock()
        for key, item := range c.items {
            if time.Now().After(item.Expiration) {
                delete(c.items, key)
            }
        }
        c.mu.Unlock()
    }
}

func main() {
    cache := NewCache(5*time.Second, 1*time.Second)
    
    cache.Set("key1", "value1")
    cache.Set("key2", "value2", 2*time.Second)
    
    // Get immediately
    if val, ok := cache.Get("key1"); ok {
        fmt.Printf("key1: %v\n", val)
    }
    
    // Wait for expiration
    time.Sleep(3 * time.Second)
    
    if val, ok := cache.Get("key2"); ok {
        fmt.Printf("key2: %v\n", val)
    } else {
        fmt.Println("key2 expired")
    }
}

// Rate Limiting with Token Bucket in Go
package main

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

type TokenBucket struct {
    mu sync.Mutex
    tokens int
    maxTokens int
    refillRate time.Duration
    lastRefill time.Time
}

func NewTokenBucket(maxTokens int, refillRate time.Duration) *TokenBucket {
    return &TokenBucket{
        tokens: maxTokens,
        maxTokens: maxTokens,
        refillRate: refillRate,
        lastRefill: time.Now(),
    }
}

func (tb *TokenBucket) refill() {
    now := time.Now()
    elapsed := now.Sub(tb.lastRefill)
    tokensToAdd := int(elapsed / tb.refillRate)
    
    if tokensToAdd > 0 {
        tb.tokens = tb.tokens + tokensToAdd
        if tb.tokens > tb.maxTokens {
            tb.tokens = tb.maxTokens
        }
        tb.lastRefill = now
    }
}

func (tb *TokenBucket) Allow() bool {
    tb.mu.Lock()
    defer tb.mu.Unlock()
    
    tb.refill()
    
    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

func (tb *TokenBucket) Wait() {
    for !tb.Allow() {
        time.Sleep(10 * time.Millisecond)
    }
}

func main() {
    tb := NewTokenBucket(5, 100*time.Millisecond)
    
    for i := 0; i < 10; i++ {
        if tb.Allow() {
            fmt.Printf("Request %d allowed at %v\n", i+1, time.Now())
        } else {
            fmt.Printf("Request %d denied at %v\n", i+1, time.Now())
        }
        time.Sleep(50 * time.Millisecond)
    }
}

// Context with Values and Timeout in Go
package main

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

type contextKey string

func processRequest(ctx context.Context) {
    // Get values from context
    userID := ctx.Value(contextKey("userID"))
    requestID := ctx.Value(contextKey("requestID"))
    
    if userID == nil || requestID == nil {
        fmt.Println("Missing context values")
        return
    }
    
    fmt.Printf("Processing request: userID=%v, requestID=%v\n", userID, requestID)
    
    // Simulate work with timeout
    select {
    case <-ctx.Done():
        fmt.Println("Request cancelled: ", ctx.Err())
        return
    case <-time.After(2 * time.Second):
        fmt.Println("Request completed successfully")
    }
}

func main() {
    // Create context with values
    ctx := context.Background()
    ctx = context.WithValue(ctx, contextKey("userID"), "12345")
    ctx = context.WithValue(ctx, contextKey("requestID"), "req-abc-123")
    
    // Add timeout
    ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
    defer cancel()
    
    processRequest(ctx)
}

// Database Transaction in Go
package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    // Connect to database
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer db.Close()
    
    // Start transaction
    tx, err := db.Begin()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // Perform operations
    _, err = tx.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "Alice", 25)
    if err != nil {
        tx.Rollback()
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    _, err = tx.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "Bob", 30)
    if err != nil {
        tx.Rollback()
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // Commit transaction
    err = tx.Commit()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    fmt.Println("Transaction completed successfully")
}

// Database Migration in Go
package main

import (
    "database/sql"
    "fmt"
    "os"
    "path/filepath"
)

type Migration struct {
    Version int
    Name string
    Up string
    Down string
}

var migrations = []Migration{
    {
        Version: 1,
        Name: "create_users_table",
        Up: `CREATE TABLE users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT UNIQUE NOT NULL,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
        )`,
        Down: `DROP TABLE users`,
    },
    {
        Version: 2,
        Name: "create_posts_table",
        Up: `CREATE TABLE posts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER NOT NULL,
            title TEXT NOT NULL,
            content TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users(id)
        )`,
        Down: `DROP TABLE posts`,
    },
}

func RunMigrations(db *sql.DB) error {
    // Create migrations table if not exists
    _, err := db.Exec(`CREATE TABLE IF NOT EXISTS migrations (
        version INTEGER PRIMARY KEY,
        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )`)
    if err != nil {
        return err
    }
    
    // Get current version
    var currentVersion int
    row := db.QueryRow("SELECT COALESCE(MAX(version), 0) FROM migrations")
    row.Scan(&currentVersion)
    
    // Run pending migrations
    for _, migration := range migrations {
        if migration.Version > currentVersion {
            fmt.Printf("Running migration %d: %s\n", migration.Version, migration.Name)
            
            _, err := db.Exec(migration.Up)
            if err != nil {
                return fmt.Errorf("migration %d failed: %v", migration.Version, err)
            }
            
            _, err = db.Exec("INSERT INTO migrations (version) VALUES (?)", migration.Version)
            if err != nil {
                return err
            }
            
            fmt.Printf("Migration %d complete\n", migration.Version)
        }
    }
    
    return nil
}

func main() {
    // In production, connect to actual database
    // db, err := sql.Open("sqlite3", "app.db")
    // defer db.Close()
    
    fmt.Println("Migration tool ready")
}

// API Client in Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

type APIClient struct {
    BaseURL string
    Client *http.Client
    APIKey string
}

type User struct {
    ID int `json:"id"`
    Name string `json:"name"`
    Email string `json:"email"`
}

type Response struct {
    Data interface{} `json:"data"`
    Message string `json:"message"`
    Status string `json:"status"`
}

func NewAPIClient(baseURL, apiKey string) *APIClient {
    return &APIClient{
        BaseURL: baseURL,
        Client: &http.Client{
            Timeout: 10 * time.Second,
        },
        APIKey: apiKey,
    }
}

func (c *APIClient) Get(path string, result interface{}) error {
    url := c.BaseURL + path
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.Client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return err
    }
    
    return json.Unmarshal(body, result)
}

func (c *APIClient) Post(path string, data interface{}, result interface{}) error {
    url := c.BaseURL + path
    
    jsonData, err := json.Marshal(data)
    if err != nil {
        return err
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.Client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return err
    }
    
    return json.Unmarshal(body, result)
}

func main() {
    client := NewAPIClient("https://api.example.com", "your-api-key")
    
    // GET request
    var users []User
    err := client.Get("/users", &users)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Users: %+v\n", users)
    }
    
    // POST request
    newUser := User{Name: "Alice", Email: "alice@email.com"}
    var response Response
    err = client.Post("/users", newUser, &response)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Response: %+v\n", response)
    }
}

// Complete Web Application in Go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

// Models
type User struct {
    ID int `json:"id"`
    Name string `json:"name"`
    Email string `json:"email"`
    CreatedAt time.Time `json:"created_at"`
}

// In-memory store
type Store struct {
    mu sync.RWMutex
    users map[int]User
    nextID int
}

func NewStore() *Store {
    return &Store{
        users: make(map[int]User),
        nextID: 1,
    }
}

func (s *Store) CreateUser(name, email string) User {
    s.mu.Lock()
    defer s.mu.Unlock()
    
    user := User{
        ID: s.nextID,
        Name: name,
        Email: email,
        CreatedAt: time.Now(),
    }
    s.users[user.ID] = user
    s.nextID++
    return user
}

func (s *Store) GetUsers() []User {
    s.mu.RLock()
    defer s.mu.RUnlock()
    
    users := make([]User, 0, len(s.users))
    for _, user := range s.users {
        users = append(users, user)
    }
    return users
}

func (s *Store) GetUser(id int) (User, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    
    user, ok := s.users[id]
    return user, ok
}

// Handlers
func handleUsers(store *Store) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case "GET":
            users := store.GetUsers()
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(users)
            
        case "POST":
            var user User
            if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
                http.Error(w, "Invalid request", http.StatusBadRequest)
                return
            }
            
            created := store.CreateUser(user.Name, user.Email)
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(http.StatusCreated)
            json.NewEncoder(w).Encode(created)
            
        default:
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        }
    }
}

func handleUser(store *Store) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // Extract ID from URL
        // Simplified: expect ID in query param
        idStr := r.URL.Query().Get("id")
        if idStr == "" {
            http.Error(w, "ID required", http.StatusBadRequest)
            return
        }
        
        var id int
        fmt.Sscanf(idStr, "%d", &id)
        
        user, ok := store.GetUser(id)
        if !ok {
            http.Error(w, "User not found", http.StatusNotFound)
            return
        }
        
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(user)
    }
}

// Middleware
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        log.Printf("Completed in %v", time.Since(start))
    })
}

func corsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

func main() {
    store := NewStore()
    
    // Add sample data
    store.CreateUser("Alice", "alice@email.com")
    store.CreateUser("Bob", "bob@email.com")
    
    // Router
    mux := http.NewServeMux()
    mux.HandleFunc("/api/users", handleUsers(store))
    mux.HandleFunc("/api/user", handleUser(store))
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status": "healthy"}`))
    })
    
    // Apply middleware
    handler := loggingMiddleware(corsMiddleware(mux))
    
    server := &http.Server{
        Addr: ":8080",
        Handler: handler,
        ReadTimeout: 10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout: 30 * time.Second,
    }
    
    // Graceful shutdown
    go func() {
        log.Println("Server starting on :8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server error: %v", err)
        }
    }()
    
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    log.Println("Shutting down server...")
    server.Shutdown(context.Background())
    log.Println("Server stopped")
}