9
$\begingroup$

As probably we all experience, plagiarism is very common in CS. I know that there are several types of plagiarism ranging from simply submitting a copy of the colleagues’ code to other highly sophisticated mechanisms. In my experience, the most common is indeed the simplest one. The student just grabs the code from another colleague and eventually change the names of the variable, and submits the solution (some students don’t even do that!).

While there are several systems that are easily capable of detecting this type of plagiarism, they do it mainly when the student submits the final version of the code. Some other tools, are capable of detect plagiarism and notify the student about that (as if they didn’t already know that!). In most cases the use of an anti-plagiarism tool will act mainly to support punitive measures.

Although it is not the main focus, as part of my PhD work, I am working in a tool that analyses the source code as it is being written and is able to detect plagiarism in “real-time”. This way, the teacher can be notified about students that are performing plagiarism even before their final solution is submitted, giving the teacher time to act and avoid the punitive measures.

My biggest question is: What should the teacher do with that information? Will this be efficient?

Improve this question
$\endgroup$
8
  • $\begingroup$ What level of class is this? I have students just learning the earliest ideas in programming, who 'help' each other a lot. Occasionally I do see nearly identical solutions handed in. I ignore it if it happens once, but if there is a pattern, I talk with the whole class, reminding that they should not be teaching each other, and need to come to me when they are having trouble. In this case it is less about taking the work of others and more about not doing the work themselves so that they can learn. The word 'plagiarism' is unfortunately used to mean both cases. What is a better word? $\endgroup$
    – user737
    Commented Jul 8, 2017 at 15:23
  • 2
    $\begingroup$ @nocomprende IMO, not teaching is a bit too much. I usually tell them "give help, not code". Teaching is one of the most efficient ways of learning. $\endgroup$
    – rcpinto
    Commented Jul 8, 2017 at 15:36
  • 1
    $\begingroup$ @nocomprende, I wish you wouldn't ignore it even once. I worry that when students get away with something it only cements the habit. First impressions matter, and the first impression of cheating should not be a good one! $\endgroup$
    – David White
    Commented Jul 8, 2017 at 15:38
  • $\begingroup$ nocomprede it happens in several different classes of an higher education degree. I also have some students that "work" along with their collegues. One is working, while the rest are looking at the screen. In the end, all feel that they've participated and so can submit the same solution. rcpinto Exactly! The problem is even worse when the students that give the code, know even less that the ones that asked for it. DavidWhite I agree! In the past some collegues were a bit permissive, so when I say, that no one is allowed to do plagiarism they kind of ignore it. $\endgroup$
    – Nuno Gil Fonseca
    Commented Jul 8, 2017 at 16:14
  • $\begingroup$ Looks like a solution in search of a problem. In an on-premise test you'd rather use supervision to prevent plagiarism, rather than detect it from program similarity. In a take-home test, you'd need to engage in highly unethical behaviour, like mandating the use of spyware on the student's computer to obtain the code as it's written. $\endgroup$
    – CodesInChaos
    Commented Jul 8, 2017 at 17:42

2 Answers 2

Reset to default
6
$\begingroup$

I assume that somewhere you discuss plagiarism and the social good of respecting the IP of others. If not, plagiarism detection is just a "gotcha" that doesn't really benefit the students or your relationship with them.

The following suggestion is offered tentatively, and might require tuning. It might also require research on the effect.

If the tool is good enough to tell you in real time that something bad is occurring, it is also good enough to tell the student at that moment. So you could build that feature into the tool.

However, there is, then, the danger that a student could game the system, modifying things just enough that the warning goes away. So it might be necessary for the warning given the student to also warn that not every "violation" will be reported to the student but will be reported to the instructor.

Caveat: This was "seat of the pants - in the moment" design. I can't claim it is best practice. It is, however, based on the principle that fairness and communication are positive attributes in education. Help the student grow in many dimensions, not just the technical.

In your discussions with students about plagiarism, be sure to include the concept of self plagiarism which many don't recognize as a problem since it doesn't violate IP rules. But does make derived research and attribution more difficult.

And, like any lesson, it needs to be reinforced. Very little that you do just once will actually be learned. Active learninig is reinforcing as lecture is not. Class discussions about plagiarism and its tradeoffs (short term gain - long term pain) might be useful.

Improve this answer
$\endgroup$
3
  • $\begingroup$ All the students are aware of what we consider as plagiarism, however, they just keep on doing it... :( As you said, if the tool warns the students about plagiarism, they may try to change the code till the tools says the code is fine. The "gotcha" thing alone was also something that we wanted to avoid, as it may be totally ineffective. So my question is: I have early knowledge about plagiarism from a student, shall I do something or just wait to punish that student? $\endgroup$
    – Nuno Gil Fonseca
    Commented Jul 8, 2017 at 13:19
  • $\begingroup$ I was once thought to be slacking by my most respected professor. Not plagiarizing, but also a problem. He and I met, by chance, in an elevator for a few moments and in a few sentences, he made me re-think my priorities. A friendly word can be stronger than a shout. It is also possible that he arranged the "elevator talk" without my noticing. $\endgroup$
    – Buffy
    Commented Jul 8, 2017 at 13:33
  • $\begingroup$ I suppose that is the way to go! Keep things "informal"! $\endgroup$
    – Nuno Gil Fonseca
    Commented Jul 8, 2017 at 13:38
3
$\begingroup$

Based on response to my comment, I will answer regarding the narrow aspect of this question that matters to me:
Students just beginning often 'help' each other or work together. If the only thing they can see is a nail, their solutions all look remarkably like the same hammer. It is not so much that they are doing something wrong as that they are not doing several things right - 1) realizing they don't know enough to teach others, 2) discovering answers for themselves (probably the most vital need at their level) and 3) asking me to explain.

I don't know what they don't know if they don't tell me.

This is vastly more important than the idea of 'cheating', and it deserves a word that makes us all want to rush to help instead of rushing to judgement. As we know, naming things properly matters.

As for teaching being a way to learn, great, if you are willing to take responsibility for that person's career outcome. "Helping someone is the same thing as messing with them." (from The Hotel New Hampshire)

Improve this answer
$\endgroup$
2
  • $\begingroup$ "As for teaching being a way to learn..." I was not the person who said that! :) I honestly prefer when a student ask me whatever rather than his colleagues. $\endgroup$
    – Nuno Gil Fonseca
    Commented Jul 8, 2017 at 17:14
  • $\begingroup$ Yes, I know, I got comments from several people, and yours agree with my views. I just thought that if there are other views, I should write a complete answer. $\endgroup$
    – user737
    Commented Jul 8, 2017 at 17:16

Not the answer you're looking for? Browse other questions tagged or ask your own question.