T-Th 9:05
T-Th 11:15
in Olin 155

CS 1110: Introduction to Computing Using Python

Spring 2014

Academic Integrity

Update for A5, May 5 2014

We have said this semester that in CS1110 plagiarism is defined as using another's work without citing the source. We need to further clarify our policy around collaboration, though, to make it clear what we expect from you.

In order to learn the material, we expect you to work in groups of one to two and complete the assignment by your own efforts. It's fine to get advice from other people, but you should develop your own code. We do not want you to get "help" by copying another student's solution, and we do not want you to do the assignment in a large team and then hand in several copies of the resulting code. We give you grades as a recognition you have completed the assignment in the way we asked. This intent has been discussed already in our pinned Piazza post about the group-size rationale.

To maintain integrity, when others have contributed to your work we expect you to clearly cite their contribution. A blanket statement that "we got help from Alice" does not mean the same thing as "Alice wrote this code" or "we wrote this code together." Think of the analogy to a citation in a paper in a literature class -- when you paraphrase another's argument you always make it clear that that particular idea belongs to the source, and when you quote verbatim you always make it unambiguously clear using quotation marks.

This leads to two concrete changes to how we are handling collaboration for A5.


On A5, assignment submissions that are, in the course staff's opinion, too similar to have been developed without different groups sharing the same code (in whatever format) cannot receive full credit. In the literature paper analogy, if you write a paper that relies heavily on paraphrasing others' arguments and whose content is primarily the inclusion of many long direct quotes, you will not get a good grade on the paper.

However, although we may reduce grades for overly similar programs, there is no *academic integrity violation* in such cases if the submitted code contains acknowledgment of the sources of help.


On A5, if you received help from other sources, be specific about which functions/concepts you were helped with and what form the help took. Do not just mention only the source name in a header comment. In the literature paper analogy, mentioning a reference in your bibliography does not give you free rein to include ideas and text from that source into your paper without further attribution; it has to be clear to the reader what is original and what is not.

To be specific, let us say "Bob helped with this function" means Bob gave some advice; "we wrote this function with Bob" means we should expect the code to be the same as Bob's and we should expect to see a corresponding citation in Bob's program, and "Bob wrote this function" means Bob did it first and then you transcribed the code into your program.

In practice, this all means that when we find substantially identical code in multiple submissions, we will not give full credit to all parties, and we will expect the citations to clearly tell us what we need to know in order to understand who deserves the credit. Citations that understate the relationship between the programs can be academic integrity violations.

Profs. Marschner and Lee

We ask you not to cheat, in any way, shape, or form. In return, we will try our best to be fair about the amount of work we are giving you, in the grading of that work, and in giving you a course grade. You can always talk to us if you have any gripe or criticism about the course, and we will attempt to respond to it immediately.

Some forms of cheating are pretty straight-forward. Others, less so. Every year, we find several academic integrity violations. In many of these cases, the students were not necessarily intending to cheat. In particular, while they understood how plagiarism applies to writing paper, they did not understand the concept of plagiarism in computer science. If you are interested in a global perspective on this issue, a web search on that phrase will reveal that these same questions arise again and again at universities everywhere.

Cornell Code of Academic Integrity

Cornell University has a Code of Academic Integrity, which explains the general expectations that apply to all courses at Cornell. The following website explains the academic integrity procedures from the standpoint of the student, the instructor, and the members of an Academic Integrity Hearing Board. Spend some time right now, and read it:


Violations of the Cornell University Code of Academic Integrity occurring in Computer Science courses are taken seriously. While there are various ways the Code might be violated in CS 1110, plagiarism is far and away the most common transgression: fraudulently representing the work of another person as one’s own work. Therefore this page discusses how to avoid plagiarism, but of course this in no way implies the rest of the Code doesn’t apply to CS 1110.

Avoiding Plagiarism in Computer Science

One of the key things to understand about programming, and computer science in general, is that it is a writing-heavy discipline. When you create a computer program, you are writing a document, just like you write documents in an English class (or any class that involves a lot of essays). Therefore, many of the same rules that apply to writing essays also apply to computer programs, particularly regarding plagiarism.

Every time you hand in a program in this course, you are representing it as the work of the stated authors (i.e., the members of the CMS group who submitted it) subject to any exceptions that are clearly stated in the submission itself. To avoid committing plagiarism, simply be sure always to accurately credit your sources. To do otherwise is to commit fraud by claiming credit for the ideas and efforts of others.

It’s that simple: if you have accurately acknowledged your sources, you are not committing plagiarism. You might not be doing what we asked you to do, if we asked you to work in separate groups, but you are being honest and are not in violation of academic integrity.

Practical implications

At the top of your assignment, you must list the names of the authors (the students who are submitting the work for course credit) and of every person or other source that contributed to the submission. (For routine non-research coursework, it is ordinarily unnecessary to acknowledge the assignment materials, which it’s understood you are using as a source.) To avoid complicated descriptions in the header, it may help to include more specific notes interspersed in the code to indicate exactly which pieces came from somewhere else.

So, if you talked to someone not in your CMS group and got an idea from them that became part of your solution, write this at the top of your submission. If a friend gave you some debugging help and suggested a fix, write this at the top of your submission. If a consultant suggested a useful test case that you incorporated in your code, write this at the top of your submission. If you found a key solution to some sticky problem in a post on stackoverflow.com and incorporated that idea into your program, write this at the top of your submission. And so on—you get the idea. When you hand in an assignment without remarking on others’ contributions, you are claiming credit for everything in it as your own creation. To turn in code that someone else invented and claim it as your own is fraudulent and punishable under the Code of Academic Integrity.

Yes, keeping track of who is due credit for ideas is work. But we want you to get in the habit of thinking seriously about these issues every time you write your name on your work—we do, and so does every reputable creative professional in any field. Learning to do this is part of what we want you to get from studying at Cornell.

To reduce the need to worry about plagiarism, follow this rule of thumb:

Never look at any other group’s assignment code, or have their code in your posession, in any portion or form whatsoever. Also never share your assignment code with students not in your group.

If you ever do find yourself seeing someone else’s code, then you must be scrupulous about watching for influences on your own code that need to be cited. That you forgot to acknowledge others, or that you never intended fraud, does not prevent you from committing plagiarism.

If you find yourself in a situation where you’re not sure what the right thing to do is, contact both profs and the head TA all in one email, explaining the situation—ideally before submitting the work. It is always better to ask when you are uncertain, and we are here to help you figure out what to do.

Course Material Authors: D. Gries, L. Lee, S. Marschner, & W. White (over the years)