We Don’t Know How To Teach Code Review
If you go to my very first blog post about code review, you’ll discover what my original research question was:
Code reviews. They can help make our software better. But how come I didn’t learn about them, or perform them in my undergrad courses? Why aren’t they taught as part of the software engineering lifecycle right from the get-go? I learn about version control, but why not peer code review? Has it been tried in the academic setting? If so, why hasn’t it succeeded and become part of the general CS curriculum? If it hasn’t been tried, why not? What’s the hold up? What’s the problem?
But I’m no teacher. I really don’t know what it’s like to run a university level course. Thankfully, two course instructors from our department gave their input on the difficulty of introducing peer code review in the classroom. Here’s the first:
The problem is that is completely un-assessable. You can’t get the students to hand in reports from their inspection, and grade them on it, because they quickly realise it’s easier to fake their reports than it is to do a real code inspection. And the assignment never gets them to understand and internalize the real reasons for doing code inspection – here they just do it to jump through an artificial hoop set by the course instructor.
What we really need to do is to assess code quality, and let them figure out for themselves how the various tools we show them (e.g. test-case first, code inspection, etc) will help them achieve that quality. Better still, we give them ways of measuring directly how the various tools they use affect code quality for each assignment. But I haven’t thought enough yet about how to achieve this.
So, I’ve long since dropped the idea of a specific marked assignment on code inspections, but still teach inspection in all of my SE courses. I need to find a way to teach it so that the students themselves understand why it’s so useful.
And here’s the second:
1. How many different tasks can we ask students to do on a 3-week assignment? I think students should learn to use an IDE, a debugger, version control, and a ticket system. We have been successful in getting students to use version control because that’s the only way they can submit an assignment. We have had mixed success getting students to use IDE’s and debuggers, partly because it is hard to assign marks for their use. We have been even less successful in convincing students to use tickets because a 3-week assignment isn’t big enough or long enough to make tickets essential.
2. If the focus of my course is teaching operating systems, how much time (and grades) should I devote to software development tools and practices that aren’t centered on operating systems?
All of this swirls around a possible answer that Greg Wilson and I have been approaching since September:
What if peer code review isn’t taught in undergraduate courses because we just don’t know how to teach it? We don’t know how to fit it in to a curriculum that’s already packed to the brim. We don’t know how to get students to take it seriously. We don’t know if there’s pedagogical value, let alone how to show such value to the students.
If that’s really the problem… Greg and I may have come up with a possible solution.
But First, Some Background
It’s a good read, but in the interests of brevity, I’ll break it down for you:
- Joordens and Pare are both at the University of Toronto Scarborough, in the Psych Department
- Psych classes (especially for the first year) are large. For large classes, it is generally difficult to introduce writing assignments simply due to the sheer volume of writing that would need to be marked by the TAs. Alternatives (like multiple-choice tests) are often used to counteract this.
- But writing is important.
- The idea: what if we let students grade one another? There’s research showing the benefits of peer evaluation for writing assignments. So lets see what kind of grades peers give to one another.
- A tool is built (peerScholar), and an experiment is run: after submitting their writing assignments, show students 5 submissions from other students, and have them grade the work (with specific grading instructions from the instructor). Then, compare the grades that the students gave with grades from the TAs.
- A significant positive correlation was found between averaged TA marks and average peer marks. More statistical analysis shows that there is no significant difference between the agreement levels of TA and peer markers.
- To ensure repeatability, a second experiment is run – similar to the first. Except, this time, students who receive the marks from their peers are able to “mark the marker” and flag any marks that seem suspicious (a 1/10, for example, if all the other students and the TA gave something closer to a 7/10).
- It looks good – numbers were closer this time.
- Conclusion: the average grade grade given by a set of peer markers was similar to the grade given by the TAs in terms of overall level and rank ordering of assignments.
This is a very interesting result. Why can’t we apply it to courses in a computer science department? What if students started marking each others code?
What they’d be doing would be called code review.
Let’s modify Joorden and Pare’s model a little bit.
Let’s say I’m teaching an undergraduate computer science course where students tend to do quite a bit of coding. Traditionally, source code written by students would be collected through some mechanism or another, be marked by TAs, and then be returned to students after a few weeks.
What if, after all of the submissions have been collected, each student must anonymously grade 5 submissions, chosen randomly from the system (with the only stipulation that students cannot grade their own work).
But here’s the twist:
Instead of just calculating a mark for students based on the peer reviews that they get, how about we mark the students based on the reviews that they give – specifically, based on how close they are to generating the same marks that the TAs give?
So now a students mark will be partially based on how well they are able to review code.
Questions / Answers (or Concerns / Freebies)
I can think of a few initial concerns with this idea.
Q: What if the TA makes a huge mistake, or makes an oversight? They’re not infallible. How can students possibly make the same mistake / give the same mark?
A: I agree that TAs are not infallible. Nobody is. However, if a TA gives a submission a 3/10, and the rest of the students give 9/10’s, this is useful information. It either means that the TA missed something, or might signal that the students in general have not learned something crucial. In either case, this sort of problem can be easily detected, and sorted out via human intervention.
Q: What if students game the system by just giving their peers all 10/10’s, or try to screw each other by just giving 0/10’s?
A: Remember, students are being marked on their ability to review. If the TAs gave a more appropriate mark, and a student starts behaving as above, they’re going to get a poor reviewing mark. No harm done to the reviewee.
Q: I’m already swamped. How can I cram a system like this into my course?
A: I’m one of the developers on MarkUs, a tool that is being used to grade source code for students at the University of Toronto and the University of Waterloo. It would not be impossible to adapt MarkUs to follow this model. Through MarkUs, a lot of this idea can be automated. Besides some possible human intervention for edge cases, I don’t see there being a whole lot of course-admin overhead to get this sort of thing going. But it does mean a little bit more work for students who have to review the code.
Q: This is nice in theory, but is there any real pedagogical value in this? And if so, how can I show it to my students?
A: First off, as a recent undergraduate student at UofT, I must say how rare it is to be given the opportunity to read another student’s code. It just doesn’t happen much. I would have found it interesting – I’d be able to see the techniques that my peers employed to solve the same problems that I was trying to solve. It would give me a good informal measuring stick to see how I rank in the class – and students always want to know how they rank in the class.
Would they learn anything from it though?
That’s a good question. Would students learn anything from this, and realize the benefits? Remember – that’s what Steve Easterbrook says was the major stumbling block to introducing peer review…we have to show them that it’s useful.
- How good are students at grading their peers? How close to they get to the grades that a TA would give?
- By study year
- By their perceived programming ability
- By their perceived programming experience
- By their programming confidence
- What happens to students’ ability to review their peers as they perform each review? Do they get better after each one? And is there a point where their accuracy gets poorer from fatigue?
- How many student reviewers are needed to approximate the grade that a TA would give?
- How long do students generally take to peer review code? (bonus)
- How long do graduate students generally take to mark an assignment? (bonus)
- Do the students actually learn anything from the process?
- How do the students feel about being graded on their ability to review?
- Do they think that this process is fair?
- Do they think that they’re learning anything useful?
- Do they feel like it is worth their time?
- Do they enjoy reading other students’ code?
- If it was introduced into their classes, how would they feel?
Lots of questions. Luckily, it just so happens that I’m a scientist.
First, I mock up (or procure) 10 submissions for a programming assignment that our undergraduates might write.
I then get/convince some graduate students to grade those 10 submissions to the best of their ability, using MarkUs. These marks are recorded.
I then take a cross-section of our undergraduate student body, and (after a brief survey to determine their opinions of their coding experience/confidence), I get the students to peer review and grade those 10 submissions. They will be told that their goal is to try to give the same type of marks that a graduate student TA might give.
After the grades are recorded, I take the submission that they reviewed first, and get them to grade it again. Do they get closer to the TAs mark than their first attempt?
Students are then given a second survey (probably Likert scales) to assess their opinions on the process. Would it be fair if their ability to grade was part of their mark? Did you get anything useful out of this? Did you feel that it was worth your time? Did you enjoy reading other students’ code? How would you feel if it was part of your class? …
The final survey will (hopefully) knock out the last series of questions in my list. Timing information recorded during marking will help answer the bonus questions. Analysis of the marks that the students give in relation to the marks that the TA give will hopefully help answer the rest.
What Am I Missing?
Am I missing anything here? Is there a gaping hole in my thinking somewhere? Would this be a good, interesting experiment to run? For those who teach…if my results are encouraging, would you ever try implementing this in your classroom?
And if this was introduced into the classroom…what would happen to student learning? What would happen to marks? How would instructors like it?
So, what do you think? I’m all ears.