Free KS3 Algorithms Cover Lesson: Paper Robot, No Tech + Answers
A complete 60-minute KS3 Computing cover lesson on algorithms and debugging that needs no computers, logins or printing. It includes a word-for-word supervisor script, timings and a full answer key.
Your Computing teacher is off, the room may have no working PCs, and the person covering may not be a computing specialist. This lesson is written for that situation. Students write and fix instructions for a "paper robot" on a grid. It covers algorithms, sequencing, tracing and debugging, which are core ideas in KS3 Computing.
You need: a whiteboard, exercise books or lined paper, and pens. Printing is optional. Everything students need can be copied from the board.
Suits: Years 7 to 9. Year 7 can stop after Task 4. Years 8 and 9 should get as far as the extension.
Lesson at a glance (60 minutes)
- Starter: what is an algorithm? (5 min)
- Set up the grid (5 min)
- Task 1: trace a program (10 min)
- Task 2: write your own program (10 min)
- Task 3: get around a wall (12 min)
- Task 4: find and fix the bugs (10 min)
- Extension and plenary: loops (8 min)
Board setup (do this before students arrive)
Draw a 6 by 6 grid. Label the columns A to F from left to right along the bottom, and the rows 1 to 6 from bottom to top. Write this key next to it:
- F = move forward one square
- R = turn right 90 degrees on the spot (do not move)
- L = turn left 90 degrees on the spot (do not move)
Write: The robot always starts on A1 (bottom left), facing up the page (towards row 6).
Supervisor script
You can read these lines out word for word.
Starter (5 min): "Today's lesson is about algorithms. An algorithm is a precise set of step-by-step instructions to solve a problem. Computers can't guess what you mean. They do exactly what they are told, in order. In your books, write the title 'Paper Robot Algorithms' and the date. Then write one sentence that answers this: why do instructions for a computer have to be more exact than instructions for a person?"
Take two or three answers. A good one is: "A computer follows instructions exactly and can't fill in missing steps or fix mistakes itself."
Grid setup (5 min): "Copy the 6 by 6 grid and the key from the board into your book. Make each square about the size of two lines of your book. Label the columns A to F along the bottom and the rows 1 to 6 up the side."
Before each task: "Read the task on the board. Work on your own in silence for the first five minutes, then you can check with the person next to you." When the time is up, read out the answers from the answer key below.
If a student says they are stuck: "Put your finger on A1, pointing up. Do one letter at a time and move your finger." This fixes most problems.
The tasks (copy onto the board)
Task 1: Trace the program
The robot runs this program:
F F R F F F L F
a) Which square does the robot finish on? b) Which way is it facing at the end? c) Draw its path on your grid.
Task 2: Write your own program
Write a program that moves the robot from A1 to F6 (top right).
a) Write your program. b) Count the commands. Can you write a shorter one? c) Swap with a partner and trace each other's program. Does it work?
Task 3: Get around the wall
Shade in squares A4, B4, C4, D4 and E4. These are a wall. The robot will crash if it moves onto one of these squares or off the grid. F4 is the only gap.
Write a program that gets the robot from A1 to A6 without crashing.
Bonus: what is the smallest number of commands that works?
Task 4: Debug the programs
A bug is a mistake in a program. Debugging means finding and fixing it. There is no wall in this task.
Bug hunt 1: This program is supposed to move the robot to C2 and finish facing up the page. It doesn't work.
F L F F L
a) Trace it. What goes wrong? b) Rewrite it so it works.
Bug hunt 2: A student wanted to move the robot from A1 to A6. They wrote F F F F F F. What goes wrong, and how do you fix it?
Extension: Loops
Programmers use a loop to repeat instructions without writing them out again and again. We will write it like this: REPEAT 3 [F] means "do F three times".
a) Trace REPEAT 4 [F F R]. Where does the robot finish, and what shape does its path make? b) Rewrite your Task 2 program using REPEAT. c) Explain in one sentence why loops are useful.
Plenary (last 3 minutes)
"In your book, finish these two sentences. An algorithm is... Debugging means..."
Answer key
Starter
Any answer saying that computers follow instructions exactly and can't guess or fill gaps gets the mark.
Task 1
- F moves to A2, then F to A3. R turns to face right.
- F, F, F moves to B3, C3 and then D3. L turns to face up.
- F moves to D4.
a) D4. b) Facing up (towards row 6).
Task 2
Many answers are correct. A short one is:
F F F F F R F F F F F (11 commands)
The robot goes up to A6, turns right, then moves along to F6. Going right first also works: R F F F F F L F F F F F. That is 12 commands because it needs two turns. 11 commands is the shortest possible. The robot must move forward 10 times (5 across and 5 up) and needs at least one turn.
Task 3
One correct answer:
F F R F F F F F L F F F L F F F F F
Trace: F, F to A3. R to face right. Five Fs to F3. L to face up. F, F, F to F4 (the gap), F5 and then F6. L to face left. Five Fs to E6, D6, C6, B6 and then A6.
Another correct answer: R F F F F F L F F F F F L F F F F F (right along row 1 to F1, up to F6, then left to A6).
Bonus: 18 commands is the smallest. The robot must travel 5 squares right, 5 up and 5 back left, which is 15 forward moves. It also needs at least 3 turns. Accept any answer that reaches A6 without passing through A4 to E4 or leaving the grid.
Task 4
Bug hunt 1: a) F moves to A2. Then L turns the robot to face left, so the next F moves it off the grid and it crashes. b) Change the first L to R: F R F F L. Trace: A2, turn right, B2, C2, then turn left to face up. Finishes on C2 facing up.
Bug hunt 2: From A1 the robot only needs 5 moves to reach A6. The sixth F moves it off the top of the grid. Fix: F F F F F. This is called an off-by-one error, and it is one of the most common bugs in real programming.
Extension
a) F, F to A3. R to face right. F, F to C3. R to face down. F, F to C2 and then C1. R to face left. F, F to B1 and then A1. R to face up. It finishes on A1 facing up, and the path is a square. b) Example: REPEAT 5 [F] R REPEAT 5 [F] c) Example: "Loops make programs shorter and easier to read. They also cut down on mistakes, because you don't have to write the same instructions many times."
Plenary
- An algorithm is a precise, step-by-step set of instructions to solve a problem.
- Debugging means finding and fixing errors in a program.
Tips for the cover supervisor
- Fast finishers: ask them to design their own wall on a new grid, write a program that gets around it, and swap with a partner to test it.
- Students who struggle: let them use a rubber or coin as the robot and move it on the grid square by square.
- Behaviour: the first five minutes of each task in silence keeps the room calm. Pair checking after that gives students a natural break.
- For the class teacher: ask students to leave their books open at this page, or collect the Task 3 answers. That makes it easy to see who understood sequencing and who needs to look at it again.
Why this works as cover
There are no logins or passwords to fail, no slides to load, and no software to learn. Every answer can be checked in a few seconds by tracing it on the grid, so anyone can mark it using the key above. The lesson still covers real computing ideas: precise instructions, tracing, debugging, off-by-one errors and loops. Students will use all of these when they next sit at a computer.
Browse the Quillwork shop