Computational Thinking: Algorithms

Active learning transforms abstract algorithm concepts into concrete understanding through movement, discussion, and hands-on testing. Students need to see why vague instructions fail when executed by others, not just hear about precision from a textbook. This topic demands physical participation to internalize how tiny ambiguities break entire processes.

• Year 10
• Computing
• 4 activities
• 25 min–45 min

Learning Objectives

1. Design an algorithm for a given everyday task using pseudocode, ensuring logical sequencing and clear instructions.
2. Compare and contrast the visual representation of algorithms using flowcharts versus their textual representation using pseudocode, identifying strengths and weaknesses of each.
3. Evaluate the impact of ambiguity in algorithmic instructions by predicting the outcome of a flawed algorithm executed by a 'human computer'.
4. Create a flowchart to represent the decision-making process within a simple algorithm, incorporating conditional logic.
5. Deconstruct a complex everyday task into a series of smaller, manageable steps suitable for algorithmic representation.

Think-Pair-Share

⏱ 35 min·Pairs

Pairs: Everyday Task Algorithm

Pairs select a routine like making a sandwich and write pseudocode instructions. One partner follows them exactly as a 'human computer,' noting errors; they switch roles, discuss failures, and revise together. Share refined versions with the class.

Prepare & details

Design an algorithm to solve a common everyday task, using pseudocode.

Facilitation Tip: During the Pairs activity, circulate and listen for students using vague words like 'then' or 'stuff'—pause their process and ask, 'What exact step comes next? How would someone who’s never done this know what to do?'

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Think-Pair-Share

⏱ 45 min·Small Groups

Small Groups: Flowchart vs Pseudocode Challenge

Groups receive a problem like sorting books by genre. Half create a flowchart, half pseudocode; they test each on sample data, then compare effectiveness in clarity and speed via peer review. Vote on best representation.

Prepare & details

Compare the effectiveness of flowcharts versus pseudocode for representing algorithms.

Facilitation Tip: In the Small Groups challenge, assign each group one task to represent in both flowchart and pseudocode, then rotate groups to compare representations and argue which communicates better for different parts of the process.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Think-Pair-Share

⏱ 30 min·Whole Class

Whole Class: Human Computer Relay

Teacher provides a buggy algorithm for navigating a mock maze. Students line up; first executes on second, passing observations down the line. Class debriefs ambiguities and collectively debugs.

Prepare & details

Evaluate the importance of clear and unambiguous instructions in an algorithm.

Facilitation Tip: For the Human Computer Relay, choose a task with a clear start and end point like making a cup of tea, and enforce strict turn-taking where each student can only speak one step at a time without elaboration.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Think-Pair-Share

⏱ 25 min·Individual

Individual: Debug and Redesign

Provide pseudocode with errors for a login sequence. Students identify issues, trace execution, and rewrite correctly using flowcharts. Submit before/after versions for feedback.

Prepare & details

Design an algorithm to solve a common everyday task, using pseudocode.

Facilitation Tip: During Debug and Redesign, provide a flawed algorithm example written in pseudocode that includes at least one logical error and one syntactic error, so students practice both types of debugging.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Teaching This Topic

Start with physical tasks students think they know well—like tying shoelaces—because overconfidence in prior knowledge reveals hidden ambiguity. Avoid starting with programming languages or syntax; instead, build the habit of translating real-world steps into formal structures first. Research shows that students who teach others by physically acting out algorithms (as human computers) develop stronger debugging instincts than those who only write code. Emphasize that flowcharts and pseudocode are tools for thinking, not just recording what they already know.

What to Expect

By the end of these activities, Year 10 students will articulate clear steps for everyday tasks and translate them into both flowchart and pseudocode formats. They will recognize ambiguity immediately when peers fail to follow their instructions, and they will adjust their representations to eliminate gaps in logic or sequence.

Watch Out for These Misconceptions

Common Misconception

During Pairs: Everyday Task Algorithm, students may assume that because they understand the task, their instructions are automatically clear to others.

What to Teach Instead

During Pairs: Everyday Task Algorithm, have students swap instructions with another pair and physically attempt to follow each other’s steps without asking questions. When confusion arises, pause and ask the original pair to revise their instructions based on the breakdown, emphasizing that clarity is measured by execution, not intention.

Common Misconception

During Flowchart vs Pseudocode Challenge, students may believe one format is always superior regardless of the task.

What to Teach Instead

During Flowchart vs Pseudocode Challenge, assign each group a task where one format clearly works better than the other (e.g., a visual task like 'navigate a maze' vs. a linear task like 'calculate change'). After comparing, facilitate a debate where groups defend their choices based on the task’s needs.

Common Misconception

During Human Computer Relay, students may think a simple list of steps is sufficient for an algorithm.

What to Teach Instead

During Human Computer Relay, deliberately include ambiguous steps like 'get ready' or 'finish up' in the original instructions. When the relay stalls, pause and ask the class: 'What does 'get ready' mean? How would a human computer know when that step is complete?' Use the breakdown to define the criteria for a true algorithm.

Assessment Ideas

Quick Check

After Debug and Redesign, present students with a simple, flawed algorithm for making a sandwich written in pseudocode. Ask them to identify at least two ambiguous instructions and explain why they would cause problems if a 'human computer' followed them literally. Collect responses to gauge understanding of clarity.

Discussion Prompt

During Flowchart vs Pseudocode Challenge, facilitate a class discussion using the prompt: 'Imagine you are explaining how to tie your shoelaces to someone who has never seen it done. What are the biggest challenges in making your instructions clear and unambiguous? How would using a flowchart versus pseudocode help or hinder this explanation?'

Peer Assessment

After Pairs: Everyday Task Algorithm, have students exchange their pseudocode algorithms for a common task (e.g., brushing teeth). Each student reviews their partner’s pseudocode, checking for: 1. Are there at least three distinct steps? 2. Is there at least one decision point (IF statement)? 3. Are the instructions clear enough for someone else to follow without asking questions? Partners provide one specific suggestion for improvement.

Extensions & Scaffolding

• Challenge: Ask students to write an algorithm for a task that includes a loop (e.g., 'keep adding sugar until the tea tastes right'), then represent it in both formats with clear loop conditions.
• Scaffolding: Provide sentence starters for pseudocode ('IF [condition] THEN [action] ELSE [alternative]') and pre-printed flowchart templates with labeled shapes.
• Deeper exploration: Introduce nested decisions (e.g., 'IF tea is too weak, THEN add more tea leaves; ELSE IF too strong, THEN add water') and have students redesign their algorithms to handle multiple conditions.

Key Vocabulary

Algorithm	A set of step-by-step instructions or rules designed to solve a specific problem or perform a computation.
Pseudocode	An informal, high-level description of the operating principle of a computer program or other algorithm, using natural language conventions rather than formal programming language syntax.
Flowchart	A diagrammatic representation of an algorithm or process, using standardized symbols to depict steps, decisions, and flow of control.
Sequence	The order in which instructions are executed in an algorithm; steps are performed one after another.
Selection	A control flow structure in an algorithm that allows for different actions to be taken based on a condition being true or false (e.g., IF-THEN-ELSE).
Iteration	The repetition of a block of instructions in an algorithm until a certain condition is met (e.g., FOR loops, WHILE loops).