Skip to main content

Make your teaching misconception-sensitive

The danger of misconceptions

Misconceptions are pervasive in many subject areas and disciplines, especially those rich in abstract concepts. Computing is therefore not alone in having plenty of conceptual hurdles for learners to overcome. However, knowledge of common hurdles is perhaps less widespread among computing educators than among educators teaching other subjects.

When misconceptions are allowed to persist, they can prevent students completing immediate tasks, lead to frustration, and ultimately inhibit future learning about related concepts. An important task then for computing educators is building an awareness of the known misconceptions in a given area and being proactive in avoiding and challenging these flawed ideas.

How do misconceptions arise?

Learners develop misconceptions for a number of reasons. Broadly speaking, misconceptions arise due to a combination of the particular content being explored, the learners’ prior knowledge, and issues with the instructional design, i.e. how concepts are presented.

  • Content: some areas of the discipline are richer in challenging concepts than others, and as educators we need to be aware of potential pitfalls so we can avoid them. You can identify many of these pitfalls thanks to research findings such as Sorva's Misconception Catalogue, and thanks to your personal experience and the experiences that other educators share with you
  • Prior knowledge: learners approach a subject with a range of prior knowledge that may conflict with new concepts you are introducing. This prior knowledge may come from earlier study of computing or from other subject areas or disciplines. A common example is how students interpret variable assignment: when learners encounter `score = score - 1` , they tend to read it as "score is the same as score - 1" instead of "score gets the value score - 1"
  • Instructional design: the most important factor for educators is how we structure learning around a concept. Choosing flawed examples or poor analogies, or making assumptions about what learners understand can introduce new misconceptions or compound existing ones. It’s important to continually ensure that learners had a suitable mental model, or Notional Machine, to write programs alongside. This abstract understanding helps underpin their appreciation of how a particular programming works and what it can and cannot do.

How to avoid misconceptions

There are no simple solutions or quick fixes to prevent or mitigate all misconceptions. Instead, you should apply some key principles and experiment with appropriate techniques to understand, challenge, and assess where your learners hold misunderstandings.

  • Awareness of misconceptions is key: before approaching a new topic or concept, ensure that you are familiar with the common issues either thanks to your own experience or that of your peers, or because you have reviewed relevant research findings.
  • View the concept from the perspective of your learners and challenge your own assumptions about what they know. Use discussions, questioning, verbalising, and walking through programs to assess their understanding in multiple ways.
  • Learners build their conceptual understanding based on the context in which we place the concept, so we must provide them with a breadth of examples and scenarios in which they can experience the concept.
  • In the area of programming particularly, as well as writing code, students should be able to read code, share it, discuss it, and read it aloud. Have them examine programs at varying levels from individual lines, to specific blocks or functions, and as a whole program.
  • Some concepts are easy to explore because they are at surface level, but others, such as function calling and parameter passing, are hidden. Use varied approaches to explore hidden concepts. For example, drawing, role play, or other unplugged activities can work well — just remember to have your students put the concepts into practice once they’ve grasped them.
  • Analogies are a really powerful way to introduce ideas by connecting ideas with familiar often concrete concepts. All analogies, however, are approximations and as such misrepresent the actual idea we are trying to convey. Choose your analogies wisely and be aware of where they fall down so you can adapt or discard them as necessary.
  • Use strategies such as peer instruction to discuss, assess, and ideally correct persistent misconceptions.

Clearly understanding misconceptions is essential to good teaching in computing, and it’s an important aspect of our collective pedagogical content knowledge. Through becoming more aware of the misconceptions that our learners routinely develop, we will be better equipped to develop excellent and secure learning.

  1. This article was heavily inspired by Misconceptions and the Beginner Programmer by Juha Sorva, Chapter 13 in Computer Science Education: Perspectives on Teaching and Learning in School
  2. Read more about common programming misconceptions in Sorva's Misconception Catalogue
  3. Find a collection of misconceptions associated with broader computing in this article on the CAS community site.

In Practice...

Mark Norwood

"I work with students with behaviour problems who have been permanently excluded from their mainstream school. They often come with negative attitudes to learning in general and have a misconception that computing is boring or really difficult.
I found it helpful to get them started with some basic physical computing: flashing an LED either with Scratch or Python gpiozero depending on ability. We quickly moved on to bursting confetti-filled balloons above people’s heads when they got an answer wrong in an onscreen quiz.
These activities help dispel the notion that computing is difficult or boring and allows students to get engaged."

Andrew Collins

"New programmers often misunderstand the sleep function in Python, thinking it means ‘stop the program’ instead of ‘continue the previous command’.

I try to resolve this by introducing a coding challenge that will reveal this understanding to them — blinking an LED, for instance."

Beverley McCormick

"I find that many misconceptions may be linked to previous poor teaching/understanding of CS language. If this isn’t explicitly taught with opportunities for students to practice and really understand, then they will always struggle.
One example. Variables… Students find this tricky. For a start, there is the acquisition of new language to overcome and then the concept of storing one piece of information to retrieve which can be something that takes time for them to really understand."

Kevin Olson

"Students usually think that an if statement will continuously check a condition, instead of it checking one time only. Lots of students write in Scratch when flag clicked, if right arrow pressed, change x by 5 and don’t understand why the sprite doesn’t move properly.

We discuss how the code is structured, and then I introduce loops right there. We also examine the differences between that code and event listeners, but that often happens later. Usually I simply prompt with, “How often do you want that code to run?” to get a forever loop added."

About the authorJames Robinson is the Senior Learning Manager at Raspberry Pi Foundation.