Pascal Scoles
11-14-2000
Computer Ethics
Professor Huang
CS CLASSES AND “CHEATING”
Cheating is not uncommon; cheating is not really a rare occurrence. It can be said that cheating has most likely occurred in the classrooms of all teachable subjects at some time or another. Cheating also is not unknown to the faculty and administrations of all educational institutions, and most of them have formed some policy regarding how they each deal with it. However, it is the opinion of this author that cheating policies and punishment in regards to Computer Science classes are inadequate and/or inappropriate in providing a realistic learning environment. This paper will discuss popular policies regarding cheating, and discuss why they are less than ideal, as well as present what this author believes to be an acceptable solution.
One popular policy, albeit an extreme one, is the policy in place at Gettysburg College, in Gettysburg PA. The policy on cheating there is an overreaching, all encompassing Honor Code, which applies to all academic conduct that takes place the school. The Honor Code states, “I have neither given nor received any unauthorized aid, nor have I witnessed a violation of the Honor Code.”[1] This pledge must be written on any and all work handed in to any professor to be graded. In the case of code that is written, it is usually written in the code as a comment, or if the assignment is to be turned in over e-mail, then sometimes it can be included in the e-mail message body. The effects of the Honor Code are as follows: if a student is accused of cheating, then the honor commission hears their case. If the honor commission finds them guilty, the student usually fails the class automatically. They can get leniency if they turned themselves in, however. One example of “unauthorized aid” is talking about an assignment with another student. Also, not reporting a violation of the Honor Code is a violation in and of itself[2].
Although Gettysburg’s Honor Code applies well and is suitable for courses such as English, Math, Science, and so forth, it does not work for Computer Science classes. One of the major problems with this policy as it affects Computer Science is that collaboration is a major part of programming. Being able to talk to other people to solve programming problems is natural and takes place in businesses everywhere, every day. Setting a policy against any collaboration, verbal or otherwise, between students seems ridiculous, and counter productive. If you talk to someone about a problem and they help you work it out, then you are learning. Without collaboration, the work you turn in will be all your own, but what does that matter if it is no good or you did not complete the assignment?
At a school with such a policy in place, is it morally wrong for the students to collaborate on projects? It is the opinion of this author that discussion never constitutes cheating when it comes to solving programming assignments. Even though the policy states that “unauthorized aid” is a violation of the Code, discussion of programming issues should never be, because in the real world, you can always ask other people questions. Some would say there is a limit where discussion becomes copying. If a person discusses a problem, they still have to sit down and actually write the code, and debug it, whereas if they were to copy it from someone else they simply copy and paste into their own code and nothing is learned.
Computers themselves open up a whole new realm of opportunities for students to cheat. In most Computer Science classes, students do their work on the school’s computer system where, if a UNIX environment, they save their work in their home directory, but if a student has not configured their directory’s access restrictions properly, then other people can browse their home directories and read whatever files that are there. There are many examples of cheating that can take place in a situation like this. One of which is that a person browses through another person’s directory and reads the code they have written, but then goes and writes their own code for the assignment and does not directly copy code from the other person. This constitutes cheating in many cases. How is this different from discussion if no code is directly copied? If you asked the person about the assignment and discussed it with them how would that be any different? Is the case of reading the code wrong because it was done without the owner’s permission? If that permission was given would it make reading the code ok, or would it make both parties wrong? More likely, the argument of why this is an unethical practice is because the person who read the code of the other person didn’t have to do any work on his or her own. This would only be the case if they copied the code directly. Deciphering someone else’s code to understand it is most certainly a learning experience and requires concentration, because everyone implements a problem differently.
Gettysburg College is an extremely conservative example of a cheating policy that is, in this author’s opinion, completely wrong for Computer Science classes. That is not to say that all colleges and universities all have similarly bad policies. One university that has close to ideal policy is the University of Indiana’s Computer Science department. Under their policy, students are encouraged to discuss problems with one another and work in groups, and also they state that, “The work of others that is submitted and appropriately acknowledged is never, of itself, cheating; but it may not earn you any credit for the assignment.”[3] This sentiment of not earning credit for an assignment for not handing in your own work is just, however it is the opinion of this author that using bits of other people’s work if properly documented should be acceptable and treated the same as it is in other Liberal Arts departments, such as English and History, who use the Modern Language Association’s guidelines[4].
In the fields of study such as English or History, many research papers are written where quotations are taken from other sources and cited properly in the paper. This is a very common practice and it is also perfectly acceptable, even encouraged, to use quotes from other sources in a student’s paper. However, if a Computer Science student were to take a portion of code from another author with that author’s permission and even if the student properly cited the source, in many cases the student would not receive full credit for the assignment. How is this different from taking quotations to write a paper?
So what is an acceptable policy to have regarding cheating in Computer Science classes? The aim of the policy is to minimize the effects of cheating on the learning experience, and to mimic a real life environment. To come up with an adequate policy, a few factors must be considered. Since the University of Indiana’s policy is pretty good, we’ll start there and then make changes.
Direct copying of another student’s work in its entirety, or in part should not be allowed, just as copying of another student’s History paper, or introductory paragraph is wrong, and in this regard a cheating policy in a Computer Science department should mimic other policies in other departments. But being Computer Scientists, we can reduce the risk of inter-student cheating by making students work in groups on different projects. This is reasonable and logical if we look at the physical and social environment in which Computer Science assignments are written and stored.
Many assignments are done by students on a UNIX multi-user system. Much of the problem with having a shared workspace such as in a UNIX environment where people can see each other’s work is that if some unscrupulous person were to copy someone else’s work, and hand it in as their own, how is the professor supposed to impartially place the blame on one student or the other, given the information available to him or her? In this case, the honest student suffers along with the dishonest student and is at the mercy of the dishonest student. This is obviously a situation that is unacceptable. From the perspective of the cheating student, they have nothing to lose in this situation. If we assume that they would have not been able to do the assignment without cheating, then they would have failed the assignment anyway if they had not cheated. So in order to take away the incentive to cheat from this student, make all assignments in Computer Science classes’ group assignments. This achieves two purposes. It takes away the dishonest student’s incentive to cheat because they are working in the framework of a group and are receiving any help that they need from the group. This situation also mimics a real life programming environment where all programming is done by groups of people.
One major problem with the University of Indiana’s policy is that it penalizes the student for using code written from other sources, even if permission is properly given and the source is fully documented by the student[5]. This only makes sense if the student uses someone else’s code exactly and hands it in as is. If a student takes methods from another source and they are fully documented that should be ok. Code should be treated in the same manner as research papers. So the policy in this area should be the same as it is in the English / History / Liberal Arts departments regarding research paper citations.
An ideal cheating policy if it were to take into account all of the issues described would be as follows. Plagiarism would be cheating; all sources must be documented. All work should be done in groups, because this eliminates intra-student cheating such as stealing someone else’s code to hand in as your own, because one assignment is handed in per group and it is assumed all students in the group worked together on the assignment. And finally using code from other sources should be permitted as long as it is properly documented and more or less follow the same guidelines as for citations in research papers.
As for punishment, mandatory punishments are usually unfair, so it should be up to the discretion of each professor to furnish their own punishments. Also in all cases, punishments may be appealed by the student to some higher authority, and this would hopefully prevent unreasonable punishment by an overly zealous professor.
This policy would represent a very good policy on cheating as in regards to Computer Science classes, as well as be more representative of how things work in the real world in a business environment. This policy would be fair to the students and to the professors, and it is the opinion of this author that this is what the policy should be.