Slashdot Mirror
Cheating Detector from Georgia Tech
brightboy writes "According to this Yahoo! News article, Georgia Tech has developed and implemented a "cheating detector"; that is, a program which compares students' coding assignments to each other and detects exact matches. This was used for two undergraduate classes: "Introduction to Computing" (required for any student in the College of Computing) and "Object Oriented Programming" (required for Computer Science majors)." Cuz
remember programmers: in the real world you are fired if you consult
with a co-worker ;)
Your Hello World program is exactly the same as Johnny's. You fail. You're kicked out of school. Good bye.
You're fired for copying someone else's work and passing it off as your own, particularly if it's a competing product.
If your employer has any integrity at all, that is.
How the hell are all those lonely CS majors supposed to get in good with the Education majors now?
It hurts when I pee.
Yes, but one of the goals of a CS department should be to produce programmers who are capable of doing work themselves. Would you want to work with (or supervise) a slacker who couldn't code his way out of a paper bag, but who graduated anyway because he cut-and-pasted the work of his (harder-working) classmates?
This is new? They used something like this when I was at the University of Maryland a few years ago. And it did more than just check for exact matches, it compared parse trees and so on to check for similar program structure (any matches were, of course, double-checked by a human before ringing the cheating bell). It caught quite a few people I knew.
Remember, folks -- you may not get fired for consulting with a fellow programmer, but if you never learn how to do anything but copy & paste other people's code, you've lost out on a LOT of problem solving skills.
:).
There's a difference, a huge difference, between collaborating and cheating.
In the real world, you _would_ get fired for taking credit for someone else's work, trying to pass it off on your own. Heck, you'd probably also violate a bunch of licenses, too
Not representing or approved by my company or anybody else.
m00.
The article talks about a program that has been around since 1993 and merely detects exact duplicates of code...
Not really a big deal... Our school uses some University's program and database which not only detects fragment duplication, but also permutations of the code (such as changing variables, white space, etc.). Not sure which University though....
Don't get me wrong, I understand that cheating on a test is wrong. I'm concerned that this sort of thing may help promote the "wasn't built here" syndrome (I believe it's called something else.)
I'm just hoping that this is balanced with a few lessons on reusing and sharing code, for practical purposes.
It better check for exact duplicates only, down to the variable names. Many undergraduate CS assignments are programs so basic that there are really only a few ways to implement them. It would suck to be a student who from scratch used the same algorithm as another student, and have them both flagged as cheaters.
A few years ago, when I was a 2nd or 3rd year at Virginia Tech, some professor implemented a cheating detector into the automated grader for a class called Intro to C++.
Prior to that year, VT had an average of 75 cheating violations for the WHOLE university (25000+ students). For that one class, on one assignment, 150 students were found cheating by the cheating detector... out of the 500 or so students in the class.
Funny as hell
Nosce te Ipsum
I always found that it wasn't easy to cheat. If I copy and pasted somebodies code, I had to go back through and change it all around so that I couldn't be caught cheating. This often proved to be more difficult than actually doing the project myself would have been.
I use code I find on the internet all the time, first thing I do when I start a new routine as a matter of fact. I search for preexisting code and use/modify that accordingly. Of course only freely available code but there are tons of sources for that. How would this program detect that? I would trust some code I got from the net over something another person in class wrote, but then again I know enough to be able to see if the code is good or not and to modify it if I need to.
Mod me down for this, but consulting with a co-worker at a job and obtaining code from a fellow student is NOT the same thing. The purpose of going to school is to learn and therefore they want your work, not your friend's. At a job, they just want the work to get done, they don't care how you do it.
If it were free and open, we could write white papers on why it sucks and/or improve it. That wouldn't be so bad.
That's sarcasm for those of you unfamiliar with the stuff.
7 November 2006: The day Americans realized corruption and incompetence weren't addressing 11 September 2001
There are many programs out there for exactly the same purpose. For example, moss at berkeley lets you do this over the net.
Well, actually, if you take work from another co-worker and pass it off as your own, you'll be fired and prosecuted.
Don't Plagiarise - it's the law. (And judging from the snide comment, probably the reason that CmdrTaco never finished college.)
In the real world, you are fired if you steal code from someone else without their permission, pretend it's your own, and incorporate it into the app you're writing for your company. In the real world, people give credit where credit is due.
A lot of the stories I hear about students plagiarizing each other's code is done without the other student's permission. Many systems have files readable by other students by default, and students don't bother to read-protect their files. Students will take printouts out of the trash. And of course, it's always convenient for students to claim they didn't know the other person copied their work.
It's better for students if professors have an accurate way of detecting cheating. The worst thing is if the method is inaccurate, and innocent students get accused. This method sounds accurate.
Find free books.
The software that U of T uses was developed somewhere else, I thought it was MIT, but I could be wrong.
They didn't actually tell us that they were using this stuff, I found out after I graduated from reading it in the newspaper. So it's probably in widespread use, it's just not something CS departments brag about (I guess catching cheaters is fun).
Moderators should have to take a reading comprehension test.
So how exactly does consulting with a fellow student (or co-worker) result in both parties having identical code? I have to say that this is the most ignorant comment I've seen attached to a slashdot story ever.
At my University they have the same code policy but they encourage you to work with others! Under no circumstances are you to copy their code line by line but you can certainly ask for their help or use a module or two. The only condition to all of this is that you credit them on the cover sheet of your assignment.
Sorry for the flame but I saw that comment and it made me quite irate.
--
Todd's Law: All things being equal, you lose!
When I was a TA, if I saw two assignments that looked suspicious, I'd hold them up side by side and cross my eyes to get the stereogram effect. If it was a bad cheating job, there would be an almost perfect match and my eyes would be able to focus on them, with the differences jumping out at me.
Of course, with freshman assignments, they tend to be pretty damn similar even without cheating (write C code to implement bubble-sort using the pseudo-code in the book as a guide). And usually, the students that were cheating would fail the tests, so there was little need to do anything special.
Why someone would pay tens of thousands of dollars to learn nothing and end up with a job that pays well but that they'll get fired from within a few weeks...
Okay, like others have mentioned, think of diff:
* determines exact matches
umm, sure, diff does that
* written in 1993
I checked man on my machine and got this date: "22sep1993"
Heh.
-ted
to stop cheating, will GT bust them for plagiarism? ;-)
Read the EFF's Fair Use FAQ
I wonder if they will start using this on the resumes of their coaches from now on?
but there is a lot of cheating in undergraduate courses.
I was one of the better students in my comp-sci classes and so other students looked for me for help etc. I would routinely point them to my own finished assignments as example of how to do something or provide listings in which we would discuess the assignment and how to do things.
This worked well until I got called before the teacher in regards to two students having taken my listings and typed them in ( with practically no modification whatso-ever ). I explained the truth - that I provided it for purposes of instruction not stealing and managed to escape. The other students were forced to retake the course.
After this incident I kept my eyes wider open and noticed more students "copying"...
It happens. Whether this program is really needed or not I think is more an indication of how well the teacher stresses the students on final exams and such.
There's a gorilla from Manilla whose a fella that stinks of vanilla and has salmonella.
Heck, even in the open source world, I can't copy someone else's program verbatim and claim I wrote it.
Even if two people work together on a project, as long as they write their code separately, the code will be significantly different enough that it shouldn't be recognized as cheating.
Probably what this will catch is the last minute "Quick, let me copy your program" right before it's due. And this DOES happen, and I find nothing "right" about that at all. That IS cheating, plain and simple, and should be stopped. In a class of 30 students, the instructor (or TA's) will probably be able to notice similarities. In larger classes, its easy for these things to slip by, especially if the grading process is split amongst multiple TA's.
-Restil
Play with my webcams and lights here
CmdrTaco says: ;)
Cuz remember programmers: in the real world you are fired if you consult with a co-worker
As someone who TAed classes at GA Tech, I take a lot of offense at this comment. There is a difference between working as a team on project based classes (of which GA Tech has a good number off including classes where we got to hack the Linux kernel and another where we got to deliver a product to a customer) once you've shown you understand the basics of programming and wholesale copying of other people's work in entry level classes where you are supposed to be learning to program on your own.
Beginning programmers need to learn how to program, find information from MAN pages & API docs, and come up with solutions on their own before being introduced into team based environments. If not they never learn how to be self sufficient or even if they are cut out for programming at all.
It is true that in the real world no man is an island but on the flip side, how many people have worked with co-workers who completely clueless about how to perform their jobs but held degrees or certifications that implied they shoould be knowledgeable about programming? These are the kind of people who hid behind the work of others in team based projects and submitted others work on individual projects.
My high school CS teacher once found a few identical programs. He printed out the source code to some transparancies, then lined them up, one on top of the other, on the overhead projector. The only blurred spot was the comment with the students' names.
Not a typewriter
When I was taking programming classes in the mid '80s at UCLA, they had a rather clever cheating detection program. It didn't look at the source (Pascal or C) code, but rather at the produced assembler code to see if students were copying others' algorithms.
So you might obfuscate your copied code by moving it around, changing variable names, etc. but it would still catch you.
You failed (ln: File Exists). That would be:
/usr/bin/diff cheatingdetector
ln -s
"don't fall into the fallacy of believing that Perl can solve social problems. Maybe Perl 6 can, but that's a ways off"
Some more info on the cheating detector from a Georgia Tech Alum of the CS program.
1. The cheating detector is not new. It's been in place for years. When I took intro programming in 1994 they mentioned it, and it wasn't new then.
2. Everybody at Tech knows about it. They tell you about this script the first day of class. Nobody here should be suprised they were caught. The fact that they were caught only shows them to be some of the stupidest people at Tech.
3. It catches people every term. Usual numbers are below 5% range. The fact that it caught someone isn't news. The fact that it caught 10% of a class is news.
4. These classes are cake. There is no reason anyone should need to cheat to pass these classes. They are the most basic concepts of programming.
Summary
Best Slashdot Co
For all of you who posted : "gee, they invented diff again", it's a little more involved than just "diff". I'm sure other schools have similar cheat-detecing programs as well. Also, why Yahoo decided to pick up on this now and pass it off as news is beyond my comprehension. Maybe they had nothing else better to pass off as news. In my entire 4 years at GA Tech, I only heard about this program once and it's not a big deal. "There's nothing here to see people. Please move on with your lives."
Biodiesel : domestic, renewable, clean, and in the fuel tank of my bone stock 2002 New Beetle TDI
Would you be so stupid as to copy it exactly? I mean theres 20 different ways to do the same thing in just about any langauge, how stupid would you have to be to copy someone eleses code without changing variable names and statements to be slightly different.
CS programs at schools are not out to end colaboration with students. They are aiming to produce students who know how to program. In the real world YES, you can just copy the code directly from someone else, but what does that teach you? Nothing. Well how to copy/paste.
I mean, we talked about this today in class, if a guy gets a degree and makes it out of school riding the coattails of others his degree is worthless. Once he is out in the real world, he also drags down everyone else who has the same degree from the same school because employeers will think - Guys from school x don't know jack.
CS departements are not evil, but they are trying to uphold the principles of school. Don't misinterpret actions such as these as some sort of action to "keep people down".
-RonB
It is human nature to take shortcuts in thinking.
No two programmers are working on the exact same bug/feature. You can't expect to just copy someone else's code or get them to do most of the work for you. At best, you can ask for help, but that's not what the article is talking about. It's talking about straight copying of code (with minor changes to fool a cursory examination).
As far as I know, both Purdue and UIUC use MOSS to catch cheaters. Personally I'm all for it. It doesn't stop people from asking/getting deisgn help, but it helps stop people from cut/apsting code frmo one rpgoram to another, and then changing struct and variable names.
Moderation: Put your hand inside the puppet head!
One of my CS profs created a program to do something similar for himself. It would take two programs and compare them and give a similarity score between 0.0 and 1.0. Seeing anything up to 0.6 in intro courses was considered normal, since the assignments were easier, but much above that and things got suspicious fast. Of course, any red flags were hand checked. Seeing as this is the prof that taught the compiler courses, I don't think there were many false positives. :-)
:-) Having a URL to an identical file from an algorithm archive helped too.
It caught a few guys that I know. When confronted they tried to say that they didn't cheat. So the prof does the only sensible thing that a CS prof should do when dealing with cheating intro students: Single out a common line of code in their programs and ask them what it did. Hint: How many of you knew the ternary operator in your first forays into C?
Pax, Ardax
I just graduated from GaTech in December and I was a Teaching Assistant for the Into to Computing class for 2 and a half years at Tech. The students are told on the first day of class that cheating is not allowed and that if you are caught you will be punished. They are told about the program and whether they believe or not is their problem.
The students are told it is ok to discuss the homeworks and project with each other and that it is ok to discuss the concepts. However it is NOT ok to copy each other's code.
The program does not just compare the text of each student's homework which is what some people seem to think it does. The program gets rid of variable names, function names and things like that because a person cheating can simply change those. It compares the style of the code and it is not given common code to look at. The only code checked is the code from problems that generally generate unique solutions.
In the time I spent there I know of over a hundred cheating cases caught by the program. In some of those cases if you had of given me the 2 pieces of code I never would have said the people were cheating but when asked the students confessed. I have never heard of someone being falsely accused. Most of the time when the 2 cheaters are asked separately they admitt to it.
Once again, Tech does not have any problem with people helping each other understand concepts like the way pointers or a vector works or the differences between stacks and queues. What they have a problem with is when each studen does not do his own work on an individual homework.
Eventhough some of the problems may seem not worth it, like writing your own version of strcpy, it is still necessary so that students understand how the library functions work even if they will never be writing library functions in their life.
I wonder how this system compares with a program developed at Berkeley called Moss to serve the same purpose. Moss is free and available as a web service. It is really pretty neat, for those of you advocating the use of 'diff' Moss is quite a bit more complicated than diff. It will match up lines of common code and also compare the choice of token names within the program. Learn more here: http://www.cs.berkeley.edu/~aiken/moss.html
The responses here, at least the ones along the lines of "But collaboration is allowed in the real world" sicken me. I would (and HAVE) fired programmers who couldn't program simple stuff on thier own. The collaboration in industry is not anywhere near the level of syntax and elementry algorithm design.
A University degree is supposed to signify that you demonstrated knowledge in certain areas.
Cheating is not demonstrating knowledge.
Undergraduate level programming assignments do not require even consultation with other students, IMHO. They are too simple. If you can't code an undergraduate programming project without extensive "consulting", then you can't program. Period.
I am sickened by the number of people with CS degrees only because of "teamwork" and "consulting". I would guess, from my experience, 95% of people with CS degrees can't write a sort routine. Widespread use of these kinds of programs might fix some of this. As would harsher grading. In the real world, you don't get partial credit for a program that only dumps core or doesn't meet any of the design objectives. (in my opinion, any program which doesn't properly run a set of tests, provided to the students in the project instructions, should receive an "F" grade)
No wonder the software industry is such a mess. I've seem CS *GRADUATE* students who couldn't use malloc(). Note that I did not say "who use malloc() wrong - no, these students could not even figure out how to call malloc() nor explain what it did. There's something strange happening (I call it cheating) when someone can graduate with a CS degree yet never use dynamic memory allocation knowingly...
First, the standard disclaimers: my comments are my own and should not be taken as necessarily representative of the GA Tech administration.
There's a much better and more accurate article on the topic at the AJC. Take the AP version with a grain of salt.
The fact that GA Tech uses software to detect possible cheating should not come as a surprise to anyone. Such systems have been in use at many schools across the country for many different disciplines besides CS. Nor should anyone be disturbed by the use of such systems: their purpose is to detect possible cheating, which according the AJC article was clearly verboten to the students in the class.
In the real world, a completely different set of rules may exist, but the fact remains that if your boss tells you he wants you to do something on your own, then you'd damn well better do it on your own. When a teacher instructs a student to perform a task on his own, he so instructs not to make life more difficult for the student, but to ensure that the student is capable of independently executing the skills necessary for the completion of the assignment. When that student eventually enters the real world, he has demonstrated the ability to perform the skills to be expected of him in the real world, so when he then has the ability to collaborate with his peers, he can actually contribure to the group's performance. A student who has always relied on others to get by will offer minimal assistance to a group and will typically act as a hinderance.
So sure, in the real world you won't be fired for collaborating with your peers, but you will be if you can't get anything done without collaborating with your peers.
we've had this at RIT for a long time. The teachers coded it. It's really really tricky. Basically they have the attitude of, if you can get by the cheating program, then you know what you're doing and deserve the grade you get.
The GeekNights podcast is going strong. Listen!
The hard part is turning up the "sensitivity," so you get not just exact copies, but also people who have taken parts of a program or made some trivial modifications.
The problem is that it's hard to find info about these sytems for the very good reason that this is one instance where security by obscurity makes sense. If students know how the systems work, they can re-implement them and check to see if they'll be caught.
Greg
Ok, check for exact match: diff source1.c source2.c
great, I just wrote a program to check for exact matches in source code, and it took me three seconds. Maybe I should apply for a patent for my ingenious approach (maybe I'd get it!!)
At my organisation, (in India) we've been developing something like this for quite some time for our internal tests.
While most of the work isn't (and probably won't be) publicly released, we can look at a systematic approach to building a better detector.
indent -i8 -kr
sed -e 's,\([^ ^I]\)[ ^I]\+,\1
sed -e 'g/^[ ^I]\+$/d'
i=i;
You may also want to first strip all #include <> statements (not #include ""), and run the code through the C preprocessor first to take care of #define, and conditional compilation
There's more obviously that I'm not sharing with you. These are the basics that anyone could figure out in a few minutes - not years.
Do not underestimate the value of print statements for debugging.
In the old sense, meaning people who believe that elegance is important and simplicity is a factor of elegance, and give them identical problems and environments to work in. Syntactically their solutions will most likely be very different (one will comment, the other not, one prefers braces indented one way, the other another way, etc.) but for many, many problems, particularly those posed in acedemia, their solutions will often be extremely similar, the algorithms possibly identical. How many ways are there to efficiently write a bubble sort, for example, or a node walker? There are lots of sucky solutions but may be very few elegant 'hackerish' ones, in my experience.
So what happens when the cheating detector spits their names out?
After 20 years of professional programming, I've recently gone back to university to get my BS in Computer Science (yes, there is a wall, Virginia.) The first time this happens to me I'm calling my cousin, the lawyer. At the least I expect to have the rest of my tuition paid for. At best I want to see some lazy prof fired. I refuse to put up with this B.S.
Here's some more info, from the perspective of a former TA (once for one of the classes in question). First, everyone at GaTech is required to take the first CS class, not just CS majors (== people in the CoC). Second, GaTech doesn't restrict collaboration in all classes. The first tier of classes are strictly individual so everyone has to be in front of the computer. In the second tier, CS2130 - Languages and Translation explicitly allows colloboration as long as people turn in their own code. Going further, later classes involve heavy amounts of group work.
With regards to the cheater-detecter program (called 'cheatfinder'), it's significantly more complicated than diff(1). It involves checking the structure of the code (ignoring variable names , indentation, and whatnot). Admittedly, I've never seen the source for it (very few people have), but it's been around since at least 1997. The output of the program is a single number indicating the probability that two people colloborated on an assignment. The threshold is typically set fairly high (0.90+), so false-positives are less likely. 187 students, the number caught this time around, is definitely the highest I've heard of, but it's definitely not the first time we've hit a large number -- just the first time it made the cover of the local newspaper.
Interestingly, many students (including myself before becoming a TA) think (well, thought now) cheatfinder is just something the profs made up to scare students.
It turns out that about half of the people cheating really weren't- they just all happened to independently come up with a seperate working implementation than the Professors originally intended, and hadn't even thought of themselves.
All that ended up coming of this was that the Professors apologized on the class newsgroup- I think they still check the code using the same program.
what about last years's students? or the entire internet? there's a ton of code out there that is freely available.
I also know that I would be pissed and question the credibility of the profressor that uses thison my code. Because that is exactly what the professors is doing, assuming that everyone is cheating and run them through the detector... maybe we should frisk and do drug testing on all the students, and hook them up to polygraphs during tests too just to be sure they dont have weapons, cheating aids, or are taking controlled substances or are cheating on the tests as we know they all are.
Any professor that would use this or even allow it to be used on his students has ZERO respect from me as that is the amount of respect he is showing his students.
Do not look at laser with remaining good eye.
Programs like this either generate horrible false positives, or they're little more than a diff that ignores comments.
We had a professor who used one of these. I know for a fact that at least one person was copying his buddy's Pascal programs, but rejiggering them to use "repeat until" loops instead of "while do" everywhere, and changing variable names, and this was enough to throw off the scent.
First off, diff doesn't work if the kids are smart enough to change their variable names and add spaces here and there.
I was a grader for the C++ and data structures class back when i was in school. And I saw my share of cheating. One instance that stands out is when a bunch of kids had variables called "dude" and "funtime". Problem was, they had enough differences elsewhere in their code, that an automated diff wouldn't have worked. For a while, I was going to write some fancy perl that would look for certain cheating patterns that I was seeing, but then I got lazy.
One deeper way to check for cheating is to pass code through the front end of a compiler and check what comes out. if there are too many simmilarities, they will stand out even if kids change paramater names and the like.
Finaly consider this: Checking for cheaters in a class isn't just doing a diff of two files. For every student in the class, you have to check his code against everyone else's. This is a O(n^2)problem. My class had around 350 people in it
so that's 122500 checks to do. If it is anything more complex than a diff (multiple files, compiler front-end, fancy perl parcing) this can take a mad amount of computing.
Blaze a trail to the New World
Of course it would be completely useless as all of the cheating detection systems I've ever seen could care less about the symbol names, only about stuff like the structures of the data and execution traces...
XML is like violence. If it doesn't solve the problem, use more.
If this program is really necessary, it suggests that very little effort is being spent evaluating students' work. Given that universities have been cutting back on teaching budgets, it's probably due to too many students in a class or inexperienced professors. If the professors took the time to actually look at the code (or in the other case, read students' papers carefully), it is pretty obvious if a student is cheating.
Also, if the professors took the time to create good homework problems, cheating wouldn't help a student even if they didn't get caught. Of course, if you're teaching two classes with 100 students each, you can't really do that.
Perhaps students should do a little math and figure that if they pay $4k per quarter and take four classes, that's $1k per student per class. And if a professor is teaching 200 students, the university is receiving $200k for the classes. The professor is probably making somewhere around $10k for the quarter, call it $20 to include benefits and taxes. Where is the other $180k going? And when budget crunches come up, perhaps budgeting should be done similar to code profiling -- look to the biggest expenses first, and make sure that the cuts don't damage the overall purpose.
Personally, if I was getting the sort of cheap-ass education where this cheater-detection software is considered a cheap alternative to proper education, I'd expect to pay much less in tuition, rather than the constant 10+% tuition increases students have been seeing for the past 20 years or so.
One assignment: modify this open source program to fix an assigned bug.
Another assignment: Modify this (Same) open source program and add a feature that they've been wanting for a while.
It's not like the solutions aren't readily available and well documented, it's just like in the real world: it hasn't been done here yet.
As long as intro courses use textbook problems with textbook solutions, students should be penalized for not doing their own work. The point in these classes is to provide an educational foundation. As soon as the foundations are laid, the students should be given work that isn't straight out of a textbook, and should be allowed to use any legal method of getting a solution. It's not like they'll find an exact solution, so they will have to do some tweaking and patching to get it to work anyway.
This was the philosophy my teaching cohort and I presented to the college Provost and the head of the CS department. They bought into it and gave us the class.
Network Security: It always comes down to a big guy with a gun.
Here at Stanford, where CS classes account for more than half of all cheating incidents, we've been using a system like this for a couple of years. Apparently, rather than comparing source code, it actually compares object code so that it can detect people who change variable names and so on. The theory is that no two people should actually write code which compiles to the exact same object code, no matter how similar their algorithms, unless they really are cheating.
$ man 1 diff
Why bother.
Yes, but that would be insufficient since cheaters often rename identifiers and scramble the code a bit, enough to fool diff, but certainly not enough to fool these systems.
XML is like violence. If it doesn't solve the problem, use more.
(Geez.. how many people just don't bother reading any articles before posting their "original idea"?)
T
---- It puts the lotion on its skin or else it gets the hose again. It does this whenever it's told.
We have had this in the UC Berkeley computer science department for some time now. IIRC it's been quite effective; when it was first unveiled it nailed many, many students for cheating (I think). The verdict amongst students is, if you're good enough to defeat the cheating detector then doing the assignment on your own should be no problem anyways.
I think there is a world market for maybe five personal web logs.
I'm sick of programmers with degrees who can't program. Honestly, 100 level CS classes are supposed to be the acid test; if you don't have the basic problem solving skills to perform simple conditional logic, understand arrays and symbolic links, and output "hello world," you shouldn't be a CS major. And yet I've seen CS students in upper level classes (there was one in my networking group in his senior year) who can't write a program from scratch without a book or template to guide them.
This is a major difference from consultation. Copying hurts the computer world, it hurts other students (who have one less peer to help them through the rough patches with hints and examples) and it unalienably hurts the cheater most of all. I dropped out of my CS department to work for IBM *because* there were so many students sliding by and yet still maintaining higher averages than mine.
Of course, I am guessing that the GT system will probably be fairly stupid at first, and it won't take long for some overworked freshman to write an app to automatically thwart it. But this system will definitely help keep honest people honest.
Hey freaks: now you're ju
...I wrote BASICA (aka GW-BASIC) code for a living (and you can wipe that smirk off your face right now, I got paid damned well for it). Because this was an interpreted language and worked within (God help me) 64k of memory, space was at a premium.
:)
There was this 3rd part product that did a bunch of nice things, but one of the options was "compact". It would remove all whitespace outside of literals, jam as many statements on a line as possible, replace long var names with "A0", "A1", "A2" and so on, if desired it would renumber lines from 0 on in increments of 1, etc etc, all in the name of reducing the memory footprint.
It would excrete the most horrific, obfuscated, unreadable, unmaintainable little turd of code you can possibly imagine.
I hope something similar is available for these students
"Today I am going to give you two examinations, one in trigonometry and one in honesty. I hope you will pass them both, but if you must fail one, let it be trigonometry, for there are many good [people] in this world today who cannot pass an examination in trigonometry, but there are no good [people] in the world who cannot pass an examination in honesty."
- Madison Sarratt (1891-1978), dean, Vanderbilt University.
Cuz remember programmers: in the real world you are fired if you consult with a co-worker
I guess the university wants to guarentee that there will be well educated people that workplace cheaters can consult with.
_______
2B1ASK1
A lot of people have been saying "this is news?" The news is that 187 people were "caught" with this program, not that the program was written. The story appeared in the Atlanta Journal-Constitution today; I presume it went out on the wire services, too.
Frankly, I'm skeptical. I'm sure this program is more sophisticated than diff, which means more likely to get false positives. It was in two introductory programming courses. I'm not sure that there are 187 different ways of writing substantially different programs for that kind of assignment, especially by people who have only seen the style of the teacher and that of the textbooks.
I love this idea. Rather than outlawing good practices, they're doing real education. And if you really cheat with this policy in place, it's very clear-cut.
If only they had used this on their football coach before Notre Dame hired him!
sulli
RTFJ.
One fool actually asked me to translate one of my Java programs into C for him so he could use it in his class! What a yutz.
To make a "cheating detector" work, they'll need to compare student's work against the vast body of public domain, published, and open source code found in the wild. And that just isn't practical. With the current system, they're only going to catch those who cheat off each other, or those who copy from the same source.
All about me
... you aren't even hired if you don't fucking know how to code in the first place and got your degree by copying others' work.
Don't say such stupid shit, Rob.
- A.P.
"Remember when the U.S. had a drug problem, and then we declared a War On Drugs, and now you can't buy drugs anymore?"
Such a project is not that difficult, in fact, we had to develop a program for my senior software engineering class, with a GUI and all. It was based on Halsted's metrics which is based on lines of code, variable names, function calls etc.
The problem with such a method is in introduction CS classes (or even OO classes) there are very few ways to do things. Furthermore if the professor gives information related to it, it's highly likely such information will appear verbatim in the solutions.
My university uses such a program, and often it seems to flag people who didn't cheat. We might hear about how many people get "caught" but it never shows how many people actually DIDN'T cheat (ie the rate of false positives). Of the three people who I know well that were flagged, none of them cheated and all were exonerated. Fortunately, I attend a small enough school that a few well placed connections can correct this, but I feel bad for people at larger institutions.
As a TA for a senior level class, I still frequently come across copied homework and lab assignments. Unfortunately, all I can do is give the people 0's on the assignment (no harm if they never did it in the first place). I'm wondering what the punishment at other institutions is.
My Slashdot account is old enough to drink...
As has been said for various other schools, the RPI CS dept has a script like this... after a pre-compilation stage, it doesn't matter if you changed variable or function names, or moved the functions around in the file... at that stage of the compile, if the searches find very similar code, it will flag it, and a real person will then compare the findings. Nice, efficient, and tougher than changing "int foo;" to "int bar;"
"It's tough to be bilingual when you get hit in the head."
Anyways... I have no particular problem with finding cheats. Learning the social skills and dynamics of group software development is one thing, but outright cheating is quite something else. When I think back to my school days, those who were pathological in their need for 'help' on their assignments were the ones typically over their head and/or in the wrong profession. Weed them out!
CrazyLegs
"Pork!!" said the Fish, and we all laughed.
Knowing slashdot, they'd prolly implement it by comparing how well they compress.
You know they're dying to use this revolutionary compression filter technology in other places!
C-X C-S
background -
I attend an English university of no distinction, and I'm completing a master's degree in CS. It's not a first CS degree, but a conversion for those who did a different subject for their undergrad.
coding -
We've done some x86 assembler, C and Java, which I think is reasonable mix. Some people on the course seem to hate programming. Personally, I wish there was more, but that's by-the-by.
question -
Of the above, the Java project was collaborative. Makes sense, given the increased orthogonality of code units versus C or assembler. I wrote most of the code, someone designed the (optional) database, someone else did most of the worrying, and betwen them they produced vast amounts of documentation. I know for a fact that our code was not read over, despite the fact that implementation was supposed to be fifty per cent of the marks. We could not have been, as far as I can see, marked fairly. I like my code - it's the thing I do best. I'm not particularly interested in documentation &c. Does anyone else think that code is overlooked in marking, to the advantage of less core CS skills? How common is it for markers to skip looking at code? Has anyone often had their code looked over in great detail by their lecturers?
I wonder how many people have tried compiling their code, then decompiling it and handing in the tidied up decompiled code? Don't know much about decompilers, but I'd imagine they make the code look pretty terse, if the initial compile was any good.
> Prior to that year, VT had an average of 75 cheating violations for the WHOLE university (25000+ students). For that one class, on one assignment, 150 students were found cheating by the cheating detector... out of the 500 or so students in the class.
IIRC, there was a year when 20% of all students busted for cheating at my alma mater were in one of the sections of Intro to CS. I wonder whether cheating is especially endemic there, or whether it's merely the getting caught that's endemic.
After all, CS seems to hold the promise of a gilded career these days, but the subject matter is so difficult that Otto B. Abusinessmajor can't hack it. Lots of motivation and opportunity to cheat, it seems.
Sheesh, evil *and* a jerk. -- Jade
...which I suspect is what they're doing.
It's easy (almost trivial) to instrument a parser to build (say) a Python data structure representing a tree (I wrote some code to do this a while ago; see the CVS repository of http://sf.net/projects/dtct, and please try not to laugh). Applying a diff algorithm to a parse tree (or putting it back out into text and running diff on it, or comparing varieties of text, and so forth) is really quite simple, and not so prone to many workarounds as the system you mention (where using inlines, macros, pragmas modifying compilation &c could have significant effect).
http://slashdot.org/article.pl?sid=01/05/09/198259 &mode=thread
"Perhaps most amazingly, votaries of 'diversity' insist on absolute conformity." -- Tony Snow
As a former Head TA for one of the classes in question (CS 1502 - Intro to Computing), I'll try to elaborate and answer common questions.
;)
;)
No, I have no current affiliation with Georgia Tech.
Yes, the cheatfinder really, really, honest-to-God exists. We used it every quarter that I was associated with the class and caught _lots_ of people. You'd be stunned how many people thought we were just making it up to scare them into not cheating.
Yes, it actually works. It examines mostly source code, although some versions of it were twiddled to look at "in-between" assembler to help catch those who just change variable names and such. It scans for patterns in the logical constructs of code blocks, even if they've been rearranged or altered in other "cosmetic" ways. It also looks for exact matches in text (like the "commas in same places" mentioned by Kurt in the article), but this is misleading -- it does a whole lot more than that.
Yes, depending on how you run it, it can generate a boatload of false positives, but it contains several tweakable threshold levels that let you control how "suspicious" a pair-match has to be before it gets flagged, and these thresholds are made looser for simple programs where there's really only one way to do it.
No, no action is *ever* taken based on the output of the cheatfinder directly. It merely alerts the TA who's responsible for cheatfinder that quarter and he/she then manually reads the source code to see if it looks like a case of cheating. If so, it gets sent on to the professor for a final verification (and possible discussion with the student if it is a borderline case), before being forwarded to Kurt for examination and possible disciplinary action.
Finally, yes, it's an old and very "evolved" codebase. You wouldn't want to be the one to maintain it, but on the other hand, it has been tweaked to the point where you'd be really surprised at the sort of clever cheating it can detect. (i.e. it works a lot better than diffing the source code
Anyway, figured I should throw in my $0.02 on this one, since I used to run that class.
If anybody has any specific questions, please post to this comment and I'll reply. (Questions from current Tech students asking how to "get around" the cheatfinder will be happily ignored, of course.
Michigan State, at least, has been using such a program in their computer science program for more than 5 years.
It was always interesting, when multiple students used an example of code out of the book for part of their projects, and then were accused of cheating as a result....
As a former TA for one of these classes who nearly ended up working on the cheat finder software for a quarter, let me add some additional fuel for the fire.
1. These are not just "programmers" in the traditional Computer Science major sense. The first class is required for almost all students at Georgia Tech. It started off just for Computer Science and Computer Engineering, then expanded to all engineering majors (civil, mechanical, etc). Now, even management majors (Georgia Tech's version of Communications, Basketweaving, or whatever the weak major that many athletes did at your school) have to take the class. The language used to be a locally developed pseudocode language (affectionately known as Russcal). Right or wrong, many of these students consider the class to be an unnecessary hurdle on their way to a degree, and to a technologically illiterate management major, programming does not come easy, nor are they inclined to learn their ethical obligations as a "programmer" - they just want out of the class.
2. Contrary to many snide remarks, the algorithm is, in fact, quite sophisticated. It is not fooled by extra white space, variable name changes, or simple rearranging. As a TA, I saw even simple algorithms done a slightly different way by every single student. Chances are that a student who will resort to cheating doesn't know enough to rearrange the code beyond the recognition of the cheat-finder and still have it be correct, and a student who does know enough would probably spend as much time dressing it up as it would take them to write the thing in the first place.
3. Once two submissions are flagged as possible copies, they are first reviewed by a student TA. If the TA believes that they are in fact copied, it is escalated to the class manager (GT staff), and then to the dean if need be.
It's not a perfect system, but the cheat-finder does a good job of crunching the role of a human down to a minimum, and leaves room for people to make a subjective judgement. It's pretty good, so cut the sarcasm back a bit - it's unwarranted.
Seen any BadMarketing lately?
It's true--I took the grad-level PLP (COP 5535, IIRC) course last summer. Dr. Bermudez announced in class that around ten students (out of ~100) had suspiciously similar code. I was shocked, since these were all graduate students.
The software compares parse trees, rendering most obfuscation techniques ineffective. Perhaps it also analyzes the machine code, counting jumps and performing statistical analysis of procedure calls. The more industrious cheater can probably resort to #inline directives and nested function calls to beat the detector, but anybody who goes to that length should just do the damn assignment instead.
I'm very grateful for any and all cheating detectors. You missed the point, Taco: collaboration is extremely important, but someone who can't produce code is useless in a production environment
"What is the sound of one belly slapping?"
Personally, I can't imagine someone who thinks that it's okay to use someone else's work in any environment where the goal is to measure the individual.
Well you see, the college educational system is really really unfair. The profs try to make you study for, like, hours every week, or else they give you a really bad grade like a B or something. So cheating isn't wrong. Cheating is actually a revolutionary blow against a corrupt system. Every tender, loving act of cheating brings us one step closer to educational utopia, where everyone will be awarded a PhD at birth.
Find free books.
Actually, CS 1311 (the intro class at GT) is taught in Scheme. They cover everything from the basics through basic linked lists, binary trees, up to the beginnings of OOP. The web page and other such assignment are there because other departments of the school requested that their students know Excel and HTML and other programs so the CS department teaches them as "labs" in addition to the regular programming assignments.
Pardon me for posting anonymously, but I've got to let a little venom loose.
I was a TA at an prestigious, well known computer science program. The professors there always unfurled elaborate anti-cheating policies. Cheating of any kind whatsoever would be brought before the Dean, where you are going to be subject to a wide range of punishments, including possible expulsion from the University. They purported to be using a script very similar to the one being described here. Yet many of my classmates cut and pasted their way through all the entry level classes while i labored away at every assignment. How did they get away with it?
That one issue -- that people who did no original work whatsoever got scores at least as high as mine -- has been dismissed as "a fact of life" by friends and family, and I tend to not think about it too much. Why? Because I'm the one getting the education, not them, and in 5 years when college GPAs don't matter a fraction as much as intelligence, experience, and work ability, I'll get sweet (or is it l33t?) revenge.
But in the meantime, I thought, let's become a TA and be on the other side of the fence for a change. Let me do my part to bring all these cheaters to justice.
And you know what? The reason they all got away with it was not because the previous TAs slacked off, but because the professors, when push came to shove, just didn't care. They lied about using the script.
When I brought identical assignments to their attention, they didn't pounce, but gave me options such as taking off some points or letting it go.
As it turns out, we have a very forgiving Dean, and any cheaters brought to his attention will get no more than a slap on the wrist. For that, professors get to do a lot of paperwork, cast themselves as the bad cop in making the case, and get a poor repuatation with students who are used to the status-quo of a cheat friendly environment. They don't want to do any of that , so they put on the pretense of being tough on cheating and hope it all goes away.
Slashdot is mostly a young crowd, and young are naive like I was, so let me break some bubbles: maybe at GA Tech profs let ethics take precedence over apathy, but not everywhere.
And to all your cheaters out there: yes, you're off the hook for now, but wait until we're co-workers.
Can someone please mod this out of the anonymous doldrums? Thanks.
...to check the resumes of candidates for their head football coaching position.
Considering the last guy who coached there was George O'Leary...
I Heart Sorting Networks
(free; for instructors only)
Measure Of Software Similarity
While originally written as a "cheat" detector, it also does a good job of identifying similar structures in systems that are good candidates for refactoring. It helps find things that should be functions rather than cut-and-paste-with-trivial-or-no-change.
-dB
"It if was easy to do, we'd find someone cheaper than you to do it."
In the real world you also won't get fired for being a complete fucking idiot. What's your point?
Well, I suppose that depends on where you work. And like whether or not they suck. The fact of the matter is, there are a lot of people out there who do cut a lot of corners in their code, and still manage to make money. Those people suck to work with, of course, because their code is always shit and they don't really know what they're doing.
autopr0n is like, down and stuff.
No one accuses the teacher of cheating when they copy the assignment straight from the textbook. Yet if the student does exactly the same thing with the answer, then suddenly it's bad.
If I assigned the classic "Hello world" program, I wouldn't expect or want something like;
main(){char *p=&13["\0\n!dlrow olleH"];while(*p) {putchar(*p--);}}
I'd expect the student to copy the program exactly. If I was worried about students not learning the material, I'd just assign a problem that hasn't been solved - preferably something actually useful, like "change this open source program to accept '--word' style options as well as the current set, or "change this to work with IPv6"
The question shouldn't be "did you copy?", the question should be "did you learn?".
So, when I was the head grader for the first hard cs couse at CMU, I wrote a similar program -- it does't need to be very complicated because cheaters are, by definition, lazy. Change some variable names, comments, whitespace, move some code around and maybe break a function into two smaller ones, and that's it. My code just counted the numbers of braces, 'if' statements, parentheses, equal signs, etcc, producing a set of numbers for each program. Then, sort them and pick out the ones that are really close to each other. Those get picked out for hand checks.
As for why: everybody was supposed to do their own work -- this was not one of the courses where people were supposed to collaborate on their programming assignments (those courses came later.) Some students went overboard on the restrictions -- there was never anything wrongg with discussing the assignments (that's part of the learning process as well), but everybody needed to do their own work to prove that they understood the material.
Now that I'm out in the "real world," this makes sense -- I can tell the people who cheated and slacked their way through school, because they don't last long without understanding what they're doing.
Now that I'm out in the work
You may not be fired for consulting a coworker, but if you take a coworker's worker and then claim you did it yourself, you'd certainly better cover your bases.
C//
> Finaly consider this: Checking for cheaters in a class isn't just doing a diff of two files. For every student in the class, you have to check his code against everyone else's. This is a O(n^2) problem. My class had around 350 people in it
so that's 122500 checks to do. If it is anything more complex than a diff (multiple files, compiler front-end, fancy perl parcing) this can take a mad amount of computing.
Not so hard, because you just generate a parse tree for everyone, which takes a bit less time than compiling the programs. Then you use Lisp to try pattern matching on the parse trees, and terminate the comparison as soon as you reach a point that won't unify. (Probably no point in checking the rest of the program on that pair.)
Though an O(n^2) problem, the actual number of pairs to check is only about half of 350^2, call it 60K tests. No sweat for a fully automated system on a 1GHz PC, unless the programs are really big.
Sheesh, evil *and* a jerk. -- Jade
No, in the real world, they try not to employee you in the first place if you don't have the basic skills to do your job.
Take a look at any Usenet group for a particular language, alt.comp.lang.learn.c-c++ for example. There are plenty of volunteers in these groups who are happy to help people out with problems. Some, like the group above, are even dedicated to helping newbies, often with their homework assignments. However, most of the professionals there will refuse to post any help at all until it's clear that a respectable effort has been made.
Every now and then, some smart-ass objects and tells them they're something unpleasant, and the reply is always the same. It goes something like this: "I do this for a living. If I help you cheat, then one day you might get a qualification you don't deserve. And then you might wind up working for me."
There's a world of difference between helping someone out who genuinely doesn't know or understand something -- a common and sensible practice in industry -- and doing everything for someone because they're too lazy to do it themselves.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
A program such as this has been in use since prior to 1998 here at Virginia Tech
in general... they are the extreme... there is a lot of general cheating going on and I think something like this is a good idea... to catch "the smarter cheaters"
-- Note: These Comments are Generated by ME! Not You! ME!
I'm in my final year at university and my project is a coursework submission program which I will hopefully have plagurism detection built in...
I wonder if anyone will notice if I just borrow some the code from the Georgia one...
I think this is a GOOD thing. Plagarism at the undergrad level runs rampant. If you're not smart enough to do the work - perhaps you should consider an educational path less taxing on the mind.
Subject: Academic Integrity
Importance: High
Welcome back! I hope that you had a wonderful holiday season. I am writing this note to you to give you a "heads up" regarding a new process for which Villanova has contracted to help us enforce our academic integrity policy.
At Villanova, class papers can now go to "Turnitin.com," which is a search engine that compares papers with others from Villanova and with thousands of websites to determine whether the material is the same. Once the search is complete, faculty receive a detailed report of what materials have been copied and from where.
I am telling you this to help you avoid academic integrity violations. Please be VERY careful and provide complete citations for your work; if your professor has indicated that you are to do your work individually, then do your OWN work; and so on. If you have ANY questions AT ALL, please seek clarification from your professor PRIOR to submitting your work to him/her!
I sincerely wish you a very successful semester!
Best regards,
Dr. Victoria McWilliams
Associate Dean C&F
Welcome to the Life! Boy it sucks!
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
It really isn't a valid criticism of preventing cheating in a compsci class to refer to the real work world where you DO consult and work together. The point of the university class is to help teach you a computer language - to make sure an individual gets it, understands it, and can use it. Once you get that, THEN you can enter the work world and collaborate instead of simply leach off the expertise of another.
If you take a chemistry class, it is generally expected that you the individual student will understand the reactions and the processes/tools rather than simply copy or leach off another student who DOES know what they're doing. You gain nothing and provide nothing if you can't do the basics on your own FIRST.
In Bushworld, they struggle to keep church and state separate in Iraq as they increasingly merge the two in America.
Not only is this a strangely old topic on the face of it, it's even older than they claim. Michael Wise at Sydney University (now a research fellow at Cambridge) had a system called "yap" (Yet Another Plague) which did fairly advanced plagiarism detection on electronically submitted assignments that was already old hat when I was a 1st year undergraduate, back in 1990.
The first paper on yap (from 1992) cites related work from 1981 (in SIGCSE) and a series of articles on the system "plague" as far back as 1986.
All of this material (as well as the successor system, YAP3) is easily available on the Web. It would be nice to see people do 10 minutes of research before spewing out Yahoo news stories and Slashdot posts (note: "research" is a slightly different skill to "cutting and pasting press releases").
- Copy the original code.
- Change every variable name (even if to a less sensible name - HalfCircleWidth instead of Radius).
- Rephrase most comments, but in the most transparent manner (e.g. "incerment the counter": becomes "the counter is incremented").
- Grab one or two lines of code near the top and rewrite them in the most awkward manner possible. Presumably, this is to prove to themselves that they're more clever than the teacher and that they could've actually done the assignment if they'd bothered.
Inevitably, it was the trivial stuff (indentation, comment structure) that set off my alarms. Then, I'd give them a moment of truth and sit them down to try to explain how "their" code works. If they didn't, I'd kick their tails out. If I was teaching a seminar at someone's workplace, I might or might not inform their management. Since all these penalties were spelled out in my syllabus, I never lost any sleep (in fact, putting them in my syllabus tends to ensure no one tries it).As to the the differenece between "consulting" with another and "cheating", I've found that the "explain your own code" is a pretty good yardstick. If I spend 2-3 hours preparing to teach a lecture, I have no sympathy with someone who doesn't spend enough time to do the assigned work but instead cheats.
"Prepare for the worst - hope for the best."
just wanted to give my past experience with this kind of thing. at my (undergraduate) college, one of the cs profs had implemented a cheating detector of his own. in my senior year i was in his class and took an extended break one weekend. i had my code done early as i knew i wouldn't be able to work on it at all that weekend, and some people in the class knew i wouldn't be around. a guy who was also in the class came over to my dorm, was let into my room by my roommate, got on my comp, and took my code. the roommate's excuse was "well he came over before to study with you before so i figured it was ok to let him on your comp". dumbass.
/tmp, stealing files located in shared storage space with bad modes set (644), etc. all of this happened while i was in college to various friends etc but most of it occured in the low-level cs classes where the non-cs/non-engineer types were struggling to get "hello world" type programs to work.
the prof called us in separately a couple weeks after the assignment was due and i honestly had no idea what was going on. despite my explanations of what happened etc, he decided that it wasn't his job to decide if i was telling the truth, what should be done, etc and so he turned us BOTH over to the honor council. we were tried separately and with my roommate's testimony i was found innocent, and never again gave my l/p to the guy so he could play games on my box when i wasn't around. the other guy got off too, but that was because he was a 2nd semester senior with 2 weeks left and they just decided to get him out of there.
there were similar examples to this (where innocent parties are in trouble unfairly) due to people stealing printouts of peoples code in a shared lab, taking printouts from the garbage, stealing floppy discs w/code, stealing code from
when a similar cheating detector was used in the cs101 intro to c class, something like 20% of the class got in trouble. it was a real mess for the honor council. groups of people would steal code from smarter people and then share it around. amazing...
wayne
E V E R Y T H I N G I W R I T E I S F A L S E
"...These fragments are frequently tedious, and rarely are useful to understand, and such fragments should be freely available in online databases..."
I agree, but with certain reservation.
I remember when I first learned C 10+ years ago, I wanted to make a my programs configurable through a config file with simple "flag=arg" lines (as well as #'s for comments). I spent more time working on text parsing and groking through pointer arithmatic than on the main program itself! It was annoying, but I learnt from it. A few programs later, it was routine, and I could write the boring stuff in a few minutes and get on with it. After a while, I just got lazy and started copying the old functions into new programs. It worked, that's all that mattered.
So my reservation is this -- yes, you should be able (and it could even be considered benevolent) to copy and paste your old code for menial tasks; but you SHOULD understand how it works, and have written said functions in the first place.
--
#nohup cat
There's a recurring joke here in the office:
:)
Good programmers know how to write good code. Better programmers know how to steal it.
Free code repositories on the net are our best friend.
I took the course last semester, and well, the rules about cheating are insane. If you so much as look at another student's code in order to help him, or her, you both are technically cheating and if found out will both flunk the course. Also, alot of people who take the course, have no business taking it! Why? Well it's not every student at the college of computing, it's EVERY student who has to take that course. Some of these kids can't move a mouse in a straight line, much less write computer programs! And it IS a programming course, from day 1, you are taught scheme syntax and usage and some stupid sorting algorithms. Half the time, there aren't very many different approachs to the problems give you (they are VERY structured in how you are to complete them.) Also...at the beginning of the semester there were 5 of these classes being taught, 300 to a class. Of those who remained after drop day, 186 people ACCUSED of cheating is very surprising that it was so few to me! This so-called scandal is not because kids wanted to circumvent the system, it's because the CoC's administration has some overbearing rules.
On a sidenote...this is actually not new...it happens there EVERY semester, it's just the first time it was announced in mass to the press.
Face it, in real life, these students will have to collaborate on projects and problems. Telling them that they can't even give each other hints (I'm not joking,they devoted an entire lecture to what constitutes cheating!) is moronic in my opinion. And no, I was not one of the 186 students, I was so bored in the course that I never even went to class, I only bothered to show up for tests.
Derek Greene
>Cheating is not demonstrating knowledge.
I agree, so why not use our ability with networking to solve the problem. The goal is to see that students can code their way out of a paper bag.
Why not have a class of networked boxes and then 'test' the students by having them come in and write their code while the network is shut down, preventing the students from getting access to any help during the test. Take the floppys and CDROMs out and they can't bring in outside help. There could be bonus marks for speed.
Experiment!
This amounts to cutting and pasting from the instructor, rather than another student, but these are intro classes. How do you teach a language without providing example code that illustrates the concepts you're trying to teach? How can the students (who don't already know the language) complete their assignments without anything to work from? Can you imagine an instructor asking a bunch of newbies to format a printf() without an example to work from?
I think a lot of people who are going to get "caught" by a system like this won't be cheaters at all. There are going to be a lot of students getting slammed for using the resources that SHOULD be available to them; textbooks, lecture notes, tutors, etc.
What it WON'T catch are the real cheaters who get their solutions off the internet. A solution to that problem would be a lot more interesting.
Under capitalism man exploits man. Under communism it's the other way around.
I took Intro to Computing in the Spring of 1996. It was cake for me because I was a Computer Science major and I dig this stuff. But a lot of non-CS people dreaded that class above all others, especially Management, International Affairs, and Architecture majors, but also some engineering people, such as Aerospace and Industrial Engineering.
(And can you really blame them? How many civil engineers really need to know how to sort numbers in O(N log N) time? Or insert into a linked list for that matter? They write hacked-up FORTRAN if they write anything at all.)
Kurt Eiselt came to the first lecture and gave us a scare speech about Cheatfinder. Knowing that it looks for similarities between two students' works, I was worried constantly about my homework answers. A typical problem was to write an inorder binary search tree traversal routine in pseudocode. Honestly, how many different ways are there to do this? And there are 500 people in all sections of the class?
Fortunately, I was never flagged, but I have heard a few stories (which may not be true, you know how that goes) of people who were flagged, and were only vindicated after losing student jobs and failing classes.
I don't think an automated cheat detection system is applicable to small problem sets like binary search, stacks, and Mergesort. For the later classes, say Sophomore level, I have no problem with it though.
Besides, many Greek orders and clubs on campus have extensive "word" banks--archives of previous homeworks and tests, with solutions, from previous class offerings. Are they going to check against all previous students' work too?
LAMP hosting on Debian, SSH, no bandwidth cap, PayPal accepted - http://secondbrainhosting.com/
Could something like this be used to detect violations of gpl'd software? It would be especially useful for detecting usage of gpl'd software in proprietary products where the source is never released.
"Don't blame me, I voted for Kodos!"
Cuz remember programmers: in the real world you are fired if you consult with a co-worker
But remember, College ISN'T the real world. The point of College is not to get the job done, but to learn stuff. If you just copy somebody else's stuff, you won't learn anything, and you'll be pretty useless in the "Real World"(tm).
Disclaimer -- when I was grading programs (back in '83/'84) I busted a few people for copying...
Fascism starts when the efficiency of the government becomes more important than the rights of the people.
When I took a lot of creative writting courses in college, the topic of plagurism often came up, often in the context of "stealing" a single phrase or idea. What I found was that people who were good writers were incapable of cutting and pasting someone else's prose. They'd wind up teaking, twisting, and "improving" it. By the time they read it aloud to the class, you couldn't recognize it at all.
Then, of course, they'd get all offended that you didn't realize that it was a Hemmingway reference or something. Human nature, I guess...
"Prepare for the worst - hope for the best."
...in a few of my entry-level CS classes where on more than one occasion my work looked remarkably like others in the class, including that of the instructor that also work the assignments during the same timeframe that we did. I didn't copy and neither did anyone else. It's just that the instructor grilled steps into our head on how we *should* program something. When all was said and done, our source had a certain resemblence to one another. On one of the hardest assignments in the class, a calendar, my source was almost identical in parts to the instructor's. We even chose many of the same variable names. I can easily see how 2 or 3 people out of a class of say 500 could have very similar source. Can't you?
Well we got every assignment in the last 5 years on file. We run hacker (which produces functionally equivalent programs = renames functions and vars) and the like (rotate ORCAD schemes) and got a cgi script that does most of this automagically.
Those dumb enough to carbon copy stuff deserve to be caught.
I hope I don't sound like an old fart when I say this, but if you have to cheat at beginning programming class, you should re-consider whether CS is the right major for you. Seriously.
My freshman year, we got Pascal I & II. I might have been one of four or five people in a class of 15 that wrote all my own code. I mean, it's fucking pascal. If you can't grok pascal, maybe it's time to change careers. (Sorry if you had trouble with pascal...I'm not saying I'm a god but I never had to cheat to get my homework done.)
All this talk of Pascal makes me nostalgiac for the goofy "everything is one big nest" code. I bet google could find a pascal compiler for Mac OS X...
Who did what now?
Geez, Taco, wtf? The classes in question aren't the real world -- they are there so you learn how to program, not how to collaborate. Perhaps instead of allowing posters to add their own comments to submissions, they should be forced to attach their witty or insightful comments they same as the rest of us.
Your quip turns the whole focus back onto the school -- they are the ones doing something wrong by looking for cheaters, instead of the cheaters themselves. Whats next, complaining about the fact that the assignments are graded at all?
Cuz remember surgeons: in the real world you will have someone assisting you.
Cuz remember pilots: in the real world you will have a co-pilot.
I once worked for a company (circa 1990) that was being sued by a competitor for stealing their source code. They did a line-by-line comparison of the codes involved and found what they determined to be a "significant" number of matching lines. Of course these lines (in FORTRAN) were 99% the typical comments, declarations, DO statements, CONTINUE, FORMAT, RETURN, etc... that occured in most programs anyway, or they were in routines commonly derived from the NETLIB or HARWELL source libraries. They figured a judge and jury wouldn't understand the issues involved, so the burden of proof (or clarification) fell on the accused.
This is really anything new.. I live in IL and I've heard of one of the larger state schools doing this.. and I've heard a lot of the younger professors describe this exact same thing from their days in the university..
whats sad is the amount of false positives produced by these things..
I'm just glad my school doesn't implement something like this.. it would be more of a hassle than anything..
I acutally had the problem of a co-worker taking a bunch of work I had done to the boss and claiming he did the work.
The funny thing is the guy was so stupid he didn't understand that there would be backups that would show who created the files and when.
I'm going for a BSCoE at KU, and in our programming classes last semester, we were told that they used software that basically did the same thing. I don't know how long they've been useing it, and I didn't hear of anyone getting caught. I think that this is just the first instance of it CATCHING people.
Comment forecast: Bits of genius surrounded by a sea of mediocrity.
So, we've now proven that in the real world, you can't very well "cheat" off a coworker becuase they're doing something different. You could reuse code, but that doesn't count either. You can ask for their input, but you can't pass their work off as yours. Try that and see how long you last (probably about as long as those cheater students).
Too big to fail? Does that make me to small to succeed?
I've come in and had to clean up behind lots of other programmers who didn't fucking know how to code. The one benefit to this crappy economy is that these people will no longer be able to job hop every 3-6 months due to the shit hitting the fan because they don't know how to program. Oh, the horror stories I could tell...
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
....who thought he would cheat by copying someone else's code.
But he was pretty paranoid about getting caught, and realised that a verbatim copy wasn't enough, you'd have to change the variable names, comments etc.
So he did some research, wrote himself a little parser that read in the source code and built a parse tree of the program. He then wrote another function that spat out all the code again but with different spacing, block ordering and some simple variable renaming (e.g. x,y,x->a,b,c)
To make sure the structure of the code didn't give him away, he wrote a few code transformations, e.g. if a then b else c became if !a then c else b. The order of non-conflicting assignments were swapped, and mathematic expressions were re-arranged (sometimes actually optimising the original code in the process!).
Still wasn't good enough, the comments needed changing and the structure of the code looked the same. So he linked in a thesaurus and NLP/AUG engine to change the words in a meaning-preserving manner. Same principle could be applied to the more complex variable and function names, so buildTree became makeStructure etc.
Finally, to put the icing on the cake he modified the program so it could output the code in a couple of different functional languages. Made the plagiarism almost impossible to spot.
Best programmer I ever met.
Disclaimer: I have no college degree :P
Here's 7 lines of C to reverse an array. The assembly would be more or less identical. I don't feel like dredging up my memories of 8086 assembler... it would probably end up screwing up my Perl for the next hour or so :-)
int list[] = {0,1,2,3,4,5};
int i,j,len=sizeof(list)/sizeof(int);
for (i=0; i < len/2; i++) {
j = list[i];
list[i] = list[len - i - 1];
list[len - i - 1] = j;
}
Reversing a linked list would be marginally longer, but a doubly linked list would be just as short or shorter than this. Only a real novice would take 100 lines of C to do it. BTW, how could you possibly learn assembly before learning what a stack is?
* And remember, it's spelled N-e-t-s-c-a-p-e, but it's pronounced "Mozilla."
How do you think bugs spread in m$ programs? Cut and paste and cut and paste...
Imperium et libertas
Autocracy and freedom
CMU 15251 Course Document and Cheating Policy
His policy encourages collaboration and specifically forbids cheating. It itemizes various types of cheating, for example copying from another student, letting another student copy you, and looking at someone else's files online (even if they forgot to set their file permissions).
Furthermore, he requires all of the students in his class to sign a statement saying that they have read and understand the cheating policy. Not only does that discourage some students from cheating, but it also makes it much easier for him to get students into serious trouble with the school when they are caught.
In addition to the course document, here's more or less what he had to say on the first day of class: (I apologize for paraphrasing; this is how I remember it) "Nobody plans to cheat. You all must be very smart, or you wouldn't be here. You think you're going to try hard and do well in this class. But later in the semester you'll get busy with other classes and activities, and all of a sudden an assignment will be due in one day and you haven't started. Or you'll be taking a test and realize that you forgot to study an important equation. Or you'll work hard on an assignment and almost completely get it working, but get stuck on one subroutine. Even though you never planned on cheating, all of a sudden you'll find yourself in a circumstance like that and it will seem tempting."
(BTW, I shouldn't have to say this, but Prof. Rudich's cheating policy is copyrighted. If you're a teacher or T.A., don't copy his cheating policy without his permission. That would be just as dishonest as cheating!!! If you want to use it, contact him and I'm sure he'd be delighted to let you use it, as long as you give him credit.)
Total: 10 points
But my biggest worry about programs like this is what would happen if someone's code was stolen? This happened to me in one of my early CS classes and thankfully nothing came of it. (Now where did that disk go?) I found out later that over ten people turned in 'revised' versions of my program. Now how would the real programmer prove that out of all of the 'cheaters', that he/she turned in genuine work?
And, yes, I know it's against the interest of the AC that posted his account of pay-for-code to help me out here, but I thought I'd give it a shot.
"Prepare for the worst - hope for the best."
As you may have read, bestselling historian Stephen Ambrose was recently caught having lifted sentences and even passages from other sources, and passing them off as his own writing in his books. (While he mentioned the source books in footnotes/endnotes, he did not put the cribbed text in quotes.) At least four different Ambrose books have now been shown to have the same pattern of lifted, unattributed passages.
These instances only came to light because an author of a lifted passage noticed it while reading Ambrose's book. Subsequent episodes came about because other authors started looking, and now some people are checking out new likely sources; this works because Ambrose only lifted passages from books that he admired and heavily footnoted (at least, so far as we know!).
Perhaps Ambrose was really just lazy, as he was fairly open about crediting others for the ideas (he "just" failed to credit them for the words, too). There are many cases of sneakier plagiarism than that, both in academia and in journalism.
So, class, the programming problem for today is, given the text of two books, spit out the most likely candidates for lifted passages, based on length and similarity of words. You get a B if you can do this for exact, verbatim matches, an A if you can do it with individual word substitution, and an A+ if you can recognize re-ordered clauses. The end users for this tool would be 1) authors everywhere who want to protect their own writing, and 2) journalists looking for juicy plagiarism scandals.
Sure, CS100 classes and maybe the second or third programming classes a student takes don't need collaboration, though many students will need help (i.e. teaching, even if it's not done by a professor) in understanding what's going on with their programs, why they're not working, learning to use the cardpunch (:-) or editor or whatever local facilities you have. But by the third or fourth programming class you're taking, you should be doing things that are large enough to require group work, whether it's writing a small operating system or writing a simulation of some complex activity, because most real projects are too big for one person to do.
Bill Stewart
New Fast-Compression-only CPR http://preview.tinyurl.com/dy575ks
So how exactly does consulting with a fellow student (or co-worker) result in both parties having identical code?
I have to say that this is the most ignorant ... well, you get the idea:
John: Hey, Bob, you got a sec? I'm trying to get this stupid utility done and it's not working right ...
Bob: Yeah, sure ... hmm ... hey, I wrote something just like this a while back. Hang on, lemme go look for it.
(a few ls's, cp's, and cc's later)
John: Cool, thanks!
Granted, school and work have different goals (learning vs. getting things done) and this argument doesn't apply to students, so I agree with the point that students shouldn't be copying without actually thinking about the assignment, but for the same reason it's absurd to say that co-workers shouldn't just copy code either.
A student came up and said "I've written all of the assignment, but the compiler is broken." My friend looked at the error output from the toy teaching language compiler.
"Unknown keyword 'From:' in line 1 'From: student2@cs.university.edu'"
"Unknown keyword 'Subject:' in line 2 'Subject: Assignment 2 answers'"
The student tried to insist that it was all his own work.
I was also thinking, for some types of projects wouldn't the code come out quite similar if it was done correctly? If you are teach C++ classes, and were implementing some simple program to test the knowledge of the students, then a correctly written program would be very similar to another correctly written program. Otherwise you are not teaching standard techniques very well, imho. A shell sort is a shell sort, not much difference between properly implemented versions.
Dear professor Andrew S. Tanenbaum of the free university of amsterdam and his colleagues already used this kind of program to check the hand-in programs we students wrote in modula-2 back 8 years ago or so, and actually it was kinda a big thing in dutch news back then. Guess these guess just reinvented the wheel.
so
The point of the Yahoo! News article was not that Georgia Tech, like many other universities, is using cheat detectors, but that out of 1700 students last semester, it nailed 187. That's around 11% and seems to be news-worthy to me.
"Which is more musical: a truck passing by a factory or a truck passing by a music school?" - John Cage
Virigia Tech has had something similar, and maybe better, for some time. It was written by a graduate student (I believe), and it pays no attention to variable names, it purely focuses on the syntax of a program. Programs with a similar enough syntax are flagged and looked at by TAs.
I know because I went through the process (long story), and it's mentioned at the beginning of any coding-intensive class at the 1000 or 2000 level.
Cuz remember programmers: in the real world you are fired if you consult with a co-worker ;)
That reminds me of something that happened during a CS lecture last year...
Prof: All of my tests are open-book, because the real world is open-book.
Jesse: Can I use Google during a test?
Prof: No.
The shareholder is always right.
Patrick Doyle
I mod down every jackass who puts his moderation policy in his sig. Oh, wait a sec....
I remember taking a class (I think in BASIC) at a community college. I already new BASIC, had been programming in it for several years. (I was only taking the class for the easy credits.)
After a test was turned in, the teacher called me over. He showed me a code fragment submitted by another student. It was practically identical, even to the variable names. (Of course, in this old dialect of BASIC, variables were single letters.)
How did this happen? Outside this class, the other student and I were collaborating on an astrophysics simulator (also in BASIC) for another class. Today, our style of coding is called Extreme Programming. In the course of this we had tacitly developed common coding conventions and styles.
Even so, I was surprised how similar our independent output was.
Fortunately for me, the teacher was a friend of mine and he believed my explanation. Even so, I sensed some doubt on his part. Were he a relative stranger, things might have gotten messy.
I honed my programming skills in college by writing a 10,000 line perl script which tranforms other students' work in ways not identifieable by automatic cheat detectors.
-mjjm
---
Nothing is more depressing than the sight of people who believe they are following collective manias of thier own free will.
--Czeslaw Milosz
Nothing's more depressing than the sight of people who believe they're following collective manias of thier own free wil
I used to work for two brothers that were coding (seperately) modules for a project. Their code looked almost identical; variable names the same, data structures and algorithms almost identical...
These two both had the same training, and guess what...their code looked really similar.
Besides, how many different ways can you code "hello world" without failing for using inefficient/bad programming style?
-ted
Was in a class where the instructor asked us to write a program to perform an ascii sort of a file (kind of like 'sort' actually). I specifically asked if we could use libraries, and he said yes. Of course most of the students were using Pascal...
You can probably guess what I did. My program featured the prominant use of "qsort()" out of the C library. Even though I had learned about callbacks with the thing, he really didn't like it. Made me go back and reimplement it so that there was an actual "sort" being performed in my code. Ug.
Now I'm a Principal Engineer.
The cheating community dealt universities a harsh blow today when they unveiled a Perl one-liner that thwarts all attempts to catch cheaters with their fancy-schmancy new program.
"And like that
This really isn't that new at all. I did some development on an autograding system at UCSD and incorporated a cheat detector using an age old system developed at Berkeley called MOSS. You simply tar up all your files and send them via mail to moss and they send email back to you with a link to an html page that gives percentages and all. Great system, uses program structure and logic to determine matches not commments and variable names. Give Berkeley the credit. DWP
I am in Intro to Computing this semester at GaTech, and we had a 20 minute lecture yesterday about this very topic. They do not automatically kick you out of school if your homework or project gets kicked out by the program. In fact, my professor told us that he got 87 of these papers that he had to hand check over christmas, all of which were found to be cheating. The program checks for similarity where there should be differences, and takes the purpose of the program into account, so that variable names can be changed and you'll still get caught if you are cheating. The program is very sophistocated, it is not merely the 'diff' command.
The reason that so many different people get caught is that they only review the cheating at the end of the semester, so it gives everybody who wants to cheat the opportunity before they are caught. EVERY student is told all of these details in lecture at the beginning of the semester, so it should not be a shock, but some people don't believe that it actually exists and don't even try to change things. Some people put their CS programs on the network, or leave them on a shared computer and other people steal them without even knowing the other person. The administration is generally pretty good about finding those who are guilty, and those who are merely ignorant. But as the article indicates, most people are just plain cheating.
How low will Georgia Tech stoop?!
Give a man a fire, and he'll be warm for a day, but set him on fire, and he'll be warm for the rest of his life.
Purdue had a simple but effective cheater-detector back in 1987 or so when I was in grad school there. It ignored variable names and comments, and simply stripped a program down to a list of keywords and tokens (for C, things like if, switch, =, etc; there was a Fortran one too). Then it took the case-insensitive token list, and ran sum on it. Then it took the sums of all the student programs, sorted the list, and ran uniq -d on it. (This was more efficient than just running a massive diff.) Matches were considered potential cheating cases, and were examined by hand. Usually they were, and usually it was fairly obvious that they were. This method didn't care about renaming variables, or comments, or indention, so those common methods of hiding cheating failed. It was effective enough to keep freshmen and sophmores honest, so it did its job.
At least mafia-owned pizzarias make excellent pizza. Compare to Bill Gates.
First, I totally agree with you (if you're implying #1 like i think you are).
Second... I agree that collaborative coders are, when all is averaged out, the most productive (and most pleasant to work with). However, at least were I got my BA, there were several large partner/group projects in a semester in addition to the individual assignments. So you did learn how to work with others (and part of the project grade was based on your ability to work with the others).
If not collaborating is part of the rules for an assignment, you just have to respect that. And since the program only does a syntactical analysis, you can still have discussions about higher level architectural issues (which is more important, anyway).
A: None. The Universe spins the bulb, and the Zen master merely stays out of the way.
It's their time and money being wasted. let them cheat on homework. i always thought homework should be optional anyway. WE are paying the school. WE should tell them what to do. But then I think testing should be done by independent 3rd parties too.. not the schools themselves. Even within the same school Professor Y can have much easier homework and tests than Professor x.. between schools the difference can be just as huge.. a degree earned by one person isn't equiv to a degree earned by another. I know some CS grads that kick ass and a lot of others who shouldn't be hired to count beans.
At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
Then they would have known he cheated. Hopefully they used it on Chan Gailey's ;-)
Every university CS department runs these cheat detector programs, and every semester several people get caught and punished. They never publicize it though.
-
Cuz remember programmers: in the real world you are fired if you consult with a co-worker
This casual quip misses the point. One does not produce identical answers to nontrivial assignments merely by "consulting." The most common cause of identical duplication typically derives from non-collegial efforts, such as "frat house sharing" (not limited to fraternities) and other modes of mass-distribution of a single individual's work.
This casual quip further misses the point. Each student who cheats in this manner, however collegially, typically has violated an express oath and promise taken at some point. YMMV as to specific honor codes. It is one thing to break the rules because one thinks one knows better -- it is another to lie about it.
The purpose of these exercises is to train each individual so they can later be part of a team. In my view, pair programming should also be taught as an inherent and principal development skill -- but a particular mode of pedagogy is the discretion of the professor.
I must confess that one of the most difficult moments of my young adult life was serving as a teaching assistant for an introductory programming course at Cornell (hundreds and hundreds of students). A massive amount of cheating was discovered, and we ultimately sorted and compared all assignments and then called in the groups, one-at-a-time, giving them an opportunity to account for the similiarities. It was horrible, for me, the professor and the students alike.
People cheating just because they (thought they) could. It was a very sad thing.
Congratulations on nailing a lot of innocent students with that one.
In my college programming courses I always learned just enough about the commands and functions to get a project done, then promptly forgot what I'd learned, only to relearn it when cramming for exams. The thing about cramming, though, is that you usually can't relearn everything.
-Legion
We do. But not until we take CS 2130, the class taken right after these two, where we are specifically told to use other people's code when possible, just so long as we label it as such.
Dyolf Knip
If work is being copied then there's at least one innocent victim here.
Plagerism happens all the time in these classes and the hardest working & best student is the one who get's copied the most.
I know a 1st class honors graduate who got his degree because he used to take the second class of a set of two. At the start of each class he'd pull the old printouts from the waste paper bin and use that as his starting point. He'd have a complete solution at the start of the exercise which he could then refine.
I'd like to see guys like him get caught, but what about the people he copies from. Unless the professors are going to take the time to investigate this there will be innocent victims. Tenured professors can be heartless and lazy and the administrators in academic beaurocracies would put Rudolf Hess to shame.
If this continues then we need regulations to protect students.
Actually, until this past semester, the cheating detector was simply an urban legend here at GA Tech.
That is incorrect. I was an STA (supervisor teacher's assistant) at Tech from 1997 - 2000 and I even modified some of the code for the cheat finder (which is a perl script). It is not an urban legend and has been around since about 1992.
The professors have always described the cheat finder as a white-space-eliminating, pattern-matching, we-will-catch-you-every-time cheat detector.
The code does in fact throw away ALL variable names, function names, indentions, white spaces, braces, and other irrelevant items. It then does a comparison and anything below 97.9% similarity is thrown out as a non-cheater. Everything else is FLAGGED and then reviewed by 2 TA's and ALL the professors currently teaching that course.
They finally deployed the legendary cheat finder once and for all at the end of last semester, and caught a significant number of students.
As I said I've been an STA for a long time and I personally have sent over 10 students during that time to the dean and every semester we averaged about 20 to 40 cheaters. Of that 3 year period ONLY 2 people were exhonorated and 7 people claimed they did not do it. The rest even admitted to cheating.
The reason last semester so many were caught is because there were many students who believe that cheat finder is a legend. When you go around telling people that there has been a cheat finder since the early 90's and very few people can actually confirm this people do believe it to be an urban legend to scare kids and people are just wanting to take more chances the more they believe things are just scare tactics and nothing more.
I took this class in fall of '99, so they might have changed it, but it was all in pseudocode, with a special section or two that used scheme.
Yeah, they got rid of pseudocode. It's all in Scheme now. I took it under pseudocode and found it to be much easier than the bitching I heard from all my friends taking the Scheme sections (Fall 2000).
I had become the ring leader of what was initially viewed as a group of "rouge" students (the professors word of choice) - how I became this "ring leader" Im not exactly certain, the only thing that I can point to was the fact that I had the highest grade amongst those involved. The professor failed all of the students involved without any prior indication. Seeing as how the professor had no idea where anyone in the class stood grade wise at any point in the semester this lead me to the conclusion that he sat on all of our assignments until the 11th hour. Had he looked at them when they were turned in (about a third of the way through the semester) he would have noticed this earlier.
The professor was also aware that all of the students and myself were all working together. We would often all go into his office together with questions, we would all be in the study lounges together before exams sharing notes and thoughts on the upcoming exam and we all took similarly scheduled classes. It was no secret that we all worked together.
In regard to your bullet points:
It was known that I was the originator of forming the group, however from there the group became it's own entity - we all used it to solve the problems that we were given (and lets face it - a 200 level course that is expected to write a compiler is a daunting task, especially considering that compilers is the class that typically follows programming languages - one is the theory, the other is the application. This prof seemd to forget about teaching theory and threw us the application).
I am all for academic honesty and making students prove that they can handle the work load, however when the work load is unreasonable or expectations are outlandish, I don't think that it is unfair to seek out answers from your peers who are in the same boat when your professor refuses to acknowledge that his work load is unfair and his methods are poor.
It is definately an ugly situation - and the resolution came by all of the students involved having to retake the class and their grades were withdrawn. *sigh* I think that covers it.
Please give your mod points to others, Im at the cap. They will appreciate it more
It makes you wonder what educators are thinking. That's just a plain ignorant way of looking at things. A year ago I was working on a project using C to make a real time video game based on physical movement measured through digital cameras. If you told me to reproduce it right now, there's no way in hell I could. Professors are so quick to lose sight of the fact that people who haven't been doing the same thing for 30 years have a hard time remembering every little detail of it on the tests.
~ now you know