3.1.1 Representing algorithms

This resource supports 3.1.1 Representing algorithms in AQA GCSE Computer Science. It stays tightly focused on what the specification actually asks students to know: what an algorithm is, how decomposition and abstraction help shape a solution, how algorithms can be represented using pseudo-code, program code and flowcharts, and how to work out the purpose of a simple algorithm from its steps.

For teachers, this is one of those topics that looks deceptively tidy until students start calling the algorithm “the code”, spotting an input but not the processing, or confidently announcing that abstraction means “making it shorter somehow”. This page is designed to help you teach the topic with clarity, keep examples purposeful, and mark answers without having to decode creative but inaccurate terminology.

At a Glance

🧭 Specification context: AQA GCSE Computer Science, 3.1.1 Representing algorithms
Students must know: the meaning of algorithm, decomposition and abstraction; that a program is an implementation of an algorithm rather than the algorithm itself; how to represent algorithms using pseudo-code, program code and flowcharts; how to identify inputs, processing and outputs; and how to determine the purpose of a simple algorithm using trace tables and visual inspection.
Key exam focus: precise definitions, clear step-by-step logic, accurate use of representation methods, and careful explanation of what an algorithm does.
Common student challenges: mixing up decomposition and abstraction, treating flowcharts as decoration rather than logic, spotting outputs but not the processing, and describing the final answer without explaining the method.

Understanding the Topic

Where this fits in the specification

This topic sits within 3.1 Fundamentals of algorithms. It is the foundation stone for later work on efficiency, searching, sorting and programming. If students do not understand how an algorithm is planned and represented here, later topics start wobbling like a chair with one heroic but missing leg.

What an algorithm actually is

An algorithm is a sequence of steps that can be followed to complete a task or solve a problem. The important distinction for AQA is this:

• an algorithm is the logical method
• a program is the implementation of that method in a programming language

Students often use the two terms as if they are interchangeable. For exam purposes, they are related, but they are not the same thing.

💡 Teacher reminder: if a student writes that an algorithm is “the code”, the answer is usually too narrow. Reward answers that focus on the ordered steps or method.

Decomposition

Decomposition means breaking a problem into smaller sub-problems.

For example, if students are planning an algorithm for a cinema booking system, they might split the job into:

• input film choice
• input number of tickets
• calculate total cost
• apply any discount
• output booking summary

This helps students build solutions logically instead of trying to write the whole thing in one leap and hoping for the best.

Abstraction

Abstraction means removing unnecessary detail so that only the important features of the problem remain.

In the cinema example, students do not need to model the colour of the seats, the shape of the popcorn tub or the emotional journey of Screen 4. They need the details that matter to the algorithm, such as:

• ticket type
• quantity
• price
• discount rules
• final total

A strong GCSE answer makes clear that abstraction helps the programmer focus only on information relevant to solving the problem.

A systematic approach to solving problems

Students should be taught to move through a problem in a deliberate order:

1. identify the task
2. break it into smaller parts using decomposition
3. remove irrelevant detail using abstraction
4. plan the steps clearly
5. represent the solution in pseudo-code, program code or a flowchart

This matters because exam questions often reward organised thinking just as much as the final representation.

Ways to represent algorithms

AQA expects students to recognise and use three main forms.

Pseudo-code

Pseudo-code is a structured way of describing an algorithm using language that looks a bit like programming code but is easier for humans to read.

INPUT mark
IF mark >= 50 THEN
	OUTPUT "Pass"
ELSE
	OUTPUT "Fail"
ENDIF

Pseudo-code is useful because it shows logic clearly without tying the answer to one specific programming language.

Program code

Program code represents the same algorithm in an actual programming language. Students should understand that the logic may stay the same even if the syntax changes.

Flowcharts

Flowcharts show the steps of an algorithm visually. They are particularly helpful when teaching sequence, decisions and loops because students can see the path the logic follows.

Inputs, processing and outputs

Students must be able to explain a simple algorithm in terms of:

• input: data entering the system
• processing: the operations carried out on that data
• output: the information produced at the end

A frequent exam slip is that students spot the input and output but skip over the processing, which is usually where the actual thinking happens.

Determining the purpose of an algorithm

Students should be able to work out what an algorithm does by:

• reading each step carefully
• tracing variable values
• using a trace table where helpful
• identifying the final output

This is especially important when the exam gives unfamiliar pseudo-code and asks what the algorithm is for. Students do not need to panic and invent a dramatic backstory for the program. They need to follow the logic.

Key Terms and Concepts

How to Teach This Topic

Teaching moves that work well

• Start with an everyday process, such as making toast or logging into a school system, to secure the idea of ordered steps.
• Move quickly from everyday algorithms to computing examples so students see that the same logic applies.
• Teach decomposition and abstraction side by side, but contrast them repeatedly.
• Model the same simple problem in pseudo-code and as a flowchart so students see that the logic stays the same across forms.
• Use mini whiteboards for identifying inputs, processing and outputs from short algorithm snippets.

Scaffolds and extension

• Give students incomplete pseudo-code and ask them to label the input, processing and output.
• Provide a finished algorithm and ask students to state its purpose in one sentence.
• Use partially completed flowcharts to help students focus on decision points.
• For stronger students, ask which details should be removed through abstraction before planning the solution.
• Use trace tables early, not just at revision time, so they become a normal reading tool rather than an emergency rescue device.

Practical classroom sequence

A strong lesson sequence often looks like this:

• define algorithm, decomposition and abstraction clearly
• model a short problem and break it into sub-problems
• strip away irrelevant detail
• represent the final steps as pseudo-code
• convert the same logic into a flowchart
• finish by asking students to identify inputs, processing and outputs

🧑‍🏫 Helpful teacher move: ask students, “What detail matters to the solution, and what detail can we ignore?” That single question sharpens abstraction more effectively than ten vague reminders.

Discussion prompts

• Why is an algorithm not the same as a program?
• How does decomposition make a problem easier to solve?
• What detail should be removed through abstraction in this scenario?
• Why might a flowchart be easier to read than pseudo-code for some learners?
• How can a trace table help us determine the purpose of an algorithm?

How to Mark This Topic Effectively

What strong answers usually contain

• precise definitions rather than vague word associations
• a clear distinction between algorithm and program
• accurate explanation of decomposition and abstraction
• correct identification of input, processing and output
• logical sequencing when writing or interpreting pseudo-code and flowcharts
• evidence that the student has followed the steps of the algorithm, not guessed its purpose

What weaker answers often do

• define an algorithm as “computer code”
• say decomposition means “making it shorter”
• describe abstraction as “simplifying it” without explaining what is removed
• miss the processing stage altogether
• identify the output correctly but fail to explain how it was produced
• guess the purpose of the algorithm from one line rather than tracing the whole thing

✅ Marking reminder: when students are asked to explain an algorithm’s purpose, reward answers rooted in the actual steps shown. A polished guess is still a guess.

Example Student Responses

Example question

Write an algorithm in pseudo-code for a program that:

• inputs a student's mark out of 100
• outputs "Pass" if the mark is 50 or more
• otherwise outputs "Fail"

Then identify the input, processing and output in your algorithm.

Marks: 6

Marking guidance:

• 1 mark for correct input of the mark
• 1 mark for a correct comparison with 50
• 1 mark for correct pass output
• 1 mark for correct fail output
• 1 mark for identifying the input accurately
• 1 mark for identifying the processing and output accurately

INPUT mark
IF mark >= 50 THEN
	OUTPUT "Pass"
ELSE
	OUTPUT "Fail"
ENDIF

Input: mark
Processing: compare the mark with 50
Output: Pass or Fail

OUTPUT "Enter mark"
IF 50 THEN
	OUTPUT "Pass"
ENDIF

📝 Teaching follow-up: after showing both responses, ask students to improve the weak one rather than simply spotting errors. That nudges them into examiner mode and writer mode at the same time.

Practice Questions

1. Define algorithm and explain why it is not the same as a program.

Marks: 3

Marking guidance: 1 mark for defining algorithm as ordered steps or a method; 1 mark for identifying a program as the implementation in code; 1 mark for making the distinction clearly.

2. A school is designing a system to calculate library fines. Explain how decomposition and abstraction would help when planning the solution.

Marks: 4

Marking guidance: reward breaking the task into smaller parts for decomposition; reward removing irrelevant detail and focusing on necessary data for abstraction.

3. A simple algorithm asks for a name and age, then outputs whether the person can join a club for students aged 16 and over. Write this as pseudo-code or draw the logic as a flowchart.

Marks: 5

Marking guidance: reward input, decision, correct comparison, and suitable outputs.

4. Read this algorithm and determine its purpose:

INPUT number
result <- number * 2
OUTPUT result

Marks: 2

Marking guidance: 1 mark for recognising the input is a number; 1 mark for stating that the algorithm outputs double the number entered.

5. Complete a trace table for this algorithm and state what it does:

total <- 0
FOR count <- 1 TO 3
	INPUT value
	total <- total + value
ENDFOR
OUTPUT total

Marks: 4

Marking guidance: reward accurate tracking of total and a clear statement that the algorithm adds three entered values and outputs the total.

Common Misconceptions

FAQ

Mark Smarter with Marking.ai

Marking.ai helps teachers give faster, clearer feedback while keeping assessment focused on what the mark scheme actually rewards. For a topic like representing algorithms, that means less time untangling vague phrasing and more time spotting whether students genuinely understand the logic, the vocabulary and the method behind the answer.