I’ve been exploring lots of ways to have students engage with code & syntax without actually writing code & syntax. One of the strategies I’ve been investigating is getting students to interact with mistakes, hopefully making them better debuggers and getting them to think critically about the grammar rules of syntax rather than the results. This post is about a strategy I tried as bellwork over 2 days where I had students generate their own purposeful mistakes, then I picked several that I liked and gave students the opportunity to find the mistakes their peers had created. It was pretty cool.
I started by giving them a simple 2-column sheet of paper and some explicit instructions on what the correct syntax should look like. After they had written the correct syntax on the left side of the paper, I had them check with me so I could confirm (which was a nice place for me to individually check in with students), then told them to re-write their syntax but purposefully make a single mistake somewhere in their code. I told them I would pick the ones I liked and use them in an activity tomorrow, which challenged students to come up with ‘subtle’ or ‘unique’ mistakes. I was also delightfully surprised with the mistakes they found – many of them came up with things I hadn’t thought of before, which was exciting. Here are some samples:
This whole activity actually took about half the class, which is a little long for a bellwork, but it was good for me to go around and check in with students and I think it helped reinforce syntax for several students who were struggling with it. I can see this being a go-to activity if I see students struggling in the middle of a coding project due mostly to confusion over syntax and disorganization – a lot of conversations I had with students during this activity seemed to help them make more progress when they returned to their larger projects.
After class, I found some time to look through their papers and I picked out mistakes that I liked (and threw in a few of my own). I wrote the mistakes on little scrap pieces of paper and hung them around the room. I also wrote a description of the mistake in pencil on the back of the paper. Here’s an example (sorry one of the pictures is blurry):
When students walked in the next day, I told them to grab a sheet of scratch paper and start walking around the room and looking at the mistake papers that were hanging around. There were 12 total papers, but I told them they only needed to investigate 8 of them. This gave students an ‘out’ if they got stuck on a particular problem. This also let students work with partners to move through the different prompts.
I told them that their answers should look like a description of what the mistake is, not just a re-writing of the syntax in its correct format. This was partially because I didn’t want them to re-write the entire syntax on another sheet of paper – that would take a while – but also because I wanted them to practice articulating and communicating the source of the mistake rather than just focusing on ‘fixing it’. I have some half-formed thoughts and hopes that this may be activating a different part of the brain or reaching a different level of cognitive demand than just being asked to fix the mistake. My hope is these types of questions will help curb the instinct of just reaching over and fixing someone else’s mistake versus describing to them what & where the mistake is. I also tie it back to some workplace skills – if they become a manager of other people, and those people make mistakes, you can’t just fix their mistakes – you need to give them directions on the wheres and whats that are incorrect. Actually, to this larger point, I wish I had put line numbers on my little half-sheets and had students also identify the line number where the mistake is.
Anyway – students walked around and investigated each of these mistakes. Here’s what that looked like:
After 5 minutes or so, I revealed that the answers were on the back of the half-sheets and told students to go back around and check their answers. But – because they had a choice of which prompts to look at, I could also tell them to go back and check any that they skipped. This led to some cool moments as students returned to problems that had stumped them and had these visible “Aha!” moments as the source of the mistake was revealed. That was cool.
I had students self-grade and turn them into me, then we started the next lesson. The whole bellwork took 5-10 minutes, had them moving around the room and being active, and had them engaging with syntax without actually doing any coding. I liked it.