As part of the SETSA Primary Curriculum project, I was tasked with exploring the new requirements for ICT through the design, presentation and evaluation of a seven week Program of Work. The new curriculum for ICT represents a dramatic shift in emphasis from being able to use computing technology to understanding how that technology works ‘under the bonnet’, that knowledge equipping our children to go on then to design and produce technology of their own. This shift is reflected in the change of subject title; it is no longer ICT, it is Computing.
In simple terms, the main addition to the new curriculum is the inclusion of programming and, since this addition is concentrated in the first three requirements, I thought it made sense to attempt to build my POW around them. I made the decision to teach the POW to Year 3 on the understanding that, since it’s a topic that will be new to all KS2 children, it also could be adapted easily for presentation to Yrs 4 to 6.
The first three requirements of the new KS2 Computing Curriculum, which my Program of Work sets out to satisfy are:
Pupils should be taught to:
 design, write and debug programs that accomplish specific goals, including controlling or simulating physical systems; solve problems by decomposing them into smaller parts
 use sequence, selection, and repetition in programs; work with variables and various forms of input and output
 use logical reasoning to explain how some simple algorithms work and to detect and correct errors in algorithms and programs
This is how the POW satisfies these requirements:
Design/write algorithm/ program
Debug
Controlling or simulating physical systems
Decomposing
Sequence
Lesson 2
Lesson 3 onwards
Lesson 2
Lesson 4-7
Lesson 2 onwards
Selection
Repetition
Variables
Inputs/outputs
Lesson 5, 6, 7
Lesson 4, 6,7
Lesson 4, 6,7
Lesson 1 onwards
How simple algorithms work Lesson 2 detect and correct errors in algorithms and programs Lesson 3 onwards
Please see Appendix 1 for a glossary of terms.

Lesson 1 Inputs and Outputs
Introduces the idea that devices have inputs and outputs, that devices take the inputs and process them to produce the outputs. Example used include simple devices (such as a toaster or a kettle) and more complicated ones (a calculator, a computer). Includes two exercises for them to reinforce what they have learnt.
Lesson 2 A Basic Algorithm For Controlling a Washing Machine
Explores a washing machine from a user’s perspective first – and in the light of the previous lesson on inputs and outputs, e.g. we put soap in the soap tray and our dirty clothes in the drum, so those are our inputs. Then we start the machine running and walk away. When it’s finished, we take out clean washing, our output. But what does the computer inside the washing machine do, while we’re away?
In this lesson, we try and create our own algorithm for a computer in a washing machine.
First, we ask ourselves, how does our parent wash clothes by hand?

She/he washes the clothes first in soap and hot water;

Then rinses the clothes in cold water;

Then wrings the clothes dry.
This is our basic algorithm.
Now we look at the washing machine as the computer sees it, in terms of the things it can control.
It can:
Empty soap into the drum;
Fill the drum with hot/cold water;
Spin the drum;
Drain the drum.
Images are provided for each of these, a pupil is put in charge of each function and then, as a class, we explore how the computer can follow our algorithm using these controls, as follows:
Algorithm For Operating Washing Machine

Wash clothes in soap and warm water o empty soap into drum o Fill drum with hot water o Turn drum for 30 minutes o Drain hot water

Rinse clothes in cold water o Fill drum with cold water o Turn drum for 30 minutes o Drain cold water


Spin dry clothes o Turn the drum for 30 minutes to spin dry ready for hanging on the line o Drain remaining water
Includes one simple and one more complicated exercise for them to reinforce what they have learnt, represent the simple/ more detailed algorithms in diagrammatic form.
Lesson 3 Debugging the Algorithm
In this lesson, the children are introduced to ‘debugging’. Debugging is, simply, running through our algorithm step by step to ensure it does what it should. A Word doc of examples is provided, containing algorithms with bugs in; go through these with the children and ask them to identify the error. Two stand alone, interactive Powerpoint slideshows (for the two exercises from the previous week) are provided which simulates the washing machine from the computer’s point of view, with a button for each control (empty soap into drum, fill drum with hot water, fill drum with cold water, spin drum for thirty minutes, drain water). The children can use these to step through their algorithms from last week to identify if they work. Where a step doesn’t work, they are encouraged to correct it.
Lesson 4 Using Selection in our Algorithm
Our initial algorithm was a sequence of steps. This lesson introduces decision-making into our algorithm, which is termed selection. Our initial algorithm assumed that nothing could go wrong; now we look at where problems could occur and build in safeguards. In this lesson, we are asking
‘what if?’ Hence, what if the door is not closed? When the drum is filled with hot water, it will flood out over the floor. What can the computer do to prevent that? Test to see if the door is closed before filling the drum, and beep if it’s still open. A typical selection statement follows the form:
if (a condition is true) then (do action 1) else (do action 2) so in our open door example, it would be:
if (door closed) then (fill drum with hot water) else (make warning beep)
The lesson goes through several examples, illustrating them in diagrammatical form and there are several examples for the children to try themselves.
Lesson 5 Using Repetition and Variables in our Algorithm
As well as instances where one of two paths can be taken, based on the result of a decision, there are also situations where a computer needs to perform the same sequence of tasks over and over again for a limited period. This is called repetition. A typical repetition statement follows the form:
Repeat (action(s)) until (a condition is true)
Though there are other forms.
In our washing machine algorithm, the clearest example of repetition is when the drum is turned for
30 minutes. Again, a volunteer is chosen to act out turning the drum, while the teacher teases out

with the rest of the class that to achieve the step, the child has to repeatedly turn the drum and check the time, until 30 minutes has passed. As an algorithm, that looks like this:
Repeat:
Turn drum;
Check time;
Until time = 30 minutes
Note also, that time, then, is a variable. Show this to them in diagrammatical form.
Get the children to complete the exercise.
Lesson 6 and 7 Revisiting Everything That Has Been Learnt
Over these two final lessons, the children are given a chance to use what they have learnt by producing an algorithm for an additional washing machine function, the ready-to-wear dry cycle.
The exercise includes sequence, selection, repetition and variables.
The first three lessons were successful in as far as the children picked up the ideas of inputs and outputs, breaking tasks up into smaller steps and looking for mistakes quite quickly, and this was reflected in the work they produced. Repetition and selection, on the other hand, while seeming to be understood during the class participation stage, was not backed up by the individual work produced. Also, in future years, I will experiment with different set tasks for determining how much has been retained. However, the usefulness of this POW is that it gathers together all the key changes in one extended half term project, within a recognisable context and provides a useful basis for reiterating and returning to, in different forms (including hands-on programming lessons using
Scratch and Python), throughout the year.
In particular, following the POW through from start to finish with me was very helpful for our KS1
Computing teacher. Initially, he had some anxieties about the extent of the curriculum changes, but by the end had gained confidence in the new topics and was clearer about how to tailor them for his year groups. The Powerpoint resource that simulates the washing machine algorithm proved particularly useful to them.
This POW is a useful introduction to the new aspects of the computing curriculum and is a good starting point for referring back to and revisiting throughout the year. The significant changes in the
Computing curriculum may seem daunting to many Primary Teachers, but hopefully this POW will

make the transition more manageable. Moreover, in attempting to grasp the system of
Computational Thinking (which underlies the new curricular approach), it is important to dwell on the similarities between it and methods that are already taught in the existing core subjects. Maths uses processes, methods and logic to break large, difficult problems into smaller, more manageable ones; this is an aspect of computational thinking. In science, we write, or follow, clear, precise instructions to perform an experiment, we analyse the data that results, and we categorise species into groups and subgroups; these are aspects of computational thinking. In English, we break a plot into a sequence of steps when we plan a story; more complicated, multi-threaded plots can include events which repeat themselves or alternative sub-plots which branch off and run in parallel; these too are aspects of computational thinking. Finally, the ability to simplify a complex problem into its most basic steps is one that is exercised by Primary teachers every day. We will all make excellent
Computing teachers.

Appendix 1
Here is a glossary of terms:
Decomposition
Debug
Control
Simulate
Logical Reasoning
Algorithm
Program
Sequence
Repetition
Selection
Variable this is a way of solving a big problem by breaking it down into smaller, more manageable parts when we have written a program, we execute it (start it running) and test it and correct any mistakes (bugs) that we have made some computer programs control devices. So, for example, a computer inside a washing machine controls the motor to make the drum rotate this is when we do something that looks real but isn’t real. Computers simulate things which would be dangerous in real life so that we can practice them without being harmed. So, for example, a computer flight simulator will have the same controls as a real plane and allows us to learn to fly a plane without the risk of a real plane crash if we make a mistake this is the ability to deduce (work out) additional information from facts we know already. For example, if the Manchester United kit is red and Wayne Rooney plays for Manchester United, then we can deduce that Wayne Rooney wears a red kit when he plays football a set of instructions, written in English, to follow to achieve a specific goal an algorithm translated into a language that the computer understands one instruction following another repeating the same set of instructions a number of times
Key vocabulary: Repeat … until … choosing one of several instructions to perform depending on whether something is true or false.
Key Vocabulary: If …. Then … Else … a place to store a value that changes, for example the current Time, or Score in a game

Appendix 2
Here are some helpful websites:
Two really good online magazines: http://www.computingatschool.org.uk/ http://www.cs4fn.org/
Great computing blog for teachers: http://www.simonhaughton.co.uk/
Some good resources: https://sites.google.com/site/primaryictitt/home/key-stage-2
Games for teaching logical reasoning: http://nrich.maths.org/10019