Premature Optimization Traps — Find the Bug¶

Category: Performance Anti-Patterns → Premature Optimization Traps — code twisted for speed that was never measured and rarely matters.

This file is critical-reading practice. Each snippet is a plausible chunk of real code in Go, Java, or Python that has been "optimized." Your job is to read it like a reviewer and answer three questions:

Was this optimization measured or guessed? What did it cost? Should it stay or go?

The skill here is judgment, not pattern-matching — because the answer isn't always "delete it." One snippet is a justified optimization that should be KEPT, and telling it apart from the premature ones is the whole point. A premature optimization and a justified one can look identical; the difference is the evidence around them. Read for the profile and the benchmark, not for the cleverness.

How to use this file: for each snippet, write your verdict (measured/guessed, cost, keep/revert) before expanding. Watch for the one you should keep — if you delete it, you've learned the most important lesson here.

Table of Contents¶

1. The branchless even-counter
2. The StringBuilder reflex
3. The memoized formula
4. The object pool
5. The hand-inlined helper
6. The tree for ten items
7. The varint encoder
8. The "fast" config parser

Snippet 1 — The branchless even-counter¶

// Go — replaces a clear loop. Comment says "// faster, no branch".
func countEvens(xs []int) (c int) {
    for _, x := range xs {
        c += ^x & 1 // branchless: 1 when x is even, 0 when odd
    }
    return
}

Measured or guessed? What did it cost? Keep or revert?

Snippet 2 — The StringBuilder reflex¶

// Java — building a two-part log message.
String line(String user, int code) {
    return new StringBuilder()
        .append("user=").append(user)
        .append(" code=").append(code)
        .toString();
}

Measured or guessed? What did it cost? Keep or revert?

Snippet 3 — The memoized formula¶

# Python — a cache wrapped around a one-line computation.
_area_cache = {}

def circle_area(r):
    if r in _area_cache:
        return _area_cache[r]
    result = 3.14159265 * r * r
    _area_cache[r] = result
    return result

Measured or guessed? What did it cost? Keep or revert?

Snippet 4 — The object pool¶

// Go — a hand-rolled pool for Buffer objects, "to reduce GC pressure".
var bufPool = make(chan *bytes.Buffer, 100)

func getBuf() *bytes.Buffer {
    select {
    case b := <-bufPool:
        b.Reset()
        return b
    default:
        return new(bytes.Buffer)
    }
}

func putBuf(b *bytes.Buffer) { select { case bufPool <- b: default: } }

// used in a handler that runs a few hundred times a day:
func handle(r Request) string {
    b := getBuf()
    defer putBuf(b)
    b.WriteString(r.Body)
    return b.String()
}

Measured or guessed? What did it cost? Keep or revert?

Snippet 5 — The hand-inlined helper¶

// Java — isValid() was inlined by hand everywhere "because method calls are slow".
void process(List<Record> records) {
    for (Record r : records) {
        // was: if (isValid(r)) { ... }   — inlined by hand:
        if (r != null && r.id > 0 && r.name != null && !r.name.isEmpty()
                && r.timestamp > 0 && r.timestamp < System.currentTimeMillis()) {
            save(r);
        }
    }
}

Measured or guessed? What did it cost? Keep or revert?

Snippet 6 — The tree for ten items¶

# Python — a balanced BST (via `sortedcontainers`) to hold a user's active filters.
from sortedcontainers import SortedList

class FilterSet:
    def __init__(self):
        self._filters = SortedList(key=lambda f: f.priority)  # "O(log n) inserts!"

    def add(self, f):       self._filters.add(f)
    def highest(self):      return self._filters[-1]
    # a user has at most ~8 active filters, ever.

Measured or guessed? What did it cost? Keep or revert?

Snippet 7 — The varint encoder¶

// Go — manual byte-packing in a protocol encoder. Has a comment block.
// appendUvarint: profiled as 71% of CPU in BenchmarkEncode (flame graph attached
// in PR #842). Manual loop is 1.6x faster than binary.PutUvarint here because it
// avoids the bounds-check on a fresh slice. Verified equal to the stdlib by
// FuzzUvarintRoundtrip. Do not "simplify" without re-running BenchmarkEncode.
func appendUvarint(buf []byte, x uint64) []byte {
    for x >= 0x80 {
        buf = append(buf, byte(x)|0x80)
        x >>= 7
    }
    return append(buf, byte(x))
}

Measured or guessed? What did it cost? Keep or revert?

Snippet 8 — The "fast" config parser¶

# Python — config loaded once at startup, "optimized" with manual byte scanning.
def parse_config(raw: bytes):
    # hand-rolled scanner instead of `tomllib.loads` / `json.loads` — "avoids overhead"
    result, i, n = {}, 0, len(raw)
    while i < n:
        # 40 lines of manual key/value byte parsing, escape handling, etc.
        ...
    return result

Measured or guessed? What did it cost? Keep or revert?

The meta-lesson¶

Lay the eight snippets side by side and the pattern is unmistakable:

Every snippet is "clever." Only one is justified — and what sets #7 apart is not the code's cleverness but the profile, benchmark, oracle, and comment around it. That is the entire discipline: cleverness is evidence-neutral; the measurement decides. When you review a performance change, don't ask "is this clever?" — ask "where's the profile and the benchmark?" If they're absent, it's premature until proven otherwise.

Related Topics¶

• junior.md · middle.md · senior.md · professional.md — recognize → measure → judge → the hard line.
• tasks.md — the fixing counterpart: profile, revert, and guard for real.
• interview.md — the Q&A on measured-vs-guessed and justified micro-opts.
• N+1 in Code → find-bug.md · Unnecessary Allocation → find-bug.md · Wrong Data Structure → find-bug.md — the real hotspots, vs the imaginary ones here.
• Over-Engineering → senior.md — Snippets 4 and 6 are also speculative over-engineering.
• The profiling-techniques and big-o-analysis skills — the evidence that turns Snippet 7 from premature into justified.