Observability

An agent run that continues without a person watching, started by a schedule, an event, or a handoff, and reports its results when done.

A coarse language for how an algorithm's cost grows as its input grows.

Shipping a change to a small slice of traffic first, and only widening it once that slice looks healthy.

Deliberately breaking parts of a running system to prove it survives failures that will eventually happen anyway.

Cryptographically attesting who produced a binary, and the operating-system checks built on it.

a genre of indirect settlement control where production chains and mood systems generate stories rather than just outcomes.

Time-based scheduling of recurring jobs, and the reasons scheduled jobs quietly stop working.

A long-running background process managed by the operating system's service supervisor.

A genre whose core verb is building the machine that plays the game, turning the player into a systems engineer.

Crash at the point of misconfiguration rather than degrading quietly into a wrong state.

The measurement that arbitrates, as opposed to the artifact that merely reports.

A design tradition that simulates consistent rules rather than scripting outcomes, so solutions the designer never planned still work.

Adding measurement to code so its execution can be observed, and the distortions that introduces.

A game operated as a running service rather than shipped as a finished artifact, with the consequences that shift implies.

Recording timestamped events from a running program so people can reconstruct what happened, and how structured logs, levels, and aggregation make them useful at scale.

The nervous system's detection of damaging stimuli, which is not the same thing as the experience of pain.

A value far from the rest of the data, which may be a typo, a member of a different population, or the most important observation in the set, and which should be explained before it is ever deleted.

A kernel metric for how much time work spent waiting on CPU, memory, or I/O, which measures contention directly where utilization figures only hint at it.

A running program with its own memory, environment, and identity.

Releasing a change to a growing share of users while watching its effect, so problems are caught when they affect few people and the rollout halts automatically.

The smallest set of steps that reliably produces a fault, and the unit of real debugging.

Failures caused by competition for a finite shared resource rather than by any defect.

Escalating past the visible symptom until you find the layer that actually produced it.

Storing, distributing, and rotating credentials without embedding them in code or history.

A failure that produces no signal, so the absence of an error reads as success.

Delivering a response incrementally as it is produced rather than all at once when complete.

Looking where the light is good rather than where the answer is.

Drawing conclusions from a sample already filtered by success.

The slowest few percent of response times, which averages hide and which dominate the experience of large systems, because one request often waits on many others.

Reading a truncated result as if it were the whole result, so every counterexample is invisible.

Measuring how people use a website, from parsing server logs to JavaScript page tags and Google's free Analytics, with metrics like pageviews and bounce rate that are distorted by bots, blockers, and consent rules and easy to optimize in the wrong direction.