25
$\begingroup$

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.

$\endgroup$
  • 28
    $\begingroup$ Do you know that the author voluntarily shared the work and it wasn't taken from them unwittingly? $\endgroup$ – Ellen Spertus Jul 10 '17 at 20:05
  • 2
    $\begingroup$ I suppose that most of the times they share the work voluntarily, although they don't admit. $\endgroup$ – Nuno Gil Fonseca Jul 10 '17 at 20:17
  • 19
    $\begingroup$ Why did you ask on CS Educators instead of Academia? There doesn't seem to be anything specific to computer science here. $\endgroup$ – jpmc26 Jul 11 '17 at 6:30
  • 1
    $\begingroup$ @jpmc26 I understand what you say, and probably my question should be more clear in that aspect, but in fact I am especially interested in programming assignments (copy of source code). $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 10:32
  • 4
    $\begingroup$ @jpmc26 Whether a question is on-topic at another site shouldn't matter—as long as the question is on-topic here, it should stay here (and from the reception, the answer appears to be that it is firmly on-topic here). Overlap between sites is absolutely fine if you want an answer from a specific group (like CS Educators, for example, rather than general Academians). $\endgroup$ – Aurora0001 Jul 11 '17 at 19:19

14 Answers 14

26
$\begingroup$

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.

$\endgroup$
  • 20
    $\begingroup$ I think it worth mentioning that the pricing scheme for some git hosting sites makes it likely that some students will use public repositories for their projects, even if working solo. I and several of my peers did this - and I am quite confident that this was done because of money, not in order to facilitate academic dishonesty. $\endgroup$ – Jeutnarg Jul 10 '17 at 21:13
  • 8
    $\begingroup$ What do you mean by facilitating cheating? When I was a student, I published a lot of assignment solutions. I was the author after all, I can do whatever I want with what I've created. $\endgroup$ – Džuris Jul 11 '17 at 0:36
  • 1
    $\begingroup$ Also -- sure, let's encourage people to keep their stuff behind 100 locks. Hell, maybe even ban the use of VCSes altogether. Why not approach this like an actual CS professional? Encourage everyone to use Git or Mercurial for their homework -- if there are any suspicions, a simple look at the commit history will reveal who's to blame (for plagiarism et al). $\endgroup$ – Priidu Neemre Jul 11 '17 at 8:45
  • 1
    $\begingroup$ @Džuris That would depend on your school's policy. If you are free to do what you want after your project is complete, and you publish it, of course it's not cheating. It's all about the intent—did you willingly help someone else in full knowledge that this is inappropriate, or did they, in effect, copy from your work without your knowledge and without crediting you? $\endgroup$ – Aurora0001 Jul 11 '17 at 14:42
  • 1
    $\begingroup$ Comments are not for extended discussion; this conversation has been moved to chat. $\endgroup$ – thesecretmaster Jul 11 '17 at 14:44
13
$\begingroup$

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.

$\endgroup$
  • 1
    $\begingroup$ I love the last line, and the overall sentiment of this answer. $\endgroup$ – Floris Jul 12 '17 at 12:57
  • $\begingroup$ Agreed that, for example, expulsion for a first offense, particularly for a freshman, might be excessively harsh, but I'd also say that the best way for most people to learn the lesson is for the punishment to be at least enough to sting, especially in case of blatant academic dishonesty where any reasonable person should have known better. Getting a zero on the particular assignment, for example, seems appropriate. I also had at least one professor who, upon discovering students shared an assignment, would grade the assignment and then divide by the number of students who shared. Seemed fair. $\endgroup$ – reirab Jul 12 '17 at 18:30
  • $\begingroup$ @reirab Your professor made my day! $\endgroup$ – cst1992 Jul 12 '17 at 19:18
10
$\begingroup$

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.

$\endgroup$
  • 10
    $\begingroup$ "there are enough artifacts in the digital file...to be confident of copying." but not to be confident that the copying is not the result of a code theft (supplier was not consenting to this copy). Would'nt this approach punish the victim of a theft along with the thief ? $\endgroup$ – Quentin Jul 11 '17 at 8:25
  • 1
    $\begingroup$ Says the guy who's never seen code stolen outright. I started booby-trapping mine after a few times. $\endgroup$ – Joshua Jul 11 '17 at 17:17
  • $\begingroup$ @Joshua your homework code wouldn't be stolen if you weren't doing something unethical with either it or your pc. Other students aren't going to hack your pc. If they are, they probably don't need to see your answer. $\endgroup$ – The Great Duck Jul 12 '17 at 1:46
  • 1
    $\begingroup$ @Typhon: It was stolen off the department server not my computer. My home computer had too weak a distro for advanced computer labs and I couldn't suck down a modern one over floppy disks. $\endgroup$ – Joshua Jul 12 '17 at 1:48
  • 1
    $\begingroup$ @Joshua in that situation the department is at fault, period. The security shouldn't be like that and you cannot be punished for illegal access like that. $\endgroup$ – The Great Duck Jul 12 '17 at 1:53
6
$\begingroup$

I have 3 usual responses at my small institution:

  1. If two students cooperated, I ignore it the first time, after that I talk with them.
  2. If one copied from another, possibly by looking in my "In Box" (on my desk), I talk with that person.
  3. I report it to the Administrator in charge of Students.

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.

$\endgroup$
5
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ Buffy, first of all thank you for such and interesting answer. I also believe that pair/group work are very important, especially in CS. The problem is that in the past I've done that, but when it came to that part when I asked them: Well, who made what? Was it 50-50? Who contributed the most?... Even when I was sure that it was like 80-20 (100-0 in some cases) they would say it was 50-50. :) $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 11:34
  • 1
    $\begingroup$ That is why I ask the sort of questions that let them avoid such answers. Not, "did your partner do his/her share", but "what did he/she contribute". $\endgroup$ – Buffy Jul 11 '17 at 11:42
  • $\begingroup$ :) Sure, with me that question would also arise immediately after the first one. But they would have their lesson well study and in the end would still seem like (50-50). Even know I receive pieces of code with almost one comment per line :) $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 11:56
  • $\begingroup$ Hmmm. Excessive comments are a "Code Smell" of course. $\endgroup$ – Buffy Jul 11 '17 at 12:01
3
$\begingroup$

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.).

$\endgroup$
3
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ Ben, my school has a code of conduct, but it does not say anything about this particular issue. Your idea about the debate is a very good one, but I teach in a higher education school where several of my "kids" are older than I am :) and I suppose I won't have time for that! But I will for sure start doing a debate about this issue on the first class of the semester. $\endgroup$ – Nuno Gil Fonseca Jul 10 '17 at 20:59
3
$\begingroup$

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).

$\endgroup$
  • 2
    $\begingroup$ Hi Scott! Welcome to Computer Science Educators! Thank you for this very interesting take on this question! I hope to hear more from you around the site. $\endgroup$ – thesecretmaster Jul 11 '17 at 3:25
  • 1
    $\begingroup$ Hi Scott! To me it is OK, if one student help other. Even if a part of the code is similar, no problem. To me, a huge problem happens when several different files are 90-100% equal... $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 10:14
3
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ Joel, I understand what you said, and I agree with you. I always have interviews and code reviews with the students. So there goes my question: I am 100% sure about who really made the work. Should I punish that student? In other answers people are saying that it might have happened involuntarily (GIT, ...)... although that might be the case, I guess that in most cases, the students simply exchange the code between themselves (via Facebook groups, Whatsapp, ...) $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 10:21
2
$\begingroup$

I would recommend the same punishment for each party, for several reasons:

  1. If you get two near-identical projects, it can be nearly impossible to determine which was the original. If you can only punish the one who copied, then you won't be able to punish anyone without determining which is which, and people can cheat with impunity.
  2. Suppose that Alice and Bob are friends in the same class, and Alice asks Bob to let her copy an assignment. If it's known in advance that there will be no consequences for Bob even if they get caught, there's some social pressure to go along with it. But if both are punished, Bob can simply say he isn't willing to take the risk. The policy makes Bob less likely to aid in cheating and also lessens any social consequences for doing the right thing if he would have done so anyway.
  3. Helping someone else cheat is unethical, so I have no problem punishing someone who does so willingly.

But we do want to avoid punishing someone who unknowingly helps someone cheat. There are two likely scenarios here:

  1. Alice looks at Bob's assignment when Bob isn't paying attention. This is less of a problem in CS than it would be elsewhere, due to the large number of coding assignments; a quick glance generally won't be enough. But for instances where it might be... The students are informed that keeping their work from being copied is their own responsibility, but if a small enough portion of the answer is copied that this is a plausible scenario, I'd probably give them the benefit of the doubt anyway (especially since small similarities can happen by coincidence).
  2. Alice and Bob collaborate a bit more than they should have, but don't actually intend to cheat. I'm perfectly okay with students discussing assignments so long as they're helping each other learn the material instead of just copying answers, but sometimes the line between the two isn't perfectly clear. My policy here is to insist that if students collaborate (or ask for help on stackoverflow, for that matter), they cite their sources on the assignment. If too much of the answer came from another source, I might take off a few points or have them redo the assignment (or more likely, just let them know that in the future, they need to do more of the work on their own), but as long as they're honest about where it came from, there's no ethical violation.
$\endgroup$
  • $\begingroup$ Bob is the author of his solutions. How can you forbid him to publish his own work? Plagiarism is the fault of the plagiazer not the original author. $\endgroup$ – Džuris Jul 11 '17 at 0:31
  • $\begingroup$ @Džuris Published? I'm talking about students copying code written for class projects; nothing's published anywhere (or worth publishing, for that matter). But if Bob had previously published code that he reused for the assignment, then the publication's timestamp would establish Bob as the original author, and I'd require Alice to cite that source just like anything else she found online. And if Bob only wrote the code for the assignment, he should hold off on publishing it until all the submissions are in. $\endgroup$ – Ray Jul 11 '17 at 0:42
  • 1
    $\begingroup$ Ray, I agree with all your scenarios, and so far I have never punished the original author, but as you mentioned, that is giving them a sense that they can share what they want. In some way, it is kind of holding an exam solution and walk in the classroom showing the solution to the colleagues. The student is just showing the solutions… the colleagues may or may not copy them. $\endgroup$ – Nuno Gil Fonseca Jul 11 '17 at 10:29
2
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ In "My advice" I think you mean "to the professor". I think that is good advice, as are your reasons for it. You might clarify the post a bit with edit. $\endgroup$ – Buffy Jul 12 '17 at 13:55
1
$\begingroup$

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).

$\endgroup$
  • $\begingroup$ Hi Dennis! Welcome to Computer Science Educators! I'm glad you were able to add a new perspective here. $\endgroup$ – thesecretmaster Jul 13 '17 at 10:41
  • $\begingroup$ I think that "guilty until proven innocent" isn't best practice in any field. There can be social pressure among students that push an innocent person to not speak up to defend themselves. Surely the system should be more fair. $\endgroup$ – Buffy Jul 13 '17 at 11:13
0
$\begingroup$

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.

$\endgroup$
  • 2
    $\begingroup$ Hmmm. Doesn't that put more work on an innocent party? $\endgroup$ – Buffy Jul 11 '17 at 0:23
0
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ Additional details: High school, none of us have been taught programming before except basic HTML. I have been programming for years, and the teachers are aware of the fact that students ask me for help, sometimes they're even sent to me by them... $\endgroup$ – rahuldottech Jul 12 '17 at 6:16
  • $\begingroup$ Hi, Rahul2001! First off, thoughtful student responses are certainly welcome in this community, so welcome to Computer Science Educators! This answer has a few problems, however. First, it violates the Be Nice policy. Second, it isn't really an answer to OP's question. I have edited for the first problem, but the second one only you can fix. (BTW, don't worry, we still like you. I promise that you aren't the first person to have trouble with an initial post, and you won't be the last!) $\endgroup$ – Ben I. Jul 12 '17 at 10:17
  • $\begingroup$ @Rahul2001 I understand what you are saying. The teachers can't cover every single student at the same time, so to me it is OK if you have a student looking at someone's code to have a board idea about the solution or to overcome a specific difficulty. On the other side, I feel that it is not so correct when a student simply grabs the colleagues code and submit the code as being written by themselves. My initial question was about this last scenario. ;) $\endgroup$ – Nuno Gil Fonseca Jul 12 '17 at 10:18

protected by thesecretmaster Jul 13 '17 at 10:39

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).

Would you like to answer one of these unanswered questions instead?

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