Computer Science Educators Stack Exchange is a question and answer site for those involved in the field of teaching Computer Science. It only takes a minute to sign up.
Sign up to join this community
The question kind of says it all. Imagine that for an assignment you receive two or more similar submissions (e.g. programs). What will you do? Annul all the works? What if you know for certain who was the original author?
Probably this is already in your schools’ code of conduct. In my school it is not and I sometimes don’t really now what to do.
This would depend on context, in my opinion. Given you know the identity of both the original author and the plagiarist, consider:
Did the original author facilitate the plagiarism, or was the code plagiarised without the original author's knowledge? Can you tell?
Clearly, if the original author was the victim of someone peeking over their shoulder, or just blatantly copying code files, then they should not be punished. But if they gave help to others despite being told that this is inappropriate, then they are equally guilty of misconduct.
It's easy for me to write this, but in practice determining whether the plagiarism was with or without consent is more difficult. I would be inclined to give the benefit of the doubt if there is any chance that one party did not intentionaly cheat.
Is there any record of the students cheating previously? If so, that might be a guide.
I would be keen to avoid punishing someone who might not have done anything wrong, but some others might not give the benefit of the doubt. It's certainly not easy to tell what exactly has gone on when two very similar works are handed in, but if you can rule out any copying without the author's awareness with certainty, then you must assume that the author facilitated cheating.
If you haven't made clear what the difference is between helping and cheating, then you can't really punish anyone fairly—if you don't clearly lay out your expectations, then you can't enforce strict rules.
I have a somewhat different suggestion. Make every infraction an opportunity for learning, not a punishment scenario. Young people (& others) mess up. They get into "situations" and make dumb decisions. It is in the nature of growing up. You can't (severely) punish young people for making young people mistakes. And any punishment that doesn't stress learning is counterproductive.
I've written elsewhere on this site that if the young weren't risk takers then the human race would still be in the trees and just prey animals. The young put themselves at risk so that the baboons didn't feast on the infants and old ones. Live with it. It is part of our nature, mediated by intelligence for the most part, but still there.
That doesn't mean you can't put a scare into an offender (as a lion would do). But your primary job as a teacher is to teach the students the lessons that they need, not just facts or technical skills.
Repeated infractions and overall disdain for the rules or their fellow students is a different matter requiring more formal measures. So do infractions that hurt other people in some way.
Let me give a personal anecdote. When in college a fellow student and I committed a somewhat different sort of infraction. The faculty were of several minds with some simply dismissing it as "kids!" and one wanting us expelled. There were meetings and a committee that called us to account. After we suitably (and honestly) abased ourselves we were let go with an informal probation. It was very enlightening as well as embarrassing. My co-perpetrator graduated at the top of our class and I wasn't terribly far behind. So it worked out. (No creatures, human or otherwise, were harmed by our little escapade, so it was a simpler case). And I must have grown up wanting to emulate the way I was treated.
But the punishment for academic dishonesty should involve something that assures that the lesson of the assignment is learned as well as learning why the rules are important. Sometimes doing a similar assignment and writing an essay on honesty or whatever is appropriate.
It took me a while, but I learned over the course of my career that the main job is to teach students, not to judge them.
As outlined in my syllabus, both the contributor and the receiver have committed an integrity violation, and both will be punished. For me to feel that this is fair for everyone, I make sure to be very clear of the rules early in the course. I have a section in my syllabus that directly addresses "helping" other students. I have a list of actions that constitute integrity violations. But I also have a list of actions that are permissible in attempting to help other students. This has proven useful for the stronger student that truly does want to help their struggling colleague. It also gives the stronger partner a reference that they can show their struggling partner when they feel they are being pressured to help too much.
When I have instances of a student using another student's code, I will go back to the syllabus and cite the specific actions that were violated. The "supplier" may think that the punishment outlined in the syllabus is too harsh, but I rarely have a student now who denies that they violated a stated rule. And the punishment was known before the offense took place.
This is all assuming that you know one student was the supplier for another. I only pursue this if I have a extremely high level of confidence that this happened. Usually with submitted programming assignments, there are enough artifacts in the digital file (white spacing, identical inconsistencies, etc.) to be confident of copying.
I have 3 usual responses at my small institution:
We have only a few dozen students and one Administrator, so it is a small problem and gets dealt with quickly. Usually, if someone is getting excessive help from other students or is copying things, they end up not being able to do this coursework and we can redirect them to another program.
There is another way to approach this sort of problem, but it requires that you have the authority or power to modify the basic structure of the course.
I actually prefer to structure a course in such a way that this sort of problem can't arise. To do this requires that you encourage or even require students to work together, either in pairs or in larger teams. Work is submitted by the team. A naive approach to this won't work, of course.
A weaker proposal is to let students help one another pretty freely, but require that all collaborators be named in any submission. A subtle form of this is to let students collaborate, but not share code. However, you need a strong and well written Code of Conduct for this to work.
The issue, as I implied in my earlier answer to this question, is that learning must take place. Some problems given to students have a crux point and seeing it allows the student to have an A Ha moment that can be very powerful. The Dutch National Flag exercise has such a crux with a key insight that can broaden the education of any student. It is a shame to deny this moment to any student, which is one of the reasons we often require our students to work alone. However, if the student doesn't arrive at the denouement in a timely manner her/his learning may be slowed. And students often panic in the face of deadlines.
When I was much younger and teaching mathematics, I really believed that students should work strictly alone so that they could have such insights. I believed that, even though, at that time it was becoming increasingly common for working mathematicians to work in groups rather than alone. In fact, one of the reasons that I left math for CS is that I was teaching at a place at which there was no opportunity for local collaboration and the synergy it brings. This was before the internet of course (but we had left stone tools behind, thankfully).
There is a dilemma here, of course. We want each student to learn. We need to permit them to advance. Insight is good and aids this. Getting "stuck" inhibits it. In my view the way to cut the Gordian Knot here is:
Teach in such a way that there are more opportunities for a ha moments.
If there are many many opportunities, then the fact that student A helps B get through the crux on one such doesn't deny B the opportunity on the next one. There is evidence in the Pair Programming community (Agile Addicts) that pairing aids synergy, and doesn't leave anyone behind. Different people can contribute different things at different times and all advance.
Some additional points:
First, teamwork is a valuable, even required, skill for most employment. It doesn't come naturally to many any more or less than programming in a functional style (for example) does. It can be taught and needs to be practiced.
Also, knowing who the collaborators are, by design, lets you assign marks fairly. But you should arrange it so that people don't always work with the same partners. Students then learn less about teamwork and you have a harder time knowing who is shining and who needs a bit more polishing.
If you do this sort of thing, it is also useful, perhaps required, that you let the students give some sort of evaluation of their team-mates. Students are reluctant to do this of course, but it can be arranged if you make it positive for them. If you ask "How did your buddy do?" you are likely to not get useful information. However you can do the following:
If students are paired have them fill out an evaluation with two questions
* What was your partners chief contribution?
* What was your own chief contribution?
Make this a part of every paired assignment. If you have a student who answers "nothing" to the first question you learn something. If you have a student who always answers this way you learn something else. Both likely require a response from you.
In larger groups, have each student fill out a questionnaire at the end with questions like, supposing a group of five, for example,
* Who were the three most valuable members of your team, possibly including yourself?
* What was the main contribution of each of the people named above?
* What was your own main contribution.
Make sure the students know about this, including the questions themselves, before the first group assignment.
If you allow collaboration, as in my "weaker" proposal at the top of this, you can also have collaborators fill out such an evaluation and submit it with the work. It doesn't add much to your work, as such submissions are usually short, but it does give you a better picture of individual progress.
An anecdote is instructive. I once had a group of students in a class and one of them seemed to be slacking. He didn't contribute much to discussions and didn't have great responses. However, on a fairly large project, he was the one named by every other member as the key to getting the work done. Since their work was done outside my view, I'd have missed this entirely. He got a big boost, of course, as he had earned it.
It depends on the situation and your school's policy on academic integrity. At my school, it clearly states that authors may not knowingly permit other students to submit their work. You may want to ask your school to update its policy to include a clause like this.
You will have to determine if authors know if other students submitted their work. The author could be a student in the current class or another class. The author could be a stranger online. In a previous class, I suspected that one student submitted another student's program. This was confirmed when I saw that the filename included the original student's first and last name. After discussing this with both students, I resolved it. I can't say that I follow a hard and fast rule. I think it depends on the situation (severity of the violation, actions of both parties, etc.).
Having been in a similar situation myself as a student (once upon a time) might I suggest a different strategy - one that doesn't immediately punish either party?
Consider Jeutnarg's comment above about source control. Firstly, you absolutely do not want to encourage budding learners to be secretive with their code as that leads to far greater problems down the line. I appreciate some of these commercial tools may cost money to host private repositories but I would say that there's more harm than good can come from punishing a student for using a public repository. (It's worth pointing out at this stage that many online apps give student and educational accounts out for either very little money, or for free.)
In this situation, I'd use this exact scenario as an opportunity - get them to write docs, or interview them one-on-one about the code. Ask them questions about the functionality, the expected output, and then discuss the plagiarism aspect directly with each student. Give them an opportunity to resubmit the work (or an entirely new piece) on their own but if the same thing happened in future, then take the steps toward punishment. If you take the route of a careless mistake (publishing code online when it should have been private), this is a perfect opportunity to explain how dependencies and open source libraries work. If they took the route of actively "cheating" (I know of not one single programmer that hasn't copied and pasted directly from Stack Overflow at one point in their career) then give them a second chance.
My advice? Speak to them directly. Perhaps both had issues with the material, or with teaching style, or perhaps even one was completely lazy and went for the easy route... but you'll never know until asking them directly.
Background: Our entire class got flunked because one student had copied various functions from other people's code. That and we used a few functions from the text book verbatim. I found this really demoralising and unfair as, although the functions were copied verbatim, that was the best way, that we knew of at the time, for that "thing" to be done. Long story short, the student that went around copying everyone had difficulty with the teaching method - and all it took was a couple of simple one-on-one sessions with the tutor to resolve... after we all had to resit the entire course though. That guy ended up dropping out due to the pressure of an entire class hating him. Don't let that happen to your student(s).
To kind of back up comments from others, I'll share something that happened to me.
I wrote an assembler for the 6800 for a software tools class, about 1985 or so. I put lot of work into it, partly because I have a bad habit of trying to do too much, and partly because I had a 6800 protoboard I wanted to be able to write programs for.
One of the TAs for the class was a really cute redhead I had a crush on (which may or may not be relevant). She looked at my completed work and convinced herself it must have been beyond my ability.
I was not party to the discussion with the prof and the other TA that determined the course of action she took, but the upshot was that she contacted me and arranged to meet me in the lab to ask me questions about my code. She had the listing and I did not. She also asked about the design process and the coding process.
I was not under pressure about my code, but I was under a different kind of pressure. She was still able to determine to her satisfaction that I had written the code.
The school did have a policy on doing your own work. That is something your school should develop, and should use your situation to get started with. They also had a policy about the process of investigating infractions, and the prof and she followed it.
I think my point is that a face-to-face interview, teacher has the source, student does not, can allow the teacher to determine whether or not the student really knows what is there in the way that the author of the code should.
If your school does not have a code of conduct, then you need to write a set of understandings that you can give out to your classes. Ultimately, there are no fair responses without some kind of memorandum of understanding. In there, you will outline what you consider to be cheating, and where, exactly, the lines are.
If you want to take a slightly different approach, the lack of a school policy also creates an interesting opportunity for you to get a lot of student buy-in for a strong policy on cheating.
At the beginning of the year, show a few CS plagiarism policies to your students, and ask each student to write their own example of a policy that they would consider to be both fair and enforceable.
During the next period, have each student pair and share, and debate each other for 3 minutes, and then rate the other student's policy on a few key metrics. Then have them switch to a new pairing and do the same. Once every kid has rated a few policies, have them rate their own. Collect all of the policies, and say that you will go over the top 3 policies along with some of your own comments the next day.
On day 3, you now have the makings of a very healthy debate, and the setup for a class vote on a policy. You will need some sort of structure to facilitate (and vote on) document modifications, and an overall vote for adoption. What you will wind up with is a document that the students created democratically, that they can take ownership of, and that they will back. You've also started a very healthy relationship between your students and your course.
I would recommend the same punishment for each party, for several reasons:
But we do want to avoid punishing someone who unknowingly helps someone cheat. There are two likely scenarios here:
I've been on the end that my work was copied. Or rather, I sent my solution to a classmate (as I needed help with a bug), discussed it, and later found out that another classmate had exactly the same code as I sent to the first classmate, with the same comments, bugs and variable names (which, knowing me and my bad naming standards/hygiene at the time, would definitely have called out that it was not his code) and all.
While I am happy that I was not punished, I believe that the teacher should at least have talked with me about it. As it was now, I had to deal with "should I call out on my friend(s)?", "Do I dare tell the teacher that I let both of them copy my code?", "If I call out on the second guy, what will happen with the first that I asked for help?"
My advice: Talk to the student, the very least. It'll save them a lot of stress. I would only annul all the works if you believe that the copying is widespread.
I should mention though that we was encouraged to help each other, so that I asked the first guy for help was not strange. What was as bit on the line was the fact that I sent him the entirety of my code. If that's the case with your students, then I would really advice NOT to annul all the works. It make them much less prone to help each other in the future, and it would just create harsh feelings.
As mentioned, there are likely institutional guidelines for students handing in duplicated work. In my university this typically led to both students drawing the short straw (and as a result it nearly never happened).
Assuming the work is clearly not made independent, and you are not worried that the work may have been copied due to a weakness in the security of the university (and its way of working), then both parties are likely involved.
Therefore I would recommend you to be strict and simply both give them zero points. If one of the students has been unjustly treated he will likely complain. If a he can indeed indicate how he was not at fault you can always become more lenient (and moving in the reverse direction is likely not something you want to do).
As someone who had a friend accused of cheating, because someone's assignment was very similar, but who knew nothing of that person, the solution is simple. Take them both and assign them two very similar, but just slightly different problems of a similar type to the one given. If they can both do them, it's coincidence. If one can and one can't, you have identified the cheater. If they both can't, then maybe they helped each other too much, or both got their work from some 3rd party.
Note: This answer specifically applies to programming-based assignments.
I'm a student, and I'd just like to add my opinion here. We're taught programming in school using Turbo C++. Yeah. That ancient compiler which hasn't been updated in decades.
Needless to say, when we search for help and find samples of code on the internet, most of the code doesn't even compile.
And to add to that, our teachers... Aren't always able to teach very well, due to time constraints or whatever.
I happen to be one of the the best students in class, and often my classmates will ask me to help them out. Whenever possible I'll take a look at their code and point out mistakes, but that's tough to do with a few dozen students in the class.
So sometimes I'll leave my code up and let the students take reference from it, but ask them to write the code themselves. Sure, there are a few kids who just straight up copy it, but I feel that the number of students benefiting learning from it outweighs that.
