So a recent change in my life is that I took a position at a coding bootcamp as an instructor, and honestly it has been so much better for my mental health than working in the industry ever has. Despite that grading student code has been surprisingly harder than I expected!
So my initial thought was "oh, it's just a code review" and indeed we do just use GitHub's code review functionally on a PR the student makes against our repository. However, code reviews are definitely something that I consider myself good at doing, and are usually pretty easy. They're like things I quickly knock off in about 15 minutes.
However, grading is almost like that, but different. First, I have 12 students I have to grade so that's 12 times the reviews. But on top of that I've been finding each review takes a lot longer. Like for the first project I got about 45 minutes at best per submission.
One reason is that I explain in so much more detail than I would in the industry since I can't assume my students are familiar with everything. Another is that by being the code of beginners, there's usually a lot more issues I end up pointing out, which takes longer.
I actually started using a bit of a baseball analogy for to explain this second reason. Let's say my student is the pitcher and I'm the batter. Their submission is their pitch.
Ideally their code is clean, easy to understand, and correct and this is like a fastball because I can just knock that out of the park easily.
A submission with many issues can sometimes be more like a change-up in that it takes me some effort to change my timing on my swing, but it's still pretty straightforward.
And then you have the curveballs, which surprisingly seem equally likely from both my most advanced and my most behind students. These are the implementations that are just so weird that I have to sit and boggle at the code to understand what it does.
In the case of the advanced students this is usually because they get really into making their code as concise as possible and using every nifty syntax feature, usually sacrificing (my) readability. (Admittedly, this is often because they understand how to be pythonic better than I do, because I don't like Python, our language of instruction very much as a language.)
But with the students who don't quite have the grasp yet of say, data structures, they throw a curveball almost by accident by coming up with incredibly odd implementations that I'm often amazed pass our tests. For example, I ran into 26-tuples in an implementation of a function that grouped a list of words into the words that were anagrams of each other.
Like, that works, and a computational linguist friend actually told me there's some benefit to them over my preferred structure in more advanced algorithms, the sorted letters of the word, but it's still weird.
Anyway, no major point here, I just was amused by my analogy here and it felt like a good longer-form post for cohost.