Code Review

Reviewing work with an explicit mandate to refute it, from a perspective that did not produce it.

A short document recording one significant technical decision, its context, and its consequences, kept alongside the code so later readers know why the system is shaped the way it is.

A commit containing exactly one logical change, complete and independently sound.

The number of people who would have to leave before a project stalls.

Imitating the visible form of a practice while the mechanism that made it work is absent.

A short written list of critical steps checked at a set moment, which aviation adopted after a 1935 crash and surgery after a 2009 study cut deaths by more than a third, because experts skip steps under pressure, not from ignorance.

Do not remove something whose purpose you cannot explain.

Prose inside source code, useful only when it records a constraint the code cannot state.

A tool that rewrites source code into one canonical layout automatically, ending style debates in code review and keeping diffs focused on what changed.

The note attached to each change in version control, conventionally a short summary line and a body explaining why, which becomes the main record of intent for anyone who later wonders why the code is the way it is.

Cryptographically signing Git commits so a commit's author can be verified rather than merely claimed, the key types used, and what a green verified badge does and does not prove.

The tendency to search for, interpret, and recall evidence in ways that favor what you already believe.

A lightweight convention giving commit messages a machine-readable type and scope.

Systems tend to reproduce the communication structure of the organization that built them.

A licensing strategy that uses copyright to require derivative works to stay open.

A team's shared checklist of what must be true before work counts as finished, such as reviewed, tested, documented, and deployed, which keeps hidden work from piling up behind items marked complete.

The listing of changes between two versions of a file, the algorithms that compute it, and the unified format that code review, patches, and merges are built on.

Documentation that has drifted from the system it describes, and is now worse than none.

A statement of the form "the last one" or "nothing else does this" — load-bearing, and only as good as the search behind it.

A branch created to develop one change in isolation before merging it back, a workflow that keeps the main line stable but grows riskier the longer the branch lives, since its divergence from everyone else's work compounds.

An urgent fix shipped outside the normal release flow, how teams branch and backport it, and why the healthiest hotfix process is the normal process run fast.

Requiring a person's judgment at chosen points in an otherwise automated process.

With enough users, every observable behavior of an interface becomes a dependency for somebody.

Defining infrastructure in version-controlled files instead of configuring it by hand through a console.

Git's tool for rewriting a series of commits before sharing them, reordering, combining, splitting, and rewording them so the history tells a clear story rather than recording every false start.

The time spent debating an item is inversely proportional to its actual stakes.

The hypothesis that language shapes thought, and the evidence that has narrowed it considerably.

Choosing identifiers so the code states its own meaning without commentary.

A license family that imposes little beyond attribution and a warranty disclaimer.

A causal explanation that was inferred rather than tested, and reads as more rigorous for being specific.

The recorded origin of a change or a claim — who made it, when, and on what evidence.

A proposal to merge a branch, carrying review, automated checks, and the discussion around it.

Changing the structure of code without changing what it does, in small verified steps, so that the next change becomes easy.

Explaining a problem aloud, in full detail, to a listener who cannot help — and finding the fault while explaining it.

Collapsing a branch's commits into one before merging, trading granularity for a clean main history.

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

The future cost of a present shortcut, metaphorically accruing interest.

Eliyahu Goldratt's management idea that every system's output is limited by a single bottleneck, so improving anything else is wasted until the constraint itself is found, exploited, and raised.