Technologies · Year 7

Active learning ideas

Branching (Selection) in Algorithms

Active learning helps Year 7 students grasp branching in algorithms because it turns abstract conditionals into tangible, visual, and collaborative experiences. When students physically sort cards, draw flowcharts, or debug together, they see how selection structures control program flow in real time, making the concept stick faster than passive note-taking.

• ACARA Content Descriptions
• AC9TDI8P02

• 30–45 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Simulation Game
• 30 min · Small Groups

Unplugged: Condition Card Sort

Provide cards with conditions and actions for scenarios like library book sorting. Students in small groups arrange cards into branching paths on paper. Test paths by inputting sample data and adjust based on group predictions.

Design an algorithm that incorporates multiple branching conditions.

Facilitation Tip

During Condition Card Sort, circulate and ask each pair to explain why they placed a card in a particular group, reinforcing the idea that conditions evaluate to true or false only.

What to look for

Provide students with a short pseudocode snippet containing an if/else statement and a specific input value. Ask them to write down the final output of the algorithm. For example: 'Input: temperature = 25. If temperature > 30, print "Hot". Else, print "Warm". What is printed?'

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Activity 02

• Simulation Game
• 40 min · Pairs

Flowchart to Pseudocode Pairs

Pairs design flowcharts for problems like eligibility checks, then convert to pseudocode with if/else. Exchange with another pair to predict and trace three input cases. Discuss discrepancies.

Predict the outcome of an algorithm with complex nested conditions.

Facilitation Tip

In Flowchart to Pseudocode Pairs, require students to swap their final flowcharts and trace each other’s logic with a different input to test accuracy.

What to look for

Ask students to draw a simple flowchart for an algorithm that checks if a number is positive, negative, or zero, using at least two branching points. They should label each decision box with its condition.

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Activity 03

• Simulation Game
• 35 min · Small Groups

Nested Debug Relay

Prepare buggy pseudocode with nested ifs. Small groups relay: one traces an input, passes to next for correction, until fixed. Whole group verifies with multiple tests.

Justify the use of selection structures in decision-making processes.

Facilitation Tip

During Branching Game Builder, limit the number of condition checks per group to encourage efficient, readable branching rather than overly complex nested structures.

What to look for

Pose this question: 'Imagine you are designing an algorithm for a vending machine. Why is it important to use selection structures (like if/else) when deciding whether to dispense a product? What specific conditions would need to be checked?'

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Activity 04

• Simulation Game
• 45 min · Individual

Branching Game Builder

Individuals create simple text-based games using if/else for player choices. Share and playtest in pairs, noting path predictions. Refine based on tester feedback.

Design an algorithm that incorporates multiple branching conditions.

Facilitation Tip

In Nested Debug Relay, provide a single shared pseudocode snippet to all groups so they focus on tracing the path rather than rewriting the entire algorithm.

What to look for

Provide students with a short pseudocode snippet containing an if/else statement and a specific input value. Ask them to write down the final output of the algorithm. For example: 'Input: temperature = 25. If temperature > 30, print "Hot". Else, print "Warm". What is printed?'

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

A few notes on teaching this unit

Teach branching by starting with real-world analogies students know well, like vending machines or traffic lights, to ground the concept in familiar decision-making. Avoid rushing to code; let students struggle slightly with tracing flowcharts first, as research shows this improves their later debugging skills. Emphasize that conditions are not linear checks but hierarchical and conditional, which helps prevent the common misconception that all branches always run.

Successful learning looks like students confidently tracing and predicting paths in conditional structures, explaining why only one branch runs per condition, and using nested conditions correctly in their own pseudocode or game logic. They should also identify and fix logical errors in branching statements during peer reviews.

---

Watch Out for These Misconceptions

• During Condition Card Sort, watch for students placing both 'if true' and 'if false' branches in the same group, indicating they believe both execute.

  Ask students to trace one card’s condition with a given input, then physically move only the matching branch to the 'executed' pile, showing that only one path runs based on the condition’s truth value.

• During Nested Debug Relay, watch for students evaluating inner conditions without considering whether the outer condition was true, suggesting they miss the dependency between levels.

  Provide a sticky note for each group to mark which outer branches execute, then have them trace inner conditions only within those marked paths, emphasizing the hierarchy.

• During Flowchart to Pseudocode Pairs, watch for students assuming that the order of multiple if statements without else-if does not change the outcome, indicating they overlook skipped conditions.

  Have students swap flowcharts with another pair and test with the same input, then adjust the order of conditions in their pseudocode to observe how priority shifts the result.

---

Methods used in this brief

• Simulation Game