reliability

Reliability Patterns

Domain expertise for runtime reliability and defensive bounds analysis. Use alongside devflow:review-methodology for complete reliability reviews.

Iron Law

EVERY OPERATION MUST TERMINATE AND EVERY RESOURCE MUST BE BOUNDED

Adapted from NASA/JPL's "Power of Ten" rules for safety-critical code [1]: every loop must have a fixed upper bound, every resource must have a known lifetime, and every assumption must be checked by an assertion. Unbounded operations are latent outages.

---

Reliability Categories

1. Bounded Iteration [1]

All loops, retries, and pagination must terminate after a known maximum.

Violation: Unbounded retry loop

while (true) {
  const res = await fetch(url);
  if (res.ok) break;
  await sleep(1000);
}

Solution: Fixed upper bound with explicit failure

const MAX_RETRIES = 5;
for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
  const res = await fetch(url);
  if (res.ok) return res;
  await sleep(1000 * 2 ** attempt);
}
throw new Error(`Failed after ${MAX_RETRIES} attempts`);

2. Assertion Density [1]

Assert preconditions and invariants in production code, not just tests.

Violation: Silent assumption

function processPayment(order: Order) {
  const total = order.items.reduce((sum, i) => sum + i.price, 0);
  chargeCard(order.paymentMethod, total);
}

Solution: Explicit precondition checks

function processPayment(order: Order) {
  assert(order.items.length > 0, 'Cannot process empty order');
  assert(order.paymentMethod != null, 'Missing payment method');
  const total = order.items.reduce((sum, i) => sum + i.price, 0);
  assert(total > 0, 'Order total must be positive');
  chargeCard(order.paymentMethod, total);
}

3. Allocation Discipline [1]

Minimize allocation in hot paths — prefer pre-sized collections, pools, or arenas.

Violation: Allocation in tight loop

func processEvents(events []Event) []Result {
    var results []Result
    for _, e := range events {
        buf := make([]byte, 4096)  // alloc per iteration
        results = append(results, process(e, buf))
    }
    return results
}