The absolute value of the difference between the observed and the correct
value. Absolute error is usually less useful than relative
error.
absolute path
A path that points to the same location in the filesystem
regardless of where it is evaluated. An absolute path is the equivalent
of latitude and longitude in geography.
A deeply nested data structure, or tree, that represents the
structure of a program. For example, the AST might have a node
representing a while loop with one child representing
the loop condition and another representing the loop body.
accidental complexity
The extra (avoidable) complexity introduced by poor design choices. The term
is used in contrast with intrinsic complexity.
accumulator
A variable that collects and/or combines many values. For example, if a
program sums the values in an array by adding them all to a variable
called result, then result is the accumulator.
actual result (of test)
The value generated by running code in a test. If this matches the expected
result, the test passes; if the two are
different, the test fails.
Adapter pattern
A design pattern that rearranges parameters, provides
extra values, or does other work so that one function can be called by
another.
alias
A second or subsequent reference to the same object. Aliases are useful, but
increase the cognitive load on readers who have to
remember that all these names refer to the same thing.
anonymous function
A function that has not been assigned a name. Anonymous functions are
usually quite short, and are usually defined where they are used, e.g.,
as callbacks. In Python, these are called lambda functions and are
created through use of the lambda reserved word.
Application Binary Interface (ABI)
The low-level layout that a piece of software must have to work on a
particular kind of machine.
Application Programming Interface (API)
A set of functions provided by a software library or web service that other
software can call.
argument
A value passed to a function when it is called.
ASCII
A standard way to represent the characters commonly used in the Western
European languages as 7- or 8-bit integers, now largely superceded by
Unicode.
assembler
A compiler that translates software written in assembly
code into machine instructions.
assembly code
A low-level programming language whose statements correspond closely to the
actual instruction set of a particular kind of
processor.
assertion
A Boolean expression that must be true at a certain point in a
program. Assertions may be built into the language (e.g., Python's
assert statement) or provided as functions (as with Node's assert
library).
Not happening at the same time. In programming, an asynchronous operation is
one that runs independently of another, or that starts at one time and
ends at another.
attribute
A name-value pair associated with an object, used to store metadata about
the object such as an array's dimensions.
automatic variable
A variable that is automatically given a value in a build
rule. For example, Make automatically assigns the name of
a rule's target to the automatic variable $@.
Automatic variables are frequently used when writing pattern
rules.
B
backward-compatible
A property of a system that enables interoperability with an older legacy
system, or with input designed for such a system.
bare object
An object that isn't an instance of any particular class.
A system which can have one of two possible states, often represented as 0
and 1 or true and false.
bit
A single binary digit (0 or 1).
bitwise operation
An operation that manipulates individual bits in memory. Common bitwise
operations include and, or, not, and xor.
block comment
A comment that spans multiple lines. Block comments may be
marked with special start and end symbols, like /* and */ in C and
its descendents, or each line may be prefixed with a marker like #.
Boolean
Relating to a variable or data type that can have either a logical value of
true or false. Named for George Boole, a 19th century mathematician.
breadth first
To go through a nested data structure such as a tree by exploring
all of one level, then going on to the next level and so on, or to
explore a problem by examining the first step of each possible solution,
and then trying the next step for each.
breakpoint
An instruction to a debugger telling it to suspend execution whenever a
specific point in the program (such as a particular line) is reached.
bug
A missing or undesirable feature of a piece of
software.
build manager
A program that keeps track of how files depend on one another and runs
commands to update any files that are out-of-date. Build managers were
invented to compile only those parts of programs that had
changed, but are now often used to implement workflows in which plots
depend on results files, which in turn depend on raw data files or
configuration files.
build recipe
The part of a build rule that describes how to update
something that has fallen out-of-date.
build rule
A specification for a build manager that describes how
some files depend on others and what to do if those files are out-of-
date.
build target
The file(s) that a build rule will update if they are out-of-
date compared to their dependencies.
byte code
A set of instructions designed to be executed efficiently by an
interpreter.
C
cache
Something that stores copies of data so that future requests for it can be
satisfied more quickly. The CPU in a computer uses a hardware cache to
hold recently-accessed values; many programs rely on a software cache to
reduce network traffic and latency. Figuring out when something in a
cache is out-of-date and should be replaced is one of the two hard
problems in computer science.
caching
To save a copy of some data in a local cache to make future access
faster.
call stack
A data structure that stores information about the active subroutines
executed.
callback function
A function A that is passed to another function B so that B can call it at
some later point. Callbacks can be used synchronously,
as in generic functions like map that invoke a callback function once
for each element in a collection, or asynchronously, as
in a client that runs a callback when a
response is received in answer to a
request.
Cascading Style Sheets (CSS)
A way to control the appearance of HTML. CSS is typically used to specify
fonts, colors, and layout.
catch (an exception)
To handle an error or other unexpected event represented by an
exception.
Chain of Responsibility pattern
A design pattern in which each object either
handles a request or passes it on to another object.
character encoding
A specification of how characters are stored as bytes. The most commonly-
used encoding today is UTF-8.
child (in a tree)
A node in a tree that is below another node (called the
parent).
A situation in which X depends on Y and Y depends on X, either directly or
indirectly. If there is a circular dependency, then the dependency
graph is not acyclic.
class
In object-oriented programming, a structure that combines data and
operations (called methods). The program then uses a
constructor to create an object with those
properties and methods. Programmers generally put generic or reusable
behavior in parent classes, and more detailed or
specific behavior in child classes.
client
A program such as a web browser that gets data from a server and
displays it to, or interacts with, users. The term is used more
generally to refer to any program A that makes requests of another
program B. A single program can be both a client and a server.
closure
A set of variables defined in the same scope whose existence has
been preserved after that scope has ended.
code coverage (in testing)
How much of a library or program is executed when tests run.
This is normally reported as a percentage of lines of code.
cognitive load
The amount of working memory needed to accomplish a set of simultaneous
tasks.
collision
A situation in which a program tries to store two items in the same location
in memory. For example, a collision occurs when a hash
function generates the same hash code for
two different items.
column-major storage
Storing each column of a two-dimensional array as one block of memory so
that elements in the same row are far apart.
combinatorial explosion
The exponential growth in the size of a problem or the time required to
solve it that arises when all possible combinations of a set of items
must be searched.
comma-separated values (CSV)
A text format for tabular data in which each record is one row
and fields are separated by commas. There are many minor
variations, particularly around quoting of strings.
command-line argument
A filename or control flag given to a command-line program when it is run.
command-line interface (CLI)
A user interface that relies solely on text for commands and output,
typically running in a shell.
comment
Text written in a script that is not treated as code to be run, but rather
as text that describes what the code is doing. These are usually short
notes, often beginning with a # (in many programming languages).
compile
To translate textual source into another form. Programs in compiled
languages are translated into machine instructions
for a computer to run, and Markdown is usually translated
into HTML for display.
compiled language
Originally, a language such as C or Fortran that is translated into machine
instructions for execution. Languages such as Java are also compiled
before execution, but into byte code instead of machine
instructions, while interpreted languages like
JavaScript are compiled to byte code on the fly.
compiler
An application that translates programs written in some languages into
machine instructions or byte code.
confirmation bias
The tendency for someone to look for evidence that they are right rather
than searching for reasons why they might be wrong.
console
A computer terminal where a user may enter commands, or a program, such as a
shell that simulates such a device.
constructor
A function that creates an object of a particular
class.
Coordinated Universal Time (UTC)
The standard time against which all others are defined. UTC is the time at
longitude 0°, and is not adjusted for daylight savings.
Timestamps are often reported in UTC so that they will be
the same no matter what timezone the computer is in.
The degree of interaction between two classes, modules,
or other software components. If a system's components are loosely
coupled, changes to one are unlikely to affect
others. If they are tightly coupled, then any
change requires other changes elsewhere, which complicates maintenance
and evolution.
cryptographic hash function
A hash function that produces an apparently-random value
for any input.
current working directory
The folder or directory location in which the
program operates. Any action taken by the program occurs relative to
this directory.
cycle (in a graph)
A set of links in a graph that leads from a node back to itself.
D
data frame
A two-dimensional data structure for storing tabular data in memory. Rows
represent records and columns represent fields.
data migration
Moving data from one location or format to another. The term refers to
translating data from an old format to a newer one.
Decorator pattern
A design pattern in which a function adds additional
features to another function or a class after its initial
definition. Decorators are a feature of Python and can be implemented in
most other languages as well.
defensive programming
A set of programming practices that assumes mistakes will happen and either
reports or corrects them, such as inserting assertions to
report situations that are not ever supposed to occur.
A directed graph showing how things depend on one
another, such as the files to be updated by a build
manager. If the dependency graph is not
acyclic, the dependencies cannot be resolved.
deprecation
To indicate that while a function, method, or class exists, its use is no
longer recommended (for example, because it is going to be phased out in
a future release).
depth-first
A search algorithm that explores one possibility all the way to its
conclusion before moving on to the next.
A style of designing software in which functions specify the pre-
conditions that must be true in order for them to run
and the post-conditions they guarantee will be true
when they return. A function can then be replaced by one with weaker
pre-conditions (i.e., it accepts a wider set of input) and/or stronger
post-conditions (i.e., it produces a smaller range of output) without
breaking anything else.
design pattern
A recurring pattern in software design that is specific enough to be worth
naming, but not so specific that a single best implementation can be
provided by a library.
destructuring assignment
Unpacking values from data structures and assigning them to multiple
variables in a single statement.
dictionary
A data structure that allows items to be looked up by value, sometimes
called an associative array. Dictionaries are
often implemented using hash tables.
directed acyclic graph (DAG)
A directed graph which does not contain any loops (i.e.,
it is not possible to reach a node from itself by following
edges).
A structure in a filesystem that contains references to other
structures, such as files and other directories.
disassembler
A program that translates machine instructions into assembly
code or some other higher-level language.
doc comment
A documentation comment ("doc comment" for short) is a specially-formatted
comment containing documentation about a piece of code that is embedded
in the code itself.
A program that runs other programs, or a function that drives all of the
other functions in a program.
dynamic loading
To import a module into the memory of a program while
it is already running. Most interpreted
languages use dynamic loading, and provide tools
so that programs can find and load modules dynamically to configure
themselves.
dynamic lookup
To find a function or a property of an object by name while a
program is running. For example, instead of getting a specific property
of an object using obj.name, a program might use obj[someVariable],
where someVariable could hold "name" or some other property name.
dynamic scoping
To find the value of a variable by looking at what is on the call
stack at the moment the lookup is done. Almost all
programming languages use lexical-scoping instead,
since it is more predictable.
E
eager matching
Matching as much as possible, as early as possible.
easy mode
A term borrowed from gaming meaning to do something with obstacles or
difficulties simplified or removed, often for practice purposes.
edge
A connection between two nodes in a graph. An edge may
have data associated with it, such as a name or distance.
edge case
A problem that only comes up under unusual circumstances or when a system is
pushed to its limits; also sometimes called a corner
case. Programs intended for widespread use have to handle
edge cases, but doing so can make them much more complicated.
element
A named component in an HTML or XML document. Elements are
usually written <name>…</name>, where "…" represents the content of
the element. Elements often have attributes.
encapsulate
To store data inside some kind of structure so that it is only accessible
through that structure.
entry point
Where a program begins executing.
environment
A structure that stores a set of variable names and the values they refer
to.
error (in a test)
Signalled when something goes wrong in a unit test itself
rather than in the system being tested. In this case, we do not know
anything about the correctness of the system.
error handling
What a program does to detect and correct for errors. Examples include
printing a message and using a default configuration if the user-
specified configuration cannot be found.
event loop
A mechanism for managing concurrent activities in a program. Tasks are
represented as items in a queue; the event loop repeatedly takes an item
from the front of the queue and runs it, adding any other tasks it
generates to the back of the queue to run later.
exception
An object that stores information about an error or other unusual event in a
program. One part of a program will create and raise an
exception to signal that something unexpected has
happened; another part will catch it.
exception handler
A piece of code that deals with an exception after it is
caught, e.g., by recording a message, retrying the
operation that failed, or performing an alternate operation.
expected result (of test)
The value that a piece of software is supposed to produce when tested in a
certain way, or the state in which it is supposed to leave the system.
exploratory programming
A software development methodology in which requirements emerge or change as
the software is being written, often in response to results from early
runs.
export
To make something visible outside a module so that other parts of
a program can import it. In most languages a module must
export things explicitly in an attempt to avoid name
collision.
Some aspect of software that was deliberately designed or built. A
bug is an undesired feature.
field
A component of a record containing a single value. Every record
in a database table has the same fields.
filename extension
The last part of a filename, usually following the '.' symbol. Filename
extensions are commonly used to indicate the type of content in the
file, though there is no guarantee that this is correct.
filesystem
The part of the operating system that manages how files
are stored and retrieved. Also used to refer to all of those files and
directories or the specific way they are stored (as in
"the Unix filesystem").
filter
As a verb, to choose a set of records (i.e., rows of a table)
based on the values they contain. As a noun, a command-line program that
reads lines of text from files or standard input, performs
some operation on them (such as filtering), and writes to a file or
stdout.
finite state machine (FSM)
A theoretical model of computing consisting of a directed graph whose nodes
represent the states of the computation and whose arcs show how to move
from one state to another. Every regular
expression corresponds to a finite state machine.
fixed-width (of strings)
A set of character strings that have the same length. Databases often used
fixed-width strings to make storage and access more efficient; short
strings are padded up to the required length and long
strings are truncated.
fixture
The thing on which a test is run, such as the parameters to
the function being tested or the file being processed.
fluent interface
A style of object-oriented programming in which methods return objects so
that other methods can immediately be called.
The process of identifying memory that has been allocated but is no longer
in use and reclaiming it to be re-used.
generator function
A function whose state is automatically saved when it returns a value so
that execution can be restarted from that point the next time it is
called. One example of generator functions use is to produce streams of
values that can be processed by for loops.
generic function
A collection of functions with similar purpose, each operating on a
different class of data.
global variable
A variable defined outside any particular function or package
namespace, which is therefore visible to all functions.
globbing
To specify a set of filenames using a simplified form of regular
expressions, such as *.dat to mean "all files
whose names end in .dat". The name is derived from "global".
graph
A plot or a chart that displays data, or a data structure in which
nodes are connected to one another by edges.
greedy algorithm
An algorithm that consumes as much input as possible, as early as possible.
H
handler
A callback function responsible for handling some particular
event, such as the user clicking on a button or new data being receiving
from a file.
hash code
A value generated by a hash function. Good hash codes have
the same properties as random numbers in order to reduce the frequency
of collisions.
hash function
A function that turns arbitrary data into a bit array, or a key, of
a fixed size. Hash functions are used to determine where data should be
stored in a hash table.
hash table
A data structure that calculates a pseudo-random key (location) for each
value passed to it and stores the value in that location. Hash tables
enable fast lookup for arbitrary data. This occurs at the cost of extra
memory because hash tables must always be larger than the amount of
information they need to store, to avoid the possibility of data
collisions, when the hash function returns the same key for two
different values.
header file
In C and C++, a file that defines constants and function
signatures but does not contain runnable code. Header
files tell the including file what is defined in other files so that the
compiler can generate correct code.
heterogeneous
Containing mixed data types. For example, an array in Javascript can contain
a mix of numbers, character strings, and values of other types.
heuristic
A rule or guideline that isn't guaranteed to produce the desired result, but
usually does.
homogeneous
Containing a single data type. For example, a vector must be
homogeneous: its values must all be numeric, logical, etc.
HTTP request
A message sent from a client to a server using the
HTTPprotocol asking for data. A request usually
asks for a web page, image, or other data.
HTTP response
A reply sent from a server to a client using the
HTTPprotocol in response to a
request. The response usually contains a web page,
image, or data.
HyperText Markup Language (HTML)
The standard markup language used for web pages. HTML is
represented in memory using DOM (Digital Object Model).
HyperText Transfer Protocol (HTTP)
The standard protocol for data transfer on the World-Wide Web.
HTTP defines the format of requests and
responses, the meanings of standard error codes, and
other features.
I
idiomatic
To use a language in the same way as a fluent or native speaker. Programs
are called idiomatic if they use the language the way that proficient
programmers use it.
immediately-invoked function expression (IIFE)
A function that is invoked once at the point where it is defined. IIFEs are
typically used to create a scope to hide some function or
variable definitions.
immutable
Data that cannot be changed after being created. Immutable data is easier to
think about, particularly if data structures are shared between several
tasks, but may result in higher memory requirements.
import
To bring things from a module into a program for use. In most
languages a program can only import things that the module explicitly
exports.
index (in a database)
An auxiliary data structure in a database used to speed up search for some
entries. An index increases memory and disk requirements but reduces
search time.
inner function
A function defined inside another (outer) function. Creating and returning
inner functions is a way to create closures.
A special register in a processor that stores the address of
the next instruction to execute.
instruction set
The basic operations that a particular processor can execute directly.
interpreted language
A high-level language that is not executed directly by the computer, but
instead is run by an interpreter that translates program
instructions into machine commands on the fly.
interpreter
A program whose job it is to run programs written in a high-level
interpreted language. Interpreters can run
interactively, but may also execute commands saved in a file.
intrinsic complexity
The unavoidable complexity inherent in a problem that any solution must deal
with. The term is used in contrast with accidental
complexity.
introspection
Having a program examine itself as it is running; common examples are to
determine the specific class of a generic object or to get the fields of
an object when they are not known in advance.
ISO date format
An international standard for formatting dates. While the full standard is
complex, the most common form is YYYY-MM-DD, i.e., a four-digit year,
a two-digit month, and a two-digit day, separated by hyphens.
Iterator pattern
A design pattern in which a temporary object
or generator function produces each value from a
collection in turn for processing. This pattern hides the differences
between different kinds of data structures so that everything can be
processed using loops.
J
JavaScript Object Notation (JSON)
A way to represent data by combining basic values like numbers and character
strings in lists and key/value structures. The
acronym stands for "JavaScript Object Notation"; unlike better-defined
standards like XML, it is unencumbered by a syntax for comments
or ways to define a schema.
join
An operation that combines two tables, typically by matching
keys from one with keys from another.
K
key
A field or combination of fields whose value(s) uniquely identify
a record within a table or dataset. Keys are often
used to select specific records and in joins.
L
label (address in memory)
A human-readable name given to a particular location in memory when writing
programs in assembly code.
layout engine
A piece of software that decides where to place text, images, and other
elements on a page.
lazy matching
Matching as little as possible while still finding a valid match.
Least Recently Used cache (LRU cache)
A cache that discards items that have not been used recently in
order to limit memory requirements.
lexical scoping
To look up the value associated with a name according to the textual
structure of a program. Most programming languages use lexical scoping
instead of dynamic scoping because the latter is
less predictable.
library
An installable collection of software, also often called a module
or package.
lifecycle
The steps that something is allowed or required to go through. The lifecycle
of an object runs from its construction
through the operations it can or must perform before it is destroyed.
line comment
A comment in a program that spans part of a single line, as
opposed to a block comment that may span multiple
lines.
link (a program)
To combine separately compiled modules into a single runnable
program.
linter
A program that checks for common problems in software, such as violations of
indentation rules or variable naming conventions. The name comes from
the first tool of its kind, called lint.
Liskov Substitution Principle
A design rule stating that it should be possible to replace objects in a
program with objects of derived classes without breaking the program.
Design by contract is intended to enforce this
rule.
A representation of a fixed value in a program, such as the digits 123 for
the number 123 or the characters "abc" for the string containing those
three letters.
literate programming
A programming paradigm that mixes prose and code so that explanations and
instructions are side by side.
loader
A function whose job is to read files containing runnable code into memory
and make that code available to the calling program.
local variable
A variable defined inside a function which is only visible within that
function.
log message
A status report or error message written to a file as a program runs.
loop body
The statement or statements executed by a loop.
loosely coupled
Components in a software system are said to be loosely coupled if they are
relatively independent of one another, i.e., if any one of them can be
changed or replaced without others having to be altered as well.
M
macro
Originally short for "macro-instruction", an instruction to translate some
of the text into a program into other text before using it.
Makefile
A configuration file for the original build manager.
manifest
A list that specifies the precise versions of a complete set of libraries or
other software components.
A set of rules for annotating text to define its meaning or how it should be
displayed. The markup is usually not displayed, but instead controls how
the underlying text is interpreted or shown. Markdown and
HTML are widely-used markup languages for web pages.
method
An implementation of a generic function that handles
objects of a specific class.
method chaining
A style of object-oriented programming in which an object's methods return
that object as their result so that another method can immediately be
called, as in obj.a().b().c().
mock object
A simplified replacement for part of a program whose behavior is easy to
control and predict. Mock objects are used in unit tests
to simulate databases, web services, and other complex systems.
module
A reusable software package, also often called a
library.
module bundler
A program that finds all the dependencies of a set of source files and
combines them into a single loadable file.
multi-threaded
Capable of performing several operations simultaneously. Multi-threaded
programs are usually more efficient than single-
threaded ones, but also harder to understand and
debug.
N
name collision
The ambiguity that arises when two or more things in a program that have the
same name are active at the same time. Most languages use
namespaces to prevent such collisions.
namespace
A collection of names in a program that exists in isolation from other
namespaces. Each function, object, class, or
module in a program typically has its own namespace so that
references to "X" in one part of a program do not accidentally refer to
something called "X" in another part of the program. Scope is a
distinct, but related, concept.
nested function
A function that is defined inside another function.
node
An element of a graph that is connected to other nodes by
edges. Nodes typically have data associated with them, such as
names or weights.
non-blocking execution
To allow a program to continue running while an operation is in progress.
For example, many systems support non-blocking execution for file I/O so
that the program can continue doing work while it waits for data to be
read from or written to the filesystem (which is
typically much slower than the CPU).
O
object
In object-oriented programming, a structure that contains the data
for a specific instance of a class. The operations the object
is capable of are defined by the class's methods.
object-oriented programming (OOP)
A style of programming in which functions and data are bound together in
objects that only interact with each other through well-
defined interfaces.
off-by-one error
A common error in programming in which the program refers to element i of
a structure when it should refer to element i-1 or i+1, or processes
N elements when it should process N-1 or N+1.
op code
The numerical code for a particular instruction that a processor can
execute.
Open-Closed Principle
A design rule stating that software should be open for extension but closed
for modification, i.e., it should be possible to extend functionality
without having to rewrite existing code.
operating system
A program that provides a standard interface to whatever hardware it is
running on. Theoretically, any program that only interacts with the
operating system should run on any computer that operating system runs
on.
P
package
A collection of code, data, and documentation that can be distributed and
re-used. Also referred to in some languages as a library or
module.
pad (a string)
To add extra characters to a string to make it a required length.
parameter
A variable specified in a function definition that is assigned a value when
the function is called.
parent (in a tree)
A node in a tree that is above another node (called a
child). Every node in a tree except the root
node has a single parent.
A piece of software that translates a textual representation of something
into a data structure. For example, a YAML parser reads
indented text and produces nested lists and objects.
A generic build rule that describes how to update any file
whose name matches a pattern. Pattern rules often use automatic
variables to represent the actual filenames.
pipe
To use the output of one computation as the input for the next, or the
connection between the two computations responsible for the data
transfer. Pipes were popularized by the Unix shell, and are
now used in many different programming languages and systems.
pipe (in the Unix shell)
The | used to make the output of one command the input of the next.
plugin architecture
A style of application design in which the main program loads and runs small
independent modules that do the bulk of the work.
polymorphism
Having many different implementations of the same interface. If a set of
functions or objects are polymorphic, they can be called
interchangeably.
post-condition
Something that is guaranteed to be true after a function runs successfully.
Post-conditions are often expressed as assertions that are
guaranteed to be true of a function's results.
pre-condition
Something that must be true before a function runs in order for it to work
correctly. Pre-conditions are often expressed as as
assertions that must be true of a function's inputs in
order for it to run successfully.
precedence
The priority of an operation. For example, multiplication has a higher
precedence than addition, so a+b*c is read as "the sum of a with the
product of b and c".
An operating system's representation of a running
program. A process typically has some memory, the identity of the user
who is running it, and a set of connections to open files.
promise
A way to represent the result of a delayed or asynchronous
computation. A promise is a placeholder for a value that will eventually
be computed; any attempt to read the value before it is available
blocks, while any such attempt after the computation finishes acts like
a normal read.
promisification
In JavaScript, the act of wrapping a callback function in a
promise for uniform asynchronous execution.
protocol
Any standard specifying how two pieces of software interact. A network
protocol such as HTTP defines the messages that
clients and servers exchange on the World-Wide
Web; object-oriented programs often define protocols for
interactions between objects of different classes.
prune
To remove branches and nodes from a tree, or to rule out partially-complete
solutions when searching for an overall solution in order to reduce
work.
pseudo-random number
A value generated in a repeatable way that resembles the true randomness of
the universe well enough to fool observers.
A pattern that specifies a set of DOM nodes. Query selectors are
used in CSS to specify the elements that rules apply to, or by
JavaScript programs to manipulate web pages.
query string
The portion of a URL after the question mark ? that specifies
extra parameters for the HTTP request as name-value
pairs.
R
race condition
A situation in which a result depends on the order in which two or more
concurrent operations are carried out.
raise (an exception)
To signal that something unexpected or unusual has happened in a program by
creating an exception and handing it to the error-
handling system, which then tries to find a point in
the program that will catch it.
read-eval-print loop (REPL)
An interactive program that reads a command typed in by a user, executes it,
prints the result, and then waits patiently for the next command. REPLs
are often used to explore new ideas, or for debugging.
record
A group of related values that are stored together. A record may be
represented as a tuple or as a row in a table; in
the latter case, every record in the table has the same
fields.
register
A small piece of memory (typically one word long) built into
a processor that operations can refer to directly.
regular expression
A pattern for matching text, written as text itself. Regular expressions are
sometimes called "regexp", "regex", or "RE", and are powerful tools for
working with text.
relational database
A database that organizes information into tables, each of which
has a fixed set of named fields (shown as columns) and a
variable number of records (shown as rows).
relative error
The absolute value of the difference between the actual and correct value
divided by the correct value. For example, if the actual value is 9 and
the correct value is 10, the relative error is 0.1. Relative error is
usually more useful than absolute error.
relative path
A path that is interpreted relative to some other location, such as the
current working directory. A relative path
is the equivalent of giving directions using terms like "straight" and
"left".
root (in a tree)
The node in a tree of which all other nodes are direct or
indirect children, or equivalently the only node in the
tree that has no parent.
row-major storage
Storing each row of a two-dimensional array as one block of memory so that
elements in the same column are far apart.
runnable documentation
Statements about code that can be executed to check their correctness, such
as assertions or type declarations.
S
sandbox
A testing environment that is separate from the production system, or an
environment that is only allowed to perform a restricted set of
operations for security reasons.
SAT solver
A library or application that determines whether there is an assignment of
true and false to a set of Boolean variables that makes an
expression true (i.e., that satisfies the expression).
schema
A specification of the format of a dataset, including the name, format, and
content of each table.
scope
The portion of a program within which a definition can be seen and used.
scope creep
Slow but steady increase in a project's goals after the project starts.
scoring function
A function that measures or estimates how good a solution to a problem is.
search path
The list of directories that a program searches to find something. For
example, the Unix shell uses the search path stored in the
PATH variable when trying to find a program whose name it has been
given.
A standard for identifying software releases. In the version identifier
major.minor.patch, major changes when a new version of software is
incompatible with old versions, minor changes when new features are
added to an existing version, and patch changes when small
bugs are fixed.
server
Typically, a program such as a database manager or web server that provides
data to a client upon request.
A variable set and used in the Unix shell. Commonly-used shell
variables include HOME (the user's home directory) and PATH (their
search path).
side effect
A change made by a function while it runs that is visible after the function
finishes, such as modifying a global variable or
writing to a file. Side effects make programs harder for people to
understand, since the effects are not necessarily clear at the point in
the program where the function is called.
signature
The set of parameters (with types or meaning) that characterize the calling
interface of a function or set of functions. Two functions with the same
signature can be called interchangeably.
single-threaded
A model of program execution in which only one thing can happen at a time.
Single-threaded execution is easier for people to understand, but less
efficient than multi-threaded execution.
singleton
A set with only one element, or a class with only one
instance.
An abbreviated portion of a page's URL that uniquely identifies it. In the
example https://www.mysite.com/category/post-name, the slug is post-
name.
source map
A table used to translate a piece of code back to the lines in the original
source.
sparse matrix
A matrix in which most of the values are zero (or some other value). Rather
than storing many copies of the same values, programs will often use a
special data structure that only stores the "interesting" values.
SQL
The language used for writing queries for a relational
database. The term was originally an acronym for
Structured Query Language.
stack frame
A section of the call stack that records details of a single
call to a specific function.
stale (in build)
To be out-of-date compared to a prerequisite. A build
manager's job is to find and update things that are
stale.
standard error
A predefined communication channel for a process typically used
to report errors.
standard input
A predefined communication channel for a process, typically used
to read input from the keyboard or from the previous process in a
pipe.
standard output
A predefined communication channel for a process, typically used
to send output to the screen or to the next process in a
pipe.
static site generator
A software tool that creates HTML pages from templates and content.
stream
A sequential flow of data, such as the bits arriving across a
network connection or the bytes read from a file.
streaming API
An API that processes data in chunks rather than needing to have all
of it in memory at once. Streaming APIs usually require
handlers for events such as "start of data", "next block",
and "end of data".
string
A block of text in a program. The term is short for "character string".
string interpolation
The process of inserting text corresponding to specified values into a
string, usually to make output human-readable.
synchronous
To happen at the same time. In programming, synchronous operations are ones
that have to run simultaneously, or complete at the same time.
T
tab completion
A technique implemented by most REPLs, shells, and
programming editors that completes a command, variable name, filename,
or other text when the TAB key is pressed.
A technique for storing data in a two-part structure, where one part
identifies the type and the other part stores the bits making up the
value.
Template Method pattern
A design pattern in which a parent class
defines an overall sequence of operations by calling abstract
methods that child classes must then
implement. Each child class then behaves in the same general way, but
implements the steps differently.
test harness
A program written to test some other program or set of functions, typically
to measure their performance.
test runner
A program that finds and runs software tests and reports their results.
test subject
The thing being tested, sometimes also called the system under test (SUT).
test-driven development (TDD)
A programming practice in which tests are written before a new feature is
added or a bug is fixed in order to clarify the goal.
Components in a software system are said to be tightly coupled if they
depend on each other's internals, so that if one is altered then others
have to be altered as well.
Time of check/time of use (ToCToU)
A race condition in which a process checks the state of
something and then operates on it, but some other process might alter
that state between the check and the operation.
timestamp
A digital identifier showing the time at which something was created or
accessed. Timestamps should use ISO date format for
portability.
token
An indivisible unit of text for a parser, such as a variable name or a
number. Exactly what constitutes a token depends on the language.
topological order
Any ordering of the nodes in a graph that respects the
direction of its edges, i.e., if there is an edge from node A
to node B, A comes before B in the ordering. There may be many
topological orderings of a particular graph.
transitive closure
The set of all nodes in a graph that are reachable from a
starting node, either directly or indirectly.
tree
A graph in which every node except the root has
exactly one parent.
tuple
A value that has a fixed number of parts, such as the three color components
of a red-green-blue color specification.
Turing Machine
A theoretical model of computation that manipulates symbols on an infinite
tape according to a fixed table of rules. Any computation that can be
expressed as an algorithm can be done by a Turing Machine.
two hard problems in computer science
Refers to a quote by Phil Karlton: "There are only two hard problems in
computer science—cache invalidation and naming things." Many variations
add a third problem as a joke, such as off-by-one
errors.
type declaration
A statement in a program that a variable or value has a particular data
type. Languages like Java require type declarations for all variables;
they are optional in TypeScript and Python, and not allowed in pure
JavaScript.
U
Unicode
A standard that defines numeric codes for many thousands of characters and
symbols. Unicode does not define how those numbers are stored; that is
done by standards like UTF-8.
Uniform Resource Locator (URL)
A unique address on the World-Wide Web. URLs originally identified web
pages, but may also represent datasets or database queries, particularly
if they include a query string.
unit test
A test that exercises one function or feature of a piece of software and
produces pass, fail, or
error.
UTF-8
A way to store the numeric codes representing Unicode characters
in memory that is backward-compatible with the
older ASCII standard.
V
vector
A sequence of values, usually of homogeneous type.
version control system
A system for managing changes made to software during its development.
virtual machine
A program that pretends to be a computer. This may seem a bit redundant, but
VMs are quick to create and start up, and changes made inside the
virtual machine are contained within that VM so we can install new
packages or run a completely different operating system
without affecting the underlying computer.
Visitor pattern
A design pattern in which the operation to be done is
taken to each element of a data structure in turn. It is usually
implemented by having a generator "visitor" that knows how to reach the
structure's elements, which is given a function or method to call for
each in turn, and that carries out the specific operation.
An instruction for a debugger telling it to suspend execution whenever the
value of a variable (or more generally an expression) changes.
well formed
A piece of text that obeys the rules of a formal grammar is said to be well
formed.
word (of memory)
The unit of memory that a particular processor most naturally works with.
While a byte is a fixed size (8 bits), a word may be 16, 32, or 64 bits
long depending on the processor.
X
XML
A set of rules for defining HTML-like tags and using them to format
documents (typically data). XML was popular in the early 2000s, but its
complexity led many programmers to adopt JSON, instead.
Y
YAML
Short for "YAML Ain't Markup Language", a way to represent nested data using
indentation rather than the parentheses and commas of JSON.
YAML is often used in configuration files and to define
parameters for various flavors of Markdown
documents.
Z
z-buffering
A drawing method that keeps track of the depth of what lies "under" each
pixel so that it displays whatever is nearest to the observer.