Computer Science terms in Programming

A variable that builds up a result, such as a running total or product, by being updated with each value processed inside a loop.

A measure of the amount of computing resources, mainly time and memory, that an algorithm uses as the size of its input increases.

A value or expression supplied in a subprogram call, which is copied into the matching parameter.

A symbol that performs a mathematical calculation on numeric values and produces a numeric result.

A fixed-size, ordered collection of elements of the same data type, stored contiguously in memory and accessed by an integer index starting at 0.

A Java class that stores an ordered, indexed collection of objects in an internal array, which it replaces with a larger one automatically when it fills.

A statement that evaluates an expression and stores the result in a variable, replacing any value the variable held before.

The expected number of steps an algorithm performs over all possible inputs of size $n$, assuming each input is equally likely, and the complexity this gives.

The condition in a recursive subprogram under which it returns a result directly, without calling itself again.

The input of a given size $n$ for which an algorithm performs the fewest steps, and the complexity on that input.

A way of describing the time or space complexity of an algorithm by the term that grows fastest as the input size $n$ increases, ignoring constant factors and smaller terms, usually for the worst case.

A search algorithm for a sorted list that compares the target with the middle element of the part still being searched and discards the half that cannot contain it, repeating until the target is found or no elements remain.

A data type with exactly two values, true and false, used to store the result of a condition.

Test data at the limits of the valid range, and just outside them, used to check that the program accepts and rejects values at exactly the right point.

Recursion in which a call of the subprogram can make two or more recursive calls, so the calls form a tree.

A statement that ends the innermost loop immediately and continues with the first statement after the loop; the related continue statement skips the rest of the current pass and starts the next one.

A marker placed on a line of code that makes the debugger pause the program just before that line runs.

A sorting algorithm that makes repeated passes through a list, comparing each pair of adjacent elements and swapping them if they are in the wrong order, until a pass makes no swaps.

An area of main memory that holds data temporarily while it is moved between a program and a slower device such as secondary storage.

A stack maintained by the running program that holds one entry for each subprogram call that has started but not yet returned, with the most recent call on top.

The number of elements a dynamic array can hold in its current block of memory before it must allocate a larger block.

A data type that holds exactly one character, stored as that character's numeric code.

In Java, an exception that the compiler requires a method either to catch or to declare with throws, used for problems outside the program's control.

A queue stored in a fixed-size array in which the front and rear pointers wrap round from the last index to index 0, so slots freed by dequeuing are reused.

Joining two or more strings end to end to make a new string.

A Boolean expression, evaluated while the program runs, whose true or false result controls a selection or a loop.

A loop that repeats its body for as long as a condition remains true (or until it becomes true), so the number of repetitions is not known when the loop starts.

A named value that is set once and cannot be changed while the program runs.

A complexity in which the number of steps stays the same however large the input becomes.

A loop that repeats its body a number of times fixed before the loop starts, using a loop variable that steps through a range of values.

A variable that counts how many times something happens, usually starting at 0 and increased by 1 each time the event occurs.

A way of organising and storing a collection of data items in memory, together with the operations used to access and change them.

A classification of data that sets which values a variable can hold, how they are stored and which operations can be performed on them.

A tool, usually part of an IDE, that runs a program under the programmer's control, pausing it and showing the values of its variables so that errors can be located.

The process of finding, diagnosing and correcting errors in a program.

A statement that introduces a variable to a program, giving its identifier and, in statically typed languages such as Java, its data type.

A character or sequence of characters that marks the boundary between fields in a line of text, such as a comma, a tab or a colon.

A double-ended queue, a data structure that allows items to be added and removed efficiently at both its front and its rear.

The queue operation that removes the item at the front of a queue and returns it.

An algorithm design strategy that divides a problem into smaller sub-problems of the same type, solves each sub-problem recursively, and combines their solutions to solve the original problem.

A data structure whose size can change while the program runs, with memory allocated and released as items are added and removed.

A language feature in which a variable's data type is decided by the value it currently holds and checked only while the program runs.

A single value stored in an array or list, identified by its index.

A selection structure that tests a series of conditions in order and runs only the block belonging to the first condition that is true, with an optional final else block for when none is true.

The condition reached when the file pointer has passed the last character of a file, so that no data is left to read.

The queue operation that adds a new item at the rear of a queue.

Invalid test data, of the wrong type or clearly outside the valid range, that a program should reject without crashing.

An event during the running of a program that disrupts the normal flow of instructions, represented by an object that records the type of error and a message.

A technique in which code that might fail is placed in a block that is monitored for exceptions, and handler code runs if a matching exception occurs, so the program can recover instead of stopping.

A complexity in which the number of steps roughly doubles each time the input size increases by one.

A named collection of data held in secondary storage, which the operating system stores, finds and protects as a single unit.

A reference, returned when a file is opened, that a program uses to read from, write to and close that file.

The setting chosen when a file is opened that fixes which operations are allowed and how the existing contents are treated: read, write (replacing the contents) or append (adding to the end).

The location of a file in a file system, written as the sequence of directories leading to it followed by the file name, either from the root of the file system (absolute) or from the current working directory (relative).

The position in an open file at which the next read or write operation will start; it moves forward automatically after every read or write.

A block attached to a try statement whose code always runs when the try statement ends, whether or not an exception occurred, typically to release resources such as open files.

The rule that the item added earliest is the first to be removed.

A Boolean variable that records whether an event has happened, set to an initial value before a loop and changed when the event occurs, so later code can test it.

A data type for numbers that can have a fractional part, stored to a limited number of significant digits so that most values are approximations.

To write all data waiting in an output buffer to the file on secondary storage, emptying the buffer.

A shape or pattern that contains smaller copies of itself at every scale, so that each part resembles the whole.

The end of a queue from which items are removed, and the operation that returns the item there without removing it; in an array-based queue, a pointer holds its index.

A variable declared outside all subprograms, which can be used anywhere in the program and exists for as long as the program runs.

The name a programmer gives to a variable, constant, subprogram or class so that it can be referred to in code.

The property of a value that cannot be changed after it is created, so any change produces a new value instead.

An algorithm that transforms its data within the memory the data already occupies, using only a constant amount of extra memory, $O(1)$.

A number that identifies the position of an item in a string or other sequence, counting from 0 for the first item.

A loop whose terminating condition is never met, so it repeats without end until the program is stopped from outside.

A data type for whole numbers, positive, negative or zero, with no fractional part.

Division that gives only the whole-number part of the quotient and discards the remainder.

A software application that brings together the tools for writing, running and debugging programs, such as a code editor, a translator and a debugger.

An operation on a stack or queue that returns true if it holds no items and false otherwise.

The control structure in which a block of instructions is repeated, either a set number of times or while a condition remains true.

The rule that the item added most recently is the first to be removed.

A collection of pre-written, tested modules that programs can import to use their subprograms instead of writing the code themselves.

A search algorithm that checks each element of a list in order, from the first, until it finds the target or reaches the end of the list.

A complexity in which the number of steps grows in direct proportion to the input size, so that doubling the input doubles the work.

A complexity in which the number of steps grows in proportion to $n$ multiplied by $\log n$.

Python's built-in ordered, mutable and dynamic sequence, indexed from 0, which grows and shrinks as elements are added and removed.

A variable declared inside a subprogram or block, which can only be used there and exists only while that code is running.

The power to which a base must be raised to give a number, so that ${\log }_{2}n=k$ means $2^k=n$; in computer science, ${\log }_{2}n$ is the number of times $n$ can be halved before reaching 1.

A complexity in which the number of steps grows in proportion to the logarithm of the input size, so that doubling the input adds only a constant amount of work.

An error in the design or code of a program that makes it produce incorrect results or behaviour without stopping it or producing an error message.

How easily a program can be understood, corrected, adapted and extended after it has been written, often by people other than its original author.

The reservation of a region of memory to hold a program's data, either once when a structure is created or repeatedly while the program runs.

Designing a program as a set of separate, self-contained parts (subprograms and modules), each performing one well-defined task and communicating with the others only through parameters and return values.

A separate file of related subprograms, constants and classes that other programs can import and use.

An operation that gives the remainder left over after integer division.

A loop placed inside the body of another loop, so the inner loop runs through all of its passes for each pass of the outer loop.

A selection structure placed inside one of the blocks of another selection structure, so the inner condition is tested only when the outer branch has been taken.

An invisible control character that marks the end of a line in a text file, written \n in Python and Java strings.

Recursion in which each call of the subprogram makes at most one recursive call, so the calls form a single chain from the first call to the base case.

Valid test data of the kind a program is expected to handle in everyday use, which it should accept and process correctly.

A variable named in a subprogram's definition that receives a value when the subprogram is called, and exists only while the subprogram runs.

Analysing a string to break it into its component parts, such as the fields of a record, and converting them into data the program can use.

In quicksort, the step that rearranges part of a list so that all elements smaller than the pivot come before it and all others come after it, leaving the pivot in its final sorted position.

One complete traversal of the unsorted part of a list by a sorting algorithm, after which at least one more element is in its final position.

A way of passing arguments in which the subprogram receives a copy of each argument's value, so assigning a new value to a parameter does not change the caller's variable.

The stack operation that returns the item at the top of a stack without removing it.

Storage that keeps data after the program that created it has ended and after the power is switched off.

The element chosen in each step of quicksort against which every other element in the current part of the list is compared.

The stack operation that removes the item at the top of a stack and returns it.

A conditional loop that tests its condition after each pass, so the body always runs at least once.

A conditional loop that tests its condition before each pass, so the body runs zero times if the condition is false at the start.

A basic data type built into a programming language that holds a single simple value and is stored directly, not as an object.

A debugging technique in which temporary output statements are added to a program to display the values of variables, or which parts of the code run, while it executes.

The stack operation that adds a new item to the top of a stack.

A complexity in which the number of steps grows in proportion to the square of the input size, so that doubling the input multiplies the work by four.

A data structure in which items are added at one end, the rear, and removed from the other end, the front, so items leave in the order they arrived.

A divide-and-conquer sorting algorithm that chooses a pivot element, partitions the list so that smaller elements come before the pivot and the others after it, and then sorts the two parts recursively.

A fault in which the result of a program depends on the timing or order in which two or more processes or threads access shared data, so the same program can give different results on different runs.

The end of a queue at which new items are added; in an array-based queue, a pointer holds the index of the last item.

A technique in which a subprogram solves a problem by calling itself on a smaller or simpler instance of the same problem, until it reaches an instance simple enough to solve directly.

The part of a recursive subprogram that calls the subprogram again with an argument that is closer to the base case, and uses the result of that call to build its own result.

The value that a subprogram sends back to the point where it was called, using a return statement, which also ends the subprogram.

The extent to which code, once written and tested, can be used again in other parts of the same program or in other programs without being rewritten.

An error that occurs while a program is running, when an operation cannot be carried out, causing the program to stop unless the error is handled.

The region of a program in which a particular identifier can be used.

The control structure in which a condition is tested and its result decides which block of instructions runs next.

A sorting algorithm that repeatedly finds the smallest element in the unsorted part of a list and swaps it with the first element of the unsorted part, so that the sorted part grows by one element per pass.

A special input value, outside the range of valid data, that signals the end of the data and stops a loop.

The control structure in which instructions are carried out one after another, in the order in which they are written.

A file whose records are read or written one after another in order, from the start of the file towards the end.

The situation in which a local variable has the same identifier as a variable in an outer scope, so the outer variable is hidden inside the inner scope.

Arranging the elements of a list into a defined order, such as ascending or descending numerical or alphabetical order, according to a key.

A description of how the amount of extra memory an algorithm needs, beyond the memory holding its input, grows as the size of its input, $n$, increases.

A sorting algorithm that keeps elements with equal keys in the same relative order as they had before sorting.

A data structure in which items are added and removed at one end only, called the top, so the most recently added item is always the first removed.

The entry on the call stack for one subprogram call, holding its parameters, its local variables and the return address where execution continues when the call finishes.

The error that occurs when a program tries to push an item onto a stack that is already full.

The error that occurs when a program tries to pop or peek an item from an empty stack.

A data structure whose size is fixed when it is created and cannot change while the program runs.

A language feature in which each variable's data type is fixed when the code is written and checked before the program runs.

Running a paused program one statement at a time under a debugger, so the effect of each statement can be seen.

A data type for a sequence of characters, written between quotation marks.

A named, self-contained block of code that performs one specific task and can be run from other parts of a program by using its name; called a function in Python and a method in Java.

A statement or expression that runs a subprogram by name, passing it any values it needs, after which control returns to the point just after the call.

A sequence of consecutive characters taken from within a longer string.

The exchange of the values held in two positions of a list or array, done with a temporary variable so that neither value is lost.

An error in which code breaks the grammar rules of the programming language, so the program cannot be translated or run.

Running a program with planned input data and comparing the actual results with the expected results, to find errors and show that the program meets its requirements.

A file whose contents are a sequence of characters in a character set, organised into lines, which can be read and edited by a person with a text editor.

To signal an exception deliberately in code, with throw in Java or raise in Python, so that normal execution stops and a handler is sought.

A description of how the number of basic steps an algorithm performs grows as the size of its input, $n$, increases.

A variable holding the index of the item currently at the top of an array-based stack, or −1 when the stack is empty.

Visiting every element of a data structure exactly once, in a systematic order, usually to read or process each one.

A statement that opens one or more resources, such as files, for the duration of a block of code and closes them automatically when the block ends, whether it ends normally or because of an exception.

An ordered, immutable sequence in Python, written in round brackets, whose elements can be read by index but whose length and contents cannot change after creation.

An array whose elements are themselves arrays of equal length, used to store a table of rows and columns; each element is accessed with a row index and a column index.

Converting a value from one data type to another.

The phase of recursion after the base case is reached, in which each call returns its result to the call below it and its stack frame is popped, until the original call returns.

An automatic check that input data is reasonable and follows set rules (for example present, of the correct type, within a range, or of the correct length or format) before a program uses it.

A named storage location in memory that holds a value which can change while the program runs.

A subprogram that carries out an action but returns no value to its caller; in Java its return type is written void.

A variable or expression chosen by the programmer whose current value the debugger displays and updates each time the paused program advances.

The input of a given size $n$ for which an algorithm performs the most steps, and the complexity on that input.