Introduction to Algorithms and Flowcharts

Active learning works well here because students often see algorithms as abstract code. By moving physically and drawing symbols, Year 11 students connect abstract logic to concrete steps, building confidence in computational thinking before formal coding. Flowcharts turn invisible decisions into visible paths, so hands-on tracing makes the topic clearer than lecture alone.

• Year 11
• Computing
• 4 activities
• 20 min–45 min

Learning Objectives

1. Analyze the function of sequence, selection, and iteration within a given algorithm.
2. Construct a flowchart representing a simple decision-making process using standard symbols.
3. Evaluate the clarity and completeness of a flowchart for a given algorithm.
4. Compare the efficiency of different algorithmic approaches for solving a basic problem.

Stations Rotation

⏱ 25 min·Pairs

Pairs: Flowchart Relay Race

Pairs collaborate on a whiteboard to build a flowchart for a daily task like checking weather before leaving home. One student draws sequence or selection steps while the partner adds iteration; they switch roles after each addition. End with pairs testing each other's flowchart by walking through it aloud.

Prepare & details

Analyze the role of sequence, selection, and iteration in algorithmic design.

Facilitation Tip: During the Flowchart Relay Race, circulate and ask pairs to explain their symbol choices aloud, forcing articulation of logic before moving to the next station.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Stations Rotation

⏱ 45 min·Small Groups

Small Groups: Algorithm Design Workshop

Groups receive a problem like planning a school trip budget and construct a flowchart incorporating all three constructs. They swap flowcharts with another group for peer review on clarity. Discuss revisions as a class to highlight effective designs.

Prepare & details

Construct a flowchart to represent a simple decision-making process.

Facilitation Tip: In the Algorithm Design Workshop, hand out blank paper and colored pencils so groups can color-code paths, making iteration exits and selection branches visually distinct.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Stations Rotation

⏱ 30 min·Whole Class

Whole Class: Debug the Flowchart

Project a sample flowchart with deliberate errors in sequence, selection, or iteration. Students raise hands to spot issues and suggest fixes. Vote on best corrections and redraw the flowchart live.

Prepare & details

Evaluate the clarity and completeness of a given algorithm represented as a flowchart.

Facilitation Tip: For the Debug the Flowchart activity, display the flowchart on the board and use a remote pointer to trace paths with students, pausing at each decision to ask, 'What happens if the condition is false?'

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Stations Rotation

⏱ 20 min·Individual

Individual: Personal Iteration Challenge

Students create a flowchart for a repetitive personal task, such as practicing piano scales with a loop condition. Share one with a partner for feedback on loop termination. Revise based on input.

Prepare & details

Analyze the role of sequence, selection, and iteration in algorithmic design.

Facilitation Tip: During the Personal Iteration Challenge, provide sticky notes labeled 'loop counter' and 'exit condition' so students physically place them to show controlled repetition.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Teaching This Topic

Teachers should start with everyday examples students recognize, like making toast or crossing the road, to show algorithms exist everywhere. Avoid introducing variables or complex conditions too early; focus first on clear sequence and one simple decision. Research shows students grasp iteration better when they simulate loops with physical objects before abstracting to code. Emphasize that flowcharts are communication tools, not just decoration, so peer review and explanation become central.

What to Expect

Successful learning looks like students confidently translating real-world tasks into flowcharts with correct symbols, identifying sequence, selection, and iteration in peers’ work, and debugging logical gaps in group tasks. They should explain why a loop exits or why a decision branches, using clear language and precise symbols.

Watch Out for These Misconceptions

Common Misconception

During Flowchart Relay Race, watch for students who treat algorithms as exclusively digital, ignoring everyday tasks.

What to Teach Instead

Use the relay stations to include tasks like 'Use a phone to call a friend' or 'Cross a busy road safely,' forcing students to map non-digital steps into flowcharts and see algorithms as universal.

Common Misconception

During Algorithm Design Workshop, watch for students who dismiss flowcharts as optional, preferring to write pseudocode instead.

What to Teach Instead

Require each group to present their flowchart first, then translate it to pseudocode, explicitly comparing how the visual path reveals logic gaps that text might hide.

Common Misconception

During Personal Iteration Challenge, watch for students who assume loops run forever without exit conditions.

What to Teach Instead

Provide sticky notes labeled 'counter = 0' and 'if counter > 5, exit loop,' so students physically place these to see how repetition ends, making the concept tangible.

Assessment Ideas

Exit Ticket

After Flowchart Relay Race, give each student a blank flowchart template and a short scenario (e.g., 'Make a sandwich'). Ask them to draw a flowchart that includes one example of sequence, one of selection, and one of iteration. Collect and check symbol accuracy and logical flow.

Quick Check

During Debug the Flowchart, display a pre-made flowchart on the board. Ask students to identify and label one instance of sequence, one of selection, and one of iteration. Then, trace the path for a specific input and ask students to state the final output aloud.

Peer Assessment

After Algorithm Design Workshop, have pairs swap flowcharts and use a checklist to evaluate: Are standard symbols used correctly? Is the logic clear? Is the sequence, selection, and iteration easy to follow? Partners provide one written suggestion for improvement.

Extensions & Scaffolding

• Challenge: Ask students to design a flowchart for a sorting algorithm (e.g., bubble sort) using only sequence and iteration, then test it with a small dataset.
• Scaffolding: Provide pre-printed flowchart templates with symbols already placed, leaving only the logic paths blank for students to complete.
• Deeper exploration: Introduce nested loops or multiple exit conditions in a flowchart for a vending machine task, encouraging students to evaluate efficiency and clarity.

Key Vocabulary

Algorithm	A step-by-step set of instructions or rules designed to perform a specific task or solve a particular problem.
Flowchart	A diagram that uses standardized symbols to represent the sequence of operations, decisions, and inputs/outputs in a process or algorithm.
Sequence	The order in which instructions are executed in an algorithm, where each step follows directly from the previous one.
Selection	An algorithmic construct that allows an algorithm to make a decision and execute different paths based on a condition, often represented by an if-then-else structure.
Iteration	A control flow statement that allows a block of code to be executed repeatedly, typically based on a condition or a set number of times; also known as a loop.