CPD for Computing Teachers

CAS Tenderfoot

How Computers Do Stuff Algorithms + Data Structures = Programs

Training Notes

The Big Picture Training Notes to support How Computers Do Stuff: Algorithms + Data Structures = Programs

CAS Tenderfoot

Background

This is the second Tenderfoot Unit with a focus on learning how to program. Many teachers new to Computing will be learning a programming language for the first time. There are many good introductory manuals for different languages but they tend to focus on the specifics of the particular language, and often follow a well-defined structure, using examples to illustrate each element they cover. This unit does not aim to teach a language, nor should it. The aim is broader; locating programming in the context of the practical realisation of problem solving. Computational thinking requires computational doing.

As the name suggests, the focus is on highlighting the key concepts that underpin the idea of Computational Thinking. The first Unit (Laying Firm Foundations) put a heavy emphasis on identifying the key constructs used to create algorithms, exploring the notion of a variable and emphasising that repeated exposure to these simple ideas is essential for laying a firm foundation on which to build. Decomposition was introduced as a technique for handling complexity and procedural abstraction used to illustrate how more complicated programs could be built and understood. Visual languages were primarily used, with text based programs introduced through a restricted toy environment.

This Unit builds on that approach, but the focus shifts to developing approaches to manage the transition to the industry standard languages used in Key Stage 4 upwards. Concepts remain to the fore, but the challenges include more complex problems. The equation ‘Algorithms + Data Structures = Programs’ provides the framework for approaching these problems and there is an emphasis on two big cognitive hurdles, manipulating linear data structures (arrays) and the nesting of programming constructs.

The extra demands presented by text based programming should not be underestimated. A constant theme throughout this, and the previous Unit is for children not to try to run before they can walk. Learning to program is difficult. There is a heavy cognitive load. Pedagogy has a vital role to play. A strong emphasis on concepts that run, like a golden thread, through approaches to all programming challenges helps children see the wood from the trees. The Unit continues to develop a staged approach to teaching programming, each activity having limited goals to minimise potential confusion. It uses two ‘transitional environments’, Turtle System (developed at Hertford College, University of Oxford) and Small Basic which have been designed specifically to support children stepping up to text based programming. This is an exciting time to engage in the subject pedagogy of coding. We hope to encourage discussion about the barriers children face, providing activities to focus on specific constructs or concepts, whilst hopefully providing motivating contexts and ideas to use in the classroom.

‘How Computers Do Stuff’ picks up where ‘Laying Firm Foundations’ left off, considering the legacy of Seymour Papert and Logo. Turtle System takes directly from some of his pioneering ideas, using an exploration of turtle graphics to illustrate and reinforce foundational concepts. Developing understanding is promoted through activities that involve reading and explaining, before writing code. When writing code, an approach is suggested that insists on prediction, observation and reasoning. A straightforward practical exercise is the first of a series of increasingly complex challenges.

The main practical activities use Small Basic, which introduces new terminology associated with objects. Data types are introduced and a classic programming challenge used to gain familiarisation with the environment. The most substantial part of Unit introduces arrays and focuses on challenges to manipulate the values they hold. The first develops and implements shuffling algorithms. The second is a more complex problem involving iterating over an array within nested loops. The final activities use the context of card shuffling to illustrate how an application can be developed with a graphical user interface (GUI). Each activity and supporting material is designed to be presented as a shorter discrete session.

2

The aim of the day The aim of the Unit is summarised in the learning objectives for teachers attending all the sessions. The primary aim is to educate teachers and illustrate the breadth and depth of Computer Science. The specific outcomes for teachers from this full Unit, are to

Be aware of tools to assist the transition to text based coding

Recognise the key concepts and constructs for tackling programming challenges

Appreciate the purpose of different data types and have practical experience manipulating linear data structures (arrays)

Develop a graphical interface for a simple program

Explore a range of activities for introducing programming concepts at KS3 upwards

The purpose of Tenderfoot is to equip trainers with material and ideas to meet these outcomes and broaden the outlook of teachers new to Computing.

It hopes to provide a buffet of resources on which teachers can draw, to enrich their Key Stage 3 lessons, at the same time as meeting the key aim: providing greater depth of knowledge for teachers themselves.

Developing teachers is the focus, not providing activities for pupils.

The purpose of a full Tenderfoot Unit is to equip trainers with material and ideas to meet these outcomes and broaden the outlook of teachers new to Computing. It hopes to provide a buffet of resources on which teachers can draw, to enrich their lessons (Key Stage 3 and above), at the same time as meeting the key aim: providing greater depth of knowledge for teachers themselves. Developing teachers is the focus, not providing activities for pupils.

Throughout the material there are references to famous computer scientists and lots of pointers to other material. The aim is to encourage teachers to delve deeper and take ideas further.

Before delivering the unit, please check you are comfortable with the narrative and references to other material. The individual Session Notes include a summary of each activity. Ensure you rehearse the delivery to familiarise yourself with transitions and animations. The slides include further detailed notes.

Outline Structure Training Notes to support How Computers Do Stuff: Algorithms + Data Structures = Programs

CAS Tenderfoot

Keep in mind the main purpose of the session – to engage experienced teachers with some of the deeper ideas in Computer Science they may not be familiar with. This sort of background knowledge is broadly ‘A Level’ standard. In time, all Computing teachers should have this grounding, so the aim is to empower the experienced teachers, providing them with material they can deliver and use with less experienced colleagues in shorter training sessions.

There is a greater emphasis on practical coding in this Unit with several key exercises and supplementary material. The pace should be fast, with the assumption that the audience are experienced teachers, probably already teaching to GCSE level. However, programming experience cannot be taken for granted and time needs to be taken to establish familiarity with the environment and the level of the audience. The time taken to complete the early exercises should give a good indication of the pace to set. With experienced coders they will not need to work through every activity in full. If progress is slower than anticipated, remember the maxim ‘don’t run before you can walk’ applies to teachers too. Sometimes it will be sufficient to part complete an activity so teachers ‘get it’ and can discuss how it might be used. Judgement is required and the timings below are indicative, to help with planning. Always be flexible and encourage discussion and engagement. Details of each activity are given in the individual Session Notes. Further guidance on the narrative, slide transitions and animation can be found in the slide notes.

Indicative Timetable

The Training Presentation is broken down into 5 sections, with several formal theoretical inputs and six practical activities outlined below:

10 minutes

Establishes key outcomes from the day for teachers (5 mins).

Quickly considers the requirements of the national curriculum at KS3. Sets the session in the context of the key educational goal: developing computational thinking.

75 minutes

Considers what we can learn from the pioneering work of Seymour Papert. Introduces Turtle System, talks through two sample programs emphasising the need to make predictions before observing, then investigating program behaviour (15 mins).

Group investigation of a series of programs to illustrate key concepts, including procedural abstraction and generalisation through parameters. Introduces capabilities of Turtle System (25 mins).

Practical coding exercise to ascertain level of group (20 mins).

Demonstration of Turtle System configuration options (10 mins).

60 minutes

Introduction to Small Basic, the IDE, intellisense, object based terminology and data types (15 mins).

Group exercises reading and predicting behaviour of 4 sample programs (15 mins).

Practical coding exercise (20 mins) dependent on group.

2

60 minutes

Introduction to compound data structures, indexing and using a loop to iterate over an array (10 mins).

Practical activity developing and implementing shuffle algorithms. Complexity of the task can be varied depending on group capability (30 mins).

More complex problem solving: The Hundred Doors Puzzle. A practical coding activity from first principles involving nested loops (20 mins).

60 minutes

Introducing the principles of a GUI, control objects and event driven programs. A practical investigation and amendment of an existing application (40 mins) with plenty of potential to extend for experienced teachers.

A final optional additional activity investigating perfect riffle shuffles (20 mins) again with potential to extend and incorporate in the Card Shuffler app.

10 minutes

A short discussion to promote classroom research and encourage reflective practice.

Draw out suggestions for potential research areas and mention possible techniques.

Ends with a quick promotion of the BCS Certificate in Computer Science Teaching

5 minutes

Concludes by reiterating the points made at the start of the day.

End with the emphasis on developing computational thinking.

Distribute any materials and discuss ways to deliver smaller presentations.

Above all else, remember that the aim is to empower attendees to offer similar sessions to colleagues. It should be inclusive, enjoyable and embody the CAS ethos of collegiality: There is no ‘them’, only us!

Suggested Reading Training Notes to support How Computers Do Stuff: Algorithms + Data Structures = Programs

CAS Tenderfoot

When someone books to attend your training session, send a prompt acknowledgment informing them when final confirmation and further details will be sent. Set a cut-off date, at which point you can decide if there are enough bookings to make a viable session.

Once you have enough people booked, contact them again with brief details and suggested prior reading. Although not essential, by suggesting some prior reading you are indicating that this is in depth CPD which requires some commitment on the part of the attendees. It also gives you a chance to establish some dialogue with attendees prior to the event. With a week to go, you could mail a reminder and enquire about the reading and whether it would be useful for teaching. This helps keep the attendees focused on the event.

Prior Reading

This Unit follows on from the Tenderfoot Unit ‘Laying Firm Foundations’. Attendees may have looked at the prior reading for that Unit. However, this is a good time to remind them if they didn’t. Paul Curzon, from QMUL, editor of the free magazine and CS4FN website, has written an excellent introductory book, “Computing Without Computers”. It introduces many key ideas in Computing in a child friendly way, often by way of analogy. Although the whole book is recommended, chapters 3 to 7 made ideal introductory reading for ‘Laying Firm Foundations’. They introduced a host of ways to explain the key constructs of sequence, selection and repetition, along with ideas to introduce variables

and accessible explanations of functions and procedures. If they haven’t been read, now would be an excellent time to reinforce the key concepts these activities exemplify. Chapters 8 to 10 are a good follow up, dealing with Input/Output, Object Oriented Programming and Arrays respectively. The latter two are a particular focus in this Unit. They can be downloaded from goo.gl/obpAUq.

This Unit has a practical flavour. To allow it to focus on pedagogy and avoid too much time getting used to software it would be advantageous for all attendees to have had some initial experience of Small Basic. If they are bringing their own computers, it needs to be installed. It can be downloaded from smallbasic.com/. The free tutorial ‘Introducing Small Basic’, signposted in this Unit can be used to gain familiarity with the software; the early chapters being sufficient. It can be downloaded via the same link. Turtle System, from Oxford University, requires no installation or prior familiarity, but if attendees are using their own equipment it is worth checking it runs beforehand. It is included in the resources, but the latest version is always available at https://www.turtle.ox.ac.uk/.

Further Reading

‘Laying Firm Foundations’ and ‘How Computers Do Stuff’ are the only Tenderfoot Units looking specifically at teaching programming with children, but many other units contain coding activities. As teachers and students begin to engage with more complex challenges good software practices become more important. Tenderfoot isn’t the place to develop these in depth but basic practices should be instilled from the start.

Jeremy Kubica has written a very entertaining follow-up to his hugely successful book/blog, Computational Fairy Tales. ‘Best Practices of Spell Design’ introduces practical aspects of software development that are often learned through painful experience. As the introduction notes, ‘Through Marcus and Shelly’s quest, the story encourages readers to think about how to write readable, well-tested and maintainable programs. Readers will discover the importance of comments in recipes, the value of testing potions, the dangers of poorly named ingredients, the wonders of code reviews in magic libraries, and the perils of premature optimization.’

Future Master Teacher Delivery Training Notes to support How Computers Do Stuff: Algorithms + Data Structures = Programs

CAS Tenderfoot

The Unit presentation is designed to support a full day of CPD, delivered to CAS Master Teachers and other curriculum champions. It will likely be fast paced, delivered to experienced teachers, involving practical engagement in the coding exercises. It is difficult to estimate timing as it depends very much on the experience of the audience.

The first two coding exercises are designed to establish the capabilities of the attendees. It is envisaged that those attendees will take the material and deliver shorter sessions, either as half day, twilight or CAS Hub inputs. The same ambiguity regarding timing is likely to arise in any subsequent sessions. However, it should be expected that practical activities will take a lot longer as teachers new to Computer Science will likely require much more time to code. If coding is likely to take longer than anticipated time can be saved by demonstrating and ‘talking through’ some of the activities. Please find an opportunity to discuss with attendees possible ways to use the material and encourage them to offer further sessions in their locality.

Resources All supporting material is available for download.

The Unit includes a full Training Presentation and these accompanying Training Notes.

Further material corresponds to each Session in the Unit and includes;

a Session Presentation to support all the activities covered in the session

a set of Session Notes explaining the material for each session

separate activity handouts, suitable for classroom use

If you intend to use the material in shorter sessions, please use the Session Presentations as these are tailored to self-standing delivery.

Half Day / Twilight CPD Sessions It is suggested the material in this Unit could be delivered as four separate shorter sessions. Transitioning to Text focuses on using Turtle System to illustrate the key constructs and concepts previously introduced in the Tenderfoot Unit, ‘Laying Firm Foundations. The content covers sequence, selection and repetition, variables, decomposition, procedural abstraction and parameters. ‘Proper’ Programming introduces Small Basic and the terminology of objects, properties and methods. Simple programming exercises are used to illustrate the key constructs and concepts involved. It also introduces data types, distinguishes between counter and condition controlled loops, and includes a classic beginners programming challenge as a practical exercise. Algorithms and Data Structures provides Small Basic exercises that introduce arrays and focus on manipulating data within them. More challenging exercises, involving iterating over arrays and nested constructs are included. It also introduces procedures and the flexibility to develop differing levels of complexity in the solutions. Going Gooey introduces the idea of event driven programming. It analyses and challenges attendees to make simple amendments to an existing program. It builds on the previous session with potential to extend complexity through challenges involving array manipulation.

Of course, Master Teachers and other trainers can combine sessions and activities as they feel best fit the local circumstances. Whatever ways you choose, the aim is to develop teacher appreciation of Computer Science concepts and pedagogy not just demonstrate an activity. We hope they are useful.

A Reflective Practitioner Training Notes to support How Computers Do Stuff: Algorithms + Data Structures = Programs

CAS Tenderfoot

A new subject offers lots of potential for research on the part of teachers. Throughout the activities in this unit there is encouragement to consider issues, reflect on classroom practice and engage in action research. Not only does it contribute to practitioner’s professional development, but can provide a key part of the evidence required for teacher accreditation via the BCS Certificate in Computer Science Teaching.

Preparation required: Publicity for the BCS Certificate available for all attendees. Familiarity with the questions to be posed and consideration of how to facilitate discussions.

Points To Ponder

Scattered throughout the trainer’s presentation are ‘Points To Ponder’ slides. Usually at the end of an activity, they have a dual purpose, both practical and professional. From a practical point of view, by posing a question for short discussion, they provide the presenter with a few minutes to prepare for the next activity and gather their thoughts. Moreover, they encourage attendees to converse with each other. The aim is not to engage in a lengthy discussion, but to plant ideas that could be pursued as classroom research. Near the end of the presentation, we hope you will raise the value of such action research.

In this Unit, the questions posed at the end of an activity are:

Transitioning to Text: What lies behind the syntax barrier? What facilities do ‘educational’ environments like Turtle System offer to help with that transition to text. Can you suggest helpful tools in other languages? The aim is to try to draw out recognition of the challenge the syntax barrier poses. Restricted environments, such as simple html markup, and RoboMind (introduced Laying Firm Foundations) help focus on specifics and lower cognitive load. Turtle System is much more powerful, but illustrates other advantages of a purpose built environment. One example is targeted error messages – can attendees identify others. Equally, are there any pitfalls in following this approach?

‘Proper’ Programming: Simple exercises like Fizz Buzz practice assembling selection and repetition constructs. They consciously avoid cognitive overload; there are no variables, no data structures, no procedures and no parameters. Can you suggest other exercises that meet these criteria? The focus here is around recognition of the difficulties involved in learning to program. Like any complex task, it can be decomposed into smaller problems, with activities designed to emphasise particular facets. It is likely that attendees will be a rich source of suggestions for other activities that could adopt this approach.

Algorithms and Data Structures: What facilities does Small Basic offer to help with the transition to text based programming? How does it compare to Turtle System? How many different languages should children be introduced to? Like previous discussion points, the primary focus is to develop a recognition of the challenge the syntax barrier poses. Attendees will now be familiar with some of the facilities in Small Basic and should be in a position to make comparisons, either in relation to Turtle System, or RoboMind (from Laying Firm Foundations) or many other educational tools. There is scope for a discussion about how many different languages children should be introduced to. What might be the problem of too many, or too few?

Going Gooey: Event driven programming, using a graphical interface, represents a different way to approach problems. Objects are assembled, and code attached to events they support. Does this make it easier or harder to learn? There is a long standing debate about the value of introducing children to event driven and object oriented programming. Traditionally, the ‘step up’ to object based approaches is seen as difficult. But many children’s environments use objects – think of Scratch, where code is attached to sprites. Perhaps we should be introducing and highlighting objects from the start? Why might some object to this?

2

Class Based Research

Why? Before concluding the session, it is worth pausing to prompt a discussion about the value of

classroom research both to support continuing professional development and to inform the wider teaching community. Use the terms “teacher enquiry”, “action research”, “reflective practitioner” and “practitioner research”. Teaching computer programming is a relatively new activity. Many teachers are experiencing it for the first time. Those with experience can offer valuable support, advice and information to other colleagues. There are lots of opportunities for colleagues, old and new to contribute to an emerging pedagogy, particularly in this field. Inform attendees of the CAS Teacher Inquiry in Computing Education project. It provides a forum and focus for research in the field of computing. It can be accessed from the home page of the CAS website, under the link to projects: http://www.computingatschool.org.uk/

Research an area in which teachers have ready access to the data but be aware of researcher bias and local ethical considerations. Don’t try to prove something you believe – always think that you are “bringing a better understanding” of the situation – it helps avoid bias.

What? Emphasise the key words such as “find out”, “evaluate” and “compare” to spark ideas. Each of

the following give examples for a possible focus for research:

Find out about pupils preconceptions of why they are learning computer programming.

Evaluate the use of a regular starter based on tracing (dry running) or reading code.

Compare school data about the pupils with their performance in programming sessions.

Design, implement and evaluate a teaching module to support primary transition.

How? Briefly tell the audience of different methods. Choose one of the examples from the suggestions

above, or those raised in ‘Points To Ponder’ and discuss methods which might be used. Remember – all research has ethical considerations. Remind them that if they embark on a University course then they will be governed by their ethics policy. Similarly, if completing the BCS Certificate then there is an explicit ethical requirement.

BCS Certificate in Computer Science Teaching

End with a reminder of the BCS Certificate in Computer Science Teaching – ensure hand-outs are available. One part of the evidence for the award is classroom research undertaken by the teacher. The other two areas involve attending CPD – like today, and completing a manageable programming project.

If that sounds a little daunting, remind teachers they can opt for either an independent or guided route. The latter means they have support from a mentor who can help guide them through the requirements. It is a valued award, giving professional recognition, accredited by the BCS, The Chartered Institute for IT. More importantly, it’s designed to help teachers in the work they are developing in school. Encourage teachers to seek support from their schools to gain accreditation. Ensure they raise it as part of the performance management cycle. More information is available at: http://www.computingatschool.org.uk/certificate.