KS3 computing in the UK has expanded a lot in the last decade. The national curriculum covers programming, data representation, computer systems, networks, ethics, plus various practical software skills. It's a wide remit.

But if you ask which concepts matter most for a Year 7-9 student's future success in computing, the list narrows fast. Five things, in roughly this order: variables, loops, conditionals, abstraction, decomposition. Get these solid and a student can absorb almost anything else. Skip one and the gaps compound.

Here's how Prof Turing teaches each, and what to watch for.

1. Variables

A variable is a named container that holds a value. The value can change. The name doesn't.

In Python: x = 5. The name "x" now refers to the value 5. Later, x = 10 changes the value but not the name.

The classic misconception

A student who writes x = 5 and then later x = x + 1 and says "that's impossible — x can't equal x plus one" is reading the equals sign as a maths equality, not an assignment. Turing catches this early. The fix is to read x = x + 1 aloud as "take the current value of x, add 1, store the result back in x". After two or three repetitions, the student stops thinking equality and starts thinking assignment.

Why it matters

If variables aren't solid, nothing else works. Every loop, every conditional, every function involves variables. A wobbly variable model produces vague code and unreliable bugs.

2. Loops

A loop runs a block of code multiple times. The two KS3 staples are for loops (run a known number of times) and while loops (run until a condition stops being true).

In Python:

for i in range(5):
    print(i)

This runs five times. The variable i takes the values 0, 1, 2, 3, 4 — not 1, 2, 3, 4, 5.

The classic misconception

The above is the misconception. Most KS3 students assume range(5) produces 1-to-5. It doesn't. It produces 0-to-4. Turing teaches this by dry-running it. The student writes down what i is on each iteration and discovers the answer for themselves.

The same student will later need range(1, 6) to get 1-to-5, or range(1, 11) to get 1-to-10. The "exclusive upper bound" rule is a pillar of Python (and many other languages). It's worth getting right at KS3.

Why it matters

Loops are how you do anything more than once. A program that can't loop can't process a list, can't repeat a question until the answer is right, can't draw a square. Without loops, programming is just calculator-style sequential statements.

3. Conditionals

Conditionals let a program make decisions. if, elif, else in Python.

if score >= 80:
    print("A")
elif score >= 70:
    print("B")
else:
    print("C")

The order matters. The first match wins. (We saw this in the FizzBuzz worked example.)

The classic misconception

Two common ones. First: misreading the comparison operator. = is assignment; == is comparison. A student who writes if x = 5 will get a syntax error and not know why. Turing teaches the distinction explicitly with a mnemonic: "single equals puts a value, double equals checks a value."

Second: missing elif and using independent ifs when they should be exclusive. A student writes two separate if blocks for score >= 80 and score >= 70. For a score of 85, this prints both "A" and "B" because both conditions are true and the if-statements are independent. The fix is elif. Turing catches this by dry-running with a borderline score.

Why it matters

Conditionals are how programs respond to data. Without them, a program is deterministic in the boring sense — it does the same thing every time, regardless of input. With them, it adapts. That's most of what makes programs useful.

4. Abstraction

This is where it stops being syntax and starts being thinking. Abstraction is the skill of choosing what details to keep and what to throw away.

Concrete example: a student is writing a program to track scores in a quiz. They might be tempted to store the user's name, their email, their favourite colour, the date they signed up, the colour of the quiz interface. Abstraction is asking: do I need any of this? For a scoring program, you need the score and maybe the user's name. Everything else is noise. Throw it away.

How Turing teaches it

Abstraction is taught with concrete examples, not abstract ones (a sentence I enjoy writing). Turing will give the student a problem with too much information and ask: "What can we ignore?"

Example: "Sarah is 13 years old, she lives in Manchester, her favourite colour is blue, and she scored 8 out of 10 on the quiz. Write a program that congratulates her on her score."

A KS3 student needs to recognise: most of that paragraph is irrelevant. The program needs the name and the score. That recognition is abstraction.

The classic misconception

KS3 students often think abstraction means "making things simpler" or "removing detail". It does — but the question is which detail. Removing the wrong detail breaks the program. Abstraction is purposeful selection, not blanket simplification. Turing teaches this by asking why a detail is being ignored, not just whether.

5. Decomposition

Decomposition is breaking a big problem into smaller, manageable parts. The mindset move that lets a student tackle non-trivial problems without freezing.

Why it's last

Decomposition only really makes sense when the student has code to decompose. Until then it's an abstract principle floating in air. Once the student has written a few small programs, decomposition becomes the question "how do I combine these into something bigger?" — and that's a question they can actually answer.

How Turing teaches it

By taking a deliberately too-big problem and refusing to start until it's broken down. For example: "Write a program that asks 10 maths questions and tells the user their score." Turing won't let the student start until they've decomposed it into discrete steps — generate a question, show it, get an answer, check it, update the score, repeat 10 times, show the final score. Each step is small enough to code separately and test independently. Now the student can start.

The classic misconception

KS3 students try to write big programs as single blocks. They start typing and get five lines in before realising they don't know what to do next. Then they panic. Decomposition prevents the panic — but only if it's done before the typing starts. Turing reinforces this constantly.

Why the order matters

The five concepts are taught roughly in this order because:

  • Variables, loops, and conditionals are concrete — you can write them, see them, dry-run them. Year 7 to early Year 8.
  • Abstraction and decomposition are mindset — they need code to be applied to. Late Year 8 to Year 9.

A KS3 scheme that teaches decomposition before the student can write a loop will fail. A scheme that teaches abstraction before the student has written enough small programs to abstract over will fail. Order is content.

What's missing from this list

You might notice: no data structures, no functions, no object-oriented programming, no recursion. These are all real things and they belong in computing education — but at GCSE and beyond, not KS3. A Year 9 student who has the five above solid is well-placed to learn any of them. A Year 9 student who skipped past the five to "do functions" will struggle in unexpected places.

Turing's role isn't to push every KS3 student to GCSE-level material. It's to make sure the foundations are properly poured.

Jason runs aitutors.me. He has a Year 8 child and about fifteen years of building software adjacent to education. Updated 21 May 2026.