Computing · Year 7 · Impacts and Digital Literacy · Autumn Term

Algorithmic Thinking: Flowcharts

Creating and interpreting flowcharts to represent logical processes.

• National Curriculum Attainment Targets
• KS3: Computing - Algorithms

About This Topic

Algorithmic thinking with flowcharts equips Year 7 students to visualise and structure logical processes using standard symbols. Ovals mark start and end points, rectangles denote actions, diamonds represent decisions, and arrows show sequence. Students construct flowcharts for everyday tasks, such as making a cup of tea, which requires decomposing the process into clear, sequential steps. They also interpret provided flowcharts, spot logic errors like missing decisions, and suggest fixes.

This content supports KS3 Computing standards on algorithms within the Impacts and Digital Literacy unit. It develops core computational thinking skills: decomposition, pattern recognition, and abstraction. By comparing flowcharts to written instructions, students see how visuals reduce ambiguity and improve precision, a foundation for programming and problem-solving in later years.

Active learning suits this topic perfectly. When students draw flowcharts on paper or digital tools, then follow a partner's in role-play, they experience execution firsthand. Group debugging sessions uncover flaws through trial and error, making abstract logic tangible and memorable while building collaboration.

Key Questions

1. Construct a flowchart to represent the steps for making a cup of tea.
2. Identify a logic error in a given flowchart and propose a correction.
3. Compare the advantages of using a flowchart over written instructions.

Learning Objectives

• Design a flowchart to accurately represent the sequential steps for a common everyday task, such as making a sandwich.
• Analyze a given flowchart to identify logical errors, such as infinite loops or missing decision branches, and propose specific corrections.
• Compare the clarity and efficiency of a flowchart representation against a set of written instructions for a given process.
• Construct flowcharts using standard symbols (oval, rectangle, diamond, arrow) to illustrate algorithms for simple problems.

Before You Start

Introduction to Computational Thinking

Why: Students need a basic understanding of breaking down problems into smaller steps (decomposition) before they can represent these steps in a flowchart.

Sequencing and Ordering

Why: The ability to understand and follow a series of instructions in the correct order is fundamental to constructing and interpreting flowcharts.

Key Vocabulary

Flowchart	A diagram that uses standardized symbols to represent the sequence of operations, decisions, and inputs/outputs of a process or algorithm.
Algorithm	A step-by-step procedure or set of rules for solving a problem or completing a task, which can be represented visually using a flowchart.
Start/End Symbol	An oval shape used in flowcharts to indicate the beginning or the termination point of the process.
Process Symbol	A rectangular shape used in flowcharts to represent an action, operation, or a step in the algorithm.
Decision Symbol	A diamond shape used in flowcharts to represent a point where a decision must be made, typically resulting in two or more possible paths.

Watch Out for These Misconceptions

Common Misconception

Flowcharts are just decorative diagrams, not precise instructions.

What to Teach Instead

Students often overlook that flowcharts must be executable step-by-step. Active tracing with props during pair activities shows ambiguities clearly. Group execution reveals where vague symbols fail, reinforcing the need for precision.

Common Misconception

Every process needs a decision diamond; simple sequences do not.

What to Teach Instead

Some assume decisions are always required, leading to overcomplicated charts. Hands-on building for simple tasks like tea-making helps students practice when to use diamonds. Collaborative reviews normalise straightforward flows.

Common Misconception

Arrows can point backwards without loops.

What to Teach Instead

Backward arrows confuse without proper loop structures. Debugging races in small groups highlight infinite loops, teaching loop symbols through trial. Visual path-tracing corrects this hands-on.

Active Learning Ideas

Pair Swap: Tea-Making Flowcharts

Pairs draw a flowchart for making tea using standard symbols. They swap with another pair, follow the flowchart step-by-step with props like cups and kettles, and note any issues. Discuss fixes as a pair before revising.

30 min·Pairs

Small Group Debug Challenge

Provide printed flowcharts with errors, such as infinite loops or missing decisions. Groups trace paths with fingers or tokens, identify bugs, and redraw corrections. Share one fix with the class.

35 min·Small Groups

Whole Class Comparison

Display a written recipe and its flowchart side-by-side. Class votes on clarity for each step via mini-whiteboards. Teacher facilitates discussion on advantages, then students recreate in pairs.

25 min·Whole Class

Individual Routine Flowchart

Students select a personal morning routine and create a flowchart individually. Peer review follows, with feedback on logic and symbols. Refine based on comments.

20 min·Individual

Real-World Connections

• Software developers use flowcharts to plan the logic of computer programs before writing code, ensuring all conditions and steps are accounted for, which helps prevent bugs in applications like mobile games or banking apps.
• Operations managers in factories create flowcharts to map out production lines, identifying bottlenecks and optimizing the sequence of tasks for efficiency, such as in an automobile assembly plant.
• Emergency service dispatchers might use simplified flowcharts to guide their questioning of callers, ensuring critical information is gathered systematically to send the correct help, like in a 999 call center.

Assessment Ideas

Quick Check

Provide students with a printed flowchart for a simple task (e.g., brushing teeth). Ask them to identify and label each symbol type (start, process, decision, end) and trace the path of execution. Check for correct symbol identification and logical path following.

Exit Ticket

On a small card, ask students to draw a flowchart for the decision of whether to take an umbrella. Include a start, a decision (Is it raining?), a process (Take umbrella), and an end. Collect and review for correct symbol usage and logical flow.

Peer Assessment

In pairs, have students create a flowchart for making toast. Then, they exchange flowcharts. Each student reviews their partner's flowchart, checking for at least one logical error (e.g., forgetting to put bread in the toaster) and suggesting a correction. Partners sign off on the review.

Frequently Asked Questions

How do I introduce flowcharts to Year 7 students?

Start with a familiar task like making tea: model a simple flowchart on the board, explaining symbols as you go. Have students copy and annotate it first. Transition to them creating their own in pairs, using symbol cheat sheets. This scaffold builds confidence before independent work, linking to real-life logic.

What are common flowchart errors in Year 7?

Frequent issues include missing end points, ambiguous decision outcomes, or crossed arrows disrupting flow. Logic gaps, like unchecked 'if kettle boiled', create dead ends. Address through group debugging: provide flawed examples for tracing, then peer teaching of fixes strengthens understanding across the class.

How do flowcharts connect to programming?

Flowcharts mirror code structure: processes as statements, decisions as if-else, loops as repeats. Year 7 practice prepares for block-based coding like Scratch. Visual planning reduces syntax frustration later, as students translate charts directly to code, building transferable algorithmic skills.

How can active learning help students master flowcharts?

Active approaches like pair flowchart execution with props make logic immediate and error-prone paths obvious. Small group challenges with flawed charts encourage collaborative debugging, where students articulate fixes aloud. Whole-class comparisons via voting engage everyone, turning passive symbol memorisation into dynamic, retained skill-building.