DRAFT — under teacher review.

VCAA Pseudocode — Write Structured English, Not Python

The Hamilton and Alexandra College · Year 12 · 2026

If you can already code in Python, pseudocode feels like a step backwards — why write count ← 5 when count = 5 is right there? The answer: VCAA assessors are checking whether you can express an algorithm clearly and independently of any language. Python-flavoured pseudocode loses marks. This page maps every construct you need.

🎬 Watch

Note

Video coming soon.

🎯 Watch for: how to translate a working Python method into clean VCAA pseudocode, keeping the logic identical while swapping Python syntax for language-independent Structured English.

The two rules that actually matter

Before the big table, pin these two rules — they matter more than any single symbol:

Be consistent. If you open a block with BEGIN, close it with END throughout. If you use WHILE … ENDWHILE, don't switch to WHILE … END_WHILE two lines later.
Write at a clear high level. You do not need to encode every trivial detail. "Load data.csv into an array of records" is perfectly acceptable pseudocode when it is self-explanatory.

Pseudocode ↔ Python comparison

Program structure and basics

Pseudocode	Python	Notes
`START` … `STOP` or `BEGIN` … `END`	(not required)	Brackets a whole program or subprogram. Pick one style and stick to it.
`count ← 5`	`count = 5`	Assignment uses a left-arrow `←`, not `=` or `:=`.
`// comment` or `# comment`	`# comment`	Comments work in pseudocode too — use them.

Selection

Pseudocode	Python	Notes
`IF condition THEN` `action_1` `ELSE` `action_2` `ENDIF`	`if condition:` `action_1` `else:` `action_2`	Must close with `ENDIF`. Chained: use `ELSE IF … THEN`.
`CASE OF variable` `value1: action_1` `value2 TO value3: action_2` `OTHERWISE action_3` `ENDCASE`	`if variable == value1:` `action_1` `elif value2 <= variable <= value3:` `action_2` `else:` `action_3`	CASE has no direct Python equivalent; use it when there are many branches.

Iteration

Pseudocode	Python	Notes
`WHILE condition DO` `action_1` `ENDWHILE`	`while condition:` `action_1`	Pre-test loop. Must close with `ENDWHILE`.
`REPEAT` `action_1` `UNTIL condition`	`while True:` `action_1` `if condition: break`	Post-test loop — body always runs at least once.
`FOR count ← a TO b STEP 1` `action_1` `ENDFOR`	`for count in range(a, b+1, 1):` `action_1`	Count-controlled. Must close with `ENDFOR`.
`FOREACH item IN seq` `action_1` `NEXT item`	`for item in seq:` `action_1`	Iterates over a sequence. Close with `NEXT item`.

Operators

Pseudocode	Python	Notes
`=`	`==`	Equality test in pseudocode is `=`, not `==`.
`<>`	`!=`	Not-equals in pseudocode is `<>`. Never use `!=` in pseudocode.
`>, <, <=, >=`	`>, <, <=, >=`	Same symbols in both.
`AND, OR, NOT`	`and, or, not`	Uppercase in pseudocode.
`+, -, *, /, ^`	`+, -, , /, *`	Pseudocode uses `^` for exponentiation; Python uses `**`.
`MOD` or `%`	`%`	Integer remainder.
`DIV`	`//`	Integer division.

Subprograms (methods / functions / procedures)

Pseudocode	Python	Notes
`BEGIN fun(arg1, arg2)` `action_1` `RETURN expression` `END`	`def fun(arg1, arg2):` `action_1` `return expression`	`BEGIN`/`END` bracket the subprogram. `RETURN` ends a function; omit it for a procedure.

Worked example — a method inside a class

This is the Level-9 OOP pseudocode skill. You are writing a method, not a standalone program, so you use BEGIN/END rather than START/STOP.

Scenario: a ScoreTracker class has a method is_passing that returns whether a student's average score meets a threshold.

BEGIN is_passing(scores, threshold)
    total ← 0
    FOREACH score IN scores
        total ← total + score
    NEXT score
    average ← total / length(scores)
    IF average >= threshold THEN
        RETURN True
    ELSE
        RETURN False
    ENDIF
END

Notice:

Assignment is ← throughout — never = or ==.
Not-equals would be <> if needed (e.g. IF count <> 0 THEN).
FOREACH … NEXT item closes the loop.
IF … THEN … ELSE … ENDIF closes the selection.
Indentation is consistent.

Tip

You do not need to write out every getter and setter in full. If a step is clear — "retrieve the current user record from the database" — that single line is enough. Save detailed pseudocode for the logic that actually matters in your design.

Common mistakes

Mistake 1 — Using `=` or `==` for assignment

~~count = 5~~ or ~~count == 5~~

Correct: count ← 5. The left-arrow shows data flowing into the variable. Using = is Python; using == is a comparison, not assignment.

Mistake 2 — Using `!=` for not-equals

~~IF count != 0 THEN~~

Correct: IF count <> 0 THEN. The != operator belongs only in Python code.

Mistake 3 — Python-only constructs leaking in

~~for item in list:~~ or ~~elif~~ or ~~print(x)~~

Use FOREACH item IN list … NEXT item, ELSE IF … THEN, and OUTPUT x instead.

Mistake 4 — Forgetting closing keywords

Every block that opens must close. Missing ENDIF, ENDWHILE, ENDFOR, or ENDCASE is a consistency error. Markers notice immediately.

Mistake 5 — Inconsistent block keywords

~~Opening with BEGIN but closing with STOP~~

Pick BEGIN/END or START/STOP and use it everywhere in the same document.

Check Your Understanding

Rewrite this Python line as valid VCAA pseudocode: score = score + 1

...

Answer: score ← score + 1 — assignment uses ←, not =.

A classmate writes IF x != 0 THEN … ENDIF. Name the mistake and write the corrected line.

...

Answer: != is Python syntax, not pseudocode. Correct: IF x <> 0 THEN … ENDIF. The not-equals operator in VCAA pseudocode is always <>.

You have a WHILE loop and an IF statement nested inside it. List the two closing keywords you need and the order they must appear.

...

Answer: ENDIF closes the inner IF first, then ENDWHILE closes the outer loop. Inner blocks always close before outer blocks.