ICDL Coding Principles (ICDL) key terms

A way of tackling problems by breaking them down, spotting patterns, ignoring irrelevant detail and describing a solution as a precise sequence of steps that a computer could follow.

An ordered set of unambiguous steps that, when followed, solves a particular problem or completes a task; it must finish after a limited number of steps and give a predictable result.

Splitting a large or complex problem into smaller, more manageable parts that can each be solved, tested and understood separately, then combined to give the overall solution.

Removing or hiding detail that is not needed for the task in hand so that the important features of a problem stand out and the solution stays simple.

Looking for similarities, repetition or trends in problems and their data so that a solution already worked out can be reused or generalised instead of invented again.

A structured, plain-language description of an algorithm that borrows words from programming but is not tied to any real language's grammar, so the logic can be agreed before code is written.

A diagram that shows the steps of an algorithm as shapes joined by arrows, with separate shapes for processes, decisions and inputs or outputs, so the order of actions is easy to follow.

The human-readable text of a program, written by a person in a programming language, which is later translated or interpreted so the computer can carry out the instructions.

The set of grammar rules that decides how the words, symbols and punctuation of a programming language may be arranged, so a piece of code is either accepted or rejected as malformed.

A name a programmer gives to something in a program, such as a variable, function or constant, so it can be referred to later; rules usually forbid spaces and starting with a digit.

A named block of code that performs one task, can receive values, may return a result and can be called repeatedly from elsewhere instead of being rewritten.

A named placeholder in a function's definition that stands for a value the function expects to be given each time it is called.

The actual value supplied to a function when it is called, which is matched to the function's parameters so the code inside can make use of it.

A collection of ready-made code, such as functions or routines, that a programmer can bring into their own program rather than writing the same features from scratch.

Text written inside a program for human readers only, ignored when the code runs, used to explain what the code does or why a particular choice was made.

A program that takes a whole file of source code, checks its syntax and translates it into machine code that can be run later without the translator being present.

A program that reads source code and carries out its instructions one statement at a time, stopping when it meets something it cannot process.

A named storage location in a program whose stored value can be changed while the program runs, for example a score or a running total.

A classification that says what kind of values something may hold, such as whole numbers, decimal numbers, text or true/false, and therefore which operations make sense on it.

A named value that is set once and deliberately cannot be changed while the program runs, used for fixed quantities such as a tax rate or the number of days in a week.

A statement that puts a value into a variable or constant, replacing whatever was stored there before; the name goes on the left and the value or expression on the right.

A symbol or word that acts on one or more values to produce a result, for example adding numbers, comparing two values or combining true/false conditions.

A data type with exactly two possible values, true and false, produced by comparisons and combined with logical operators to drive decisions in a program.

A construct that runs one block of code or another depending on whether a tested condition is true or false, letting a program choose between alternative paths.

A construct that repeats a block of code, either a set number of times or while a condition remains true, so the same instructions need not be written out again.

A single named collection holding several values of the same type in a fixed order, each reached by its position number so a loop can process them one by one.

The position number used to pick out one item in an array or list, often starting at zero, so code can read or replace a specific element.

The part of a program in which a particular name is recognised and can be used; a name declared inside a function is normally invisible outside that function.

A mistake or flaw in a program that makes it behave differently from what is intended, ranging from a typing slip to a piece of faulty reasoning.

The process of finding, understanding and fixing the cause of a fault in a program, often by reproducing it, inspecting values and then re-running the code.

A fault that occurs when code breaks the grammar rules of the language, such as a missing bracket or a misspelled keyword; the translator usually reports it before the program can run.

A fault where the code is written correctly but the reasoning behind it is wrong, so the program runs and produces an incorrect result without any error message.

A defined set of inputs, preconditions and expected outputs used to check that a particular part of a program behaves as it should.

The values chosen and fed into a program during testing, deliberately including normal, extreme and invalid examples so that weaknesses are exposed.

A test input sitting at the edge of an allowed range, such as the smallest, largest or just-outside value, because mistakes often gather at those limits.

A marker set on a line of code in a debugging tool that pauses the running program there, so the programmer can inspect current values before continuing.

Working through an algorithm or a short section of code by hand, recording the value of each variable at every step, to check the logic without a computer.

Checking one small, isolated piece of a program, usually a single function, against known inputs and expected outputs, often automatically and repeatedly.

Material written for the people who maintain or extend a program, describing how the code is structured, what each part does and how to install or change it.

Instructions written for the people who will use the finished software rather than build it, covering what the program does, how to install it and how to complete common tasks.