In today’s ever-evolving landscape of computer science education, finding the most effective methods for teaching programming is paramount. Both educators and students face the challenge of balancing the depth of knowledge with the need for retention.
JUMP123 is an adaptation of the PRIMM lesson structure with the bonus of including a way to easily assess pupils’ programming progress. Specifically, the JUMP part looks at teaching programming pedagogy and the 123 focuses on the programming assessment. If you want to find out about 123, I have written another blog post which also includes a handy video. But for now we are only focussing on JUMP.
This post aims to compare these two pedagogy approaches (PRIMM and JUMP), concentrating on the lesson structure rather than the assessment method of JUMP123. This is written for computer science educators, computing teachers and anyone involved in teaching programming.
Why was PRIMM first introduced?
PRIMM was developed by Sue Sentence and her team in 2017 and is a way of structuring programming lessons.
At the time, it was a groundbreaking method, being one of the first structured pedagogies tailored to the new computer science qualifications emerging in the UK.
PRIMM was designed to provide teachers with a clear framework for delivering programming lessons, especially as many educators were still gaining confidence in their coding abilities.
Since then, various adaptations have been developed including TIME 2 Code and KPRIDE. JUMP takes the basic premise of PRIMM and improves upon it.
What is the PRIMM programming pedagogy?
Let’s break down the PRIMM process with a practical example:
Predict:
Students are presented with a piece of code and asked to predict its output. This encourages them to think critically about what the code is intended to do.
Example code:
# starter program lesson 1
name = "Billy"
print("We want to know if you like programming!")
print()
print("Do you like programming " + name + "?")
answer = input()
print("Great! You said " + answer + "!")
print("Let's learn some Python today")
In this example, students might predict that the code will ask a user named Billy if they like programming and then respond based on the user’s input.
Run:
After making their predictions, students run the code to see if their predictions were correct. This immediate feedback helps students validate their understanding.
Investigate:
This step involves a deeper dive into the code. Students analyse specific components, such as variables, functions and operators, to understand how each part contributes to the program’s overall functionality.
For instance, students might be asked:
How many variables are there and what are they used for?
What is the purpose of the input() function?
What is the role of the + operator in this context?
Modify:
Students then modify the code to see how changes affect the program's behaviour. For example, they might change the value of the name variable or alter the program to prompt the user for their name at the beginning.
Make:
Finally, students use the knowledge they've gained to create a new program. This might involve designing a program that follows specific instructions or experimenting with different elements to achieve a desired outcome.
The Semantic Wave in PRIMM
A key aspect of PRIMM is its alignment with the semantic wave theory, an educational psychology concept introduced by Karl Maton in 2013. The semantic wave describes the process of taking abstract concepts and breaking them down into simpler, more concrete ideas before reassembling them into a coherent understanding. This approach is particularly effective in teaching technical subjects like programming, where abstract ideas need to be made accessible to students.
In a PRIMM lesson, the semantic wave can be observed as students start with a high-level concept (Predict), delve into the details (Investigate) and then reconstruct their understanding (Modify and Make).
The semantic wave can clearly be seen over the entire lesson when using the PRIMM structure.
PRIMM and Cognitive Load
While PRIMM is effective it does have some limitations, particularly concerning cognitive load. Cognitive load theory, introduced by John Sweller in 1988, posits that working memory has limited capacity. When this capacity is overloaded, students struggle to transfer knowledge from working memory to long-term memory.
In a typical PRIMM lesson, students might encounter several new concepts at once such as variables, concatenation, input and print statements. This can overwhelm their working memory.
This overload can hinder their ability to retain information, leading to frustration and a need for repeated revision of basic concepts.
In a lesson where students are expected to understand both string concatenation and input functions, they might focus so much on getting the syntax right that they miss the underlying concepts. Weeks later, when faced with similar tasks, they may struggle to recall how to structure an input() statement or how to concatenate strings, indicating that the knowledge wasn't fully transferred to long-term memory.
How many times have you taught programming for a number of lessons and have worked up to the dizzy heights of putting a for loop inside an if statement only for a pupil to put their hand up and say “How to you do an input again?”
It is totally demoralising when you realise that student has never really grasped the basics. And you may even wonder how many others are also struggling with things you taught them weeks ago.
Introducing JUMP: An Adaptation for Reduced Cognitive Load
JUMP is an adaptation of the PRIMM structure that aims to mitigate the issues of cognitive load by breaking lessons into smaller, more manageable chunks. JUMP stands for Judge, Unpack, Modify and Program. While it shares similarities with PRIMM, it offers a more flexible approach that can be tailored to the needs of individual lessons.
The JUMP Process: Flexibility in Teaching
One of the key differences between JUMP and PRIMM is the flexibility in how the steps are applied. Teachers using JUMP are not bound to a strict sequence; instead, they can “jump” between stages as needed, allowing for a more dynamic and responsive teaching approach.
Judge:
Students evaluate a piece of code, identifying its purpose, functionality or potential errors. This step encourages them to think critically and consider the “big picture” of the program. It is much broader than simply predicting and running the code and often asks pupils to give an opinion or consider why something may be happening.
For instance, students might be asked, "What do you think this program is supposed to do?", "Why do you think this program was created like this?" or even “Why do you think this program may not work?”. It is looking at the program as a whole.
Unpack:
Students drill down into the details and mechanics of the code. They identify key components, such as variables, loops or functions and explore how these elements work together. This is where we may focus on syntax or how a function or small part of the overall code works. It is looking at the detail and not the entire program.
Questions here can include “Can you identify the variables/input/selection?”, “What would happen if we changed the condition to...” or “How can we alter this part of the program so that...”
Modify:
Students modify the code, experimenting with changes to see how these affect the program’s outcome. This hands-on, practical experimentation reinforces their understanding by allowing them to see the immediate impact of their alterations. They change either a piece of code they have previously created themselves or a piece of code that has been supplied to them. It could also include correcting the errors in a program or simply testing out a program using a variety of different inputs to see the effect on the output.
Program:
Students create their own programs. This may be from a written algorithm, a flowchart or even include designing a program first and then creating a program from their own design. This stage is similar to the Make section in PRIMM.
The similarities between the activities in PRIMM and JUMP are obvious but JUMP, particularly the Judge and Unpack sections, have some key differences. Judge and Unpack are primarily concerned with the theory. Judge looks at the big picture and Unpack is concerned with detail. However, Modify and Program are similar to the Modify and Make in PRIMM.
To be honest, it doesn’t matter if you prefer using Predict, Run, Investigate, Modify and Make or you use Judge, Unpack, Modify and Program. The individual elements are not the most important difference between PRIMM and JUMP.
The most important difference is how these elements are applied.
In PRIMM the steps are in a rigid order and always follow the same sequence. That sequence is always Predict, Run, Investigate, Model and finally Make. This allows a complete semantic wave to be completed in one lesson.
JUMP allows teachers to introduce the activities at any point in the lesson, in any order or sequence they wish, depending on the need and complexity of the task.
That means we can do a Modify first, followed by a Judge and an Unpack and then a Program task. Or we could do a Judge, followed by a Modify, another Judge and a Program, missing out on the Unpack all together. Either way, it still provides students with an impactful learning experience. It really depends on what is needed at that time.
More often, I find I revisit the same section several times in one lesson. In my first lesson I use Judge, Judge, Unpack, Unpack, Judge, Unpack, Modify, Modify, Unpack, Unpack, Modify, several more Unpacking questions followed by a Program activity.
JUMP allows the teacher greater flexibility which keeps the lesson more interesting and still covers the key skills and knowledge that pupils need to master.
Here is the PRIMM semantic wave over a single lesson:
And here is the JUMP semantic wave over a single lesson:
Using the JUMP method, it is possible to fully utilise the semantic wave but instead of delivering just one semantic wave we have several shallower waves in a single lesson.
Reducing Cognitive Load with JUMP
JUMP is particularly effective at reducing cognitive load by breaking down lessons into smaller, more digestible segments. Instead of covering multiple concepts in a single lesson, JUMP encourages teachers to focus on one or two skills at a time. This approach helps students master the basics before moving on to more complex tasks.
It is about the quality of learning that is taking place, not the quantity of how much content can be presented to the students in a short time.
There is little value in rushing through lessons to cover as much material as possible, especially when students are unable to retain what they have learned. While students may appear to grasp the content during the lesson, much of it is often forgotten within a week or two, necessitating re-teaching.
Rushing through content and presenting too much in one go leaves some pupils floundering which can lead to early disengagement. This in turn can lead to low level disruption which makes your lessons so much harder to teach.
Instead, I advocate for dedicating more time to teaching the foundational concepts, ensuring they are deeply understood and securely transferred into your student’s long-term memory before introducing new skills.
Cognitive Load Theory highlights that overwhelming students with complex programs too early can impede the transfer of knowledge from working memory to long-term memory. Therefore, it is essential to introduce abstract concepts in a more measured and gradual manner.
Reducing Cognitive Load using Chapters
My approach involves structuring lessons with clearly defined "chapters" which guide students through the learning process, making them aware of upcoming abstract concepts and helping them understand where they are in the lesson. Students are introduced to the chapters at the start of a lesson and we use them as checkpoints as we progress through the lesson. This approach significantly reduces cognitive load.
In my first lesson the chapters are:
Text-based programming
Strings
Errors in your code
Creating a string
By breaking down learning into smaller, more manageable steps, I do cover less material per lesson compared to the PRIMM approach.
For example, instead of expecting students to master variables, concatenation, comments, input and print all in one session, my initial focus is solely on print statements and strings. This reduction in technical overload allows students to become proficient in the basics more quickly, building their confidence and enabling them to apply these skills effectively in later, more complex programs without the frustration of having to go back and re-learn earlier elements.
As students see tangible progress in their skills their confidence and interest in programming grows. This approach also reduces the need to re-teach forgotten material, leading to more consistent progress over time and easier lesson planning for you as you are more secure in the previous knowledge your pupils have.
Ultimately, the goal is not to race through content but to ensure that each concept is thoroughly understood before moving on.
Can PRIMM still work when the lesson is in smaller chunks?
Given the structured nature of PRIMM, one might wonder whether it can still be effective when lessons are broken into smaller chapters, as with JUMP.
While PRIMM’s step-by-step approach works well for more comprehensive lessons, it can become cumbersome when you try to cram in all 5 steps into a single chapter.
In order for a new technical skill to be successfully learnt we need to have an entire semantic wave. That means, we need a complete semantic wave for each new chapter they are encountering.
Because PRIMM covers one semantic wave it would be necessary to try and get all 5 elements in order into each single chapter, which means we are repeating the PRIMM cycle several times in one lesson.
In my experience, students can become disengaged if they’re required to follow the same rigid structure that PRIMM requires for each chapter in a lesson. For example, if a chapter is focused solely on understanding strings, running through all the PRIMM steps can feel repetitive and unnecessary. A large challenge for any teacher lies in maintaining student engagement while ensuring they fully grasp each concept.
Obviously, the semantic wave for a single chapter is much shallower than for an entire lesson as the concept is generally easier to grasp when it is not combined with other concepts. So, we can cover a complete semantic wave without the need for the full PRIMM cycle.
Here is a representation of the activities used in my first lesson following the JUMP pedagogy:
As you can see there are several times when we are using Judge, several times when we are using Unpack, several times we are using Modify and only once where we are using Program.
However, in each chapter we don’t need to cover all 4 elements and can use whatever we need to cover the semantic wave for that section. Pupils don’t necessarily need to create a new program with that skill but need to be able to unpack and repack the knowledge to fully understand the concept, using whichever type of activity or questioning is most suitable.
The engagement throughout the lesson varies too. Sometimes there is the teacher posing a question to the class. These are shown by the shorter bars in the graph above, which have lower engagement from all the students and a couple are slightly higher as they require multiple answers from the class.
At other times we are using paired or group discussions or performing a simple activity on the computer. These are shown by the middle height bars as they require a greater depth of student engagement.
And the two tallest bars are ones where all pupils are actively engaged in the activity by either modifying or programming a task on the computer.
By using JUMP rather than PRIMM the teacher can select the best methods of engaging with their students for each small chapter to ensure the semantic wave is completed.
Conclusion: Choosing the Right Approach for Your Classroom
PRIMM works well if you are using only a single semantic wave per lesson but its rigidity can lead to cognitive overload, especially when multiple concepts are introduced all at once at the start of a lesson.
By splitting the lesson into smaller chunks, each chunk focussing on a single skill or piece of knowledge, it is possible to teach several chunks in one lesson. I refer to these chunks as chapters. However, this means that it is impractical to have a complete semantic wave for each chapter when you try to follow PRIMM. Therefore, JUMP encourages you to follow a more flexible strategy which allows each chapter to cover its own semantic wave whilst also reducing your pupils’ cognitive load and creates more enjoyable and effective lessons.
Comments