How to minimize cheating with open source assignments?

Question

For my computer science programming-based course, I'd like to:

1) host my course and assignments (without solutions) open and free to all (e.g., as public GitHub repos)

but this seems at odds with also wanting to

2) not have to deal with rampant cheating.

Any open source assignments seem to suffer from the problem that a random stranger could do the assignment in her spare time and then post the solution online. So in theory, publicly hosting the assignments has created an avenue for my students to find a free solution.

Hosting my assignments on GitHub lubricates this process because the programming community knows how to click "fork" and any forks are listed right there for future students to browse.

What are recommendations or best practices to find the right balance?

The extremes have clear tradeoffs:

A) go full public. this is easy for me to implement using GitHub, but even students in our classes will have easy access to other students in the same section. I can run/threaten to run MOSS, but students may still try to beat it and that will create a hassle.

versus

B) go full private. I lose all the niceties of the GitHub interfaces, lose my open source freely available and advertised assignments to the larger community and world.

Answer 1

As somebody who has, for years, hosted assignments publicly I feel that you are vastly overestimating the threat case here. If all you do is make your assignment and material public on GitHub, it is extremely unlikely that somebody will just browse by, do it out of fun, and then make the solution available to your students.

I often analyse GitHub data as part of my research, and the number of repositories out there is downright staggering, and by far most of them get no traction at all. In order to make a repository visible, quite a bit of active marketing is necessary. If you don't go out of your way to advertise your assignment, and if your assignment is not somehow extremely intriguing so that a random developer would really want to work on it, it is very likely to just sit there, all in the public, without getting any kind of attention at all.

Additionally, even if somebody would solve your assignment and make a solution public, so what? You presumably do some sort of plagiarism check on the solutions your students submit anyway (otherwise, how do you ensure that different students or teams did not copy from each other?) - this is just one more existing solution to compare your student's solution to.

In my experience, by far the most "rampant" type of cheating is student teams copying from each other, and this is really unaffected by how you decided to host your assignment.

Answer 2

The answers depends on the purpose of your assignments. If they are "only" meant to be a learning resource (in the sense of "learning by doing") then having the solutions online would only be harmful for those who are cheating. You might still be interested to reduce the chance that this happens, since lazy students might be demotivated to do it on their own by the availability of a solution, but in the end it is their fault.

If the assignments are the basis for grading it is, of course, a little bit more difficult since it might favor cheating students over honest students, but this does not mean that you should not publish assignments. It does, however, usually means that you have to do more work to mitigate the negative effects.

• You can modify your actual assignments slightly (but transparently for the students!). Often it is more difficult to understand and modify the code written by someone else than to rewrite it from scratch. The learning effect is nearly the same (of course depending on the amount of required modifications). Guess how many submissions we get where a certain calculation uses a mean instead of a median as requested ;-)

• You have already mentioned MOSS, but that is usually only a first step. We do individual interviews about all submitted solutions. While this is very laborious it provides a good opportunity to screen cheaters. I do not say that no cheater was ever able to pass our interviews, but it is usually very clear after a short time if a student has written the code by himself. Also (and even more important in my opinion), an interview should not only be a examination but provides a perfect opportunity to discuss open questions and to give individual support. Often 10 minutes interview seem to teach more than several hours of lecture. If your course is small enough (or you have others who assist you), you should think about this.

• As an addition to that, especially in the first semester, our interviews also contain small on-the-spot assignments from time to time. Even if they are only something trivial like adding all numbers from 1 to 100 in a for loop with C, it identifies a fair amount of students without basic learning success and seems to motivate them to work harder in the future.

• Usually, our assignments only cover a small percentage of the final grade and the major share is covered by an exam (including tasks with and without the need to write code). This might or might not be applicable in your situation (it is actually a requirement at our university), but it mitigates the influence of cheating during the assignments. As one would expect, the correlation between the points achieved for the assignments and those for the exam is very high, even though there are outliers.

• And as others have already mentioned, you have to apply such techniques anyway since cheating is possible in so many other ways, including the help by other students and solutions from students who have taken the course earlier... Even though our assignments are not available at GitHub, there are for example students posting their solutions at GitHub.

In a nutshell, security by obscurity rarely helps and you should rather ask yourself how to make the grading itself as fair as possible.

Answer 3

Your conflict doesn't seem resolvable - at the extremes. On the one hand you want "everyone" to be able to use your posts without restriction. On the other hand you want "bad players" not to use it in ways they determine.

You will need to choose one over the other in this scenario.

For a certain value of money you could host your repository behind a firewall, of course. But you still won't control students having their work done for them on contract. But that assumes your students really do engage in "rampant cheating". I wonder why you believe that. I hope most students are most interested in actual learning if the system isn't so unbalanced that they feel forced to take shortcuts.

You can also organize the course so that you interact with the students frequently enough that bad behavior becomes less useful to them and more visible to you.