Capstone: optimize a hot path

The method, before the function

Optimisation without measurement is superstition. The loop is always the same: profile to find the dominant cost, name the mechanism, make one change, re-measure. This track gave you the vocabulary for the “name the mechanism” step — which is where most engineers get stuck, guessing instead of reading the trace. By the end of this capstone you will have named and fixed every slow thing in this function — and know exactly which tool to reach for next time.

Here is the regressed handler. Read it as the engine would.

function scoreBatch(rows) {
  const out = [];
  for (const row of rows) {
    const e = {};
    e.id = row.id;
    if (row.name) e.name = row.name;       // conditional field
    e.score = row.weight * 1e9 + row.bonus; // overflows Smi range
    if (row.flagged) e.flag = true;          // late conditional field
    out.push(e);
    log(`scored ${e.id}`);                    // synchronous console in the hot loop
  }
  return out;
}

Layer 1 — the shape (units 02–03)

--trace-ic shows the access site that reads .score downstream going megamorphic. The cause is the conditional fields: name and flag are added only sometimes, so objects walk different transition-tree branches and land on different hidden classes (unit 03). The IC at the consumer sees five-plus maps and falls back to the generic lookup — tens of cycles instead of one. When you see megamorphic or GENERIC in a trace, your first question should be: which call site produces objects with inconsistent shapes?

Fix: initialise every property unconditionally, in a fixed order, so all objects share one Map.

const e = {
  id: row.id,
  name: row.name ?? null,
  score: 0,                 // set below
  flag: row.flagged === true,
};

Layer 2 — the boxing and the deopt (units 02, 04)

--trace-deopt shows scoreBatch deoptimising on a CheckSmi guard. row.weight * 1e9 overflows the Smi range (±2³¹), so the result becomes a HeapNumber — a heap-allocated box (unit 02). TurboFan had speculated Smi from early feedback; the first overflow fails the guard and triggers a deopt, and because it recurs every batch, you get a deopt loop (unit 04): optimise → deopt → re-optimise, never staying fast.

Fix: stop pretending the value is an integer. Compute in double from the start so the optimiser specialises on Float64 and never guards on Smi — or, if the consumer is numeric-heavy, accumulate scores into a Float64Array instead of object fields, eliminating the box entirely.

Layer 3 — the GC churn (unit 06)

Even with shapes fixed, allocating one out object per row floods new space; the bump-pointer allocator fills a semi-space and triggers a Scavenge (unit 06) far more often than necessary. Minor GC is cheap individually but death by a thousand cuts at this volume, and survivors get promoted to old space, eventually forcing a major GC.

Fix: reduce allocation. If out feeds a reducer, fold rows directly instead of materialising an array of objects; if the array is required, pre-size it (new Array(rows.length) is fine here because you fill every slot, keeping it PACKED). Fewer, longer-lived allocations beat a storm of short-lived ones.

Layer 4 — the scheduling (unit 07)

The log() call is synchronous I/O inside the loop. Beyond its own cost, in a request context it interleaves with the event loop: a flood of synchronous work on the stack delays the microtask checkpoint and starves other handlers (unit 07). The fix is not “make logging async” — it is don’t log per row on a hot path. Aggregate and emit once, or sample.

Layer 5 — prove it, then guard it (unit 08)

Measure the rewrite against the original on warmed-up code, consuming the result so dead-code elimination can’t delete your benchmark (unit 08), with allocation kept out of the timed region and the engine recorded. Then add a CI microbenchmark asserting a throughput floor, plus a unit test that counts distinct Object.keys signatures from scoreBatch and fails if it ever exceeds one. The shape regression that started this incident now cannot ship silently again.