Determinism

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

The tool that resolves an application's modules into the files a browser downloads.

Deciding when a cached value has stopped being correct — famously one of the hard problems.

A grid of cells whose states evolve by a local rule applied simultaneously everywhere.

Concurrency is structuring independent tasks together; parallelism is actually running them at the same instant.

Repeatedly narrowing the possible values of each variable using the constraints, until nothing more can be deduced.

Packaging an application with its dependencies into an isolated, reproducible runtime unit.

A versioned, ordered change to a database schema, applied once and recorded.

Software reimplementation of console hardware, and the fault line between preserving a game and possessing it legally.

A guarantee that replicas converge given no further updates, without guaranteeing when.

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

A hash over everything that determined a result, used to detect when the result has gone stale.

A model with a fixed set of states, one active at a time, and defined transitions between them on each input.

A test that passes and fails on identical input, and the most corrosive thing a suite can contain.

The startup, active and recovery cost of an action measured in simulation ticks, and what it predicts about a matchup.

Computer opponents built to be interesting to play against rather than optimal.

The perceptual layer between input and simulation, and the tuning that makes a control scheme read as responsive.

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

A function mapping arbitrary input to a fixed-size digest, used for identity, integrity, and addressing.

A key-value structure that uses a digest of the key to index an array of buckets.

A fault that changes or disappears when someone tries to observe it.

The property that performing an operation twice has the same effect as performing it once.

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

A value that cannot change after construction, so sharing it never risks a caller seeing another caller's edit.

A coordinate system in which an undisturbed body moves at constant velocity, and none is privileged.

The animation window during which a character is immune to hits despite appearing vulnerable on screen.

A rewriting grammar that generates branching structures by repeated substitution.

Deferring a computation until its result is actually needed, and then caching it so it never runs twice.

A generated file recording the exact dependency versions an install resolved to.

The property that identical inputs may produce different outputs, and what it costs to test around.

A timed defensive window that, met exactly, punishes the attacker instead of the defender.

Pressure applied to a confined fluid is transmitted undiminished throughout it.

Creating content algorithmically rather than authoring it by hand.

A function whose output depends only on its input and which causes no observable effect outside itself.

A defect whose occurrence depends on the relative timing of concurrent operations.

Converting geometry into pixels — the dominant real-time rendering approach.

Renders images by tracing individual light paths through a scene instead of projecting geometry onto a screen.

Capturing a real interaction once and replaying it deterministically in later test runs.

A pattern language for matching text, compiled internally into a finite state machine that runs over the input.

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

A genre defined by procedurally generated runs and permanent death, and the design pressures those create.

A networking model that hides latency by predicting inputs and silently resimulating when the prediction was wrong, instead of freezing to wait.

Reloading a save to retry a chance-dependent outcome until it lands, converting a game's stated stakes into a series of do-overs.

Initial content created programmatically to make an empty system usable or demonstrable.

Pseudorandom generation from an explicit seed, so any output is reproducible.

A small program run on the graphics processor for every vertex or every pixel.

The racing genre spectrum running from arcade handling to full physical simulation, and the hardware built to serve the far end of it.

A dice-plus-modifier resolution borrowed from tabletop play to decide whether an attempted action succeeds.

A design lineage in which high difficulty is a deliberate authorial position, sustained by making every death legible.

Completing a game as fast as possible under a ruleset the community defines, not the game.

The prepared data or state a test runs against.

Civil time is a political layer over solar time, and its rules change often enough to be data.

A closed loop that moves heat by boiling and condensing a working fluid at two pressures.

Comparing rendered output against a stored baseline to catch unintended visual change.

A volumetric pixel — a value on a regular three-dimensional grid.

Recording the intent of a change durably before applying it, so a crash can be recovered.