Race Condition

A concurrency model where isolated actors communicate only by asynchronous message, never by shared memory.

A many-player elimination format that uses a shrinking play area to force an ending the players would otherwise avoid.

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

A circuit breaker stops calling a failing dependency, converting slow repeated failures into a fast, cheap one.

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

A snapshot of a crashed program's memory saved for later inspection, how to get one, how to read one, and why it can leak secrets.

Rules declared in the schema that the database itself enforces on every write, such as uniqueness, required values, and allowed ranges, so bad data is refused at the door rather than cleaned up later.

When two or more processes each wait for something another holds, so none can ever proceed, and the four conditions that must all be true for it to happen.

A single-threaded runtime's mechanism for pulling the next callback off a queue once the call stack is empty.

Splitting work across parallel workers and recombining their results.

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

A column that points at a row in another table, with the database refusing any change that would leave the pointer dangling.

The Linux primitive that makes locks cheap by handling the uncontended case entirely in user space and asking the kernel for help only when a thread actually has to wait, the foundation under most thread libraries.

An additional working directory attached to one repository, each on its own branch.

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.

How much concurrent transactions are allowed to see of each other's unfinished work, a dial between correctness and speed that most databases set lower than people assume.

Concurrent data structures built on atomic hardware instructions instead of locks, so a stalled thread can never block the others, at the price of some of the hardest code in computing.

The smallest self-contained program or set of steps that still shows a bug, and why making one is often the moment the bug gets understood.

Coordinating several model instances on one body of work, each with its own context.

Letting concurrent writers proceed unchecked and catching conflicts only at commit time, betting that collisions are rare.

Data structures that preserve every previous version when changed, sharing unchanged parts between versions so "copying" is cheap.

Blocking every other writer up front for the duration of a transaction, betting that collisions are common enough to prevent rather than clean up.

JavaScript's object for a value that will arrive later, how it replaced nested callbacks, and the microtask queue that decides when its handlers run.

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

Tricking a server into making requests on an attacker's behalf, reaching internal services and cloud credential endpoints that the attacker could never reach directly, behind some of the largest cloud breaches.

Finding bugs by examining code without running it, from linters and type checkers to deep security analysis, always trading missed bugs against false alarms.

A model instance spawned by another to handle a scoped task with its own context.

A race where a program checks a condition and then acts on it, but the world changes in between, the root of classic file-permission exploits and of double-spending bugs in web applications.

The finite allowance of model usage a task may consume, and the design decisions it forces.

Inserting a row if it doesn't exist and updating it if it does, in one atomic statement, which is harder than it sounds because the obvious check-then-insert version races with itself.

A webhook is an HTTP callback a service pushes to you when an event happens, inverting who initiates the request.