How we teach computing
This month, the National Centre for Computing Education is sharing its 12 pedagogy principles for computing. These principles can be found embedded across all the work of the NCCE, from the Teach Computing Curriculum materials to our professional development courses, and we have shared many of these principles via our Pedagogy Quick Reads, the Teach Computing podcast, and the regular Research Bytes newsletter. You can now also download a handy classroom poster featuring all 12 pedagogical principles, to act as a quick reminder for busy teachers.
In this article, I'd like to explore the 12 principles in a little more detail, and provide a few more examples of how they might apply to your teaching.
Lead with concepts
As a discipline, computing is rich with concepts, many of which are very abstract. Often, educators can get distracted by the technology, tool, programming language, or context that they are using, however, it is these concepts that should be the main focus of your teaching. With a rich knowledge of these concepts, pupils can build a solid understanding of all areas of computing, which can be applied to new tools, contexts, programming languages, and projects.
Pupils should be supported in developing their conceptual understanding by associating a concept with key vocabulary that is reinforced and revisited. Concepts can be explored and connected using tools such as concept maps, which we’ve talked about in a previous Pedagogy Quick Read. You can also use glossaries to help students define key terminology and help them revise and revisit those terms in the future. Regular recall and revision should form part of your everyday practice, to ensure that these concepts and terms become embedded within students’ understanding and vocabulary.
Structure lessons
Like in any other subject, computing lessons benefit from structure, planning, and a well-thought-out journey through learning. There are several frameworks that educators can use to help them structure their computing lessons. For example, before asking students to create something new, you might ask them first to use an existing example and modify that example before they create their own. The Use-Modify-Create framework can be really helpful in supporting learners to move from the examples of experts to building something that they understand and own themselves.
If we think specifically about programming, a well-evidenced and popular framework that has been developed over the last few years is PRIMM. PRIMM stands for Predict, Run, Investigate, Modify and Make. We have spoken about PRIMM in detail previously, and you can find out more in our Pedagogy Quick Read and in a recent episode of our podcast. These frameworks ensure that differentiation can be built in at various stages of the lesson, and that students are supported, engaged, and challenged at the right moments.
Make concrete
Many of the ideas that pupils will encounter within computing are abstract and complex, and need to be illustrated using concrete examples and activities. Bringing these abstract concepts to life with real-world contextualised examples, and connecting them to other subjects, will help pupils assimilate new ideas into their existing understanding.
There are many ways in which you might make an abstract concept more concrete. An example that computing teachers may be familiar with is unplugged activities, where you take a computing concept and explore it in a non-computing context. You can also make use of analogies and storytelling to help connect a new concept with familiar experiences and analogous examples.
Unplug, unpack, repack
Building on the idea of making concepts concrete is the idea that you should unplug complex terms and concepts, spend time unpacking and exploring them, then repack a shared understanding back into the original terms.
One approach to exploring new concepts is to follow a semantic wave. To begin, you take the terminology used by experts, which is often rich in meanings, and you unpack those meanings. You make them simpler, more relevant to the learners, and more concrete. Pupils explore this new concept using a familiar context and simple terminology, making it easier for them to understand and apply. Following this, the pupils can repack those simple meanings into the expert terminology, ensuring that they understand its nuances and can use it appropriately. By following this wave from the original meaning down to something familiar and then back up, you can build pupils’ understanding and prevent them misunderstanding key terms or being limited to overly simplistic language.
Work together
Collaboration is crucial: not only is it highly prevalent in modern computing professions, but it is also a valuable way for individual pupils to learn from their peers. Specifically, you can use activities such as pair programming, which is a really effective approach to programming where pupils share the cognitive load placed upon them. They work in pairs, with one pupil focusing on the wider problem and the other focusing on the implementation of the code that they are working on. We’ve spoken about pair programming in a previous Pedagogy Quick Read, and it’s a fantastic activity that research demonstrates will support learners in developing their programming confidence and attainment. We've also spoken about peer instruction, which is a great way of building a shared understanding between your pupils whilst identifying and challenging misconceptions. You can support your pupils’ development by providing opportunities for conversation through structured group tasks, to enable them to articulate concepts and develop their own shared understanding.
Read and explore code first
There is no doubt that programming can be a highly rewarding, highly satisfying experience for all. However, you should be in no rush to have your students write their first independent program; in doing so, you may miss out some important steps. We typically wouldn’t ask pupils to write before they had learnt the basics of reading, or encourage them to write number sentences before they could count. Likewise, there is a body of evidence that suggests that pupils who engage in reading code before they write code can enhance and augment their ability to write better code later on. Research suggests that educators should be encouraging their pupils to engage with other people’s code prior to writing their own, to review it, interpret it, understand it, and manipulate it. This approach applies to all sorts of programming experiences, whether they be text-based (eg Python) or block-based (eg Scratch).
Create projects
Pupils need opportunities to apply the skills, knowledge, and understanding that they have developed, and project-based activities can be a great way to facilitate this. Projects give pupils a goal, an audience, and a brief to fulfil, for which they need to make autonomous decisions about the skills, knowledge, and tools that they will need. Projects are a valuable context in which pupils can develop their design, analysis, and evaluation skills, as well as providing opportunities for collaboration. Many of the Teach Computing Curriculum units use projects as a form of summative assessment at the end of the unit, providing students with a project brief as well as assessment criteria in the form of a marking rubric.
Model everything
There are many practices and processes in computing that can easily be taken for granted, for example:
- Program debugging
- Converting data between different forms of representation
- Planning and writing a program from scratch
- Tracing programs and algorithms
- Compressing data
All of these are skills that pupils need to learn and practise, and as an educator, your role is to model these through techniques such as worked examples. A worked example provides a complete (or partially complete) model process for solving a problem or achieving a task. Novice learners can be supported using this scaffolding as a reference to complete similar or parallel tasks. This support can then be gradually removed as pupils become more comfortable.
In programming specifically, educators should consider modelling the process of programming and debugging through live coding, where teachers write programs live with students. The teacher explains their thought processes, modelling how to construct the program, making mistakes, and demonstrating what to do when things go wrong. Taking this approach can help demonstrate the thought processes and approaches of an “expert”, which pupils can apply in their own programming practice.
Get hands-on
Physical computing and making activities are shown to be highly engaging approaches for learners, giving them a sensory, tactile, and creative experience in which they can combine computing with art, craft, and design. Physical computing is both a tool to engage learners and a strategy to help them develop their understanding in more creative ways. This approach also has the benefit of supporting and engaging a diverse range of learners in tangible and challenging tasks. There is also some evidence that girls engage more with physical computing, as a physical project may have more immediate real-world applications.
Physical computing can be utilised to teach many areas of the computing curriculum in all key stages. Whilst primarily supporting the development of programming skills, it can also support more conceptual areas of the curriculum.
Through physical computing, learners can encounter, develop, and practise the whole range of programming skills and concepts, including sequences, loops, conditions, functions, and data structures. Alongside applying these concepts, learners will also encounter other languages, models of programming, and novel computer systems.
Challenge misconceptions
From the very earliest experiences of computing, pupils can easily develop misconceptions about a concept, what it means, and how it can be applied. These misconceptions, if left unchecked, can undermine the students’ understanding and their ability to grasp concepts in the future. As an educator, it is therefore important for you to understand common misconceptions that students are likely to encounter, many of which are well documented. Prepared with this knowledge, you can use a range of techniques to challenge those misconceptions. There are some great ways to achieve this. In particular, concept mapping can be used by pupils to connect and define concepts visually, and peer instruction can be used to challenge students and engage them in dialogue, which can uncover and address misconceptions. As well as in a couple of relevant Pedagogy Quick Reads, common misconceptions are highlighted and addressed throughout the Teach Computing Curriculum materials.
 Quick Read - Peer Instruction |
 Podcast - Peer Instruction |
 Quick Read - Concept Maps |
 Teach Computing Curriculum |
Add variety
Explore and employ a wide variety of activities and teaching approaches in your computing lessons. Sometimes, an activity with a high degree of direction may be appropriate, but other times, you may want to use a more exploratory approach. Some activities may require more scaffolding and support, while others may be appropriate for promoting more active learning. Your lesson objectives might also call for alternative formats such as debate and discussion, and even role play. Expanding the approaches in your personal teaching toolbox will enable you to adapt your instruction to suit different objectives, help keep your pupils engaged, and encourage and foster greater independence.
Foster program comprehension
The final principle relates specifically to programming, and it's something that we've talked about in a recent Pedagogy Quick Read. It's important when programming that learners are exposed to and appreciate both the function and structure of programs, and not simply keywords, syntax, and symbols.
The Block Model is a useful framework through which to view this notion of program comprehension, as it captures 12 perspectives through which a programmer might view a program. Each of these perspectives is useful, and you should encourage your pupils to be able to use each perspective and traverse between them. There are many ways in which you might support program comprehension, but particular examples include activities that promote debugging, tracing, and the use of Parson’s Problems. Additionally, tasks that ask pupils to consider the purpose of a program are very helpful, as are tasks such as naming variables, functions, or programs; predicting the output of a program; or matching programs to their purpose.
These simple comprehension activities should be embedded into your practice on a regular basis, to secure understanding and build stronger connections with new knowledge.
About the author
James Robinson, Senior Learning Manager (Pedagogy), Raspberry Pi Foundation