Component 2.1 Comp

Abstraction

Removing unnecessary detail from a problem so you only focus on what is important.

Decomposition

Breaking a complex problem down into smaller, more manageable sub

Algorithmic Thinking

Producing a logical step

Algorithm

A set of step

Input

Any data or information sent into a program or system for processing.

Process

Any action, calculation, or manipulation performed on data during a program's execution.

Output

Any data or information sent out of a system or program after processing.

Structure Diagram

A hierarchical diagram used in decomposition to show how a large problem is broken down into smaller sub

Pseudocode

A simple, language

Flowchart

A graphical representation of an algorithm using standard shapes to show the flow of execution.

Start/Stop Symbol

A flowchart shape (rounded rectangle) used to indicate the beginning or end of an algorithm.

Process Symbol

A flowchart shape (rectangle) used for calculations, assignments, or internal operations.

Input/Output Symbol

A flowchart shape (parallelogram) used to represent data entering or leaving the system.

Decision Symbol

A flowchart shape (diamond) used for branching or conditional checks (e.g., IF statements).

Syntax Error

An error where the code breaks the grammatical rules of the programming language, preventing the program from running.

Logic Error

An error where the program runs without crashing, but produces incorrect or unexpected results due to flawed design.

Runtime Error

An error that occurs while a program is running, such as dividing by zero, causing it to crash.

Trace Table

A tool used to test an algorithm step

Test Data

Input values chosen to test whether a program or algorithm works correctly under various conditions.

Normal Test Data

Data that is typical, valid, and expected to be accepted by the program (e.g., age 25).

Boundary Test Data

Data that sits right on the extreme edges of valid input limits (e.g., 0 and 120 for age).

Erroneous Test Data

Invalid data that the program should reject or throw an error for (e.g., text instead of a number, or negative age).

Linear Search

A searching algorithm that checks every item in a list sequentially from start to finish until the target is found.

Binary Search

A searching algorithm used on an ordered list that repeatedly checks the middle item and discards half of the remaining elements.

Bubble Sort

A sorting algorithm that compares adjacent pairs of items, swaps them if out of order, and repeats until sorted.

Merge Sort

A divide

Insertion Sort

A sorting algorithm that builds a sorted list one item at a time by inserting each new element into its correct place.

Divide and Conquer

A problem

Ordered List

A list of items sorted into a specific sequence (ascending or descending), which is required for a binary search.

Unordered List

A list of items in no particular sequence, which requires a linear search to find a specific element.

Midpoint

The middle position of a sub

Adjacent Elements

Two items sitting directly next to each other in a list, which are compared during a bubble sort.

Swapping

The action of exchanging the positions of two items in a list if they are in the wrong order.

Sub

problem

Efficiency

A measure of how many computational resources (such as time or memory) an algorithm uses.

Iteration

The repetition of a block of code or steps within an algorithm (e.g., loops like FOR or WHILE).

Selection

A decision

Sequence

The order in which instructions or steps are executed in an algorithm, one after another.

Assignment

Giving a value to a variable within an algorithm or program (often represented by an arrow or equals sign).

Variable

A named storage location in computer memory that holds data which can change while the program is running.