Go Performance
Expert guidance for writing efficient, high-performance Go code.
Quick Reference
| Concern |
Solution |
Impact |
| String concatenation in loops |
strings.Builder |
O(n) vs O(n²) |
| Repeated allocations |
sync.Pool |
Reduces GC pressure |
| Large byte slice to string conversion |
unsafe package (carefully) |
Avoids allocation |
| I/O operations |
bufio.Scanner/buffered writers |
Reduces syscalls |
| Defer in tight loops |
Move defer outside function |
Prevents memory buildup |
| Premature optimization |
Don't do it |
Measure first |
What Do You Need?
- String operations - Building, concatenating, converting
- Memory allocations - Reducing allocations, object reuse
- I/O efficiency - Buffered operations, batch processing
- Resource pooling - sync.Pool for frequently allocated objects
- Benchmarking - How to measure improvements
Specify a number or describe your performance concern.
Routing
| Response |
Reference to Read |
| 1, "string", "concat", "build" |
strings.md |
| 2, "allocation", "memory", "pool" |
allocations.md |
| 3, "io", "file", "reader", "writer" |
io.md |
| 4, "benchmark", "measure", "profile" |
benchmarking.md |
| 5, general performance |
Read relevant references |
Critical Rules
- Measure before optimizing: Use benchmarks to identify real bottlenecks
- strings.Builder for concatenation: Never use + in loops
- Avoid defer in tight loops: Defers accumulate until function return
- Use bufio for I/O: Reduces system call overhead
- sync.Pool for reuse: Pool frequently allocated objects
- Prefer fmt.Errorf over errors.New: For error wrapping context
Performance Impact Table
| Issue |
Performance Cost |
Fix |
| String + in loop |
O(n²) allocations |
strings.Builder |
| Defer in loop |
Unbounded memory |
Move to separate function |
| Byte to string conversion |
Allocates new string |
unsafe.String (careful) |
| Unbuffered I/O |
System call per byte |
bufio.Reader/Writer |
| Repeated allocations |
High GC pressure |
sync.Pool |
| Substring allocations |
O(n) per operation |
Use []byte views |
Common Optimizations
Strings
// Bad: O(n²) allocations
func build(items []string) string {
var s string
for _, item := range items {
s += item + "," // New string each iteration
}
return s
}
// Good: O(n) with pre-allocation
func build(items []string) string {
var b strings.Builder
b.Grow(len(items) * 10) // Pre-allocate if you can estimate
for _, item := range items {
b.WriteString(item)
b.WriteByte(',')
}
return b.String()
}
Defer in Loops
// Bad: Defers accumulate until function returns
func process(files []string) error {
for _, f := range files {
file, err := os.Open(f)
if err != nil {
return err
}
defer file.Close() // BAD: All deferred until return!
}
return nil
}
// Good: Each defer released when function returns
func process(files []string) error {
for _, f := range files {
if err := processFile(f); err != nil {
return err
}
}
return nil
}
func processFile(path string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close() // GOOD: Released when processFile returns
// ...
return nil
}
sync.Pool
var bufferPool = sync.Pool{
New: func() interface{} {
return new(bytes.Buffer)
},
}
func getBuffer() *bytes.Buffer {
return bufferPool.Get().(*bytes.Buffer)
}
func putBuffer(b *bytes.Buffer) {
b.Reset()
bufferPool.Put(b)
}
Reference Index
| File |
Topics |
| strings.md |
Builder, Reader, efficient concatenation |
| allocations.md |
sync.Pool, escape analysis, reduction strategies |
| io.md |
bufio, Scanner, buffered writers, chunking |
| benchmarking.md |
Writing benchmarks, pprof, flame graphs |
Success Criteria
Code is performant when:
- benchmarks show improvement (measure, don't guess)
- strings.Builder used for string building in loops
- no defer in tight loops
- sync.Pool used for frequently allocated objects
- bufio used for I/O operations
- allocations are minimized (check with -benchmem)
Converted and distributed by TomeVault — claim your Tome and manage your conversions.
1---2name: go-performance-23description: Go performance optimizations including memory allocation reduction, efficient string building, I/O operations, and resource pooling. Use when optimizing Go code for speed or memory efficiency. Use when this capability is needed.4---56# Go Performance78Expert guidance for writing efficient, high-performance Go code.910## Quick Reference1112| Concern | Solution | Impact |13|---------|----------|--------|14| String concatenation in loops | strings.Builder | O(n) vs O(n²) |15| Repeated allocations | sync.Pool | Reduces GC pressure |16| Large byte slice to string conversion | unsafe package (carefully) | Avoids allocation |17| I/O operations | bufio.Scanner/buffered writers | Reduces syscalls |18| Defer in tight loops | Move defer outside function | Prevents memory buildup |19| Premature optimization | Don't do it | Measure first |2021## What Do You Need?22231. **String operations** - Building, concatenating, converting242. **Memory allocations** - Reducing allocations, object reuse253. **I/O efficiency** - Buffered operations, batch processing264. **Resource pooling** - sync.Pool for frequently allocated objects275. **Benchmarking** - How to measure improvements2829Specify a number or describe your performance concern.3031## Routing3233| Response | Reference to Read |34|----------|-------------------|35| 1, "string", "concat", "build" | [strings.md](./references/strings.md) |36| 2, "allocation", "memory", "pool" | [allocations.md](./references/allocations.md) |37| 3, "io", "file", "reader", "writer" | [io.md](./references/io.md) |38| 4, "benchmark", "measure", "profile" | [benchmarking.md](./references/benchmarking.md) |39| 5, general performance | Read relevant references |4041## Critical Rules4243- **Measure before optimizing**: Use benchmarks to identify real bottlenecks44- **strings.Builder for concatenation**: Never use + in loops45- **Avoid defer in tight loops**: Defers accumulate until function return46- **Use bufio for I/O**: Reduces system call overhead47- **sync.Pool for reuse**: Pool frequently allocated objects48- **Prefer fmt.Errorf over errors.New**: For error wrapping context4950## Performance Impact Table5152| Issue | Performance Cost | Fix |53|-------|------------------|-----|54| String + in loop | O(n²) allocations | strings.Builder |55| Defer in loop | Unbounded memory | Move to separate function |56| Byte to string conversion | Allocates new string | unsafe.String (careful) |57| Unbuffered I/O | System call per byte | bufio.Reader/Writer |58| Repeated allocations | High GC pressure | sync.Pool |59| Substring allocations | O(n) per operation | Use []byte views |6061## Common Optimizations6263### Strings64```go65// Bad: O(n²) allocations66func build(items []string) string {67 var s string68 for _, item := range items {69 s += item + "," // New string each iteration70 }71 return s72}7374// Good: O(n) with pre-allocation75func build(items []string) string {76 var b strings.Builder77 b.Grow(len(items) * 10) // Pre-allocate if you can estimate78 for _, item := range items {79 b.WriteString(item)80 b.WriteByte(',')81 }82 return b.String()83}84```8586### Defer in Loops87```go88// Bad: Defers accumulate until function returns89func process(files []string) error {90 for _, f := range files {91 file, err := os.Open(f)92 if err != nil {93 return err94 }95 defer file.Close() // BAD: All deferred until return!96 }97 return nil98}99100// Good: Each defer released when function returns101func process(files []string) error {102 for _, f := range files {103 if err := processFile(f); err != nil {104 return err105 }106 }107 return nil108}109110func processFile(path string) error {111 file, err := os.Open(path)112 if err != nil {113 return err114 }115 defer file.Close() // GOOD: Released when processFile returns116 // ...117 return nil118}119```120121### sync.Pool122```go123var bufferPool = sync.Pool{124 New: func() interface{} {125 return new(bytes.Buffer)126 },127}128129func getBuffer() *bytes.Buffer {130 return bufferPool.Get().(*bytes.Buffer)131}132133func putBuffer(b *bytes.Buffer) {134 b.Reset()135 bufferPool.Put(b)136}137```138139## Reference Index140141| File | Topics |142|------|--------|143| [strings.md](./references/strings.md) | Builder, Reader, efficient concatenation |144| [allocations.md](./references/allocations.md) | sync.Pool, escape analysis, reduction strategies |145| [io.md](./references/io.md) | bufio, Scanner, buffered writers, chunking |146| [benchmarking.md](./references/benchmarking.md) | Writing benchmarks, pprof, flame graphs |147148## Success Criteria149150Code is performant when:151- benchmarks show improvement (measure, don't guess)152- strings.Builder used for string building in loops153- no defer in tight loops154- sync.Pool used for frequently allocated objects155- bufio used for I/O operations156- allocations are minimized (check with -benchmem)157158---159> Converted and distributed by [TomeVault](https://tomevault.io/claim/jovermier) — claim your Tome and manage your conversions.160<!-- tomevault:4.0:skill_md:2026-04-13 -->
tomevault-io