Unnecessary Allocation — Find the Bug¶

Category: Performance Anti-Patterns → Unnecessary Allocation — throwaway objects, boxing, and copies churned in a hot path.

This file is critical-reading practice. Each snippet is a plausible chunk of real Go, Java, or Python with an allocation question hiding in it. Read it like a reviewer and answer three things:

Where does it allocate needlessly? Is that allocation in a hot path? What's the behavior-preserving fix — and does its allocs/op actually drop?

The skill is judgment, not pattern-matching — because the answer isn't always "it allocates, remove it." One snippet allocates exactly as much as it must (the allocation is necessary or harmless), and telling it apart from the wasteful ones is the whole point. A needless allocation and a required one can look identical; the difference is whether you can remove it without changing behavior. Read for the lifetime and the loop, not just for new.

How to use this file: for each snippet, write your verdict (where it allocates, hot-or-not, the fix) before expanding. Watch for the trap — if you "fix" the one that's already correct, you've introduced a bug.

Table of Contents¶

1. Snippet 1 — The CSV builder
2. Snippet 2 — The lookup map
3. Snippet 3 — The defensive copy ← read carefully
4. Snippet 4 — The growing result
5. Snippet 5 — The stream that re-collects
6. Snippet 6 — The interface logger
7. Snippet 7 — The per-iteration regexp
8. Scorecard
9. Related Topics

Snippet 1 — The CSV builder¶

// Builds a CSV line from fields. Called once per row, millions of rows.
func csvLine(fields []string) string {
    line := ""
    for i, f := range fields {
        if i > 0 {
            line = line + ","
        }
        line = line + f
    }
    return line + "\n"
}

// Fixed — one builder, presized.
func csvLine(fields []string) string {
    n := len(fields) // commas + newline
    for _, f := range fields {
        n += len(f)
    }
    var b strings.Builder
    b.Grow(n)
    for i, f := range fields {
        if i > 0 {
            b.WriteByte(',')
        }
        b.WriteString(f)
    }
    b.WriteByte('\n')
    return b.String()
}

Snippet 2 — The lookup map¶

// Counts word frequencies. Called per document in a large corpus.
Map<String, Integer> wordCounts(List<String> words) {
    Map<String, Integer> counts = new HashMap<>();
    for (String w : words) {
        Integer c = counts.get(w);
        counts.put(w, c == null ? 1 : c + 1);
    }
    return counts;
}

Map<String, Integer> wordCounts(List<String> words) {
    // presize: avoids rehash storm for up-to-`words.size()` distinct keys
    Map<String, Integer> counts = new HashMap<>((int) (words.size() / 0.75f) + 1);
    for (String w : words) {
        counts.merge(w, 1, Integer::sum); // still boxes, but clearer
    }
    return counts;
}

Snippet 3 — The defensive copy¶

// Returns the internal config's allowed hosts to a caller.
type Config struct {
    allowedHosts []string
}

func (c *Config) AllowedHosts() []string {
    out := make([]string, len(c.allowedHosts))
    copy(out, c.allowedHosts) // a copy on every call
    return out
}

Snippet 4 — The growing result¶

// Filters records; size of result is bounded by len(in).
func keepValid(in []Record) []Record {
    var out []Record // nil slice, grows by reallocation
    for _, r := range in {
        if r.Valid {
            out = append(out, r)
        }
    }
    return out
}

func keepValid(in []Record) []Record {
    out := make([]Record, 0, len(in)) // cap = upper bound; no growth reallocs
    for _, r := range in {
        if r.Valid {
            out = append(out, r)
        }
    }
    return out
}

Snippet 5 — The stream that re-collects¶

// Top customer names by spend. Called on each dashboard refresh.
List<String> topNames(List<Customer> customers) {
    List<Customer> active = customers.stream()
        .filter(Customer::isActive)
        .collect(Collectors.toList());           // materialize 1
    List<Customer> sorted = active.stream()
        .sorted(Comparator.comparingDouble(Customer::spend).reversed())
        .collect(Collectors.toList());           // materialize 2
    return sorted.stream()
        .limit(10)
        .map(Customer::name)
        .collect(Collectors.toList());           // materialize 3
}

List<String> topNames(List<Customer> customers) {
    return customers.stream()
        .filter(Customer::isActive)
        .sorted(Comparator.comparingDouble(Customer::spend).reversed())
        .limit(10)
        .map(Customer::name)
        .collect(Collectors.toList());           // single materialization
}

Snippet 6 — The interface logger¶

// Debug logging inside a hot request handler.
func handle(req *Request) {
    for _, item := range req.Items {
        log.Printf("processing item %d for user %s", item.ID, req.UserID)
        process(item)
    }
}

// Fixed — gate the log so it costs nothing when disabled.
func handle(req *Request) {
    for _, item := range req.Items {
        if log.Enabled(LevelDebug) { // no formatting / boxing unless enabled
            log.Printf("processing item %d for user %s", item.ID, req.UserID)
        }
        process(item)
    }
}

Snippet 7 — The per-iteration regexp¶

// Validates each line of a large file.
func countMatches(lines []string) int {
    n := 0
    for _, line := range lines {
        re := regexp.MustCompile(`^\d{4}-\d{2}-\d{2}`) // compiled every line!
        if re.MatchString(line) {
            n++
        }
    }
    return n
}

// Fixed — compile once, hoisted out of the loop (package-level is idiomatic).
var dateRe = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}`)

func countMatches(lines []string) int {
    n := 0
    for _, line := range lines {
        if dateRe.MatchString(line) {
            n++
        }
    }
    return n
}

Scorecard¶

If you flagged #3 as a bug, re-read it. A defensive copy looks like a wasteful allocation but is buying encapsulation; deleting it leaks mutable internal state. The lesson of this whole file: an allocation is only "unnecessary" if you can remove it without changing behavior — and the only way to be sure of both (it's removable and it's worth removing) is to check the lifetime and then check the profile.

Related Topics¶

• optimize.md — fix a full allocation-heavy hot path with before/after allocs/op.
• tasks.md — guided exercises that build these fixes with benchmarks.
• N+1 in Code — the per-iteration regexp (#7) and logger (#6) overlap with repeated work in a loop.
• Premature Optimization Traps — the sibling "spot the unjustified optimization," including a keeper to recognize.
• junior.md · middle.md · senior.md — recognition → forms → hot-path judgment.
• The profiling-techniques and memory-leak-detection skills.