3 Easy Techniques To Teach Programming To Low Ability Students
Computer science can be seen as a game of two halves. There is the theory element such as systems architecture, network protocols and cyber security. But there is also another important element.
Programming and computational thinking.
Most students are able to learn the theory side of computer science. It's a familiar learning method that they would have perfected in other subjects.
But, working out how to solve programming problems is a new skill in which some will not yet have gained confidence. And because of this some students will switch off early and not even attempt to solve the problems assuming they'll never understand it.
How do you overcome this?
You need to help your students build their confidence. Don’t rush through skills that you find easy as they will need to develop them further and make sure they are embedded before you move onto the next skill.
Let’s look at two scenarios. You can either…
Show a screenshot of the completed code on your whiteboard for the students to look at; or
Have your screen projected in front of the class so they can see your screen as you’re typing in the code
The obvious advantage of the first option is that you don’t have to type any code in front of your students.
This saves on the embarrassment of making a typo or, even worse, your students may realise you don’t feel as confident as you pretend when it comes to programming. But, what you see as a boost is actually a massive drawback for many students.
When you display a screenshot of your pre-written code it can appear overwhelming. And some students will switch off if faced with a large chunk of seemingly indecipherable text.
Even though you may talk through each line, it is still a visual overload. And some students may well be trying to read and understand what is on the screen rather than listen to you. They can’t do both at the same time so they inevitably miss out on what you’re saying.
Also, they never get to see you make a mistake, so they don’t realise that making mistakes is a HUGE part of programming. Finding those annoying typos, realising you used the wrong variable name and watching you work out where it went wrong is a valuable learning opportunity.
If your code has already been written, tested and then put into your presentation, they never see the actual work that goes into solving all those niggly bugs. So they won’t know how to solve them when they crop up in their own programs.
Many pupils, no matter their ability, actually benefit from you typing in the code in front of them, commonly referred to as “live coding”.
Advantages of live coding:
It reduces the amount of text displayed at once
It gives you an excellent opportunity to talk about what you're doing, as you do it
They get to see how you make and solve coding mistakes. It also makes a good excuse for some pupil questioning so you can solve it together
It slows down the time it takes to explain the program giving pupils more time to digest the technique
Students can see that creating a program is not always a linear task. We create a bit of code then go up and add a line above it. Then drop down to the end to call that subprogram, before going back to another section and changing something we had written before. If they only see the finished article, they miss out on seeing how you built it
The next time you are planning a lesson and tempted to put in a screenshot of the code, think about if it this is really the best thing to do. See if you can live code instead.
If you're worried that you may forget the code, you can always pop that screenshot you were about to put into your PowerPoint presentation into a document and have it printed and placed strategically on your desk so you can refer to it if you need to.
Can you remember when you first learnt how to walk? No, it’s not surprising. And quite frankly it would be odd if you did.
However, you’ve most likely seen a baby learning to walk whether that be within your own family, friend’s children or even on film.
Nobody props a baby up on their chubby little legs and expects them to get it right first time. They don’t even expect them to get it right the second, third or even fourth time. Babies, like all humans, learn in stages.
First they may grab onto a chair leg, table or more painfully your hair and heave themselves up before taking a few wobbly steps. They grip onto whatever they can before bumping back down again onto their bottoms.
The next step is for the adult to hold the child’s hands as you walk together helping them. The adorable bundle slowly gets used to moving those legs with purpose. But at times it can still appear as if they are goose-stepping or doing a modern interpretive dance.
Then they move onto holding just one hand. The child starts to find their balance and then finally… that moment when you let go…
And they stand there, wobbling uncertainly before taking that magical first step on their own.
You may even shed a tear of pride and joy.
All these steps take time. It doesn’t happen overnight and each step helps the next. Going straight from pulling themselves into a standing position to expecting them to walk unaided without ever holding your hand seems a little harsh.
Yet, I've seen computing teachers do just this. Okay not with teaching pupils to walk, but certainly with teaching them programming.
They show their class a piece of code and then expect them to be able to reproduce something similar on their own. Or worse still, ask them to use that technique as part of a large, complicated program and then wonder why the students can’t do it.
Students need to tackle the complexity in stages.
They need the opportunity to experiment with the code in many different ways. For instance, here are a few ideas you can incorporate into your lessons:
Experiment with the code and change parts to see how that will affect the outcome
Find errors in the code (this is essential to help them embed the syntax)
Pick the correct piece of code for a partially completed program that you have created for them
After they’ve had the opportunity to “play” with the code in this way it will be much easier to progress onto making their own programs. They will have a deeper understanding of how the code will behave.
I’m not suggesting for a moment that pupils need to do all these activities for every new technique they're learning. But rather I wrote these ideas as a way of showing that there are many different ways that pupils can play with the code. Don't assume you have to leap straight into writing a program each time.
If you’re looking for more ideas, please read my previous blog post that outlines 10 easy ways to play with code when teaching computing.
Repetition is the key to embedding new knowledge. Repetition is the key to embedding new knowledge. Ha ha - see what I did there?
Some pupils will learn a new technique after a quick explanation. But the vast majority of your pupils will need more. Some students may need the opportunity to create 10 or more very similar programs before they can feel confident in using a new skill.
Don’t rush this. Give them as much practice as they need.
Having a library of differentiated activities makes the world of difference.
You can give your high ability students more advanced challenges to work through whilst your lower ability students consolidate the basics with easier tasks. You can even let them pick their own tasks to suit their own ability.
If you haven’t got time to create your own, grab a copy of my input and output programming task cards that can save you hours of preparation time.
If you’re looking for some ready-to-use computer science or Python lessons to help you manage your workload, check out my teach computing section to save hours of preparation time.
I hope this, rather longer than I expected, post has given you some helpful advice for teaching your computing students.
Let me know in the comments your best tips to teach programming to low ability students.