Argthtjtr

Leave the solution visible. Comment on it to everyone (so it is fair). Still require everyone to turn in a solution, but cannot be verbatim copy (but they can copy the algorithm/ideas/etc).

Then, announce and include that same tool/problem solving technique in the final exam. Those who work the hardest on understanding (not just copying) will be rewarded for their effort. Those who do not, will not do as well on the final.

Naturally the final has less time to do the work, but they have already seen an explicit way to work out that type of problem. If it is too big, you could provide some pieces, and they have to add the remaining functions.

The net effect of leaking the solution will just that everyone studies it to learn the tool for their exam.

Instead of a programming task, make them explain in a short paper how your solution works, what advantages and disadvantages there are, what compromises you made and so on.

I would just give them all the 10% saying that you made the solution available by accident - they will laugh and forget in 10 minutes. And, yes, been there, done that... You are not alone.

Just rely on the other 90% to give you the grading curve - nothing wrong with those I hope.

Based on one comment below, Just for clarity for some, I am not suggesting forcing the results to some arbitrary grading curve - just that the results will have a « curve » some in the highest band, others in other bands.

You might be able to measure the damage by just asking the students. Most students are honest if you're transparent with them (though some campus cultures might be different than others). Consider asking each student to attach a signed statement to their assignment saying that they cited any resources, including solution sets, that they referenced. You can explicitly mention why you're asking -- tell the students that you will not penalize anyone who saw the solutions, but you do consider it cheating if they lie about it.

If it turns out that everyone saw the solutions, or if you don't feel that the above approach would work in your situation (e.g., very large class, too many unscrupulous students), then I agree with the other answers -- don't grade for "quality." Instead, just grade for effort -- all working solutions get 10/10, regardless of whether they just barely met the requirements from the assignment or whether they are as good as your solution. That way no one who made a good effort would get a lower score than someone who used the solutions.

You could make the leaked solution available to everyone. However if you only do this, it will be somewhat inequal to students who have already put a lot of work in on the problem, compared to students who have not done much/any work on the assignment yet. That is somewhat balanced by the intrinsic unmeasurable natural usefulness of having worked on assignments, however.

To iron out that inequality, you could also modify the assignment slightly so that it now involves a slight (not major, or else you would be unfairly increasing the expected work load of the class) twist, that will require them to both implement the leaked solution, and then solve some additional problem on top of it that requires understanding the leaked solution and expanding slightly upon it. The extra work should be designed to be more than balanced by the reduced work resulting from having the original solution provided. (Weight the assignment a bit less since most of the assignment solution was provided.)

The advantage of adding a twist designed that way, is that the students still need to do the work and understand the original assignment, and get the deeper experience of building upon it (which is of course a good sort of experience for programming problems).

Ask whoever is responsible for teaching in your department for guidance. It is likely that your university has a policy in place for these sorts of events, and there's no way for strangers on the internet to know what those are.

I would take the answers away and give everyone the 10%, but sneak a question or two from the assignment into the final (if you have a final) so that the people who put the effort in and learned it properly would still get rewarded

One option would be to change the objective of the assignment. Instead of implementing a solution from scratch, improve the one that has been given.

Of course you may have to define what kind of improvements are going to get good grades (just changing the color scheme of the game probably isn't going to be worth much, unless the new scheme gives better user feedback of the game status, or whatever), and may sure the new task is consistent with the learning objectives of the original assignment. This idea would probably be more useful at an advanced level than for complete beginners.

Not ideal, but you could give an alternative criterion: explain the working example source to satisfaction (works better if you don't have to change the assignment for everyone, but can rather ascertain who discovered the source; although it will surely leak to others if some have already discovered it), so that it is equivalent to having come up with the solution themselves. As I said, not ideal, but you seem to be in a pickle, so I thought I'd suggest it anyway.

one idea:

Announce the error. Post the source code. Extend the deadline.

The assignment is now to annotate your code full, detailed explanation of how it works and why. Provide office hours for students to bring in what they have completed, and try to help them understand your implementation in terms of (what there is of) theirs.

This way, students who have put in a lot of work up to this point can still benefit indirectly. But still, probably err on the side of forgiveness with the grading.

Firstly I'd make all the students aware of your error. The students will do one of two things.

1. They'll copy the solution verbatim which means they at least looked at your provided link, either before (good) or after (not so good, but at least they looked) you published your mistake.

Or

2. They'll either write it themselves entirely without your source code, or they'll rewrite your source code enough that it's not easily recognisable as your source code.

Now, you could penalise the first group if they don't give recognition that it's copied from the source you (accidently) provided, but depending on the wording of the assignment (if it said find a way to do X) then they may of technically done nothing 'wrong' by copying your source anyway. Much of the open source's world's code is simply copied from elsewhere, sometimes sadly without reference to where it's copied from.

The second group have at least put some effort into either writing the original code and then referring to your solution, or re-writing your code enough that it no longer looks like your code, hopefully learning something in the process.

What maybe interesting, is if you do this disclosure in a sensible fashion (i.e. only in the lecture, go to the website and show students 'Look, if you click here, you can see my solution'.) Only students paying attention, coming to the lecture will benefit directly from you disclosing your mistake. I may of had lecturers do things like this, such as displaying via a overhead projector (rather than the shared lecture slides) certain questions which may of been very like those questions you'd find in the final exams.

Plagiarism is always something you should be worrying about. Especially for an undergraduate class like this where there are plenty of solutions online for building a tictactoe game, or even building it in processing. If people wanted to copy, they would likely have found someone else's solution online due to yours being hidden.

If you are worried that someone may copy of it, the simplest way to address the problem is to tell the class what happened and to remind them that copying your solution is plagiarism.