A class that defines or requires methods it does not implement. An abstract class typically specifies the methods that child classes must have without providing default implementations. See also: concrete class.
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 difficulty added to a problem because of poor notation, poor tooling, an unclear problem statement, distractions, etc. 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.
active record
A class that represents each record in a database table as one object whose fields automatically reflected the fields of that table. Active records are one way to implement an object-relational mapper.
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.
affordance
An action that a thing can do: for example, a door can be opened or a document can be printed. Good user interfaces make affordances easy to discover.
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 without a name. Languages like JavaScript make frequent use of anonymous functions; Python provides a limited form called a lambda expression.
ANSI character encoding
An extension of ASCII that standardized the characters represented by the codes 128 to 255.
append mode
An option for writing to a file in which new data is appended to existing data rather than replacing it.
Application Binary Interface (ABI)
The low-level layout that a piece of software must have to work on a particular kind of machine. See also: Application Programming Interface.
Application Programming Interface (API)
A set of functions provided by a software library or web service that other software can call. See also: Application Binary Interface.
argument
A value passed into a function or method call. See also: parameter.
ASCII character encoding
A standard way to represent the characters commonly used in the Western European languages as 7-bit integers, now largely superceded by Unicode. See also: ANSI character encoding.
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 or provided as functions.
atomic operation
An operation that is guaranteed to complete, i.e., one that cannot be interrupted part-way through.
atomic value
A value that cannot be broken down into smaller parts, such as a Boolean or integer.
attention budget
The amount of time your activity is allowed to require of other people in an organization.
attribute
A name-value pair associated with an object, used to store metadata about the object such as an array’s dimensions.
authentication
The process of establishing identity. Authentication relies on something someone knows (such as a password), something they have (such as a key card), or something they are (such as a fingerprint).
backward-compatible
A property of a system that enables interoperability with an older legacy system, or with input designed for such a system.
Executing a set of non-interactive tasks on a computer, such as backing up files or copying data from one database to another overnight.
benchmark
A program or set of programs used to measure the performance of a computer system.
big endian
A storage scheme in which the most significant part of a number is stored in the byte with the lowest address. For example, the 16-bit big-endian representation of 258 stores 0x01 in the lower byte and 0x02 in the higher byte. See also: little endian.
big-oh notation
A way to express how the running time or memory requirements of an algorithm increase as the size of the problem increases. See also: space complexity, time complexity.
binary mode
An option for reading or writing files in which each byte is transferred literally. The term is used in contrast with text mode.
bit mask
A pattern of bits used to set or clear bits in a byte or word in memory.
An operation that manipulates individual bits in memory. Common bitwise operations include and, or, not, and xor.
block (of memory)
A region of memory of a fixed, constant size. Data is often divided into blocks to optimize input and output at the hardware level; software is then used to convert between blocks and streams.
block (on page)
A rectangular region of a page that may contain text, images, and other visual elements along with other blocks.
body (of HTTP request or response)
The “extra” data associated with an HTTP request or response, such as the file being uploaded or the page being returned for display.
One of the two values “true” or “false”. Named for George Boole, a 19th century mathematician.
boxed value
A value (such as an integer) that is embedded in a larger structure in memory that carries metadata about its type, how many structures are referring to it, and so on.
breakpoint
A point in a program where a debugger should halt execution in order to interact with a user.
bucket
A subset of values from a dataset, typically represented by a single bar in a histogram.
buffer (in memory)
A temporary storage area in memory.
buffer (of text)
A data structure that stores text while it is being viewed or edited.
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 manager
A design pattern in which a complex object is filled in step by step after its creation by calling its methods.
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.
bytecode
A set of instructions designed to be executed efficiently by an interpreter.
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.
call stack
A data structure that stores information about the active subroutines executed.
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 way to represent characters as bytes. Common examples include ASCII and UTF-8.
child (in a tree)
A node in a tree that is below another node (call the parent).
A situation in which a build target depends on itself either directly or indirectly, i.e., a situation in which the DAG of dependencies contains a cycle.
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.
class method
A function defined inside a class that takes the class object as an input rather than an instance of the class. See also: static method.
A program such as a browser that sends requests to a server and does something with the response.
closing tag
The textual marker showing the end of an element in an HTML document, written </tag>.
closure
A record that stores a function and its environment so that variables that were in scope when the function was defined can still be accessed from within the function even if they are no longer visible to other parts of the program.
code point
A number that uniquely identifies a character in the Unicode standard.
cognitive load
The mental effort required to solve a problem.
collision (in hashing)
A situation in which two or more values have the same hash code.
column-wise storage
To organize the memory of a two-dimensional table so that the values in each column are laid out in contiguous blocks. See also: row-wise storage.
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.
Command pattern
A design pattern in which operations are represented as objects so that they can be stored and re-used.
compact (data or files)
To pack data so as to remove wasted or unused space.
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 bytecode 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 bytecode.
compression (of file)
Any of several techniques for reducing the size required to store a file. Compression works by finding patterns and replacing them with shorter sequences of bits or bytes.
concrete class
A class that can actually be instantiated. The term is used in contrast with abstract class.
conditional breakpoint
A breakpoint at which the debugger should only halt if some user-specified condition is true.
conditional jump
An instruction that tells a processor to start executing somewhere other than at the next address if a condition is true. Conditional jumps are used to implement higher-level constructs like if statements and loops.
confirmation bias
The tendency for someone to look for evidence that they are right rather than searching for reasons why they might be wrong.
constructor
A function that creates an object of a particular class.
context manager
An object that automatically executes some operations at the start of a code block and some other operations at the end of the block.
Originally a “character” that made a teletype perform some operation, such as moving to the next line or ringing the bell. Only a handful of control codes such as tab and newline are still in common use.
control flow
The order in which a program executes statements and expressions.
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.
cross product
The set of all possible combinations of items from one or more sets.
cryptographic hash function
A hash function that produces an apparently-random value for any input.
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.
Someone responsible for designing, developing, and maintaining systems for collecting, storing, and analyzing data.
data migration
The act of moving data from one system or format to another.
dataframe
A two-dimensional data structure for storing tabular data in memory. Rows represent records and columns represent fields.
deadlock
A situation in which no one can proceed because everyone is blocked on someone else.
debugger
A program that enables its user to monitor and control another program, typically by single-stepping through its execution or setting breakpoints.
decorator
A function A that can be applied to another function B when function B is being defined to change its behavior in some way.
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.
delayed construction
The practice of constructing an object after something that needs it has been constructed rather than before. See also: lazy evaluation.
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. See also: Liskov Substitution Principle.
To convert machine instructions into assembly code or some higher-level language.
disassembler
A program that translates machine instructions into assembly code or some higher-level language. See also: assembler.
docstring
A string at the start of a module, class, or function in Python that is not assigned to a variable, which is used to hold the documentation for that part of code.
The tree formed by a set of properly-nested DOMnodes.
Domain Name System (DNS)
A decentralized naming system for computers that translates hostnames into the IP address of particular computers.
dry run
An execution of a program that doesn’t change anything.
duck typing
A programming style in which the methods an object happens to have determines how it can be used, rather than what classes it inherits from.
dynamic dispatch
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.
dynamic typing
A system in which types are checked as the program is running. See also: static typing, type hint.
eager evaluation
Evaluating expressions before they are used. See also: lazy evaluation.
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.
element (in HTML)
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.
enumeration
A set of distinct named values defined in a program.
environment
The set of variables currently defined in a program.
error (result of 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.
escape sequence
A series of two or more characters used to represent a character that otherwise couldn’t be represented. For example, the escape sequence \" is used to represent a single " character inside a double-quoted string.
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.
exclusive or
A logical (or bitwise) operator that is true (or 1) if its arguments have different values and false (or 0) if they are the same. Exclusive or implements “either/or” or “one or the other”.
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.
exponent
The portion of a floating-point number that controls placement of the decimal point. See also: mantissa.
expression
A part of a program that produces a value, such as 1+2. See also: statement.
extensibility
How easily new features can be added to a program or existing features can be changed.
Extract Parent Class refactoring
A refactoring in which some functionality of an existing class or set of classes is moved into a newly-created parent class.
factory method
A method whose only job is to construct an object of some type. Factory methods are typically created to make it easier for child classes to construct objects of other types.
A report that something is missing when it is actually present. See also: false positive.
false positive
A report that something is present when it is actually absent. See also: false negative.
falsy
Refers to a value that is treated as false in Boolean expressions. In Python, this includes empty strings and lists and the number zero. See also: truthy.
field
A component of a record containing a single value. Every record in a database table has the same fields.
file locking
The act of restricting updates to a file, or its deletion, so that operations on it appear atomic.
fixture
The thing on which a test is run, such as the parameters to the function being tested or the file being processed.
format string
A string that contains special markers showing how to format values. For example, the string "{age:02d} years old" specifies that the value of age is to be inserted at the front of the string and formatted as a 2-digit decimal number with a leading 0 (if necessary).
garbage collection
An automatic process in a program that finds and recycles memory that is no longer being used.
generic function
A collection of functions with similar purpose, each operating on a different class of data.
global
Referring to the top or outermost scope a program. See also: local.
globbing
Matching filenames against patterns. The name comes from an early Unix utility called glob (short for “global”). Glob patterns are a subset of regular expressions. See also: regular expression.
grammar
The rules that define a formal language recognized by a parser.
graph (data structure)
A data structure in which nodes are connected to one another by edges. See also: tree.
greedy matching
Matching as much as possible while still finding a valid match. See also: lazy matching.
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 (of HTTP request or response)
A name-value pair at the start of an HTTP request or response. Headers are used to specify what data formats the sender can handle, the date and time the message was sent, and so on.
headless application
An application run without its usual graphical interface. Browsers, editors, and other applications are often run headless for testing purposes.
helper class
A class created to support another class that has no other purpose on its own.
helper function
A function created to support another function (or functions) that has no other use on its own.
helper method
A method designed to be used only by other methods in the same class. Helper methods are usually created to keep other methods short and readable.
heterogeneous
Containing mixed data types. For example, an array in Javascript can contain a mix of numbers, character strings, and values of other types. See also: homogeneous.
hexadecimal
A base-16 numerical representation that uses the letters A-F (or a-f) to represent the values from 10 to 15.
homogeneous
Containing a single data type. For example, a vector must be homogeneous: its values must all be numeric, logical, etc. See also: heterogeneous.
hostname
The human-readable name for a networked computer, such as example.com.
HTML
The standard markup language used for web pages. HTML is represented in memory using DOM (Digital Object Model). See also: XML.
HTTP
The protocol used to exchange information between browsers and websites, and more generally between other clients and servers. Communication consists of requests and responses.
HTTP method
The verb in an HTTP request that defines what the client wants to do. Common methods are GET (to get data) and POST (to submit data).
HTTP protocol version
Specifies the version of HTTP being used, which in turn defines what headers can appear, how they are to be interpreted, etc.
HTTP request
A precisely-formatted block of text sent from a client such as a browser to a server that specifies what resource is being requested, what data formats the client will accept, etc.
HTTP response
A precisely-formatted block of text sent from a server back to a client in reply to a request.
HTTP status code
A numerical code that indicates what happened when an HTTP request was processed, such as 200 (OK), 404 (not found), or 500 (internal server error).
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.
index (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.
infinite loop
A loop (usually a while loop) that never ends because its controlling condition is never false. See also: infinite recursion.
infinite recursion
Recursion that never stops because it never reaches a case that doesn’t require further evaluation; the recursive equivalent of an infinite loop.
infix notation
Writing expressions with operators between operands, as in 1 + 2 to add 1 and 2. See also: prefix notation, postfix notation.
inheritance
The act of creating a new class from an existing class, typically by adding or changing its properties or methods. See also: multiple inheritance.
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.
Internet Protocol (IP)
A set of specifications for ways computers can communicate. TCP/IP is the most widely used.
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 that runs programs written in a high-level interpreted language. Interpreters can run interactively but may also execute commands saved in a file.
intrinsic complexity
The inherent difficult of a problem. The term is used in contrast to accidental complexity.
A four-part number that uniquely identifies a computer on a network.
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
A function or object that produces each value from a collection in turn for processing.
Iterator pattern
A design pattern that uses iterators to hide the differences between different kinds of data structures so that everything can be processed using loops. See also: Visitor pattern.
join (tables)
An operation that combines two tables, typically by matching keys from one with keys from another.
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.
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.
key-value store
A simple form of database in which each record can only be accessed by a single key.
label (of address in memory)
A human-readable name given to a particular location in memory when writing programs in assembly code.
lambda expression
An expression that takes zero or more parameters and produces a result. A lambda expression is sometimes called an anonymous function; the name comes from the mathematical symbol λ used to represent such expressions.
layout engine
A piece of software that decides where to place text, images, and other elements on a page.
lazy evaluation
Evaluating expressions only when absolutely necessary. See also: eager evaluation.
lazy matching
Matching as little as possible while still finding a valid match. See also: greedy matching.
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.
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 single expression that constructs a list by looping over its items.
literal (in parsing)
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.
little endian
A storage scheme in which the most significant part of a number is stored in the byte with the highest address. For example, the 16-bit big-endian representation of 258 stores 0x02 in the lower byte and 0x01 in the higher byte. See also: big endian.
local
Referring to the current or innermost scope in a program. See also: global.
log file
A file to which a program writes status or debugging information for later analysis.
log-structured database
A database to which data can only be appended, i.e., existing records cannot be overwritten.
manifest
A list of something’s parts or components.
mantissa
The portion of a floating-point number that defines its specific value. See also: exponent.
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. See also: XML.
metadata
Data about data, such as the time a dataset was archived.
method
An implementation of a generic function that handles objects of a specific class.
method injection
To add methods to an existing class after its definition.
minimum testable class
The simplest extension to an abstract class that can actually be used, particularly in tests.
mixin class
A class that is not meant to be instantiated itself but which contains methods to be added to other classes (typically via multiple inheritance).
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.
model
A set of values for variables that satisfies a specific set of constraints.
module
A reusable software package, also often called a library.
monkey patching
To replace methods in a class or object at run-time without modifying the original code.
multiple inheritance
Inheriting from two or more classes when creating a new class.
name collision
A situation in which two or more things are trying to use the same name at the same time or in the same scope.
named tuple
A tuple whose fields can be accessed by name as well as by location. Named tuples are used to implement records that don’t have any associated methods.
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.
null byte
A byte with the value zero. Null bytes are used to mark the ends of strings in C and C++, and are sometimes used to fill unused space in fixed-size binary records.
Null Object pattern
A design pattern in which a placeholder object is used instead of None. The placeholder object has the methods of the object usually used, but those methods do nothing. This pattern saves other code from having to check repeatedly for None.
nybble
Four bits, i.e., half a byte.
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.
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.
online analytical processing (OLAP)
Analyzing data in bulk. The term is used in contrast to OLTP.
online transaction processing (OLTP)
Adding records to a database or querying individual records. The term is used in contrast to OLAP.
op code
The numerical operation code for an 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.
opening tag
The textual marker showing the start of an element in an HTML document, written <tag>. An opening tag may contain attributes.
operator overloading
Defining or redefining the implementation of built-in operators like +.
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.
page
A fixed-size block of storage space. Most modern filesystems manage disks using 4K pages, and many other applications such as databases use the same page size to maximize efficiency.
parameter
The name that a function gives to one of the values passed to it when it is called. See also: argument.
parameter sweeping
To execute a program multiple times with different parameters to find out how its behavior or performance depends on those parameters.
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 function or program that reads text formatted according to some grammar and converts it to a data structure in memory. Every programming language has a parser that reads programs written in that language; parsers also exist for various data formats.
A single file containing a set of changes to a set of files, separated by markers that indicate where each individual change should be applied, or the semantic versioning identifier for such a file.
path resolution
The process of converting the filename portion of a URL into a specific file on disk.
persistence
The act of saving and restoring data, particularly heterogeneous data with irregular structure.
phony target
A build recipe that doesn’t update any files. Phony targets are typically used to make tasks such as running tests reproducible.
pipe (in the Unix shell)
The | used to make the output of one command the input of the next.
placeholder file
A file stored in place of some other file (such as a large dataset) that contains metadata about that other file.
polymorphism
Having many different implementations of the same interface. If a set of functions or objects are polymorphic, they can be called interchangeably.
port
A logical endpoint for communication, like a phone number in an office building. Only one program on a computer may use a particular port on that computer at any time.
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. See also: design by contract, pre-condition.
postfix notation
Writing expressions with the operator after the operand, as in 2 3 + to add 2 and 3. See also: infix notation, prefix notation.
pre-condition
Something that must be true before a function runs in order for it to work correctly. Pre-conditions are often expressed as assertions that must be true of a function’s inputs in order for it to run successfully. See also: design by contract, post-condition.
prefix notation
Writing expressions with the operator in front of the operand, as in + 3 4 to add 3 and 4. See also: infix notation, postfix notation.
To format textual output in a way that makes it easier to read.
profiler
A tool that measures one or more aspects of a program’s performance.
profiling
The act of measuring where a program spends its time, which operations consume memory or disk space, etc. See also: profiler.
protocol
A set of rules that something promises to obey, i.e., the contract between that thing and its users.
Pythonic
Conforming to common Python programming style and practices.
query parameter
A key-value pair appended to the path portion of a URL.
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. See also: throw exception.
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.
recursion
To define something in terms of itself, or the act of a function invoking itself (directly or indirectly).
Recursive Enumeration pattern
A design pattern that generates the cross product of a set of items using recursive function calls. Each level of recursion adds items from one more set of possibilities to an accumulator.
refactor
To rewrite existing code in order to make it simpler or more efficient without changing its functionality.
reflection
To inspect the properties of a running program in a generic way. Reflection relies on the fact that a program is just another data structure.
register (in code)
To add a function, class, or other object to a lookup table for later use.
register (in hardware)
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). See also: SQL.
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.
reverse lookup
To find the key associated with a particular value in a table.
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-wise storage
To organize the memory of a two-dimensional table so that the values in each row are laid out in contiguous blocks. See also: column-wise storage.
runtime
A program that implements the basic operations used in a programming language.
schema
A specification of the format of a dataset, including the name, format, and content of each table.
scope
A region of a program in which names can be defined without colliding with definitions in other parts of the program. In Python, each module and function creates a new scope.
scoring function
A function that measures how good a solution to a problem is.
search space
The set of all possible solutions to a problem, i.e., the set of possibilities that an algorithm must search through to find an answer.
self-closing tag
A textual marker representing an element in an HTML document that has no content, written <tag/>. A self-closing tag may contain attributes.
semantic versioning
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
A program that waits for requests from clients and sends them data in response.
A binary representation of integers in which one bit indicates whether the value is positive or negative and the remaining bits indicate its magnitude. See also: two’s complement.
signature
The ordered list of parameters and return values that specifies how a function must be called and what it returns.
single stepping
To step through a program one line or instruction at a time.
A communication channel between two computers that provides an interface similar to reading and writing files.
space complexity
The way the memory required by an algorithm grows as a function of the problem size, usually expressed using big-oh notation. See also: time complexity.
spread
To automatically match the values from a list or dictionary supplied by the caller to the parameters of a function.
SQL
The language used for writing queries for a relational database. The term was originally an acronym for Structured Query Language.
stable sort
A sorting algorithm that preserves the original order of items that are considered equal.
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 finds and updates things that are stale.
A predefined communication channel typically used to read input from the keyboard or from the previous process in a pipe. See also: standard error, standard output.
standard output
A predefined communication channel typically used to send output to the screen or to the next process in a pipe. See also: standard error, standard input.
statement
A part of a program that doesn’t produce a value. for loops and if statements are statements in Python. See also: expression.
static method
A function that is defined within a class but does not require either the class itself or an instance of the class as a parameter. See also: class method.
static site generator (SSG)
A software tool that creates HTML pages from templates and content.
A sequence of bytes or other data of variable length that can only be processed in sequential order.
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”.
The file(s) that a build rule will update if they are out-of-date compared to their dependencies.
technical debt
The work that will be required in the future because of limited quick-fix solutions or unaddressed complexity today.
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 fidelity
The degree to which a mock object or other replacement for part or all of a system mimics the behavior of that system for testing purposes.
test-driven development
The practice of writing tests before writing the code to be tested. Research shows that the order doesn’t actually make a difference; what does is alternating in short bursts between testing and coding.
text mode
An option for reading or writing files in which bytes are translated to or from characters and end-of-line markers are normalized. The term is used in contrast with binary mode.
A widely-used pattern for managing exceptions whereby they are raised in many places at low levels of a program but caught in a few high-level places where corrective action can be taken.
time complexity
The way the running time of an algorithm grows as a function of the problem size, usually expressed using big-oh notation. See also: space complexity.
time of check - time of use
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.
tokenizer
A piece of software that groups individual characters together into meaningful tokens.
top-down design
In software design, the practice of writing the more abstract or higher-level parts of the program first, then filling in the details layer by layer. In practice, programmers almost always modify the upper levels as they work on the lower levels, but high-level changes become less common as more of the details are filled in. See also: successive refinement.
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.
Transmission Control Protocol (TCP/IP)
The most popular member of the IP family of protocols. TCP/IP tries to deliver messages reliably and in order so that programs can communicate as if they were reading and writing files.
tree
A graph in which every node except the root has exactly one parent.
truthy
Refers to a value that is treated as true in Boolean expressions. In Python, this includes non-empty strings and lists and numbers other than zero. See also: falsy.
tuple
A value that has a fixed number of parts, such as the three color components of a red-green-blue color specification.
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.
two’s complement
A binary representation of integers that “rolls over” like an odometer to represent negative values. See also: sign and magnitude.
type hint
Extra information added to a program to indicate what data type or types a variable is supposed to have. Type hints are a compromise between static typing and dynamic typing.
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.
unit test
A test that exercises one function or feature of a piece of software and produces pass, fail, or error.
Universal Resource Locator (URL)
A multi-part identifier that specifies something on a computer network. A URL may contain a protocol (such as http), a hostname such as example.com, a port (such as 80), a path (such as /homepage.html), and various other things.
unparsing
The act of turning the data structure generated by a parser back into program text.
upcall
The act of explicitly invoking a method of a parent class from inside a child class. A method in a child class may upcall to the corresponding method in the parent class as part of extending that method.
UTF-32
A way to store the numeric codes representing Unicode characters in which every character is stored as a 32-bit integer.
Short for “variable arguments”, a mechanism that captures any “extra” arguments to a function or method.
variable capture
The process by which a closure “remembers” the variables that were in scope when it was created.
variable-length encoding
Any technique for representing data in which a single logical unit of data may be represented by a variable number of bits or bytes.
vector
A sequence of values, usually of homogeneous type.
version control system
A system for managing changes made to software during its development.
viewport
A class or other data structure whose purpose is to keep track of what can currently be seen by the user.
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. See also: Iterator pattern.
watchpoint
A location or variable being monitored by a debugger. If the value at that location or in that variable changes, the debugger halts and gives the user a chance to inspect the program.
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.
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.
YAML
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-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.
