Cheating in Computer Science
ubiquity.acm.org
ubiquity.acm.org
To actually be a good programmer one should learn how to write code by themselves, and then start thinking about reusing it. If you start with reusing code, you will never be able to code anything new but will always rely on copying other people. You will also always copy other people's mistakes without noticing.
I finished school long time ago and cheating was rampant, and it really pissed me off. All it did was prevent the truly exceptional from standing out from the crowd. Also it gave the faculty a really false sense of their effectiveness as teachers.
The author of the orignal article uses the examples of code re-use and efficiency as just that: mere examples of real world considerations that his students should use in class as they would in real life. One lesson has the author providing students with an executable and asking them to reverse-engineer the code: this has nothing to do with re-using code or copying mistakes or cheating. The author creates interesting, useful problems for his students to solve. In this way, the students are self-motivated to learn and grow and problem solve for themselves, rather than simply try to achieve the highest grade by whatever means necessary. The author does not encourage cheating, he encourages engaging students meaningfully.
I, for one, would have loved such a teacher in my CS classes. It might have prevented me from dropping out of the CS program. To add context, I was regularly in the top 5% of my CS classes. I would rush to complete all assignments on my own so that I could spend the rest of my lab time creating my own interesting problems to solve (wherein I would start to truly learn things that would be useful to me even if I was never tested on them directly.) I ended up pursuing (and obtaining) my degree in entrepreneurial management where cheating was also the norm among my classmates, but where I at least felt like I was being taught new things that I would be able to apply in my later life. While cheating was rampant, I never let it piss me off... I simply went on being exceptional and always found myself standing out from the crowd.
CS higher education is faced with deep challenges (not least of which is the continuing argument of how much CS should be software-engineering oriented).
Ignoring those challenges entirely though, we should not conflate plagiarism of programs with code re-use. Code re-use is an important part of the "real world." But not in the practice of programming for learning purposes. Exploratory programming and code hacking, as you point out, is a wonderful learning mechanism.
I'm scared when the original article makes statements like "I no longer teach programming by teaching the features of the language and asking the students for original compositions in the language." And you should be too.
I don't worry so much about cheating, but rather more about the end result in the marketplace. Why do organizations shy away from developing their own tools and software internally? High cost with a low likelihood of success? I think that poor software developers negatively influence the opportunity for software development.
There are times when custom software development has significant advantages over the purchase of software solutions. While it is important to actually consider the benefits and costs of custom vs buy, I always feel a little bewildered explaining that we can create and support custom software in-house. I also cringe at in-house software dev shops that primarily are configuration experts and administrators for purchased solutions.
Of course, that same reluctance to do in-house dev is probably a major opportunity for entrepreneurial hackers.
I disagree. Not sure in what capacity you are speaking of "starting" (ie. third line or third language), but I find this statement to be (in my experience) false on both ends of the spectrum. Maybe I am just arguing an irresponsible use of "always" and "never". :)
Slavish copying, then the inevitable debugging; then modifying others programs; then writing ones own things and referring to others code for syntax hints and such. I never really went as far as copying algorithms. At this early stage I never learnt code reuse in the sense of having libraries and such, that probably held me back quite a bit. But then any instruction at that stage would have helped I think.
You're not helping him/her by upvoting their post, though if you are a cheater, it definitely pays to do so -- you want as many people as possible to be pissed off in the face of "rampant" cheating. Pissed off people do poorly in life, as a general rule.
In fact, given a choice between cheating and being pissed off, most people would be better off cheating.
Didn't your parents ever tell you that life is not fair?
I think (2) is the prudent course of action. The majority of cheating that I am aware of is only possible because professors reuse assignments and homework/exam questions from previous years. Solutions are simply passed down each year. One notable exception is in our theory classes, where the faculty make the effort to produce unique homework and exam questions every semester. I believe cheating in the theory classes is far lower as a result and I am extremely thankful that the faculty put forth this effort.
I am cognizant of the work required to generate unique assignments each semester. However, as demonstrated by how departments typically handle quals, it is doable if the workload is distributed. It is my sincere hope that this becomes standard practice. It is the easiest and most fair way to handle the cheating problem. The reason why such a system usually doesn't get implemented in practice is because it requires the entire department to commit to undergraduate education, which is quite difficult to achieve at research universities.^
Some other minor additions to the above system that have a good payoff/cost ratio: (1) static analyzers to detect duplicate code submission and (2) higher weights on exams to punish those who share complete answers on homework assignments.
^Don't take this as a condemnation of undergraduate education in the CS department at UIUC. There are incredible teachers here you'll get an excellent education if you make a little effort to avoid professors whose priorities are elsewhere.
My viewpoint is: If I'm expected to spend my time studying hard for the class, the professor better spend theirs making the class worth studying for. Which includes making the exam relevant to what we covered, rather than what was covered three years ago when the exam was made up.
For this, she gets paid less than 50K per year. If you could halve her workload, she could create better lectures and better assignments and grade with more detailed feedback. But then the university would have to hire two of her to teach the same number of students.
I worked as an undergraduate teaching assistant for intro programming classes at my school, and the amount of debugging (as that's what it is) that goes into designing a good assignment is extraordinary. We had a small collection of world-class teaching professors, and each time a new assignment was introduced, there were always problems. Some starter code didn't work for students A-E. Or a requirement was so ambiguous that solutions varied in a material way.
Like everything else, writing a really excellent assignment is an iterative process. After two or three offerings, you finally have something your users (ie, students) really value: an assignment that teaches well.
And to be honest, the presence of cheating on programming assignments never made any sense to me. It's so simple to detect plagiarism: you have the source right there (and a database of all previous submissions). I really do think that CS stands out among the classes for plagiarism because of how much easier it is to spot rather than an unusual incident rate.
New assignments should be just that, another iteration on the original, excellent assignment. I had a few assignments in undergrad for which even solutions to previous versions were essentially useless unless you understood the underlying principles. The professor made this quite clear from the beginning. Minor changes in input/intermediate/output structures and changing constraints on the expected solutions easily confound the copy-pasters. I think this method even enhanced the learning experience for me by highlighting early on how a subtle difference in an algorithm can make all the difference in the world.
Take classes from people on these lists: http://cte.illinois.edu/teacheval/ices/exc_teach.html. Make sure you go back at least a few years because there are several good teachers who don't teach every semester or were on sabbatical. Prof Bailey comes to mind as someone who was on sabbatical.
When you register for a class go to every single office hour and figure out which TAs know their stuff. Only go to those office hours.
Figure out how much the Professor actually loves the textbook. If he really likes it, problems on homeworks and exams will be of the same theme as the textbook. In classes like that you benefit immensely from taking notes out of the book. Note most textbooks are on reserve at Grainger, no need to buy if you dont want to.
If you haven't taken 241 already, just get through it. The department is still figuring out how to teach that class.... it's not the teachers fault. It just doesn't quite fit right and probably should be two classes.
Use 242 as an opportunity to meet good programmers and continue to work with them afterwords. The actually increase in programming ability from the course itself is questionable. Although again, not the teacher's fault. It's a really hard thing to do.
Get involved in undergraduate research. A great starting point is Lawrence's CS498la (undergraduate research lab). Professors are a lot more tolerant and welcoming than you'd think (but be ready to work hard). Note that research doesn't have to be crazy hardcore theoretical stuff. It can be both cool and relevant (studying some sort of HCI problem on mobile devices?).
Figure out who the competent Math professors are for those classes that are required. I didn't do my research here and got bitten by it. My impression is that there aren't very many good sections for Math.
Take a graduate level course in the subject you are interested in. One of the unique things about top tier programs is that you pretty much can take a course in whatever you want. So for example if dbases are your thing, taking 511 after 411 is the way to go. People who have to scale Rails applications to massive sizes need to know data bases very well... you might as well take the opportunity now to get ahead of the game.
Oh and don't leave freshman physics until your last semester. That was a major fail :P
I don't really have any big secrets, but a lot of people manage to miss most of the above. Apologies if you already know it all. :P
So the way I see it, a teacher does have two options: (1) try to force students to learn by trying to make "learning" the only way to earn a better grade, or (2) try to encourage students to learn by trying to make "learning" feel like the rewarding experience it should be. Note that neither of these approaches involves catching or punishing students, nor does it involve forcing students to learn in order to achieve a better grade. If in the end you're a student who finds yourself with the same grade as someone who cheated their way through the class, so long as you got what you paid for (an education), why should you care?
A couple of things unacknowledged in your argument. First, there's the practical implications of cheaters on GPA. Cheaters get higher grades than what is possible without cheating, making the curve in a class lower than what it would be in a completely honest classroom. I'll be the first to champion someone who doesn't care about GPA, but there are concrete affects that a lower GPA has on students. Even though you got a good education, it's still something to think about. Second, there's the fact that the solution you propose is not possible in the current system. The incentive structure is all wrong (read: nonexistent) for undergraduate teaching in universities. Further, the majority of professors don't even have the requisite skills to be good teachers. Even if we did get the incentives right, the talent simply isn't there. To be honest I doubt there are enough people on board with improving undergraduate education to get it done.
Because they're competing for the same jobs as me!!
I suppose this has to do with a flawed mindset about what they're paying for: they feel like they are paying for their grades and you're saying that they should be paying for their education instead. Unfortunately, like qntm said, the cheaters are competition for jobs and on paper, they look just as good as the honest students, despite paying far less for their grades. Of course, I guess that this is what rigorous interviews are for.
It is my job to satisfy the student, the paying customer, not the other way around. Perhaps cheating is a strategy that students bring to an artificial problem that I have created. Perhaps it is a symptom of my failure to teach.'
"I suggest that we have gotten the cart before the horse. We are less concerned with whether students learn the right thing than whether they learn in the way that we rely upon to measure how well they learn when compared to their peers. We do this without even having considered whether the measurement is even useful, much less necessary or even counter-productive. We do it without considering whether encouraging sin is a good way to teach morals. We do it for no better reason than tradition, habit, and inertia."
Christian Queinnec set up what is probably the world's coolest interactive tutoring/assignment/testing environment for the introductory programming courses at Université Pierre et Marie Curie that has tools to detect cheating. He gave a very interesting talk about it at ILC 2007:
http://www.international-lisp-conference.org/2007/speakers#q...
Dartmouth College addressed this in a number of ways:
1. Collaboration was routinely encouraged, so long as all work was properly credited. You weren't expected to be able to ace some of the theory classes by yourself, for example.
2. Many courses included large team projects.
3. Each course began with a clear, unambiguous description of what behavior constituted cheating, and which types of collaboration were allowed.
4. When caught, cheating was treated as a major offense: a 9-month suspension and a permanent annotation on your transcript for a first offense, and an irrevocable expulsion for a second offense. I was friends with a CS TA who _always_ took the time to ram through these penalties.
Even with those precautions, we had a cheating scandal in a non-major course. Unfortunately, it was hard to identify the cheaters, and the usual penalties couldn't be enforced.
Still, I do admire Dartmouth both for encouraging collaboration and for ruthlessly ending the academic careers of students who lacked personal integrity.
> it was hard to identify the cheaters, and the usual penalties couldn't be enforced.
This might be a common problem. My university had similar draconian penalties for cheating, but the seriousness of the penalty requires an appropriately-serious proof of culpability, and it's surprisingly hard to get one.
One thing I want to add: The really bad thing about these "reusing" students is, that they have no skill to see which code to reuse. Most code you find with google is just duct taped itself. And trying to solve any problem with ducttaping an already ducttaped monster is ridiculous. What I saw in my undergrad classes from my classmates was so bad to read and use, that I decided for myself to write a lot by myself and don't rely on others. That got so far, that in one project I wrote my own linked list instead of using the Java's basic one. Of course that is a little too far, but makes for a small, funny story. I'm still not a really big fan of reusage, because design and engineering is something that is treated to lighthearted by many many coders out there. Until you are finished analysing all the options, you often have constructed your own solution and learned more about the innards on the way.
There are no exams, and there is no cheating, because there is simply no point to either. Though there is homework.
The CS department did it a little differently. It is fairly easy to tell if you copy a programming assignment(loop structure is identical, code is identical, variable names, etc.), so what they would do is divide the total grade of the assignment and split it between all the people who copied, so if 4 people copied, there was no way to determine who copied who, so the maximum mark you could get was 25%. This happens once and no one wants to cheat simply because by letting someone else copy of you, you are taking a chance at screwing yourself.
Collaboration was still encouraged, but wholesale copying obviously punished.
Let's say that two students need help from one another on parts of an assignment. If they cheat their chance of getting caught is 50%. If they don't get caught their grade is (it doesn't matter for purposes of discussion) a 100 each. If they don't cheat they get a 0 each because they just can't complete the assignment.
So the expected payoff from NOT cheating is 0.
And the expected payoff from cheating is 0.5 * 100 + 0.5 * (100 / 2) = 75.
Who wouldn't cheat? Even if the probability of getting caught was 100%, you'd expect to get a 50. Holy cow! What university IS THIS?
The only way to discourage cheating is to make the net utility of cheating negative, and so negative that every student realizes it.
If you would get partial marks for completing what you can, where is the upside in cheating in this scenario where the maximum you get is 50%, which you may get from your partially completed assignment.
Cheating is always taken on a case by case basis. There is always a chance that if you get caught doing this(or doing this more then once), you could easily get a zero in the course, expelled or one of the other university's regulations.
I think the entire point for this initial leniency I think is that on an assignment where you are encouraged to collaborate, some students can cross the line from collaboration to copying.
There are two factors to utility: probability of getting caught, and the outcome of getting caught.
The problem is that the probability of getting caught, while substantial, is actually much lower than 50% in my experience. As a result the payoff differential has to be that much worse.
Let's revisit my example. In order for cheating not to be the smart thing to do, the expected grade for not cheating would have to be over 75!
And that's with a ridiculous 50% chance of being caught. Now if we lowered the probability of being caught to, say, 25%, the expected grade for not cheating would have to exceed 0.75 * 100 + 0.25 * (100/2) = 87.5.
It's a terrible, terrible policy.
What we need to do is to remove grades as something which you can use to validate yourself to others, and use it strictly as an internal measure of how well you understand the material and what you need to focus on.
More power to the OP if he's able to write entire, semester-long curricula based on these sorts of assignments.
Really? That's news to me, and I'm in the late stages of getting some credentials granted by a British University.