Programming

By the end of this lesson students will be able to design and algorithm for a chatbot and implement it using a visual program.  

Retrieval: If a computer could have a conversation, what instructions would it need to know what to say next? 

Computers do not understand conversations the way people do. They respond by following algorithms that tell them what to do when they receive different inputs. By creating a chatbot, we can explore how instructions can be used to simulate a conversation. 

Explain that we will learn to code a simple conversation using questions, answers and decision-making. 

Step 1: Start with an algorithm. 

The class settles on a simple algorithm for their chatbot’s first question and response. The algorithm can be developed as written text on the board. This example makes use of two blocks (ask and answer) that are useful for early programming. 

For example: 

1. Ask ‘Which flavour ice cream is your favourite?’ 
2. If the answer contains ‘chocolate’ 
   • • Say ‘Chocolate is awesome.’ 
   • Otherwise 
     • Say ‘That’s OK, but chocolate is better.’ 
3. (Optionally) Ask the same question another two times. 

Step 2: Write and run code. 

Students code the algorithm in a visual coding environment like Scratch. This can be done explicitly, with the whole class, or students can be given time to do it themselves. 

Step 3: Build on it. 

Have students continue the conversation with other questions and responses. 

Note: Activities in this lesson are designed to develop foundational programming skills. Although students may associate chatbots with generative AI, the chatbot developed in this activity is a rule-based program that responds according to predefined algorithms rather than generating new content. 

By the end of this lesson students will be able to create a visual program that responds to a condition by changing the stage backdrop. 

Retrieval: When playing an online game, what might happen if your character runs out of lives or health? How does the game let you know? 

Games often react to what is happening during play. Programmers use conditions to make events happen when certain requirements are met. In this lesson, we will create a game that changes its backdrop when the player's health changes. 

Goal: Add code to a game that will change the stage backdrop depending on the player’s health score. 

Rather than design an entire algorithm without coding, the class will build up code a little at a time, with the teacher adding ‘bugs’ to solve. 

Students may notice that the above code is not working as expected. The doing well backdrop appears at the start, but the backdrop does not change to defeated when the player reaches zero health. 

Why? 

The computer only checks the health value once, right when the game starts. 

What is needed to make the computer keep coming back to check?

What’s needed is a loop.

Now the health value is continually monitored. 

We want four different backdrops: 

• doing well backdrop when health is above 50 
• health low backdrop when health is between 25 and 50 
• health very low backdrop when health is between 0 and 25 
• defeated backdrop when health is 0. 

The expanded code is also not working as expected. The backdrop changes continuously, or gets stuck on health very low, even when health is 25 or more. 

Why? 

Step through the logic carefully. The IF-THEN blocks are all running as separate checks after each other. This means as long as health is greater than 0, the health very low backdrop overrides the previous settings. 

What is needed to make the checks more sophisticated? 

A different arrangement of control structures is needed, with the use of IF-THEN-ELSE structures. 

Discuss how this logic is different, and why it works. 

By the end of this lesson students will be able to create a function that draws a regular polygon with a specified number of sides. 

Retrieval: What instructions would you give a computer to draw a shape such as a square or triangle? 

Computers draw shapes by following a sequence of instructions. By identifying patterns in these instructions, we can create algorithms that draw many different shapes instead of just one. 

Students explore polygons and as a class record their observations in a table:

Ask: 

• What happens to the turn angle as the number of sides increases? 

What relationship is there between the number of sides and the turn angle? How can we write an algorithm that works for any regular polygon? 

Goal: Starting with a simple square, gradually code a function that can draw any polygon with a specified number of sides. 

Test at each step. First, we get a result like this: 

There should no change to the drawn shape. 

Note how the left turn angle must be adjusted to make a complete polygon each time. 

How can we make it work for any number of sides? What’s the pattern? 

Here’s a working algorithm in pseudocode: 

REPEAT no_of_sides TIMES 

MOVE FORWARD 100 

TURN LEFT (360 ÷ no_of_sides) 

END REPEAT 

With no_of_sides set to 5, we should get a pentagon. 

Discuss, why is this a better way to organise code?  

Consider that we can now call draw_polygon at any time, for any number of sides we want. 

Through this activity, students recognise that programmers can generalise solutions by identifying patterns, using variables and parameters, and organising code into reusable functions. 

By the end of this lesson students will be able to explain the effect on quality of images and audio files by different compression techniques.  

Retrieval: Why might someone choose a lower-quality image or audio file instead of the highest-quality version available? 

Reducing a file's size can make it easier to store, share and transmit, but this may affect quality. In this lesson, we will explore how different compression techniques involve trade-offs between file size and fidelity. 

Students work with a digital image or sound file and create multiple versions using different compression settings. 

Students: 

• compare file sizes and quality across multiple compressed versions 
• observe changes in quality 
• identify whether compression is lossy or lossless 
• explain how the purpose of the file influences which version is most suitable 
• select the most appropriate version for a given purpose and justify their choice. 

Students discuss: 

• what information is removed or preserved during compression 
• how compression affects storage, transmission and user experience 
• why a smaller file size may reduce quality and affect how the file can be used. 

Through this activity, students recognise that digital representations are designed for particular purposes and involve trade-offs between file size, quality, storage requirements and ease of transmission 

By the end of this lesson students will be able to use code to analyse a large dataset.  

Retrieval: How can you analyse a large dataset in a spreadsheet? What challenges might arise when the dataset becomes very large? 

Spreadsheets are useful for many data-analysis tasks, but some forms of analysis become difficult when datasets are very large or unstructured. Programming allows us to automate complex processing and analyse data at a much larger scale. 

Goal: Gradually code an application to read in text for an entire (out of copyright) book, then find the most frequent words. 

This is an example of data analysis that is difficult in a spreadsheet, but easier with code. 

Already, we are using a simple loop to print every line in the file. 

‘words’ is a list data structure containing the words in the current line. 

We are attempting to strip all special characters that are attached to each word. We also convert each word to lower case. 

Discuss: Why is cleaning the words necessary? 

Students should recognise that: 

• ‘Dog’, ‘dog’ and ‘DOG’ should usually be counted as the same word. 
• Punctuation attached to words creates duplicates. 
• Raw data often contains inconsistencies. 
• Data cleaning improves the quality of analysis. 

We’ve added a dictionary data structure called ‘word_frequencies’. This data structure will hold each unique word alongside the number of times it appears in the book. 

Note that the single line of code used for sorting could be considered a ‘shortcut’. It saves implementing a sorting algorithm from scratch, but it uses advanced functions and techniques that students are not expected to know at this point.  

Students could instead code their own sorting function with a known algorithm, such as a Selection Sort.