Code programming constructs including variables, data types, operators, control structures, functions and arrays to implement an algorithm as a working, testable digital solution

What this dot point is asking

QCAA wants you to translate an algorithm into working code using the core constructs every imperative language shares: variables and data types, operators, control structures, functions and collections such as arrays. In IA2 you build a digital solution, so your code must run, be readable and be testable. The examples below use Python, the most common Queensland school language, but the constructs map directly to JavaScript or any procedural language.

Variables, data types and operators

A variable is a named store for a value. Each value has a data type that fixes what operations are valid: integer, float, string, Boolean. Choosing the right type matters for both correctness and storage efficiency.

age = 17              # int
gpa = 6.25            # float
name = "Priya"        # string
is_enrolled = True    # bool

Operators fall into groups: arithmetic (+ - * / // % **), relational (== != < > <= >=) and logical (and or not). The // operator is integer division and % is modulo, both useful for digit manipulation and even/odd tests.

Control structures in code

Selection and iteration look almost identical to pseudocode, which is why a clean algorithm translates quickly.

def classify(mark):
    if mark >= 85:
        return "A"
    elif mark >= 70:
        return "B"
    elif mark >= 50:
        return "C"
    else:
        return "Fail"

total = 0
for n in range(1, 11):     # 1..10 inclusive
    if n % 2 == 0:
        total += n
print(total)               # 30

range(1, 11) stops before 11, a deliberate convention that prevents off-by-one errors once you internalise it.

Functions and parameters

A function packages logic behind a name so it can be reused and tested in isolation. It takes parameters (inputs) and usually returns a value (output). Functions are the main tool for managing complexity: decompose a large problem into small, independently testable units.

Arrays and lists

A collection stores many values under one name, indexed from 0. You process collections with a loop, which is the foundation of data-driven solutions.

marks = [55, 88, 72, 49, 91]
total = 0
for m in marks:
    total += m
average = total / len(marks)
print(round(average, 1))     # 71.0

Indexing (marks[0] is 55), slicing and built-in functions (sum, max, min, len) make collection handling concise, but you should still be able to write the manual loop, because QCAA may ask you to demonstrate the underlying logic.

Writing testable code

A digital solution must be verifiable. Good practice:

• keep functions short and single-purpose;
• use clear identifiers and comments that explain why, not what;
• separate input, processing and output;
• write test cases that include normal, boundary and erroneous data.

Testing with a table of inputs and expected outputs is direct evidence for the IA2 evaluation criterion.

How this appears in IA2

IA2 is a digital solution: working, documented code that meets the prescribed requirements. Markers look for correct use of constructs, decomposition into functions, validation of inputs and a clear test plan showing the solution behaves correctly across normal and edge cases. Submit code that runs, annotate the non-obvious parts, and pair it with evidence (screenshots or a test table) that each requirement is met.