Concepts

Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.

673 entries, all primary-sourced
concept 1980

Protocol Layering

The architectural principle of organizing network communication as a stack of protocols, each layer offering services to the layer above through a defined interface, exemplified by the OSI and TCP/IP models.

concept 1980

Ray Tracing

A rendering technique that follows rays of light through a scene to compute reflections, refractions, and shadows. Long an offline method, it became real-time on consumer GPUs with dedicated hardware in 2018.

concept 1981

Network Protocol

A set of rules defining the format, meaning, and timing of messages exchanged between communicating systems, so that independently built machines can interoperate over a network.

concept 1981

Integrated Development Environment

A single program that combines an editor, compiler or interpreter, debugger, and build tools into one interface, so that writing, running, and fixing code happen without leaving the environment.

concept August 12, 1981

The BIOS (Basic Input/Output System)

The BIOS is the firmware that boots a PC and abstracts its hardware behind a stable interface; IBM published its full source in the 1981 PC, and legally reimplementing it made the clone industry possible.

concept September 1981

Internet Protocol

IP is the connectionless datagram-delivery protocol that addresses and routes packets across networks, handling fragmentation but leaving reliability to higher layers; it forms the narrow waist of the internet.

concept September 1981

IP Address

The numeric identifier that locates a host on an IP network; originally a 32-bit value carved into classful network and host parts and written in dotted-decimal notation.

concept September 1981

TCP Three-Way Handshake

The three-message exchange - SYN, SYN-ACK, ACK - by which two hosts establish a TCP connection and synchronize their initial sequence numbers before exchanging data. Specified in RFC 793 (September 1981).

concept 1982

Shareware

A software distribution model in which a fully working program is given away freely to copy and try, with a written request that satisfied users voluntarily send a payment. It began around 1982 with Andrew Fluegelman's PC-Talk and Jim Knopf's PC-File, and later carried games such as Doom.

concept 1982

Sprite

A sprite is a small 2D image, often hardware-generated, that a video chip composites onto a background and moves independently; it was the workhorse of arcade and home-console graphics.

concept June 1982

Profiling

Profiling is the measurement of where a running program spends its time or memory, using either statistical sampling or code instrumentation, and presenting the result as a flat profile or a call-graph profile.

concept October 1982

Chiptune

Music synthesized by the dedicated sound chips of early home computers and consoles, such as the Commodore SID, the General Instrument AY, and the NES audio unit, later revived as a genre that treats the chips' constraints as an aesthetic.

concept November 1982

The IBM PC Clone

A PC clone is a machine that reproduces the IBM PC architecture by legally reimplementing its copyrighted BIOS; clones commoditized the hardware and shifted lasting power to Microsoft and Intel.

concept 1983

The Daemon

A long-running background process that provides a service or supervises the system rather than serving an interactive user; the Unix tradition of daemonizing, the -d naming convention, and the double-fork that detaches a process from its terminal.

concept May 1983

Telnet and the Network Virtual Terminal

The remote-terminal protocol that lets a user operate a distant computer as if at a local terminal, built on the Network Virtual Terminal abstraction defined in RFC 854.

concept August 1983

Berkeley Sockets

The BSD sockets API - socket, bind, listen, accept, connect, send, and recv - introduced in 4.2BSD Unix in 1983, which made TCP/IP programmable through ordinary file-like descriptors. It became the de facto standard for network programming and was later codified by POSIX.

concept August 1983

Knuth-Liang Hyphenation Algorithm

The pattern-based method for breaking words at line ends, devised by Frank Liang in his 1983 Stanford dissertation and used by TeX, which finds hyphenation points by matching compact letter patterns rather than storing a full dictionary.

concept 1984

Literate Programming

Knuth's methodology, introduced in a 1984 paper, of writing a program as a piece of literature addressed to human beings, interleaving prose and code so that documentation and source come from one combined document.

concept 1984

Normal Accident Theory

Charles Perrow's argument that in systems combining complex interactions with tight coupling, catastrophic failures are not anomalies but an inherent, expected property of the system itself, hence 'normal' accidents.

concept 1984

Shader

A small program that computes shading, geometry, or other effects on a GPU. The idea began with Cook's 1984 shade trees and the RenderMan Shading Language, and became programmable hardware via GLSL and HLSL.

concept 1984

Terminal Emulator

A terminal emulator is software that imitates a hardware video terminal such as the DEC VT100, providing the screen and keyboard surface where a shell or program runs. It interprets the same escape and control sequences that real terminals once decoded in hardware.

concept 1984

The IOCCC (International Obfuscated C Code Contest)

The contest, running since 1984, for the most creatively unreadable working C program, where entrants turn the C language's quirks and the C preprocessor into ASCII art that still compiles and runs.

concept June 1984

FidoNet

A store-and-forward network of hobbyist bulletin board systems, started by Tom Jennings in 1984, that moved private mail (netmail) and shared public conferences (echomail) worldwide by having boards call each other over the phone, typically late at night, to exchange batched messages.

concept November 1984

End-to-End Principle

The design principle, argued by Saltzer, Reed, and Clark in 1984, that functions like reliability are best placed at the communicating endpoints rather than inside the network, keeping the network simple.

concept 1985

Emacs Lisp

Emacs Lisp, the dialect of Lisp that both implements and extends GNU Emacs. Because almost every command is written in Emacs Lisp and can be inspected and redefined at runtime, the editor is self-documenting and endlessly customizable.

concept June 1985

Heisenbug

A heisenbug is a software fault whose behavior changes or vanishes when you try to observe it; Jim Gray's 1985 Tandem report contrasts these transient, retry-tolerant faults with solid, repeatable Bohrbugs.

concept November 1985

INI File

The simple key=value-with-sections configuration format popularized by MS-DOS and Windows, and the family of informal dialects it inspired.

concept 1986

Breakpoint

A breakpoint pauses a program's execution at a chosen location so it can be inspected; a watchpoint pauses it when a value changes. They are implemented in software with trap instructions or in hardware with dedicated debug registers.

concept 1986

Core Dump

A core dump is a file holding a snapshot of a process's memory written when the process terminates abnormally, allowing post-mortem debugging of a crash. The name derives from the magnetic-core memory of early computers.

concept 1986

Debugger

A debugger is a program that controls the execution of another program so a developer can pause it, step through it, and inspect or modify its state in order to find and fix defects.

concept 1986

Global Illumination

Rendering that accounts for indirect light bouncing between surfaces, not just direct illumination. Formalized by Kajiya's 1986 rendering equation and approached through radiosity and path tracing.

concept 1986

The Four Essential Freedoms

The four freedoms (numbered 0 through 3) that the Free Software Foundation says a program must grant its users -- to run, study, redistribute, and modify it -- in order to qualify as free software.

concept 1986

The Free Software Definition

The Free Software Foundation's statement of the criteria a program must meet to be free software, grounded in the idea that 'free' refers to liberty rather than price and resting on four essential freedoms.

concept 1987

The Fabless-Foundry Model

The fabless-foundry model splits the semiconductor industry into companies that only design chips (fabless) and dedicated foundries that only manufacture them, a separation pioneered by TSMC in 1987 that made it possible to build a chip company without owning a fabrication plant.

concept 1987

Tracker Music

A style of music software, pioneered by the Ultimate Soundtracker on the Amiga in 1987, that sequences sampled instruments in a scrolling pattern grid and stores the result as a self-contained module (MOD) file.

concept July 1987

Reyes Rendering

Pixar's micropolygon-based rendering architecture, named Reyes for Renders Everything You Ever Saw, designed for fast high-quality rendering of very complex scenes and the basis of early RenderMan.

concept August 1988

TCP Congestion Control

The set of algorithms - slow start, congestion avoidance, fast retransmit, and fast recovery - that lets TCP senders detect network overload and back off, preventing the kind of congestion collapse that nearly broke the early Internet. Introduced by Van Jacobson and Michael Karels at SIGCOMM 1988 and standardized in RFC 5681.

concept 1990

RTFM

RTFM, short for 'Read The Fucking Manual,' is the canonical curt reply in hacker culture telling someone the answer to their question is already in the documentation; it captures both the self-help ethic and the friction of newcomer questions.

concept September 1990

Priority Inversion

Priority inversion is a scheduling hazard in which a high-priority task is blocked by a lower-priority task holding a shared resource, often made unbounded by intervening medium-priority tasks; the priority inheritance and priority ceiling protocols bound the delay.

concept 1991

Rapid Application Development

A development approach that replaces long, sequential specification phases with fast iteration, visual tools, and working prototypes built with end users, popularized by James Martin and embodied in tools like Visual Basic, Delphi, and PowerBuilder.

concept 1992

Bitmap

A bitmap is an image stored as a rectangular grid of pixels, each represented by one or more bits; its bit depth sets the number of colors, and it stands in contrast to vector graphics that store shapes as math.

concept April 1992

MD5 (Message-Digest Algorithm 5)

Ron Rivest's 128-bit message-digest algorithm, published as RFC 1321 in 1992, once a popular hash but now cryptographically broken by practical collisions.

concept July 16, 1992

Rough Consensus and Running Code

Rough consensus and running code is the working ethos of the IETF: technical decisions are reached by broad agreement on substance rather than formal voting, and validated by working implementations rather than paper specifications.

concept 1992

Codec

A coder-decoder: a paired algorithm for compressing media into a coded representation and reconstructing it, spanning lossy and lossless schemes for audio, image, and video, and distinct from the container formats that package them.

concept 1993

SHA (Secure Hash Algorithm)

The NIST family of standard cryptographic hash functions - SHA-1, SHA-2, and SHA-3 - of which SHA-1 is now broken and SHA-256 is ubiquitous in TLS, Bitcoin, and git.

concept September 1993

CIDR (Classless Inter-Domain Routing)

The 1993 scheme that replaced fixed address classes with variable-length prefixes written as a /N suffix, allowing right-sized address blocks and route aggregation to slow the growth of the global routing table.

concept May 1994

Network Address Translation (NAT)

A technique that rewrites IP addresses at a network boundary so many internal hosts can share a small pool of public addresses; conceived as a stopgap for IPv4 exhaustion, it became one of the main reasons IPv4 endured.

concept May 1994

Software Rot

Software rot, or bit rot, is the apparent degradation of software over time even when its code is unchanged, as its environment and dependencies shift and as repeated edits erode its design; David Parnas's 1994 paper Software Aging is the foundational treatment.