Shipping it

// The whole journey of one change, as data.
const stations = [
  "commit", "review", "build", "test", "package",
  "staging", "canary 5%", "production", "monitor",
];
​
let minutes = 0;
const cost = { commit: 1, review: 45, build: 2, test: 4, package: 1,
  staging: 10, "canary 5%": 15, production: 5, monitor: 0 };
​
for (const s of stations) {
  minutes += cost[s];
  console.log(String(minutes).padStart(4), "min ", s);
}
console.log("from laptop to every user in about", Math.round(minutes / 60 * 10) / 10, "hours");

function hash(text) {
  let h = 0x811c9dc5;                      // FNV-1a, 32-bit
  for (let i = 0; i < text.length; i++) {
    h ^= text.charCodeAt(i);
    h = Math.imul(h, 0x01000193) >>> 0;
  }
  return h.toString(16).padStart(8, "0");
}
​
const commits = {};
​
// A commit's id is the hash of its content AND its parent's id,
// so changing anything in the past changes every id after it.
function commit(files, parent, message) {
  const tree = hash(JSON.stringify(files));
  const id = hash("tree " + tree + "\nparent " + parent + "\n\n" + message);
  commits[id] = { tree, parent, message };
  return id;
}
​
const c1 = commit({ "app.js": "hello" }, null, "first version");
const c2 = commit({ "app.js": "hello, world" }, c1, "greet the world");
const c3 = commit({ "app.js": "hello, world!" }, c2, "add excitement");
​
// walk the history backwards, like git log
let at = c3;
while (at) {
  console.log(at, commits[at].message);
  at = commits[at].parent;
}
console.log("HEAD is", c3);

// A line diff, built on the longest common subsequence (LCS).
function diff(a, b) {
  const n = a.length, m = b.length;
  // L[i][j] = length of the LCS of a[i..] and b[j..]
  const L = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
  for (let i = n - 1; i >= 0; i--)
    for (let j = m - 1; j >= 0; j--)
      L[i][j] = a[i] === b[j] ? L[i + 1][j + 1] + 1 : Math.max(L[i + 1][j], L[i][j + 1]);
​
  const out = [];
  let i = 0, j = 0;
  while (i < n && j < m) {
    if (a[i] === b[j]) { out.push("  " + a[i]); i++; j++; }
    else if (L[i + 1][j] >= L[i][j + 1]) out.push("- " + a[i++]);
    else out.push("+ " + b[j++]);
  }
  while (i < n) out.push("- " + a[i++]);
  while (j < m) out.push("+ " + b[j++]);
  return out;
}
​
const before = [
  "function greet(name) {",
  "  return 'Hi ' + name;",
  "}",
];
const after = [
  "function greet(name) {",
  "  if (!name) name = 'friend';",
  "  return 'Hello, ' + name + '!';",
  "}",
];
console.log(diff(before, after).join("\n"));

function hash(text) {
  let h = 0x811c9dc5;                      // FNV-1a, 32-bit
  for (let i = 0; i < text.length; i++) {
    h ^= text.charCodeAt(i);
    h = Math.imul(h, 0x01000193) >>> 0;
  }
  return h.toString(16).padStart(8, "0");
}
​
// Five source files and what each one imports
const modules = {
  "main.js":   { imports: ["math.js", "ui.js"], code: "render(add(2, 3));" },
  "ui.js":     { imports: ["format.js"], code: "const render = (x) => show(format(x));" },
  "math.js":   { imports: [], code: "const add = (a, b) => a + b;" },
  "format.js": { imports: [], code: "const format = (n) => 'Total: ' + n;" },
  "unused.js": { imports: [], code: "const never = () => 0;" },
};
​
// Depth-first: put every dependency before the file that needs it
function bundle(entry) {
  const order = [];
  const seen = new Set();
  function visit(name) {
    if (seen.has(name)) return;
    seen.add(name);
    for (const dep of modules[name].imports) visit(dep);
    order.push(name);
  }
  visit(entry);
  return order;
}
​
const order = bundle("main.js");
const code = order.map((f) => modules[f].code).join("\n");
console.log("order:  ", order.join(" → "));
console.log("dropped:", Object.keys(modules).filter((f) => !order.includes(f)));
console.log("file:    app." + hash(code) + ".js");

// The code under test
function slugify(title) {
  return title.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-");
}
​
// A tiny test runner: a test is a name and a function that throws on failure
const tests = [];
const test = (name, fn) => tests.push({ name, fn });
const expect = (got, want) => {
  if (got !== want) throw new Error("expected " + JSON.stringify(want) + ", got " + JSON.stringify(got));
};
​
test("lower-cases", () => expect(slugify("Hello"), "hello"));
test("joins words with -", () => expect(slugify("Ship it now"), "ship-it-now"));
test("drops punctuation at the ends", () => expect(slugify("  Hi, there! "), "hi-there"));
​
function runTests() {
  let failed = 0;
  for (const t of tests) {
    try { t.fn(); console.log("    ✓", t.name); }
    catch (e) { failed++; console.log("    ✗", t.name, "·", e.message); }
  }
  return failed === 0;
}
​
// The pipeline: every stage must pass, or nothing ships
const pipeline = [
  ["install", () => true],
  ["lint", () => typeof slugify === "function"],
  ["test", runTests],
  ["build", () => true],
  ["deploy", () => true],
];
for (const [name, run] of pipeline) {
  console.log("▶", name);
  if (!run()) { console.log("✗ stopped at", name, "· nothing was deployed"); break; }
}

function hash(text) {
  let h = 0x811c9dc5;                      // FNV-1a, 32-bit
  for (let i = 0; i < text.length; i++) {
    h ^= text.charCodeAt(i);
    h = Math.imul(h, 0x01000193) >>> 0;
  }
  return h.toString(16).padStart(8, "0");
}
​
// Each Dockerfile step makes a layer. Its cache key covers the step,
// the files it copies, and the key of the layer below it.
const steps = [
  { cmd: "FROM node:24-slim" },
  { cmd: "WORKDIR /app" },
  { cmd: "COPY package*.json ./", reads: ["package.json", "package-lock.json"] },
  { cmd: "RUN npm ci" },
  { cmd: "COPY . .", reads: ["package.json", "package-lock.json", "src/server.js"] },
  { cmd: "RUN npm run build" },
];
​
const cache = new Set();
function build(files) {
  let key = "";
  for (const step of steps) {
    const inputs = (step.reads || []).map((f) => files[f]).join("|");
    key = hash(key + step.cmd + inputs);
    console.log(cache.has(key) ? "CACHED" : "RUN   ", step.cmd);
    cache.add(key);
  }
  return key;
}
​
const files = { "package.json": "deps v1", "package-lock.json": "lock v1", "src/server.js": "v1" };
console.log("first build →", build(files));
files["src/server.js"] = "v2";          // edit one source file
console.log("second build →", build(files));

// One build, three environments: only the configuration differs.
const environments = {
  dev:        { API_URL: "http://localhost:8080", LOG_LEVEL: "debug" },
  staging:    { API_URL: "https://staging.api.example.com", LOG_LEVEL: "info" },
  production: { API_URL: "https://api.example.com" },
};
​
// Read the config once, at start-up, and refuse to start if it's wrong.
function loadConfig(env) {
  const required = ["API_URL", "LOG_LEVEL"];
  const missing = required.filter((k) => !(k in env));
  if (missing.length) throw new Error("missing config: " + missing.join(", "));
  return Object.freeze({ apiUrl: env.API_URL, logLevel: env.LOG_LEVEL });
}
​
for (const [name, env] of Object.entries(environments)) {
  try {
    console.log(name.padEnd(11), JSON.stringify(loadConfig(env)));
  } catch (e) {
    console.log(name.padEnd(11), "✗ won't start:", e.message);
  }
}

// Infrastructure as code: describe what you WANT; a tool works out the steps.
const desired = {
  "web-1": { kind: "server", size: "small" },
  "web-2": { kind: "server", size: "small" },
  "db":    { kind: "database", size: "large" },
};
let actual = {
  "web-1":      { kind: "server", size: "small" },
  "db":         { kind: "database", size: "medium" },
  "old-worker": { kind: "server", size: "small" },
};
​
function plan(desired, actual) {
  const steps = [];
  for (const [name, want] of Object.entries(desired)) {
    if (!(name in actual)) steps.push("+ create  " + name);
    else if (JSON.stringify(actual[name]) !== JSON.stringify(want)) steps.push("~ update  " + name);
  }
  for (const name of Object.keys(actual)) {
    if (!(name in desired)) steps.push("- destroy " + name);
  }
  return steps;
}
​
console.log(plan(desired, actual).join("\n"));
actual = structuredClone(desired);              // "apply": make it so
console.log("after apply:", plan(desired, actual).length, "changes");

const minutesPerYear = 365 * 24 * 60;
const down = (a) => {
  const m = (1 - a) * minutesPerYear;
  return m >= 1 ? Math.round(m) + " min down a year" : (m * 60).toPrecision(2) + " s down a year";
};
​
const zone = 0.999;                       // one zone: up 99.9% of the time
console.log("1 zone:  ", down(zone));
​
// In parallel, the app is up if ANY zone is up.
// (This assumes zones fail independently; real outages don't always.)
const two = 1 - (1 - zone) ** 2;
const three = 1 - (1 - zone) ** 3;
console.log("2 zones: ", down(two));
console.log("3 zones: ", down(three));
​
// In series, a request needs EVERY part to work: multiply.
const db = 0.9995, loadBalancer = 0.9999;
console.log("2 zones + db + LB:", down(two * db * loadBalancer));

// A canary rollout: widen step by step, roll back if it looks worse.
let seed = 42;
const rand = () => (seed = (seed * 16807) % 2147483647) / 2147483647;  // repeatable
​
const OLD_ERROR_RATE = 0.002;
const NEW_ERROR_RATE = 0.002;             // try 0.02: a bad release
​
function errorRate(rate, requests) {
  let errors = 0;
  for (let i = 0; i < requests; i++) if (rand() < rate) errors++;
  return errors / requests;
}
​
for (const percent of [1, 5, 25, 50, 100]) {
  const requests = 200 * percent;         // traffic grows with the slice
  const canary = errorRate(NEW_ERROR_RATE, requests);
  const baseline = errorRate(OLD_ERROR_RATE, 20000);
  const ok = canary <= baseline * 2 + 0.002;
  console.log(String(percent).padStart(3) + "%", "canary", (canary * 100).toFixed(2) + "%",
    "baseline", (baseline * 100).toFixed(2) + "%", ok ? "✓ widen" : "✗ ROLL BACK");
  if (!ok) break;
}

// Feature flags: decide per user, the same way every time.
function bucket(userId, flag) {          // 0..99, stable for this user and flag
  let h = 0x811c9dc5;
  const s = flag + ":" + userId;
  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 0x01000193) >>> 0;
  return h % 100;
}
const isOn = (userId, flag, percent) => bucket(userId, flag) < percent;
​
let on = 0;
for (let i = 0; i < 10000; i++) if (isOn("user" + i, "new-checkout", 5)) on++;
console.log((on / 100).toFixed(1) + "% of 10,000 users get the new checkout");
console.log("user42, twice:", isOn("user42", "new-checkout", 5), isOn("user42", "new-checkout", 5));

// 1,000 request times in milliseconds: most fast, a few very slow
let seed = 1;
const rand = () => (seed = (seed * 16807) % 2147483647) / 2147483647;
const times = Array.from({ length: 1000 }, () =>
  rand() < 0.96 ? 40 + rand() * 60 : 400 + rand() * 1600);
​
const sorted = [...times].sort((a, b) => a - b);
const pct = (p) => Math.round(sorted[Math.ceil((p / 100) * sorted.length) - 1]);
const mean = Math.round(times.reduce((a, b) => a + b, 0) / times.length);
​
console.log("mean", mean, "ms");
console.log("p50 ", pct(50), "ms   half the requests are faster than this");
console.log("p95 ", pct(95), "ms");
console.log("p99 ", pct(99), "ms   1 in 100 users waits at least this long");

// An SLO: 99.9% of requests succeed, measured over 30 days.
const slo = 0.999;
const budget = 1 - slo;                   // 0.1% may fail: the error budget
const hoursInWindow = 30 * 24;
​
// Burn rate: how fast you are spending the budget (1 = exactly on pace)
const errorRateLastHour = 0.015;      // 1.5% of requests failed
const burn = errorRateLastHour / budget;
const spent = burn * 1 / hoursInWindow;   // fraction of the month's budget, in one hour
​
console.log("burn rate", burn.toFixed(1) + "×");
console.log("spent", (spent * 100).toFixed(1) + "% of the 30-day budget in one hour");
console.log("budget gone in", (hoursInWindow / burn / 24).toFixed(1), "days at this pace");
console.log(burn >= 14.4 ? "→ page someone now" : "→ a ticket can wait");

// A timeline, the backbone of every postmortem
const timeline = [
  ["14:02", "start",    "v42 rolls out to 5% (canary)"],
  ["14:09", "",         "error rate on the canary climbs"],
  ["14:11", "detect",   "alert fires; on-call is paged"],
  ["14:14", "ack",      "on-call acknowledges, opens an incident"],
  ["14:19", "",         "decision: roll back first, debug later"],
  ["14:23", "mitigate", "rollback to v41 done; errors back to normal"],
  ["15:40", "resolve",  "cause found: a config key missing in production"],
];
const min = (t) => { const [h, m] = t.split(":").map(Number); return h * 60 + m; };
const at = (kind) => min(timeline.find((e) => e[1] === kind)[0]);
​
for (const [t, , what] of timeline) console.log(t, what);
console.log("---");
console.log("time to detect:  ", at("detect") - at("start"), "min");
console.log("time to mitigate:", at("mitigate") - at("start"), "min");
console.log("time to resolve: ", at("resolve") - at("start"), "min");

// Keep learning: the Leitner box. Right answers wait longer; wrong ones start over.
const gaps = [1, 2, 4, 8, 16, 32];       // days until the next review, by box
​
function reviewDays(answers) {
  let box = 0, day = 0;
  const days = [];
  for (const right of answers) {
    days.push(day);
    box = right ? Math.min(box + 1, gaps.length - 1) : 0;
    day += gaps[box];
  }
  return days;
}
​
// "What does a canary deploy do?" answered over two months
const answers = [true, true, false, true, true, true, true];
console.log("review on days", reviewDays(answers).join(", "));