Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
The highest level in the DNS hierarchy -- the rightmost label of a domain name, such as .com, .org, or a two-letter country code. The original set and the rules for it were defined by Jon Postel and Joyce Reynolds in RFC 920 (1984).
Ordering the nodes of a directed acyclic graph so that every edge points forward, which is how build systems, package managers, and schedulers order dependent tasks.
A communication primitive, also called atomic broadcast, that delivers messages to all nodes in the same total order; it is equivalent in power to consensus and underlies state-machine replication.
The practical dividing line in complexity: problems solvable in polynomial time are 'tractable,' while those needing exponential time are 'intractable' for large inputs.
A unit of database work that is all-or-nothing: a group of operations that either all commit or all roll back, keeping data consistent despite failures and concurrent users.
The dependencies of your dependencies, recursively, which is why a project with a few direct packages can pull in hundreds and why deep trees are fragile.
A small, fast cache of recently used virtual-to-physical address translations that lets virtual memory work at speed, sparing the processor a slow walk through page tables on most memory accesses.
A prefix tree that stores strings along paths of characters, so lookups and prefix queries take time proportional to the key length.
Google's clock API that reports time as an interval with bounded uncertainty, letting Spanner assign globally meaningful commit timestamps.
A branching strategy where developers integrate small changes into a single main branch very frequently, avoiding long-lived feature branches; closely tied to continuous integration.
A system is Turing-complete if it can simulate a Turing machine, meaning it can compute anything that is computable in principle.
Turing's abstract model of computation - an infinite tape, a read-write head, and a finite set of rules - that defines what it means for a function to be computable.
A thought experiment showing that two parties communicating only over an unreliable channel can never become certain they have agreed, because no finite exchange of acknowledgments is ever enough.
A protocol for committing a transaction atomically across multiple databases or nodes: a coordinator asks every participant to prepare, then tells them all to commit or all to abort.
Automatic synchronization between the data model and the view in both directions, so a change in either is reflected in the other, popularized by AngularJS.
The distinction between bare-metal hypervisors that run directly on hardware and hosted hypervisors that run as an application on top of an operating system.
A compiler's ability to deduce the types of expressions without explicit annotations, giving the safety of static typing with the brevity of dynamically-typed code; the type system of ML is the classic example.
The branch of logic and computer science that studies type systems, formal rules classifying terms so that well-typed programs cannot go wrong.
A standardized family of diagrams for visualizing, specifying, and documenting object-oriented software systems, unified at Rational in the mid-1990s and standardized by the Object Management Group.
A decision problem for which no algorithm can always return the correct yes-or-no answer; the existence of such problems was proved independently by Turing and Church in 1936.
The practice of testing the smallest pieces of code (functions, classes) in isolation and automatically, so that regressions are caught the moment they are introduced.
A short, plain-language description of a feature told from the user's point of view, used in agile development to capture a need and spark a conversation rather than write an exhaustive specification.
An extension of logical clocks in which each process keeps a vector of counters, allowing a system to tell whether two events are causally related or genuinely concurrent.
Copying a project's third-party dependencies directly into its own repository instead of fetching them at build time.
The practice of tracking and managing changes to files over time so that past versions can be recovered and many people can work on the same project together.
An in-memory representation of the user interface that a framework diffs against the previous version to compute the minimal set of real-DOM mutations, popularized by React.
A software emulation of a complete computer that runs its own operating system in isolation, sharing the underlying physical hardware with other virtual machines.
Giving each program its own address space that can be larger than, and independent of, the physical RAM, pioneered by the Atlas computer at Manchester around 1962.
Building integrated circuits with hundreds of thousands or more transistors on a single chip, and the structured design methodology that made such complex chips tractable to design.
The computer design with a processing unit, a single memory holding both instructions and data, and input/output, the template behind nearly all modern computers.
The performance limit caused by the single channel between processor and memory in the von Neumann architecture, a phrase John Backus made famous in his 1977 Turing Award lecture.
A sequential software process in which each phase - requirements, design, implementation, testing, and operation - is completed before the next begins.
The component of a web browser that parses HTML and CSS and renders a page through layout and painting.
Controlling type on the web with CSS and downloadable web fonts -- the @font-face rule plus the WOFF and WOFF2 formats -- which ended the era when designers were limited to a handful of fonts already installed on the reader's machine.
A user-defined HTTP callback that a provider fires at your endpoint when an event happens -- a reverse API where the server initiates the request.
A NoSQL model (BigTable, HBase, Cassandra) that stores data in tables whose rows can hold billions of dynamic, sparse columns grouped into families; optimized for huge scale and write throughput, not joins.
Recording changes to a durable log before applying them to the data files, so a crashed database can recover a consistent state by replaying the log.
An Extreme Programming principle that you should not add functionality until it is actually required, because speculative generality usually costs more than it saves.
Hacker term for the recursive chain of seemingly unrelated tasks you must complete before you can do the task you actually wanted to do; coined at the MIT AI Lab and recorded in the Jargon File.
On many systems Unix time is stored in a signed 32-bit integer counting seconds since 1970, which overflows on January 19, 2038, and wraps to a negative value read as 1901. The fix is a wider, 64-bit time_t, now standard on modern systems but still being chased through old code and data formats.
Jamie Zawinski's law that every program attempts to expand until it can read mail, and programs that cannot are replaced by ones that can.
A vulnerability unknown to the vendor and therefore unpatched, so defenders have had zero days to fix it; zero-day exploits are highly valued by attackers and governments and traded on gray and black markets.
The program that turns characters into editable text on a screen or terminal. Editors evolved from line editors that worked one line at a time, through full-screen editors, to programmable editors that users can extend without limit.
TTY is short for teletypewriter and became the Unix name for a terminal device. On Unix systems the kernel exposes terminals through tty device files governed by a line discipline (termios), and later through pseudo-terminals (ptys) that let software present a terminal interface to other programs.
A parametric curve defined by control points, developed independently by Pierre Bezier at Renault and Paul de Casteljau at Citroen, now the basis of fonts, vector graphics, CAD, and animation paths.
Henri Gouraud's 1971 method for smoothly shading polygonal surfaces by computing intensities at vertices and linearly interpolating them across each polygon, eliminating faceted appearance.
The microprocessor is a complete central processing unit on a single integrated circuit; its arrival shrank the computer from rooms of cabinets to a chip and made computing cheap enough to spread everywhere.
A model of concurrent computation in which independent actors hold private state and interact only by sending each other asynchronous messages.