> **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. {{Video|src=https://www.youtube.com/watch?v=wKe31Xi2Ck8}} **✍️ 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: 1. **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. 2. **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`<br> `action_1`<br>`ELSE`<br> `action_2`<br>`ENDIF` | `if condition:`<br> `action_1`<br>`else:`<br> `action_2` | Must close with `ENDIF`. Chained: use `ELSE IF … THEN`. | | `CASE OF variable`<br> `value1: action_1`<br> `value2 TO value3: action_2`<br> `OTHERWISE action_3`<br>`ENDCASE` | `if variable == value1:`<br> `action_1`<br>`elif value2 <= variable <= value3:`<br> `action_2`<br>`else:`<br> `action_3` | CASE has no direct Python equivalent; use it when there are many branches. | ### Iteration | Pseudocode | Python | Notes | |---|---|---| | `WHILE condition DO`<br> `action_1`<br>`ENDWHILE` | `while condition:`<br> `action_1` | Pre-test loop. Must close with `ENDWHILE`. | | `REPEAT`<br> `action_1`<br>`UNTIL condition` | `while True:`<br> `action_1`<br> `if condition: break` | Post-test loop — body always runs at least once. | | `FOR count ← a TO b STEP 1`<br> `action_1`<br>`ENDFOR` | `for count in range(a, b+1, 1):`<br> `action_1` | Count-controlled. Must close with `ENDFOR`. | | `FOREACH item IN seq`<br> `action_1`<br>`NEXT item` | `for item in seq:`<br> `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)`<br> `action_1`<br> `RETURN expression`<br>`END` | `def fun(arg1, arg2):`<br> `action_1`<br> `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.  *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](https://en.wikipedia.org/wiki/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. {{Video|src=https://www.youtube.com/watch?v=mFOSd44_NfA}} **🎯 Watch for:** the very same rule driving a physical Lego EV3 robot through a real maze — same algorithm, different machine. {{Video|src=https://www.youtube.com/watch?v=AdOLnKFzBoM}} > [!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 1. Rewrite this Python line as valid VCAA pseudocode: `score = score + 1` >| **Answer:** `score ← score + 1` — assignment uses `←`, not `=`. 2. 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 `<>`. 3. 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](https://commons.wikimedia.org/wiki/User:Grufo), via Wikimedia Commons, licensed GPLv3. --- ## See also - [IPO Charts — Process Means Steps](/sd/C05/IPO%20Charts%20-%20Process%20Means%20Steps) — turn an IPO Process column into formal pseudocode - [Object Descriptions and Class Diagrams](/sd/C05/Object%20Descriptions%20and%20Class%20Diagrams) — the methods you write pseudocode for come from here - [C05 Resources](/sd/Resources/C05-Resources) --- ← Back to [C05 Home](/sd/C05/C05-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)