Hello World in Go — Optimize the Code¶

package main

import "strings"

// Fast version — same behavior, no reflection overhead
func fastGreeting(name string) string {
    var b strings.Builder
    b.Grow(8 + len(name)) // "Hello, " (7) + name + "!" (1)
    b.WriteString("Hello, ")
    b.WriteString(name)
    b.WriteByte('!')
    return b.String()
}

func BenchmarkFastGreeting(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = fastGreeting("World")
    }
}

package main

import "strings"

// Fast version — single allocation with strings.Builder
func fastMultiHello(n int) string {
    line := "Hello, World!\n"
    var b strings.Builder
    b.Grow(len(line) * n) // Pre-allocate exact capacity
    for i := 0; i < n; i++ {
        b.WriteString(line)
    }
    return b.String()
}

func BenchmarkFastMultiHello(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = fastMultiHello(1000)
    }
}

package main

import "os"

// Fast version — direct write to stdout, no fmt overhead
func fastPrint() {
    os.Stdout.WriteString("Hello, World!\n")
}

func BenchmarkFastPrint(b *testing.B) {
    devNull, _ := os.Open(os.DevNull)
    old := os.Stdout
    os.Stdout = devNull
    defer func() { os.Stdout = old }()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        fastPrint()
    }
}

package main

import (
    "bufio"
    "io"
)

// Fast version — buffered I/O batches writes
func fastBulkOutput(w io.Writer, n int) {
    bw := bufio.NewWriterSize(w, 65536) // 64KB buffer
    for i := 0; i < n; i++ {
        bw.WriteString("Hello, World!\n")
    }
    bw.Flush()
}

func BenchmarkFastBulkOutput(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fastBulkOutput(io.Discard, 10000)
    }
}

package main

import (
    "strconv"
    "strings"
)

// Fast version — strconv + strings.Builder, no reflection
func fastNumberedGreeting(n int) string {
    var b strings.Builder
    b.Grow(20) // "Hello, User #" (13) + digits + "!" (1)
    b.WriteString("Hello, User #")
    b.WriteString(strconv.Itoa(n))
    b.WriteByte('!')
    return b.String()
}

func BenchmarkFastNumberedGreeting(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = fastNumberedGreeting(42)
    }
}

package main

import (
    "io"
    "strconv"
    "strings"
)

// Fast version — manual string building, no fmt overhead
func fastGreetingCard(w io.Writer, name string, age int, city string) {
    var b strings.Builder
    b.Grow(64)
    b.WriteString("Hello, ")
    b.WriteString(name)
    b.WriteString("!\nAge: ")
    b.WriteString(strconv.Itoa(age))
    b.WriteString("\nCity: ")
    b.WriteString(city)
    b.WriteString("\nWelcome!\n")
    io.WriteString(w, b.String())
}

func BenchmarkFastGreetingCard(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fastGreetingCard(io.Discard, "Alice", 30, "Tokyo")
    }
}

package main

import (
    "bufio"
    "io"
    "time"
)

// Fast version — buffered writes with cached timestamp
func fastLog(w io.Writer, n int) {
    bw := bufio.NewWriterSize(w, 32768)
    // Cache timestamp — acceptable for sub-second batches
    ts := time.Now().Format("2006/01/02 15:04:05 ")
    for i := 0; i < n; i++ {
        bw.WriteString(ts)
        bw.WriteString("Hello, World!\n")
    }
    bw.Flush()
}

func BenchmarkFastLog(b *testing.B) {
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        fastLog(io.Discard, 1000)
    }
}

package main

import "sync"

var bufPool = sync.Pool{
    New: func() interface{} {
        buf := make([]byte, 0, 64)
        return &buf
    },
}

// Fast version — zero allocation using sync.Pool
func fastGreetZeroAlloc(name string) []byte {
    bp := bufPool.Get().(*[]byte)
    buf := (*bp)[:0] // Reset length, keep capacity

    buf = append(buf, "Hello, "...)
    buf = append(buf, name...)
    buf = append(buf, '!')

    // Make a copy for the caller (the pool buffer will be reused)
    result := make([]byte, len(buf))
    copy(result, buf)

    *bp = buf
    bufPool.Put(bp)
    return result
}

func BenchmarkFastGreetZeroAlloc(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = fastGreetZeroAlloc("World")
    }
}

package main

import (
    "bufio"
    "io"
    "sync"
)

var writerPool = sync.Pool{
    New: func() interface{} {
        return bufio.NewWriterSize(io.Discard, 4096)
    },
}

// Fast version — pooled bufio.Writer with Reset
func fastWriteGreeting(w io.Writer, names []string) {
    bw := writerPool.Get().(*bufio.Writer)
    bw.Reset(w) // Rebind to new writer, reuse buffer

    for _, name := range names {
        bw.WriteString("Hello, ")
        bw.WriteString(name)
        bw.WriteString("!\n")
    }

    bw.Flush()
    bw.Reset(io.Discard) // Prevent holding reference to w
    writerPool.Put(bw)
}

func BenchmarkFastWriteGreeting(b *testing.B) {
    names := []string{"Alice", "Bob", "Charlie", "Diana", "Eve"}
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        fastWriteGreeting(io.Discard, names)
    }
}

package main

import (
    "bytes"
    "io"
    "strconv"
    "sync"
)

// Fast version — per-goroutine buffering, single lock per flush
func fastConcurrentHello(w io.Writer, goroutines, msgsPerGoroutine int) {
    var mu sync.Mutex
    var wg sync.WaitGroup
    wg.Add(goroutines)

    for g := 0; g < goroutines; g++ {
        go func(id int) {
            defer wg.Done()
            // Each goroutine builds output locally — no lock needed
            var buf bytes.Buffer
            buf.Grow(msgsPerGoroutine * 48) // Estimate line length
            idStr := strconv.Itoa(id)

            for i := 0; i < msgsPerGoroutine; i++ {
                buf.WriteString("Hello from goroutine ")
                buf.WriteString(idStr)
                buf.WriteString(", message ")
                buf.WriteString(strconv.Itoa(i))
                buf.WriteString("!\n")
            }

            // Single lock acquisition to flush entire buffer
            mu.Lock()
            buf.WriteTo(w)
            mu.Unlock()
        }(g)
    }
    wg.Wait()
}

func BenchmarkFastConcurrentHello(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fastConcurrentHello(io.Discard, 8, 1000)
    }
}