Why Use Go — Optimize the Code¶

package main

import (
    "fmt"
    "strings"
)

func buildStringFast(n int) string {
    var b strings.Builder
    b.Grow(n * 15) // Pre-allocate estimated capacity
    for i := 0; i < n; i++ {
        fmt.Fprintf(&b, "item-%d,", i)
    }
    return b.String()
}

func main() {
    s := buildStringFast(10000)
    fmt.Println("Length:", len(s))
}

package main

import "fmt"

func filterEvensFast(nums []int) []int {
    // Pre-allocate: at most len(nums)/2 even numbers
    result := make([]int, 0, len(nums)/2)
    for _, n := range nums {
        if n%2 == 0 {
            result = append(result, n)
        }
    }
    return result
}

func main() {
    nums := make([]int, 1000000)
    for i := range nums {
        nums[i] = i
    }
    evens := filterEvensFast(nums)
    fmt.Println("Even count:", len(evens))
}

package main

import "fmt"

func charFrequencyFast(s string) map[rune]int {
    freq := make(map[rune]int, 128) // Pre-size for ASCII character set
    for _, c := range s {
        freq[c]++
    }
    return freq
}

func main() {
    text := "Go is a statically typed compiled language designed at Google"
    for i := 0; i < 100; i++ {
        text += text
        if len(text) > 100000 {
            break
        }
    }
    freq := charFrequencyFast(text)
    fmt.Println("Unique chars:", len(freq))
}

package main

import "fmt"

func sumInts(items []int) int {
    total := 0
    for _, v := range items {
        total += v
    }
    return total
}

func main() {
    items := make([]int, 1000000)
    for i := range items {
        items[i] = i // No boxing — stored directly as int
    }
    result := sumInts(items)
    fmt.Println("Sum:", result)
}

package main

import (
    "container/heap"
    "fmt"
    "math/rand"
)

type MinHeap []int

func (h MinHeap) Len() int            { return len(h) }
func (h MinHeap) Less(i, j int) bool   { return h[i] < h[j] }
func (h MinHeap) Swap(i, j int)        { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x interface{})  { *h = append(*h, x.(int)) }
func (h *MinHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[:n-1]
    return x
}

func topNFast(nums []int, n int) []int {
    h := &MinHeap{}
    heap.Init(h)

    for _, num := range nums {
        if h.Len() < n {
            heap.Push(h, num)
        } else if num > (*h)[0] {
            (*h)[0] = num
            heap.Fix(h, 0)
        }
    }

    result := make([]int, h.Len())
    for i := h.Len() - 1; i >= 0; i-- {
        result[i] = heap.Pop(h).(int)
    }
    return result
}

func main() {
    nums := make([]int, 1000000)
    for i := range nums {
        nums[i] = rand.Intn(10000000)
    }
    top := topNFast(nums, 10)
    fmt.Println("Top 10:", top)
}

package main

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

type FastCounter struct {
    value int64
}

func (c *FastCounter) Increment() {
    atomic.AddInt64(&c.value, 1) // Lock-free atomic operation
}

func (c *FastCounter) Value() int64 {
    return atomic.LoadInt64(&c.value)
}

func main() {
    counter := &FastCounter{}
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 100000; j++ {
                counter.Increment()
            }
        }()
    }

    wg.Wait()
    fmt.Println("Count:", counter.Value())
}

package main

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

func writeLinesFast(filename string, n int) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    // Buffer writes — flushes to disk in large chunks
    writer := bufio.NewWriterSize(file, 64*1024) // 64KB buffer
    defer writer.Flush()

    for i := 0; i < n; i++ {
        fmt.Fprintf(writer, "line %d: some data here\n", i)
    }
    return nil
}

func main() {
    err := writeLinesFast("/tmp/output.txt", 100000)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Done writing")
}

package main

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

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

func processRequestFast(data string) string {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufferPool.Put(buf)
    }()

    buf.WriteString("PROCESSED: ")
    buf.WriteString(data)
    buf.WriteString(" [OK]")
    return buf.String()
}

func main() {
    for i := 0; i < 1000000; i++ {
        result := processRequestFast(fmt.Sprintf("request-%d", i))
        _ = result
    }
    fmt.Println("Done processing 1M requests")
}

package main

import "fmt"

// Approach 1: Better field ordering (minimal padding)
type ItemOptimized struct {
    Price    float64 // 8 bytes
    Quantity int64   // 8 bytes
    Name     string  // 16 bytes
    Category int32   // 4 bytes
    Active   bool    // 1 byte + 3 bytes padding (at end, less waste)
}

// Approach 2: Struct-of-arrays for hot-path queries
type ItemStore struct {
    Prices     []float64
    Quantities []int64
    Names      []string
    Categories []int32
    Active     []bool // Separate array — perfect cache locality for filtering
}

func countActiveSOA(store *ItemStore) int {
    count := 0
    for _, a := range store.Active {
        if a {
            count++
        }
    }
    return count
}

func main() {
    n := 1000000
    store := &ItemStore{
        Prices:     make([]float64, n),
        Quantities: make([]int64, n),
        Names:      make([]string, n),
        Categories: make([]int32, n),
        Active:     make([]bool, n),
    }
    for i := 0; i < n; i++ {
        store.Prices[i] = float64(i)
        store.Active[i] = i%3 == 0
        store.Quantities[i] = int64(i)
        store.Names[i] = "item"
        store.Categories[i] = int32(i % 100)
    }

    count := countActiveSOA(store)
    fmt.Println("Active count:", count)
}

package main

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

func processItem(item int) int {
    time.Sleep(10 * time.Millisecond)
    return item * item
}

type work struct {
    index int
    value int
}

func processAllFast(items []int) []int {
    numWorkers := runtime.NumCPU()
    results := make([]int, len(items))

    jobs := make(chan work, len(items))
    var wg sync.WaitGroup

    // Start workers
    for w := 0; w < numWorkers; w++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results[job.index] = processItem(job.value)
            }
        }()
    }

    // Send jobs
    for i, item := range items {
        jobs <- work{index: i, value: item}
    }
    close(jobs)

    // Wait for completion
    wg.Wait()
    return results
}

func main() {
    items := make([]int, 100)
    for i := range items {
        items[i] = i
    }

    start := time.Now()
    results := processAllFast(items)
    elapsed := time.Since(start)

    fmt.Printf("Processed %d items in %v (using %d workers)\n",
        len(results), elapsed, runtime.NumCPU())
    // Takes ~100-130ms with 8-10 workers instead of ~1 second
}