Teaching programming in computer science can be a complex task, especially when balancing the introduction of technical skills with maintaining student engagement. The JUMP123 pedagogy offers a structured and effective way to teach programming, breaking down the learning process into manageable steps that align with how students best absorb and retain information.
JUMP123 involves both the pedagogy and a method of assessment. The JUMP part is concerned with the pedagogy and the 123 is all about the assessment.
Here, I will be explaining the JUMP pedagogy to teach programming, focussed on instructional strategies. You will be able to revolutionise your computer science lessons and improve your students' programming skills.
Working memory and long-term memory in learning
Before we leap straight into JUMP, I want to first give you a little background information about why this pedagogy is so powerful.
Learning involves both working memory and long-term memory. Working memory is the short-term memory we use whilst we are learning a new piece of knowledge or a new skill. It is only a temporary store and will quickly be forgotten.
Long-term memory is used for remembering information over a longer period of time. We can recall information that has been successfully stored in our long-term memory many weeks, months or even years later.
The challenge is moving information from working memory to long-term memory, a process influenced by cognitive load.
Cognitive Load Theory in Programming Education
Cognitive Load Theory (CLT), introduced by educational psychologist John Sweller in 1988, plays a crucial role in understanding how students learn programming.
The cognitive load is how much new knowledge we’re able to hold in our working memory. Some experts believe it can only hold around 3 or 4 pieces of new information before it is forgotten. Each person’s cognitive load is different and varies depending on a number of factors such as stress and how the knowledge is presented.
When the working memory is overloaded, students struggle to retain new information, which hinders their ability to learn and apply new programming concepts.
There are three types of cognitive load to consider:
Intrinsic Cognitive Load: This relates to the inherent complexity of the new information.
Extraneous Cognitive Load: External factors that distract or complicate the learning process.
Germane Cognitive Load: The mental effort used to process and integrate new information with existing knowledge.
When teaching computing, it’s essential to manage these types of cognitive load effectively. Overloading students with too much information at once, especially with complex programming tasks, can prevent them from transferring new skills to their long-term memory.
The Semantic Wave: A Framework for Teaching Abstract Concepts
The Semantic Wave, a concept developed by Karl Maton in 2013, is a method of teaching complex topics by gradually moving from abstract, difficult-to-understand concepts to more concrete, relatable ideas and then back to the technical level. This approach is particularly effective in programming lessons, where students need to understand both abstract concepts and technical terminology.
For example, when introducing a programming concept like a for loop, start by explaining the concept in simple terms and break it down using diagrams. Once the students can relate it to things they easily understand, build the concept back up to the technical level required for students to apply it in their coding projects. This process helps students fully grasp and retain new programming knowledge.
How students learn programming.
Teachers need to help students develop:
the technical terminology specific to each programming language
an understanding of abstract concepts such as how selection with an if statement works
the soft skills (problem solving, resilience and creative thinking) needed to become a programmer.
To help pupils grasp the technical concepts and abstract theories, the teacher needs to present them using the semantic wave. However, computing teachers also need to be mindful of the cognitive load of their students and not try to cover too many disparate concepts in a short space of time without allowing pupils time to process them and commit them to long term memory.
As computer science teachers, we are often looking at programming from the viewpoint of an expert, or at least more of an expert than our students. And we often forget how difficult it is to comprehend the difference between something as simple as a string and a variable when we are first learning to program. When we are a seasoned programmer, certain things become second nature to us and we often assume pupils will also understand them without too much explanation.
If a pupil doesn’t fully understand a concept before you introduce a new one, the student’s misunderstandings and vagueness around the topic may not come to light until much further down the road. This can lead to frustrations for both the student and the teacher.
Finally, one of the most powerful tools in learning how to be a better programming is by doing it. Students need to experiment and make mistakes. They need time to play with the code. Rather than just completing one or two examples, computing students need many more than we often give them time for. We need to build time into our lesson planning to give them the opportunity to experiment and play with their code.
Giving pupils multiple similar examples, only altering them slightly, allows pupils to discover the nuances of how the specifics of code work. Far from becoming bored by doing so many similar exercises, students relish them and enjoy the challenge of reusing pieces of code they are familiar with to solve a new problem.
Introducing JUMP: a pedagogy for teaching programming in computer science lessons
JUMP is a simple pedagogy used to help teachers easily plan more impactful activities in their computer science lessons.
The JUMP pedagogy is designed to help teachers structure their lessons in a way that optimises student learning and reduces cognitive load. JUMP stands for Judge, Unpack, Model and Program, representing four key elements of the teaching process:
Judge: big picture view and giving opinions.
Unpack: detailed view, drilling down into the mechanics of the program.
Model: experimentation and alteration of a program.
Program: create new programs using different prompts.
Judge and Unpack are used to reinforce the theories and technical language used.
Modify and Program deal with the practical activities that pupils can do on a computer.
These elements can be integrated into lessons to create a clear structure that supports student learning.
Part of the JUMP pedagogy also relies on splitting the technical concepts into much smaller sections known as chapters.
Reducing Cognitive Load with Chapter-Based Lessons
We know cognitive load has a huge impact on a pupil’s ability to transfer new information into their long-term memory so we need to reduce the cognitive load when teaching new technical skills.
To further reduce cognitive load, it’s beneficial to divide lessons into smaller chapters, each focussing on a single concept or skill. For example, in an introductory Python lesson, rather than covering multiple concepts like input, print, strings and variables all at once, you might start with just strings and print statements.
In my first lesson the chapters are:
Text-based programming
Strings
Errors in your code
Creating a string
Each chapter should follow a semantic wave, starting with a basic explanation, breaking down the concept into simpler terms and then building it back up to a technical level. This approach ensures that students have a solid understanding before moving on to more complex topics.
Additionally, each chapter leads me onto the next one so pupils can use what they have learned to help them later on in the lesson.
Applying JUMP in the Classroom
When implementing the JUMP pedagogy, you can choose which elements to use in each chapter based on your lesson objectives. Not every chapter needs to include all four elements, but it’s important that students fully grasp each concept before moving on.
As you can see in the above example, some chapters include some of the JUMP elements and other chapters use other elements:
Chapter 1: 2 x Judge activities and 2 x Unpack activities.
Chapter 2: 1 x Judge, 1 x Unpack and 1 x Model activity.
Chapter 3: 2 x Unpack and 1 x Model activity.
Chapter 4: 6 x Unpack activities and 1 x Programming activity.
The teacher doesn’t need to use all 4 elements in each semantic wave but they need to be sure that pupils are secure in their knowledge. The need to complete the wave and apply that knowledge before they move onto the next chapter. This can be done with simple questioning, a paired or group discussion, any other type of activity such as a sorting or matching activity or a practical task using the computer.
By considering the technical knowledge and skills you want the pupils to understand, teachers can choose the activities that would be most effective for their classes.
Teachers don’t need to cover all 4 elements in one lesson, but over a unit you should include all elements several times so pupils are comfortable with looking at both the big picture, small detail, adapting programs and creating their own programs.
Avoiding Cognitive Overload in Early Programming Lessons
When students are first learning a programming language, especially a text-based one like Python, it’s crucial to avoid introducing too much complexity too soon. While advanced programming practices such as using sub-routines and object-oriented programming (OOP) are valuable, they can overwhelm beginners who are still grappling with basic concepts like variables, data types and simple input/output operations.
For instance, while sub-routines are excellent for structuring larger programs, they are not necessary in early lessons where students are just learning how to create basic programs. Introducing complex syntax like def and return too early can increase the intrinsic cognitive load, making it harder for students to grasp the foundational concepts they need.
Instead, focus on ensuring that students have a strong grasp of the basics before introducing more advanced topics. This approach not only reduces cognitive load but also helps students build confidence in their programming abilities.
Building in Practice Time
Helping pupils transfer skills from the working memory into their long-term memory means giving them time to apply their newly learnt programming skills and embed those skills into long-term memory.
Don’t just give students one or two chances to apply their programming, give them plenty of practice. Sometimes my most productive programming lessons have been consolidation lessons where pupils are given a list of programming challenges and they work through as many as possible.
Students who finish quickly are encouraged to take on more challenges, fostering a competitive yet supportive learning environment. Those who need more time can receive additional support, ensuring that everyone has the opportunity to master the material.
Practice is key and the programs don’t all have to be difficult. They can be variations of a very similar program and make sure they are only focussing on the key skills they have already been taught and don’t use it to try and teach them new skills.
You can change things up by also introducing paired programming or even peer assessment of programs so students also see how the same problem can be solved in many different ways.
Conclusion: Enhancing Programming Lessons with JUMP Pedagogy
The JUMP pedagogy provides a practical framework for teaching programming in a way that supports student learning and reduces cognitive load. By breaking lessons into chapters and using the JUMP elements to guide activities, computer science teachers can help students develop a deep understanding of programming concepts and skills.
Key takeaways for implementing JUMP in your lessons include:
Focus on essential skills and knowledge to reduce cognitive load.
Use chapter-based lessons with semantic waves to introduce and reinforce new concepts.
Apply JUMP elements to plan varied and effective activities.
Ensure students have ample practice time to transfer skills to long-term memory.
By adopting this approach, teachers can create more effective and engaging programming lessons, ultimately helping students become confident and proficient programmers.
Comentarios