Applying Rosenshine to the computing classroom

In 2012, Barack Rosenshine published the Principles of Instruction: a set of 10 research-based principles of instruction, along with suggestions for classroom practice. The principles come from three sources: (a) research in cognitive scienceThe study of the human mind, such as the processes of thought, memory, attention and perception, (b) research on master teachers, and (c) research on cognitive supports.

The 10 Principles of Instruction are as follows:

• Principle 1: Begin a lesson with a short review of previous learning: Daily review can strengthen previous learning and can lead to fluent recall.
• Principle 2. Present new material in small steps with student practice after each step. Only present small amounts of new material at any time, and then assist students as they practice this material.
• Principle 3. Ask a large number of questions and check the responses of all students: Questions help students practice new information and connect new material to their prior learning.
• Principle 4. Provide models: Providing students with models and worked examples can help them learn to solve problems faster.
• Principle 5. Guide student practice: Successful teachers spend more time guiding students’ practice of new material.
• Principle 6. Check for student understanding: Checking for student understanding at each point can help students learn the material with fewer errors.
• Principle 7. Obtain a high success rate: It is important for students to achieve a high success rate during classroom instruction.
• Principle 8. Provide scaffolds for difficult tasks: The teacher provides students with
  temporary supports and scaffolds to assist them when they learn difficult tasks.
• Principle 9. Require and monitor independent practice: Students need extensive, successful, independent practice in order for skills and knowledge to become automatic.
• Principle 10. Engage students in weekly and monthly review: Students need to be involved in extensive practice in order to develop well-connected and automatic knowledge.

On this page, we have gathered a collection of guides for how the principles might be applied to secondary computing. The guides have been written by Keith Gage, Chesterton Community College.

This content was originally produced as part of the Accelerate programme, a Department for Education-funded early career teacher programme designed and delivered by Education Development Trust with the Chartered College of Teaching. It is used here with kind permission of Education Development Trust.

Principle 1: Begin a lesson with a short review of previous learning: Daily review can strengthen previous learning and can lead to fluent recall.

Rosenshine’s (2012) first principle proposes the importance of short reviews of previous learning at the beginning of a lesson, with the idea being to develop fluent recall of subject material and strengthen students’ previous learning. This would seem to be a logical starting point for any lesson that we begin, but I will consider how particularly relevant this is in computer science lessons and how we might go about achieving this aim.

If I was to use a simile of driving a car, practically we can’t start in fifth gear, happily motoring along at sixty miles an hour. We start in first and gradually build up speed. This short review, is our first gear activity for the lesson, where the students can stop thinking about their previous lesson or break time, and start thinking about their computer science lesson. We need to develop momentum in the lesson and practically that begins by ‘revisiting and practising skills or consolidating knowledge’ and also enables us to ‘establish any gaps’ (DFES 2004, p10).

In lesson starters, I use techniques that enable the pupils to be assessed effectively and quickly and to initiate their thinking towards the lesson. Computer science allows us to use online configurable tests like Google forms, which identify each pupil and their score. In addition, this also allows me to subsequently re-test pupils on the same test again at another point in time, which might be as soon as the end of the lesson if I have felt that certain points need revisiting.

I look to also review students based on what they have learnt in any of my previous lessons, not just the most recent. My fear is that the students only remember a narrow set of the last one or two lessons, creating a ‘slide rule’ set of lessons than can be recalled, rather than the entire curriculum to that point.

My key stage 5 students never really knew where a recap quiz at the start of the lesson would take them. Posing questions in this manner meant that I could also understand my and other teachers’ effectiveness in their teaching over the previous months. This provided insight into those lessons that were so effective they could be recalled without practice or prior notice of being tested upon that subject material.

Online quizzes often come with live statistics and graphs which engage the class and demonstrate their overall ability. Statistics help to highlight questions that are frequently wrong or frequently missed, enabling us to evaluate the effectiveness of previous lessons and respond accordingly. Recapping these highlighted questions ensures that students are able to build on their understanding with the content of the new lesson. It also aligns with the current OfstedThe Office for Standards in Education, Children’s Services and Skills – a non-ministerial department responsible for inspecting and regulating services that care for children and young people, and services providing education and skills Framework which promotes the need to identify any misconceptions that the pupils hold and address them with ‘clear, direct feedback’ as well as the integration of any new knowledge within larger concepts (Ofsted 2019).

Misconceptions need to be identified to show the ‘true’ understanding of what the pupil has actually learnt in those lessons. It allows the teacher to look at those elements that they believe all students would know at that point in the scheme of work. I have previously reviewed classes and been amazed that although students might appear to be aware of what programming involves within the lesson, there are gaps and a lack of true understanding that would not have been evident otherwise.

We are therefore looking to ensure ‘deep learning’ where there is a real understanding of the topic, rather than just ‘surface learning’ (Williams & Upchurch 2001) with the pupil simply recalling the facts, and these early reviews are essential in determining which level the child has achieved.

Starting a lesson with a review of previous learning allows students to also gain satisfaction in regards to what they can recall. If they can remember what has already been taught and felt confident in its recall, then their mindset for the lesson is going to begin with a feeling of capability and a stronger impetus to engage with the lesson. With success in this initial task, the child is said to develop an improved concept of their own ‘metamemory’ where we move facts from being ‘wholly irretrievable’ to them being easier to recall (Flavell & Wellmanm 1975, p6). Some students might feel disheartened in regards to how well they could recall those facts, so we also need to focus on ‘previous attainments’ (Lane, Lane & Kyprianou 2004, p255) to ensure a positive mindset towards the rest of the lesson.

If we build upon the foundations of the lesson on a strong footing, our students are more likely to make greater progress when new material is taught. This is because computer science concepts will have been brought to the front of the mind, where previously they were buried amongst the plethora of material from other subjects. We can reflect that as a result, pupils will have better understood the direction and material of the lesson and its links to their existing broader knowledge of the computing curriculum.

References

DFES (2004) Pedagogy and Practice: Teaching and Learning in Secondary Schools. Unit 1: Structuring Learning. Crown Copyright.Available at: https://webarchive.nationalarchives.gov.uk/20110506023606/https://www.education.gov.uk/publications/eOrderingDownload/04 24-2004.pdf (accessed 22 Oct 2019).

Ofsted (2019) The Education Inspection Framework, Crown Copyright. Available at:
https://www.gov.uk/government/publications/education-inspection-framework (accessed 22 Oct 2019).

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Williams L and Upchurch R (2001) Extreme programming for software engineering education?. In 31st Annual Frontiers in Education Conference. Impact on Engineering and Science Education. Conference Proceedings. Reno, Nevada (1): T2D-12.

Principle 2. Present new material in small steps with student practice after each step. Only present small amounts of new material at any time, and then assist students as they practice this material.

Working memory only has the capacity to work with a small amount of information at a time. If we are given more information than our capacity, inevitably some of that information will be lost.

Craik & Lockhart’s (1972) model analogised this storage capacity limitation by comparing it to a computer processor, highlighting the similarities between ourselves and technology and the difficulties in attempting to handle too much information at one time. Rosenshine (2012) proposes that this constraint can be managed more effectively by presenting a limited amount of information at one time and by providing students with practice time to fully develop their understanding.

Teachers have a clear understanding of what their students need to know or what they should have achieved by the end of the lesson. How this is presented to them depends upon the ability of the group being taught. In addition to this, we also need to understand that children have a limited capacity in processing the information that is given to them in all interactions. When we teach code, we might feel the need to spend long periods of time discussing the programming language and how each particular function is used. However, this approach has been shown to discourage the actual problem solving skills we need our pupils to gain (Gomes & Mendes 2007). Furthermore, if we do overwhelm the student, it might result in them feeling incapable, negative or reluctant to perform the work.

Ensuring that each student can develop a belief in their own ability, as well as whether they can achieve their desired result, may improve their performance and their desire to also rethink problems if they have difficulties (Bandura 1992). The enticement is to provide them with enough information that they feel capable of understanding the subject and this then provides them with confidence within the actual task.

Within computer science, especially with codingIn qualitative research, coding involves breaking down data into component parts, which are given names. In quantitative research, codes are numbers that are assigned to data that are not inherently numerical (e.g. in a questionnaire the answer 'strongly agree' is assigned a 5) so that information can be statistically processed., there are concepts that need to be understood fully before continuing. If we are to imagine their understanding to be similar to climbing a flight of stairs, not fully understanding particular steps results in steps being ‘missing’ for the pupil and makes it more difficult for them to reach the next step. If these steps are missed out, a teacher might spend considerable time trying to help each pupil making that leap. By chunking small pieces of subject material and individual practice, that each step is made concrete in the child’s mind leading to improvements in the short term memory (Burtis 1982) and will lead to the improved recall of that information at a later date.

Within my key stage three lessons, code is gradually unveiled to the students, line by line. The amount of work the need to understand at an early stage is relatively small, but they need to understand it well. Their individual practice is designed to ensure that when they make mistakes, they can do so without losing confidence over what they have done. They are working with relatively small amounts of code that they have written and should an error occur when their code is compiled, their mistake is likely to reside in the limited line or lines that they have just written. The mental model that the child has of the program is left relatively unscarred by the problem, as we have reduced the time between editing and successful compilation and therefore limit the students frustration with any errors (Lui, Kwan,, Poon, M. and Cheung 2004).

That said, there is often a difference between what the child understands or remembers and what they are capable of using as a fully-formed model of a particular function. Their fragile understanding of these functions could be because they have simply forgotten what was originally taught. Conversely, they are able to remember what was learnt, but they have either never used it or used in the wrong scenario.

A function as simple as an ‘if statement’ in the Python programming language has many different operators when it is used. Students need to have an understanding of what those operators are as well as when to use them. It is through the process
of ‘doing’ (Robins, Rountree & Rountree 2003, p160) that elements, like operators that typically might lack relevance or context, can be assimilated into their model of an ‘if statement’ and help build their confidence in its usage.

Each pupil begins to feel more confident in their abilities, each step is a gradual unveiling of the overall task. They can gain confidence through taking small steps in their coding and this helps in them being able to pinpoints errors quickly within the
code they have changed. There is a translation in the child’s mind between what they have written and what the program does.

Children see coding as having a relatively ‘modest return’ (Jenkins 2012, p56) in respect of the amount of effort they carry out and the resulting output on the screen. Providing a rapid cyclical process of ‘typing and running’ code ensures that they can see a result of their work almost instantly, which develops their confidence in the language and generates a desire to learn how to develop their program further.

References

Bandura A (2010) Self‐efficacy. The Corsini encyclopedia of psychology: 1-3.

Burtis P J (1982) Capacity increase and chunking in the development of short-term memory. Journal of Experimental Child Psychology 34(3): 387-413.

Craik F I and Lockhart R S (1972) Levels of processing: A framework for memory research. Journal of verbal learning and verbal behavior 11(6): 671-684.

Gomes A and Mendes A J (2007) September. Learning to program – difficulties and solutions. In International Conference on Engineering Education: 283-287.

Koedinger K R and Aleven V (2007) Exploring the assistance dilemma in experiments with cognitive tutors. Educational Psychology Review 19(3): 239-264.

Jenkins T (2002) On the difficulty of learning to program. In Proceedings of the 3rd Annual Conference of the LTSN Centre for Information and Computer Sciences 4: 53-58.

Lui A K, Kwan R, Poon M and Cheung Y H (2004) Saving weak programming students: applying constructivism in a first programming course. ACM SIGCSE Bulletin, 36(2): 72-76.

Robins A, Rountree J and Rountree N (2003) Learning and teaching programming: A review and discussion. Computer science Education 13(2): 137-172.

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Principle 3. Ask a large number of questions and check the responses of all students: Questions help students practice new information and connect new material to their prior learning.

Rosenshine’s (2012) third principle looks at the amount of questioning that we carry out within the lesson. If we are trying to determine how much pupils know, then it is necessary to question them frequently to ensure their concept of the subject material is correct. Only questioning the children occasionally throughout a lesson opens the potential for cracks to develop within their concept of what they understand and may potentially lead them to make false assumptions about what they have learnt as well
as what follows.

Remembering to question regularly is something that might be missed in the inertia of a lesson. To ensure that this is not the case, I ensure that questions are built into my planning and incorporate these directly into my PowerPoint slides as a minimum to work from. I also ensure that hinge questions are inserted at the most pertinent point, to ensure that we do not continue on to new topics that rely on an understanding of what has already been taught within the lesson, without that understanding being secure.

Computer science is also a subject which is difficult for many pupils to grasp. However some pupils arrive to their first lesson with us, already competent with a variety of software and hardware. Our tendency might be to focus our questioning on these experienced students, but instead I try to develop an environment where participation is always seen as positive for everyone.

At a simplistic level, I ensure that incorrect answers are still seen positively within the class. If a pupil responds incorrectly, I try to use techniques such as asking another pupil, who knows the answer, to help the other pupil in answering. The pupil who understands, deepens their answer by constructing a new response, which also helps the rest of the class who might also have struggled to respond if they had been asked.

I also try to not accept an answer of ‘I don’t know’ and will present the child with simpler or rephrased questions at a level that builds on their existing understanding to guide them in to providing the correct answer. Additionally, in coding, syntax and understanding might be easy to recall, but we need to ensure that pupils can use the facts in different scenarios. We seek to ensure that they can describe the process in respect of how they got to the answer whenever they answer. This ensures that pupils who get the answer right, did not just do so as they guessed correctly, but because they actually know the reasoning why they have given that answer.

Questioning through technology

When I started teaching, it became obvious to me that questioning was an essential way to determine the understanding of the class particularly when coding. It would be pointless attempting to move on to more complex coding techniques unless your pupils fully understand what has been taught so far. The target is to ensure that all pupils within the class have achieved this understanding, but asking each pupil individually is very difficult and time consuming. I believed that one possible method might be to utilise the technology in front of the students to help in this process.

Most recently within my own practice I created individual online spreadsheets for each pupil. The sheet was a relatively simple design with a large field for them to enter their answer and a question that would appear at the top. All of the pupils
sheets were linked to my own teacher sheet, using the inbuilt functions within the application, enabling me to automatically display a question on each of the students sheets and for them to type their reply. As they answered, a summary sheet would anonymously show how many students were yet to respond, without the actual answer shown. Additionally, by using a premade question bank and with each student answering on their own sheet, questions could be translated or rephrased to meet their individual needs. Other online questioning resources such as kahoot provide similar analysis of the students’ answers.

This facilitated three things:

• firstly, I expected a reply from all students and was able to identify who was still left to respond;
• secondly, I could anonymously display all the pupils’ responses when I was happy with what had been entered (a different view within the application allowed only myself to see the response of each named pupil);
• and thirdly, those who I knew would need additional support could be provided it without being singled out within the lesson.
• This generated an environment within the classroom in which students understood that all would need to participate in responding and also that other children in the classroom might also not respond correctly. If a large proportion of the students were unable to answer the question, then it would also highlight my need to revisit the topic.

Using a variety of different technologies alongside traditional verbal methods enables students to participate and answer in a number of ways and gives as many chances to participate in the lesson as possible, whilst also providing the teacher with a better perspective on the progress the class is making as a whole.

Principle 4. Provide models: Providing students with models and worked examples can help them learn to solve problems faster.

The fourth principle that Rosenshine (2012) outlines relates to modelling. This technique supports pupils in the steps that they need to take to solve a particular problem. Instead of having to develop their own ideas about how to reach a particular answer, the method they need to follow is demonstrated to the pupils in a way that they can each follow. The cognitive load placed upon them is significantly reduced as each stage is given to them so that they only have a limited amount of information to understand before they move on to the next.

Students of all abilities need this modelling to be present so that they can begin the task. They will have been presented with a lot of information during the previous teaching segment and they will need that direction or initial foothold into the task to help them synthesise the different elements of what was just taught. Furthermore, that initial step of the model needs to be simple and understandable so that pupils can gain confidence with the task from the outset. This might be as simple as opening the editor to enter code, but without it they would be unable to any coding at all.

Using Screen Recording:

Ensuring that a model is provided for the pupil is essential in providing the child with the concept of how their work should look. They can compare the example provided and the work they have done in determining whether they have completed the work effectively. The model needs to be something that the student can also access in their own way. Some students might not have understood what I was doing when I presented the model or were simply not paying attention. To address this I record my modelling within PowerPoint using the Screen Recording function. This enables me to replay my model at any point to the children who are having difficulty as well as post the PowerPoint to our online teaching resource which they have access to. This also enables me to go on to help those students who are ready to move on to the next stage of the task. It ensures that the pupils are working towards the best representation of that model and have clear goals to achieve within the lesson. If I feel any additional modelling is required within a lesson, I will also start a screen recording, which also includes audio and use that as a basis for any future lessons.

Differentiating models:

Within a coding lesson, we use a variety of models that are differentiated for students are different ability levels within the class. These are shared with the students within their own individual groups in the online learning environment. All students are given the model, but the narrative that supports the model differs. Additionally for key stage three programming lessons, we use partially completed code, to varying degrees, to guide the students in how their code should look and allowing them to work from a strong basis when the add their own code to the model.

Thinking aloud:

Thinking aloud is an essential narrative to add to the lesson. When discussing code, I talk about why I am doing certain things in certain ways. “Here I am going to indent these lines so that the computer knows that all these commands are related to the statement above” shows the mental processes and reasoning I am giving to my work. Instead of the child wondering why I am doing code in a certain way, there is a continual monologue surrounding the work I am carrying out, which will also potentially answer any questions as they come into the mind of the student. It also helps to note down those questions that are being asked by the pupils during this modelling phase to ensure that future sessions answer them.

References

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Principle 5. Guide student practice: Successful teachers spend more time guiding students’ practice of new material.

Student practice is a key part of any lesson in which the pupils are given time to work with the material that has been taught and is the basis of Rosenshine’s fifth principle. It is through the processes of elaboration, summarisation and rephrasing that Rosenshine believes children are then able to store that information in their long term memory (Rosenshine 2012).

Key stage three students in secondary school have a tendency in computer science to simply copy the code shown on the board. They believe that the way the code is presented to them is a fixed structure that must be adhered to in order to get the output they want to achieve. Their schema of what a function does has little depth, and fails to understand the multitude of ways in which it can be be articulated within a program together with how the syntax of the code subtly changes. We ensure the guided practice is focused on developing their understanding of a key coding concept by presenting different perspectives on how it can be used in a number of different ways, as well as ensuring that the activities they need to do makes them rehearse its use multiple times.

Rosenshine notes that students were able to enter into independent practice when they have been given ‘sufficient instruction’ (Rosenshine 2012, p16) which is sometimes difficult to determine when teaching programming. We might question whether our students understand the ways in which certain code must be written and the ways in which it can be subtly changed to provide different results. To ensure that they have fully understood what they need to do within a given task, we question them before and after the task to ascertain how developed the pupils’ schema of a given function is.

Our coding environments also go some way in providing instant feedback, albeit in a way that may be unintelligible to the pupils – they attempt to elaborate the code in a way that they believe is acceptable for the computer to understand, but may have mistakenly understood the ways in which the various functions should be presented to it before compiling or running.

I use a bluetooth remote keyboard, when asking the pupils to develop some code. In questioning, the child types on the remote keyboard with their code being shown on the board in front of the class and a number of students will work through a given set of instructions ‘live’ in front of their classmates where they describe their mental processes and reasoning for what they are doing.

To ensure that the class is achieving the highest level of understanding throughout the lesson, I will often create shared online code through websites such as https://codeshare.io or http://collabedit.com/. These sites mean that instead of having to visit each child individually, I can check their work, question them in regards to their understanding and also support any difficulties they have, without having to be sat with them. This allows me to give a higher proportion of time within the lesson to guided practice as well as give advice and tuition to all pupils wherever I am within the lesson. As the editor continually updates on my screen, I can look at what the child is typing remotely to see their depth of understanding and see the difficulties that the entire class might be facing without having to individually question all of the students.

References

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Principle 6. Check for student understanding: Checking for student understanding at each point can help students learn the material with fewer errors.

When we check for students’ understanding within a lesson, we engage their thought processes of the material they have been presented so far. Instead of passively sitting and try to understand what they have been shown at that point, they are engaged in answering questions that help them develop their understanding of the content within their long term memory and this concept forms Rosenshine’s sixth principle (Rosenshine 2012).

Within a normal key stage four lesson, we need to ensure that students are capable of answering questions specifically related to the GCSE curriculum. Some pupils, particularly within computer science, are reluctant to ask questions within the lesson and especially in front of their classmates, as they might feel embarrassed about answering (Newton 2003). I ensure that I spend time with those students who have not wanted to answer within the time that the entire class is questioned. Questioning the entire class to determine their understanding to that point can be carried out in a variety of ways.

Question and answer sessions:

We use question and answer sessions where individual student google sheets are linked to my overview of the entire class, which enables me to ascertain understanding and provides students with the right to ask questions anonymously through the use of technology (Barnes 1997). Similarly other technologies such as a google forms can provide the students with a simple and fast way of being tested on what they know. However, multiple choice questions have sometimes been unreliable as the student may have simply been lucky in the answer they have selected, rather than actually knowing what the answer is (Reye 2006) which I have seen with low ability students. We ensure that those students are asked to explain their reasoning within the questionnaire alongside the multiple choice questions.

Within all key stages, during programming lessons, students sit in front of computers for the majority of the time and it is sometimes difficult to determine whether they truly understand what they have done. Asking them to explain what they have done is necessary to ensure that they are capable of using a function within a variety of different scenarios, rather than simply the exemplar they were given to work from. This might be done by asking the students to add comments within the program that reflect what they believe the following lines of code will do when the program is run. It has been particularly effective to use paired programming, where students work together on a piece of code and have to articulate to their understanding of what the program needs to do to their partner.

At the heart of all programming languages are a set of functions that have pre-defined schemas that dictate what they do, together with contexts that they can and cannot be used within. Similarly the pupil begins by creating a narrow schema about how code should be written without truly knowing the breadth of how it can be used. A lot of students. especially at key stage 3, will have difficulties progressing from going beyond a one-dimensional concept of a particular programming element.

Questioning needs to be aimed at showing them that lines of code are less rigid than they might expect and helps to develop their concept so that it is multi-dimensional and capable of being used in a wide variety of scenarios that are given to them.

References

Barnes D (1997) Students asking questions: Facilitating questioning aids understanding and enhances software engineering skills. ACM SIGCSE Bulletin 29(4): 38-41.

Newton D P and Newton D (2003) Talking Sense in Science: Helping Children Understand Through Talk. London Routledge.

Reye J (2004) Student Modelling based on Belief Networks. International Journal of Artificial Intelligence in Education 14: 63-96.

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Principle 7. Obtain a high success rate: It is important for students to achieve a high success rate during classroom instruction.

Some concepts need to be delivered in small chunks as students in computer science often feel overwhelmed by the subject. The teaching strategies employed by the computer science teacher must, due to the nature of the subject, differ from those strategies used in subjects that pupils may be more familiar or comfortable with; the nature of coding itself means that pupils are asked to apply abstract ideas to solve concrete problems, which is complex in itself (Gomez & Mendes 2019). Furthermore the concepts take a while to develop in the child’s mind, requiring the teacher to deliver small manageable amounts of the topic and help them to not be overwhelmed by the subject.

Computer science lessons at key stage three need to be managed effectively, especially when pupils are working through programming tasks which they might have had little exposure to before. For many, when entering secondary school, this
might be their first time using high level programming languages and also having to interpret complex compilation messages.

We begin by exposing code to the students gradually to ensure that they understand what one line of code does and its implications on how the program runs. Concepts have to be clear and simple so that as many students as possible can grasp them ensuring that they will be able to move along with the rest of the class. Otherwise, there is the potential that their mental summary of the concepts, where they do not have ‘adequate or well-formed background knowledge’ (Rosenshine 2012, p17) can lead them to make assumptions rather than question the teacher in respect of every problem they have.

At key stage 4, we progress onto more complex concepts such as asking students to understand the binary, insertion or merge sort. I would begin by verbally describing the algorithm that they needed to grasp. I would then visually develop their understanding by using animated graphics which show the way in which the different sort processes behave and then ask them to do the same on their own computer. Using a website like http://deck.of.cards gives the students the ability to use cards to conceptually sort algorithms which would be difficult physically practice within the confines of a computer lab.

Another important point to consider here is the depth of understanding that each pupil has when they are practising. Sometimes I will review the work the children have done after they have started the task and suddenly become aware of a concept that has been misunderstood or which needs a further clarification. If more than one child has had the same misunderstanding, I will stop the class and ask them to listen as I redefine their understanding of the mistake that has been seen to ensure that other children do not potentially go down the same path. However, within programming lessons, if the same scenario arises where a number of students have misunderstood, this is almost immediately evident as the compiler stops them from progressing
any further.

Errors in the code are not something that we seek to shy away from, as this is an essential stage in understanding how to debug code. Furthermore, we sometimes work with pre-written code that actually has errors in it to ensure that the students can work with code that is not their own and fix problems within that code, as real developers have to do on a regular basis. Ensuring the pupils’ mastery of a particular concept is more about ensuring that programming syntax has been understood to a high degree and any mistakes are purely simple typographical ones

The concept of mastery is also paramount in how well the students understand a particular command. Commonly, we might just provide a simple example of how a command works to ensure that the child is capable of using it should the need arise.
After the child has become confident in its use, we look to advance their understanding of it to a greater degree, as invariably many programming commands have a multitude of different syntactic variations, which we want the pupils to
explore so that they can utilise the full breadth of functionality within the language that is available to them. Through this guidance and support we can ensure pupils experience a high success rate and develop the foundations for ongoing learning.

References

Gomes A and Mendes A J (2007) September. Learning to program – difficulties and solutions. In International Conference on Engineering Education.

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Principle 8. Provide scaffolds for difficult tasks: The teacher provides students with temporary supports and scaffolds to assist them when they learn difficult tasks.

ScaffoldingProgressively introducing students to new concepts to support their learning is a particularly vital teaching technique within computer science. We have to deal with a range of difficult conceptual ideas that pupils need to understand and in this respect, we need to ensure that the scaffolding is cemented in strong underpinnings that each pupil can build on in order to understand more complex functionality. This is especially important within our subject at secondary level as we are often using programming languages and software that are used by people and businesses for a variety of commercial purposes and considerably beyond the level that the pupil will need to achieve for our assessments.

I scaffold in a variety of ways, depending upon the class, year and material being taught. Within programming, I describe the ways in which I think about how I construct the code during the first lesson with early key stage three students. This
narrative is particularly important as programmers often pick up bad habits that they perpetuate for the rest of their career in coding. I also need to ensure that should they decide to take computer science into further education, that they have the
foundations that allow them to code confidently and professionally, even if this is the first time that they have started coding.

For example, my narrative not only describes my thinking about what I am doing and why I am doing it, but also why it is particularly important to ensure that the method is followed to make subsequent debugging or modifications, as efficient as possible.

I develop my questions throughout the programming projects, which begin to strengthen more advanced cognitive skills within the students. Instead of fixing programming problems as quickly as possible, we discuss why the problem has occurred and how they can formulate their own strategies. These strategies are not only to help the pupil develop their coding skills where those bugs are less likely to happen, but additionally, they provide a toolkit that they can refer to when a problem does occur. This toolkit is gradually developed, rather then being pre-prepared with each pupil, so they take responsibility for its construction which further embeds these concepts within their thinking.

Whether a problem is likely to occur within a particular pupil’s work as they are coding is impossible to predict. Some pupils may instantly grasp what they need to code, with a high level of accuracy and initial success. For them, particular mistakes that other pupils have experienced and corrected, have not occurred. To ensure that all students have an experience of correcting code, we also ask them to correct code that has a number of mistakes based around regularly occurring errors. This scaffolds the pupils’ understanding of correcting errors – which is a necessary and valuable skill for all pupils to master.

Principle 9. Require and monitor independent practice: Students need extensive, successful, independent practice in order for skills and knowledge to become automatic.

Independent practice and coding go hand in hand. Pupils need time to work with a programming language, typing code, making mistakes and correcting those mistakes. It is a process they go through individually and within their own head space where they develop their own skills in reasoning, analysis, abstraction and decomposition.

Independent practice is key in getting children to understand the material being taught. Within computer science at key stage three, for example, we ensure that when working on animations, each child is given tasks that develop their skills fully. Children might be happy working solidly on a complex animation for entirety of double period, but the skills they have used within this are likely to be limited as they have only achieved their personal target of creating something that they were interested in. Instead we will teach a skill during a short guided practice time throughout the lesson that picks on a particular element that we want the pupil to practice. They are then given just five minutes to complete a task using that new skill. Pupils then practice that skill during a short five minute exercise in an activity which is
not part of their on-going assessed work. They then go on to develop that skill further with their own practice of it on their own original work.

Automaticity is essential, especially when a rolling two week timetable is used and we only see our key stage three students once during that period. We need children to be able to recall those automatic skills quickly from their long term memory to ensure they can continue their work without having to relearn those skills from the previous lesson.

We have used online Google sheets when children have been putting together their own work on flowcharting. I create a series of sheets for each child within the lesson and share it with them individually via our own web-based teaching site. The children are aware that I am monitoring their work and will provide comments and support from my laptop directly to students, from wherever I am within the room. I am able to see errors as they occur and provide support directly to the pupil whilst monitoring the rest of the class at the same time.

At key stage four there is a potential for parts of the curriculum to be taught and then not re-visited for a considerable period of time. Independent practice is therefore necessary to ensure mastery of these skills, so I often use a variety of different tasks that approach the same topic in ways that all students will be able to master. For example, within programming we sometimes utilise an agile coding technique of paired programming. Each partner takes ten minutes to type the code at the keyboard with the support and direction of their observing partner, who helps correct errors, solve problems faster and learn from each others’ coding (Williams & Cockburn 2000)

Within a computer science lesson, the explanation of how to understand particular topics helps the pupil also strengthen their own understanding as well as highlight misunderstandings that other pupils have. Having to think of the perspective
that the other child has, as well as trying to grasp why the other student has this understanding, are essential skills in deepening the child’s learning of a particular topic. Techniques like these ensure the time that students are spending in independent practice is as successful as possible, developing fluency in their coding and masters of our subject.

References

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

Williams L and Cockburn A (2000) The Costs and Benefits of Pair Programming. Computer Science.

Principle 10. Engage students in weekly and monthly review: Students need to be involved in extensive practice in order to develop well-connected and automatic knowledge.

Interconnection of information from one topic to the next can provide a computer science student with an understanding of how different physical and conceptual ideas within the syllabus may be interlinked. We are trying to ensure that new knowledge is easier to learn and anything previously learnt is also more accessible, which forms the basis of Rosenshine’s tenth and final principle (Rosenshine 2012).

Pupils have difficulties in their early lessons in computer science, where they lack a model or a ‘cognitive structure that the student can use to make viable constructions of knowledge’ (Ben-Ari 1998). To develop this structure we start each term with conceptual ideas, such as the arrangement of the CPU along with interactive PowerPoints that allow us to click on images which identify each part of the computer, or having old computers that we have taken apart to allow them to see how it physically appears within the computer. We then develop concepts such as the complexity of how a fetch-execute-decode cycle works by asking the student to relate the operation to which physical elements are involved within the computer. Similarly when teaching new topic areas, each lesson is interlinked to other topics through questioning or content where the pupil is able to add further detail to their conceptual model of that element.

When we discuss elements, such as algorithms, I also look to position the concepts, not only within the curriculum, but within real life examples which might normally be considered to be too complex for children to understand. Previously, when discussing algorithms, recall is stronger when they can relate them to the difficulties that university robotics labs have had in developing the walking movement of robots or similarly, the algorithm that allows programs to classify and identify fingerprints as quickly as possible.

We also try to develop students’ understanding by giving them ‘application activities’ (Rosenshine 2012, p38) that get them to write code that emulates the topic we have covered within the lesson. For example, within a lesson we might have discussed the physical improvements to the speed of a CPU by adding cores or increasing the clock speed. The students develop their understanding further by writing code where they create a virtual pc that performs faster calculations based upon the configuration entered by the user at the start.

Similarly, when revisiting the memory topic, we write code to print the contents of different arrays which emulate the different types of memory in the computer. The user interacts with the program to start up the PC and open and close applications, which the student has to code to deepen their knowledge. Instead of simply understanding memory, they are given the opportunity to develop very rudimentary code that emulates the way in which the operating system actually works which deepens their learning and improves their coding skills within the subject.

Interconnecting the different materials and reviewing previously learned content in this way ensures that relevance is given to each strand of the subject. Reviewing the students’ work on a regular basis and ensuring that the lessons use a wide variety of interconnected knowledge strengthens their understanding and develops these ideas within their long term memory. This concept completes the set of Rosenshine’s principles that I have outlined previously and which have been invaluable as guidelines for lesson design. Within our department, they have helped to promote a greater awareness of the limitations of our memory – this informs us about the most effective ways to structure learning and ensures we carefully consider how complex computer science ideas can be taught in a way that all students can access.

References

Ben-Ari M (1998) Constructivism in Computer Science Education. In ACM SIGCSE Bulletin 30(1): 257-261.

Rosenshine B (2012) Principles of Instruction: Research-Based Strategies That All Teachers Should Know. American Educator 36(1): 12.

View the Principles of Instruction research paper

Return to the Principles of Instruction collection