Learning Objectives:

• Understand algorithms (written in pseudocode or flow diagram), explain what they do, and correct or complete them
  
• Produce algorithms in pseudocode or flow diagrams to solve problems
  

Lesson 1: Theory (Flowcharts)

Suggested time: 50 mins

Starter

I started by showing students a clip from an episode of the Big Bang Theory in which Sheldon shows his friendship algorithm in the form of a flowchart. (Thanks to Phil Smith for suggesting this one via CAS)

Introduction:

I started by explaining that an algorithm is simply a sequence of steps for completing a task. I went on to explain that algorithms can be represented in many ways, the most commonly used being flow charts and pseudocode.

I followed this by going through an example on the board (see below).

Next, I displayed a set of the most commonly used flowchart symbols on the board and explained what they meant (see below). I then challenged the students to give examples of how each symbol might be used – giving prompts where necessary.

Activity 1: (Interactive Challenge)

I followed the introduction with two matching exercises which I downloaded from clickschool.co.uk - see below (requires flash).

In the first matching exercise, students had to match the flowchart symbols to their names. In the second exercise, students were challenged to complete a given flowchart by placing the events in the correct order.

Activity 2:

With input from the students, I went through the solution to the second matching exercise - “going to school”. I then asked the students to suggest what daily routines were missing from the example.

Students were then placed into small groups and asked to improve the algorithm for getting up and going to school in the morning (in the form of a flowchart).

Tip: You can get the students to write down any algorithm (e.g. making the tea, tying a shoelace, making a jam sandwich etc.) however, I find, the more complex the algorithm, the easier it is to explain the need for sub-routines later in the lesson. The going to school algorithm is great for demonstrating this as you can have several sub-routines for brushing your teeth, taking a shower, making breakfast etc. Also, try to encourage your students to make their algorithms as detailed as possible - this will also help with explaining the need for sub-routines later. 


Activity 3:

Whilst the students were busy creating their flowcharts, I wandered around the classroom and picked out the group with most complex solution. I then invited that group to replicate their flowchart on the whiteboard and explain their solution to the rest of the class. As the group explained their solution, with the aid of the class, I corrected any errors and highlighted any misconceptions.

I waited for the group to fill the whiteboard, at which point I stopped them and asked the rest of the class to suggest how the group could simplify / clean up their flowchart. This is where I introduced the flowchart symbol for sub-routines (see below).

Activity 4:

I asked the students to suggest the possible benefits of using sub-routines and waited for answers such as “easier to understand” and “several people can work on the same algorithm at the same time”. I finished by asking the students to modify their solutions to include at least one sub-routine.

Resources:

The friendship algorithm - Clip from an episode of the Big Bang Theory in which Sheldon shows his friendship algorithm in the form of a flowchart.

BBC Byte Size (System Flowcharts) 

Algorithms in pseudocode and flow diagrams - Lesson plan on algorithms in pseudocode and flow diagrams.

Algorithms in pseudocode and flow diagrams - This video, presented by Clive Beale of the Raspberry Pi Foundation, looks at good practice in the techniques of writing pseudocode and producing flow diagrams.

Teach-ICT (Flowcharts)

Alternative Activities:

There are several ways in which you can introduce flowcharts. Here are some alternatives to the ones I suggested:

1. Jam Sandwich activity.

In this exercise, students are asked to create an algorithm from set commands to program their teacher (sandwich bot) to make a jam sandwich. Students must write a set of working instructions, using commands such as Pick Up and Put Down, which their teacher has to follow precisely in order to make a jam sandwich. This task can be easily adapted to incorporate flowcharts and is great for introducing algorithms (at any age)! To find out more, check out this lesson plan, courtesy of Phil Bagge, CAS Primary Master Teacher (@baggiepr): Jam Sandwich Algorithm (programming teacher bot)

2. Making the tea starter.

This is a starter activity I use to introduce algorithms. Print and cut out the attached instructions for making a cup of tea. Instruct students to put the instructions in the correct order. The “Making the Tea” exercise has been doing the rounds for sometime. I remember doing it at college back in the early 90’s. What I find interesting is seeing all the different variations for such as simple task. Extension task: If your students are feeling really confident, you could challenge them to create a BS 6008 compliant algorithm for making the tea!

3. More flowchart tasks.

Here are a set of Flowchart tasks for simple activities (making tea, coffee, pizza, lasagna etc.) courtesy of David Barnard (via CAS). Includes a differentiated version of the making tea exercise. (Requires you to login to the CAS community - FREE)

Tags: GCSE Computer Science, Algorithms, Pseudocode, Computing

In my fifth lesson, I decided to look at the CPU in a little more detail, exploring the three major parts: Arithmetic/Logic Unit (ALU), Control Unit (CU) and Memory. I also decided to spend a little time looking at the Little Man Computer simulation to demonstrate the fetch-execute cycle.

Learning Objectives:

• State the purpose of the CPU
  
• Describe the function of the CPU as fetching and executing instructions stored in memory
  
• Understand the concept of machine code instructions
  

Lesson 1: Little Man Computer

Suggested time: 50 mins

Starter:

I started with an activity, courtesy of CS Unplugged, which provides students a basic understanding of how computers work by having them act out a simple computer simulation.

Each student takes on the role of a different part of a simplified computer (CPU, ALU and Display) and, working in groups of three, run a simple program. The end result of this program is to draw a picture on a simulated computer display.

You download the activity here: http://cse4k12.org/how_computers_work/index.html 

Main:

I showed students a CPU, left over from the first lesson, and explained to students that, in the starter activity, they simulated what goes on inside the CPU (All be it at a very basic level!). I then explained that we would be taking a deeper look inside the CPU using a simulation called Little Man Computer (LMC). - http://www.yorku.ca/sychen/research/LMC/LittleMan.html

I loaded Little Man Computer and explained to students that the main function of the CPU is to fetch and execute the instructions. I then showed students an example set of instructions to add two numbers and loaded it into the simulator to show students how the simulator works. 

Note: At this point, depending on the group, you could also show students an animation showing how the fetch-execute cycle works. Here are a couple of good examples:

http://www.eastaughs.fsnet.co.uk/cpu/execution-fetch.htm

http://community.computingatschool.org.uk/resources/95#post_18284 (Requires you to sign up – FREE)

Next, I gave students a sequence of instructions, which I printed and cut into pieces. (See attached). I asked students, in their teams, to load the Little Man Computer simulator and execute the sample program. I then asked the students to place the printed instructions in the correct order and recorder their answers on the task sheet, provided. After 5 mins, we discussed the students’ findings.

After discussing the sample program with the class, I then showed them the LMC reference sheet (See attached) and explained the different instructions.

Finally, I challenged the students, using the reference sheet and what they had learnt, to write a program to add 3 numbers and execute it in the LMC simulator. As an extension, I asked some students to write a program to add and subtract a number or to write a program of their own.

Extension: If you are feeling really brave, you could ask the students to convert the instructions from machine code to binary.

Resources:

Plenary: CPU Dingbats

I finished by playing a game of CPU dingbats (See attached). This version is based on a starter activity shared via CAS by John Bilton. (Original version can be found here: http://community.computingatschool.org.uk/resources/1314). Once the students had guessed the answers correctly, I explained to them that their homework was to research each of the three keywords (Clock Speed, Core and Cache Memory) and to explain how these effect the speed of the CPU. I asked the students to use their revision wikis to record their findings.

Lesson 2: TouchDevelop Challenge

Suggested time: 50 mins

Main task:

Following on from the previous week’s lesson, I asked students to load TouchDevelop (www.touchdevelop.com) on their computers and sign in with their google, microsoft or yahoo id.

Once logged in, I directed the students to the TouchDevelop Challenge website (www.touchdevelop.weebly.com) and challenged them to attempt lesson 2 of the TD Challenge (http://touchdevelop.weebly.com/td-challenge.html).

Plenary:

To finish the lesson, I asked the students to swap seats and invited them to try out each other’s scripts - giving feedback where appropriate.

In my fourth lesson, I decided to give the students a little break from the theory element and do some simple programming using TouchDevelop Turtle. But first, I thought I would teach them about algorithms.

Learning Objectives:

• Understand algorithms (written in pseudocode or flow diagram), explain what they do, and correct or complete them
  
• Understand and use sequence in an algorithm
  
• Understand and use iteration in an algorithm (FOR, WHILE and REPEAT loops)

Lesson 1: Understanding Algorithms

Suggested time: 50 mins

Starter:

I started by giving students a sequence of instructions, which I had printed and cut into pieces, for making a cup of tea (See attached). I asked students, in their teams, to put the pieces in the correct order. After 5 mins, we discussed the different solutions.

Or if you prefer your students to do the task on computers:

Part 1: Introducing Algorithms

I showed students 3 websites and asked them to explain what each website had in common:

1.    Google maps: Lands end to John O’Groats

2.    How to make a ring wing glider

3.    How to make a pancake

Once the students had worked out that they were all instructions, I then explained that an algorithm is basically a set of instructions for solving a problem.

Part 2: Card Trick

I followed this by demonstrating a simple card trick - courtesy of Mark Dorling (Digital School House). The purpose of card trick is to teach pupils about sequencing and modelling a sequence of instructions. See video below: 

I followed the video exactly, including the Harry Potter story! For some reason my Year 10s appeared to love it! They even seemed to know all the answers.

At the end of the trick, I divided the students into small teams and gave each team a set of cards. I then challenged each team to try to repeat the trick and to produce step-by-step instructions. (Note: Try to encourage the students to write down every step – this is key for the next part). Alternatively, to speed things up, you could ask for a volunteer – someone confident enough to explain the trick to the rest of the class and another volunteer to write down the instructions on the board.

After each team had completed their step-by-step instructions, I reviewed their answers with the rest of the whole class. I then selected the team with the most detailed set of instructions and showed the instructions to the rest of the class. I then asked the students how could we optimise the instructions. I tried to get them to use words such as repeat or loop. I then asked the students to suggest possible benefits of optimising code – I encouraged students to think about file size, download times, loading times, debugging code and fixing errors etc. I then explained to students about how we can optimize code by using loops and sub-routines.

Part 3:

Finally, I showed students the first task (Making the tea) as a flow chart and explained the different symbols. I then challenged the students to create a flow chart explaining how to perform the card trick. Tip: Don’t worry if the students don’t complete this exercise, the key is that they know the different flow chart symbols and understand how to model a sequence of instructions using a flow chart. 

If you are feeling a little adventurous, and have access to an iOS device such as an iPad, you could get your students to use Grafio to create their flow charts.

Create flow diagrams using Grafio

Plenary:

I finished by reviewing a small sample of students flow charts.

Lesson 2: Turtle Power

Suggested time: 50 mins

Starter:

I instructed pupils to visit touchdevelop.weebly.com, click on Student Showcase and view some of the examples.

I explained to students that they were going to learn how to program a turtle by issuing it simple instructions (algorithms).

Challenge:

I asked students to load TouchDevelop (www.touchdevelop.com) on to their computers and sign in using their google, microsoft or yahoo account.

Once logged in, I showed them the link to the TouchDevelop Challenge (touchdevelop.weebly.com/td-challenge.html) and ask them to download the PowerPoint for lesson 1 (TouchDevelop Turtle) and follow the instructions.


Why TouchDevelop? I find that the turtle facility in TouchDevelop is great for introducing students to programming and teaching students how to model sequences of instructions. Alternatively, if you prefer not to use TouchDevelop, there are a number of great alternatives. See my blog on tools for creating games.

Plenary:

I finished with a game of Cargo-bot on the iPad. Cargo-bot is a fun and challenging game designed to teach programming. The idea is simple; players have to program a crane to move boxes back and forth between platforms. The player controls the crane using blocks (Up, Down, Left, Right) which they must place in the correct sequence however, there is only a limited number of spaces to place the blocks meaning that the player is forced to create sub-routines (progs) to optimise the sequence of instructions. The challenge is to move the crane using the least number of instructions. Stars are awarded for the number of instructions used – The more optimised the instructions, the more stars the player is awarded.

Alternatively, if you do not have access to a set of iPads, you could ask students to swap seats and review each others turtle drawings.

Cargo-bot - Fun and challenging game designed to introduce programming concepts.