Technologies · Year 7 · The Logic of Machines · Term 1

Branching (Selection) in Algorithms

Students implement conditional statements (if/else) in algorithms to allow for different paths based on specific criteria.

• ACARA Content Descriptions
• AC9TDI8P02

About This Topic

Branching, or selection, in algorithms introduces conditional statements such as if/else to direct different paths based on criteria. Year 7 students implement these structures in pseudocode or block-based coding tools, allowing algorithms to respond dynamically to inputs, like sorting items or guiding choices in a game.

This content meets AC9TDI8P02 by focusing on designing algorithms with multiple branches, predicting results from nested conditions, and explaining selection's role in decision processes. Students build logical reasoning and precision, key to computational thinking, while connecting to real-world applications in automation and apps.

Active learning excels with this topic because students test and iterate on their code immediately. Creating flowcharts, running simulations with varied inputs, or debugging in pairs turns abstract logic into observable outcomes, helping students refine their understanding through trial and immediate feedback.

Key Questions

1. Design an algorithm that incorporates multiple branching conditions.
2. Predict the outcome of an algorithm with complex nested conditions.
3. Justify the use of selection structures in decision-making processes.

Learning Objectives

• Design an algorithm that uses multiple if/else statements to control a character's actions in a simple game.
• Predict the output of a pseudocode algorithm containing nested conditional statements for a given set of inputs.
• Explain how selection structures (if/else) enable algorithms to make decisions based on specific criteria.
• Compare the outcomes of two algorithms that differ only in the conditions used within their selection structures.
• Justify the choice of specific conditions within an if/else statement to achieve a desired algorithmic behavior.

Before You Start

Sequencing in Algorithms

Why: Students need to understand that algorithms follow a specific order of instructions before they can learn to alter that order with conditional logic.

Basic Input and Output

Why: Understanding how algorithms receive information (input) and provide results (output) is fundamental to designing algorithms that react to different conditions.

Key Vocabulary

Conditional Statement	A programming structure that executes a certain block of code only if a specific condition is true. This is often written as 'if'.
Selection Structure	A control flow statement that allows a program to choose between different paths of execution based on whether a condition evaluates to true or false. Common examples are 'if', 'if-else', and 'else-if'.
Branching	The process within an algorithm where the execution path can diverge into two or more possibilities based on a condition being met or not met.
Nested Condition	A conditional statement placed inside another conditional statement, allowing for more complex decision-making logic.
Boolean Expression	An expression that evaluates to either true or false, used as the condition in selection structures.

Watch Out for These Misconceptions

Common Misconception

Both if and else branches always execute.

What to Teach Instead

Only one branch runs based on the condition's truth value. Peer testing with varied inputs in group activities reveals this, as students trace paths and see single outcomes, correcting the linear misconception.

Common Misconception

Nested conditions evaluate all inner ifs regardless of outer.

What to Teach Instead

Inner branches depend on outer results. Relay debugging tasks show this dependency clearly, with students marking execution paths step-by-step to visualize the hierarchy.

Common Misconception

Condition order in multiple ifs does not affect results.

What to Teach Instead

Sequential ifs without else-if can lead to unexpected skips. Flowchart building and simulation help students reorder and test, observing how priority changes outcomes.

Active Learning Ideas

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.

30 min·Small Groups

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.

40 min·Pairs

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.

35 min·Small Groups

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.

45 min·Individual

Real-World Connections

• Traffic light systems use conditional statements to change signals based on sensor inputs detecting vehicles, ensuring safe and efficient traffic flow.
• Video games employ branching algorithms extensively, determining character responses, enemy behaviors, or puzzle solutions based on player actions and game state.
• Automated customer service chatbots utilize selection structures to guide users through menus and provide relevant information based on their spoken or typed queries.

Assessment Ideas

Quick Check

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?'

Exit Ticket

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.

Discussion Prompt

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?'

Frequently Asked Questions

What is branching in algorithms for Year 7 Technologies?

Branching uses if/else statements to create decision points in algorithms, allowing different actions based on conditions. Students design these for tasks like data validation, predict nested paths, and justify their efficiency per AC9TDI8P02. This builds decision logic essential for programming.

How do you teach nested conditions effectively?

Start with simple if/else, then layer nests using real scenarios like access levels. Use visual flowcharts before code, test with edge cases, and have pairs trace executions. This scaffolds complexity, ensuring students predict outcomes accurately.

How can active learning help students master branching in algorithms?

Active approaches like building physical decision trees or pair-debugging make logic tangible. Students input test data, observe single-path execution, and iterate fixes, turning errors into insights. Group predictions and relays foster discussion, deepening understanding beyond passive reading.

What are common errors in implementing selection structures?

Errors include ignoring else clauses, flawed condition logic, or mishandling nests. Address via test-driven activities: students run inputs, log paths, and peer-review. This reveals issues quickly, with 80% improvement in accuracy after two cycles of hands-on refinement.