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.
The extra (avoidable) complexity introduced by poor design choices. The term is used in contrast with intrinsic complexity.
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.
A design pattern that rearranges parameters, provides extra values, or does other work so that one function can be called by another.
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.
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.
A value passed to a function when it is called.
See also: parameter.
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.
A low-level programming language whose statements correspond closely to the actual instruction set of a particular kind of processor.
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.
See also: synchronous.
A name-value pair associated with an object, used to store metadata about the object such as an array's dimensions.
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.
See also: Makefile.
A property of a system that enables interoperability with an older legacy system, or with input designed for such a system.
An object that isn't an instance of any particular class.
An operation that manipulates individual bits in memory. Common bitwise operations include and, or, not, and xor.
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 #.
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.
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.
See also: depth-first.
An instruction to a debugger telling it to suspend execution whenever a specific point in the program (such as a particular line) is reached.
See also: watchpoint.
A missing or undesirable feature of a piece of software.
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.
See also: build rule, dependency, Makefile.
The part of a build rule that describes how to update something that has fallen out-of-date.
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.
A set of instructions designed to be executed efficiently by an interpreter.
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.
To save a copy of some data in a local cache to make future access faster.
A data structure that stores information about the active subroutines executed.
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.
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.
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.
The amount of working memory needed to accomplish a set of simultaneous tasks.
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.
Storing each column of a two-dimensional array as one block of memory so that elements in the same row are far apart.
See also: row-major storage.
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.
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.
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).
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.
An application that translates programs written in some languages into machine instructions or byte code.
The tendency for someone to look for evidence that they are right rather than searching for reasons why they might be wrong.
A computer terminal where a user may enter commands, or a program, such as a shell that simulates such a device.
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.
A two-dimensional data structure for storing tabular data in memory. Rows represent records and columns represent fields.
Moving data from one location or format to another. The term refers to translating data from an old format to a newer one.
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.
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 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.
A program that runs other programs, or a function that drives all of the other functions in a program.
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.
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.
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.
Matching as much as possible, as early as possible.
A term borrowed from gaming meaning to do something with obstacles or difficulties simplified or removed, often for practice purposes.
A connection between two nodes in a graph. An edge may have data associated with it, such as a name or distance.
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.
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.
To store data inside some kind of structure so that it is only accessible through that structure.
Where a program begins executing.
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.
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.
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.
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.
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.
See also: actual result (of test).
A software development methodology in which requirements emerge or change as the software is being written, often in response to results from early runs.
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.
A component of a record containing a single value. Every record in a database table has the same fields.
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.
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").
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.
The thing on which a test is run, such as the parameters to the function being tested or the file being processed.
A style of object-oriented programming in which methods return objects so that other methods can immediately be called.
Proving the correctness of an algorithm, program, or piece of hardware using mathematical techniques.
The process of identifying memory that has been allocated but is no longer in use and reclaiming it to be re-used.
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.
See also: Iterator pattern.
A collection of functions with similar purpose, each operating on a different class of data.
A variable defined outside any particular function or package namespace, which is therefore visible to all functions.
See also: local variable.
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".
A plot or a chart that displays data, or a data structure in which nodes are connected to one another by edges.
See also: tree.
An algorithm that consumes as much input as possible, as early as possible.
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.
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.
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.
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.
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.
See also: homogeneous.
A rule or guideline that isn't guaranteed to produce the desired result, but usually does.
Containing a single data type. For example, a vector must be homogeneous: its values must all be numeric, logical, etc.
See also: heterogeneous.
The standard markup language used for web pages. HTML is represented in memory using DOM (Digital Object Model).
See also: XML.
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.
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.
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.
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.
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.
The basic operations that a particular processor can execute directly.
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.
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.
The unavoidable complexity inherent in a problem that any solution must deal with. The term is used in contrast with accidental complexity.
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 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.
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.
See also: Visitor pattern.
See also: YAML.
An operation that combines two tables, typically by matching keys from one with keys from another.
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.
label (address in memory)
A human-readable name given to a particular location in memory when writing programs in assembly code.
A piece of software that decides where to place text, images, and other elements on a page.
Matching as little as possible while still finding a valid match.
See also: eager matching.
Least Recently Used cache (LRU cache)
A cache that discards items that have not been used recently in order to limit memory requirements.
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.
An installable collection of software, also often called a module or package.
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.
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.
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.
A programming paradigm that mixes prose and code so that explanations and instructions are side by side.
A function whose job is to read files containing runnable code into memory and make that code available to the calling program.
A variable defined inside a function which is only visible within that function.
See also: closure, global variable.
A status report or error message written to a file as a program runs.
The statement or statements executed by a loop.
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.
See also: tightly coupled.
Originally short for "macro-instruction", an instruction to translate some of the text into a program into other text before using it.
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.
An implementation of a generic function that handles objects of a specific class.
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().
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.
A program that finds all the dependencies of a set of source files and combines them into a single loadable file.
Capable of performing several operations simultaneously. Multi-threaded programs are usually more efficient than single-threaded ones, but also harder to understand and debug.
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.
See also: call stack.
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.
See also: name collision, scope.
A function that is defined inside another function.
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.
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).
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.
The numerical code for a particular instruction that a processor can execute.
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.
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.
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.
A variable specified in a function definition that is assigned a value when the function is called.
See also: argument.
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 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.
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.
A style of application design in which the main program loads and runs small independent modules that do the bulk of the work.
Having many different implementations of the same interface. If a set of functions or objects are polymorphic, they can be called interchangeably.
Something that is guaranteed to be true after a function runs successfully. Post-conditions are often expressed as assertions that are guaranteed to be be true of a function's results.
See also: design by contract, 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.
See also: design by contract, post-condition.
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.
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.
See also: promisification.
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.
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.
A value generated in a repeatable way that resembles the true randomness of the universe well enough to fool observers.
The portion of a URL after the question mark ? that specifies extra parameters for the HTTP request as name-value pairs.
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).
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.
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.
A small piece of memory (typically one word long) built into a processor that operations can refer to directly.
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.
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.
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.
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".
See also: absolute path.
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.
Storing each row of a two-dimensional array as one block of memory so that elements in the same column are far apart.
See also: column-major storage.
Slow but steady increase in a project's goals after the project starts.
A function that measures or estimates how good a solution to a problem is.
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.
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).
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.
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.
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.
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.
A table used to translate a piece of code back to the lines in the original source.
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.
The language used for writing queries for a relational database. The term was originally an acronym for Structured Query Language.
A section of the call stack that records details of a single call to a specific function.
A software tool that creates HTML pages from templates and content.
A sequential flow of data, such as the bits arriving across a network connection or the bytes read from a file.
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".
A block of text in a program. The term is short for "character string".
The process of inserting text corresponding to specified values into a string, usually to make output human-readable.
To happen at the same time. In programming, synchronous operations are ones that have to run simultaneously, or complete at the same time.
See also: asynchronous.
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.
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.
See also: loosely coupled.
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.
A digital identifier showing the time at which something was created or accessed. Timestamps should use ISO date format for portability.
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.
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.
The set of all nodes in a graph that are reachable from a starting node, either directly or indirectly.
A value that has a fixed number of parts, such as the three color components of a red-green-blue color specification.
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.
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.
A test that exercises one function or feature of a piece of software and produces pass, fail, or error.
A system for managing changes made to software during its development.
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.
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.
An instruction for a debugger telling it to suspect execution whenever the value of a variable (or more generally an expression) changes.
See also: breakpoint.
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.
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.
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.
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.