Unpack the Curriculum

Follow, describe and represent a sequence of steps and decisions (algorithms) needed to solve simple problems (ACTDIP004)

Define simple problems, and describe and follow a sequence of steps and decisions (algorithms) needed to solve them (ACTDIP010)

Design, modify and follow simple algorithms involving sequences of steps, branching, and iteration (repetition) (ACTDIP019)

Design algorithms represented diagrammatically and in English, and trace algorithms to predict output for a given input and to identify errors (ACTDIP029)

Design algorithms represented diagrammatically and in structured English and validate algorithms and programs through tracing and test cases (ACTDIP040)

Follow algorithms

Follow algorithms is the process of performing the steps required to solve a problem.

Follow algorithms: Follow an ordered sequence of steps to solve a simple problem or complete a task.; Students follow a short ordered sequence of steps and make decisions to solve a simple problem (e.g follow a recipe or directions to reach a location).
Represent algorithms: Represent a clear, ordered sequence of steps and decisions using words and images.; Students describe the steps and decisions (in the correct order) required to solve a simple problem (e.g. write, say, draw, or photograph the steps needed to make a sandwich).

Follow algorithms: Follow an ordered sequence of steps to solve a simple problem or complete a task.; Students follow the steps and decisions of algorithms (e.g. follow rules to form progressive verbs such as eat to eating, run to running, make to making), and know what step they are up to (e.g. checking off items on a list as they are completed).
Represent algorithms: Represent a clear, ordered sequence of steps and decisions using words and images.; Students describe algorithms using representations such as a list of steps or a diagram (e.g. drawing a diagram of a recipe involving decisions).

Follow algorithms: Follow an ordered sequence of steps to solve a simple problem or complete a task.; Students follow the steps, decisions, and loops in algorithms (e.g. repeating the steps to add two digits for each column in multi-digit addition), and know what step they are up to (e.g. know which column they are adding and when to stop).
Represent algorithms: Represent a clear, ordered sequence of steps and decisions using words and images.; Students describe algorithms using procedural language (e.g. repeat until all items are scanned, or if it is hot then wear a hat, otherwise wear a jumper) and flowcharts (e.g. rectangles for steps and diamonds for decisions).

Trace algorithms: Desk check (track the state of) an algorithm to determine output for a given input.; Students follow an algorithm precisely (e.g. desk check with a table of input, variables, and output) to confirm it produces the expected output for the given input.
Represent algorithms: Represent a clear, ordered sequence of steps and decisions using words and images.; Students describe algorithms precisely in written form or with flowcharts for each part of the problem (e.g. separate flowcharts to describe the purchase of an item, and the giving of change during the purchase).

Trace algorithms: Desk check (track the state of) an algorithm to determine output for a given input.; Students trace and debug an algorithm by identifying when its state is unexpected, why this has occurred, and the changes needed to correct it (e.g. identifying that a loop has finished one iteration too early).
Represent algorithms: Represent a clear, ordered sequence of steps and decisions using words and images.; Students describe algorithms precisely and succinctly using pseudocode (e.g. short, unambiguous statements such as if length of word is greater than 4 and first letter is a vowel) and appropriate diagram types (e.g. a decision-tree for classifying an animal based on physical characteristics).

Design algorithms

Design algorithms captures the solution design we undertake to develop an automated solution to a problem.

The content descriptions do not explicitly address Design algorithms in band F-2.

The content descriptions do not explicitly address Design algorithms in band 3-4.

Design and modify algorithms: Design an algorithm, or modify an existing one, to fix an error or change functionality.; Students design an algorithm (e.g. to decide when to water a garden) or understand and modify an existing algorithm to fix an error (e.g. watering when the soil is too wet) or change functionality (e.g. taking into account humidity as well as soil moisture level).

Test algorithms: Define the expected (correct) output for given input and check an algorithm against it.; Students specify test cases (i.e. input and expected output) and compare the expected and actual output to determine the correctness of an algorithm (e.g. a test case of the change-calculating algorithm could have input $1.45, and expected output 1 x $1, 2 x 20c, 1 x 5c coins).
Design and modify algorithms: Design an algorithm, or modify an existing one, to fix an error or change functionality.; Students design an algorithm (e.g. to calculate the coins and notes needed for an amount of money) or understand and modify an existing algorithm to fix an error (e.g. rounding amounts smaller than the minimum denomination) or change functionality (e.g. changing the denominations used).

Test algorithms: Define the expected (correct) output for given input and check an algorithm against it.; Students determine boundary test cases and test that they are handled correctly by the algorithm (e.g. checking that an intersection is detected when two shapes are perfectly aligned).
Design and modify algorithms: Design an algorithm, or modify an existing one, to fix an error or change functionality.; Students design an algorithm (e.g. to detect if two shapes intersect) or understand and modify an existing algorithm to fix an error (e.g. not detecting when shapes just touch), extend functionality (e.g. support a new shape), or improve the algorithm (e.g. make it more efficient or elegant).

Algorithm constructs

Algorithm constructs are the building blocks we use to define our algorithms in a form digital systems can execute.

Sequence of steps: An sequence of steps (instructions) where order might or might not matter.; Students identify the steps needed to solve a problem, and understand when their order is important (e.g. socks must go on before shoes) or when they can be reordered (e.g. jumper can go on before or after shoes).
Branching (decisions): Branching involves following different steps based on a yes/no decision.; Students identify the decisions needed to solve a problem and the next steps to follow in each case (e.g. if it is raining, take a raincoat, otherwise take a hat).

Sequence of steps: An sequence of steps (instructions) where order might or might not matter.; Students understand there can be more than one sequence of steps to solve a problem, some are better than others, and the steps should be unambiguous (e.g. describing two different ways to get to the same location).
Branching (decisions): Branching involves following different steps based on a yes/no decision.; Students determine the decisions required to solve a problem. Decisions should include numerical and text comparisons (e.g. if the UV index is above 3, put on sunscreen and a hat).

Sequence of steps: An sequence of steps (instructions) where order might or might not matter.; Students describe more than one sequence of steps that solve the same problem (e.g. specifying the exact route through a maze vs. using the right-hand rule) , and can explain why one is better than the other (e.g. the right-hand rule is a general algorithm that works for all mazes).
Branching (decisions): Branching involves following different steps based on a yes/no decision.; Students describe a decision that has more than two options (e.g. selecting transport i.e. if distance < 2km then walk, else if distance < 5km then ride, else catch the bus) to select the next step.
Iteration: Iteration involves repeating a sequence of steps until a condition is met.; Students describe algorithms that repeat one or more steps a fixed number of times (e.g. recite number facts from 1 to 12) or until a condition is met (e.g. keep mixing until the ingredients are combined).

Control structures: Control structures (e.g. branching and iteration) determine the steps taken in an algorithm.; Students describe algorithms with nested control structures, including a nested if (e.g. if it is raining then [if parents are home then drive to school]) or an if inside a loop (e.g. repeat [select the largest coin smaller than the remaining total, and subtract it] until the remainder is zero).