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.

🎬 What is pseudocode?

🎯 Watch for: the core idea — pseudocode describes what the algorithm does in plain, structured steps, without committing to any one programming language.

✍️ While you watch: write down the one sentence that best explains why we bother with pseudocode instead of going straight to code.

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 1 — 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.

Worked example 2 — one algorithm, any machine

Pseudocode's superpower is that it is language- and machine-independent. Here is a complete algorithm — the wall-follower, or right-hand rule, for escaping a maze — written once and able to run anywhere: in your head, in a software simulation, or on a Lego robot.

The rule is simple: keep your right hand on the wall and never lift it. In any maze whose walls are all connected, following it will always bring you to the exit.

A maze with an entrance at the top-left and an exit at the bottom-right

Trace it yourself: start at the top-left entrance and keep your right hand on the wall. Where do you come out? (Background reading: Wikipedia — Maze-solving algorithm.)

The same idea in VCAA pseudocode:

START at the maze entrance

WHILE not at the exit DO
    IF the right-hand side is open THEN
        // an opening — follow the wall around the corner
        turn right
        step forward
    ELSE IF the way ahead is clear THEN
        // keep moving, right hand sliding along the wall
        step forward
    ELSE IF only the left is open THEN
        // wall ahead and on the right
        turn left
        step forward
    ELSE
        // dead end — walls on three sides
        turn around
    ENDIF
ENDWHILE

OUTPUT "Hooray! I escaped the maze!"

There is no Python and no Java here — nothing tied to one language. That is exactly what makes it pseudocode.

Now watch the same rule run on two completely different machines:

🎯 Watch for: the right-hand rule as a software simulation — the logic is identical to the pseudocode above.

🎯 Watch for: the very same rule driving a physical Lego EV3 robot through a real maze — same algorithm, different machine.

Note

Activity — why does the right-hand rule work? Write two or three sentences. Hint: picture a wall that is connected to the outer boundary of the maze. If you trace its edge without ever letting go, can you ever get stuck in a loop — or must you eventually walk the whole of that wall, including the stretch that contains the exit?

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.

Credits

Maze diagram — Grufo, via Wikimedia Commons, licensed GPLv3.