Why Computer Science Students Cheat
alphadogg writes "Enrollment in undergraduate computer science courses is at an all-time high at colleges nationwide. But this trend that's been hailed by the US tech industry has a dark side: a disproportionate number of students taking these courses are caught cheating. More students are caught cheating in introductory computer science courses than in any other course on campus, thanks to automated tools that professors use to detect unauthorized code reuse, excessive collaboration, and other forbidden ways of completing homework assignments. Computer science professors say their students are not more dishonest than students in other fields; they're just more likely to get caught because software is available to check for plagiarism. 'The truth is that on every campus, a large proportion of the reported cases of academic dishonesty come from introductory computer science courses, and the reason is totally obvious: we use automated tools to detect plagiarism,' explains Professor Ed Lazowska, chair of computer science and engineering at the University of Washington. 'We compare against other student submissions, and we compare against previous student submissions and against code that may be on the Web. These tools flag suspicious cases, which are then manually examined.'"
If someone asked me to (in Java say) print the numbers from 1 to 10, I would probably do something like
for (int i=1;i=10;i++) {
System.out.println(i);
}
So would most other people. Would this flag me as a cheater?
Rhymes that keep their secrets will unfold behind the clouds.There upon the rainbow is the answer to a neverending story
Could it be that more dumb people are flocking toward higher paying careers without the slightest bit of ability. Instead of accepting the fact that they don't know where the power button on a computer is they instead turn to cheating to try to skate by.
Is this not the goal of code re-use? I mean, if there is no copyright violations, that's what ppl should do... Schools are always trying to make you implement retarded things anyway...
You're not supposed to provide balanced, reasonable, fairly probable explanation as part of the summary. What are we supposed to write about? (no, really, give your suggestions below)
One that hath name thou can not otter
True CS curriculum require a massive amount of critical thinking and other analytical skills. Something the recent graduates of HS are not prepared for. Match that up with the sense of entitlement and you get expected results. Back when I was in CS the dropout rate was around 90%. There were no rent-a-coders and using the web for a resource was a very new thought. So it was write your own damn code or head over to liberal arts...
CS: It is all sink or swim...oh and did I mention there are sharks in that water?
They're cheating just as much in other disciplines, it's just in CS we have a lot of good tools to catch them. Plus, we get a lot of false positives with no defense, so we get to inflate our successful catch statistics.
"Who is the Journal of Quantum Physics going to believe?" --Stephen Hawking
Professors tend to give out very similar assignments year after year.
Is it surprising at all that these automated programs detect similarities between hundreds of thousands of programs that all do the exact same thing?
This hasn't happened to me yet, but a friend of mine (whom I trust to be truthful) told me that he didn't cheat on a programming assignment, but he along with half of the class had to do their assignments again because of suspected plagiarism.
While I dont promote cheating I do however believe that you should not reinvent the wheel. When I went through school, it was encouraged that we look for examples and code that we could modify or reuse to fit our needs as long as we understood the concepts and could prove we understood it.
maybe this says something more about how introductory level computer science courses are taught.
CS is just difficult for some people. We didn't all grow up programming in the basement. I've seen students who finally got their program to "run" by commenting out every line, and sadly, were so clueless that they were quite proud of the fact.
Oddly, it's actually easier now that computers are ubiquitous and going to the CS lab to complete an assignment isn't necessary.
Please do not read this sig. Thank you.
There are only so many ways to print 'Hello World'. Don't expect all students to have different code for an Introductory course's simplistic assignments. Now if their comments are the exact same, raise some flags.
Long long ago, in a land far far away, I started down the CS degree path but stopped after the first required programming class. Guess how often I've used Pascal since then? If the students know the class is meaningless, why not cheat?
"Have you ever thought about just turning off the TV, sitting down with your kids, and hitting them?"
...why the possession of a degree is only a tertiary (at best) indicator of ones ability in any particular field. Schooling != Education
I judt got a nre Kinesis keybiartf so please excusr ant egregiou typos.
When the most optimum solution to any problem is frequently the same code, and the same exact question gets asked every single time for that course, is it cheating or is it just optimization?
I use code libraries and recode old stuff to new uses every day - is that cheating or just efficient coding?
-- Tigger warning: This post may contain tiggers! --
If there was only one copy on campus (and since there was no pubmed or anything similar), that would do.
Enrollment in undergraduate computer science courses is at an all-time high at colleges nationwide. But this trend that's been hailed by the US tech industry has a dark side: a disproportionate number of students taking these courses are caught cheating. More students are caught cheating in introductory computer science courses than in any other course on campus, thanks to automated tools that professors use to detect unauthorized code reuse, excessive collaboration and other forbidden ways of completing homework assignments. Computer science professors say their students are not more dishonest than students in other fields; they're just more likely to get caught because software is available to check for plagiarism. 'The truth is that on every campus, a large proportion of the reported cases of academic dishonesty come from introductory computer science courses, and the reason is totally obvious: we use automated tools to detect plagiarism,' explains Professor Ed Lazowska, chair of computer science and engineering at the University of Washington. 'We compare against other student submissions, and we compare against previous student submissions and against code that may be on the Web. These tools flag suspicious cases, which are then manually examined.'"
the preceding post was not spell checked... suck it.
Isn't OO all about code reuse?
all the students had the line
for(int i = 0; i < 128; i++)
in their comp-sci assignment.
For the same reason Psychology students cheat.
For the same reason Math students cheat.
For the same reason English students cheat.
For the same reason Economics students cheat.
For the same reason Biology students cheat.
You get the idea...
I used to cheat in college, and all my friends do. I don't cheat anymore. My secret? I switched to a major I like. For the most part, I enjoy and look forward to assignments, and haven't cheated on any since changing majors. For me the subject is CS, but I'm sure that most people could find something they like well enough to look forward to assignments.
If we're talking introductory courses like Data Structures, then it's pretty hard not to look like everyone else. I don't code most of the basic data structures anymore, but I expect that anyone I hire would have been through the basics at least, so I see the value in teaching these things. But I can imagine that if I were to write basic code to manipulate a hash table or binary search it would look a lot like everyone's else code.
}#q NO CARRIER
This is very similar to finding bugs in QA phase of software (or hardware) testing. The only way you're going to stop finding bugs is if you stop looking for them...
TZ
Perhaps it has more to do with the hacker mentality that seems to be prevalent (or was when I was earning my CS degree) amongst first year cs students. Aren't they just gaming the system for maximum benefit with minimum work?
The only issue is that the cs depts are able to detect this more easily....
A CS intro class is often required by other majors, and these generally have the HIGHEST cheating rates. The worst ones at my campus are the non cs-major only intro to cs classes. My girlfriend had to take one and apparently 30 out of the 100 or so kids were caught cheating (with definite positives). They seem to be the most clueless that they WILL get caught by the automation.
When I ran a tutorial group for fellow students who were taking the Imperative Programming module, I can guarantee that there was no plagiarism nor cheating going on. I helped them learn coursework and each of their assignments were done by them and I only intervened if they had made a mistake. They experienced some frustration because I would not give them the solution: I had them work through it themselves and figure out their own mistake. Only one time, I was concerned that they really were considering throwing me out through the 3rd floor window.
Only after they had completed their assignments, would I show them how I would complete the same assignment.
I think a difference was that each of them really did want to learn the material but many students today taking these courses just want a job and have no personal interest in the topic.
No sig. Move along - nothing to see here.
If you are one of those who cheat in an Intro. to CS class, then chances are pretty good that you won't make it too far with your programming aspirations. Just don't complain when the college keeps taking your tuition money for the same course!
That's taken out of context. In context, it carries a clear implication of "manually examined for the specific purpose of confirming or denying plagiarism", on top of whatever manual examination takes place for the purpose of confirming or denying that the code is any good.
It should be
i<=10
or
i<11.
The professors say:
"Many of our students like to collaborate, but at what point are you copying?" Pitt asks. "The course policy needs to be really clear. Some courses will allow you to work in pairs but not in triples. If you don't follow that policy, we would call that cheating."
The industry says:
"In the real world, people write code in teams where they are given pieces of a project to work on," Foote says. "The academic world should be mapping onto the real worldThey shouldn't be handing out assignments where people are coding on their own."
Ladies and Germs:
We see here where academia isn't keeping up with industry. I can't tell you how many times I've seen where jobs descriptions demand "team players" and "the ability to work in teams".
And I'd argue that academia promotes the prima donna. Someone who was a 4.0 CS student is going to have the impression that he's better than everyone else (maybe true) and that everyone else should get out of his way and let him do it all (not good). I worked with the latter. He was a GA Tech grad and he was rather brilliant. Unfortunately, with all his smarts he was a liability to the team. He couldn't possibly do everything himself (2 million+ line project due in 6 months) and he caused a lot of problems to the point where he was slowing the others down even more.
The geniuses need to be off on their own developing - whatever - that's what we had to do with this guy. He was still miserable, though.
RIP America
July 4, 1776 - September 11, 2001
One of my lecturers decided to test our university's plagarism software as it was coming back with a unusually high number of false positives. As soon as he submitted a sample he wrote it came back positive for plagarism even though he answered a question just using the knowledge he had gained over his 20+ years experience in the industry. He and many other people in the department put hardly any weight on the results that pop up. His issue with using it is that the content of the course changes so little that with every iteration of students passing through the school its more likely to have incorrect results as its saves a copy of the submission to add to its database. I myself have had work come back as plagarised beacuse there arte only so many ways to write the same damn sentance.
Could it be that more dumb people are flocking toward higher paying careers without the slightest bit of ability. Instead of accepting the fact that they don't know where the power button on a computer is they instead turn to cheating to try to skate by.
No, it's simply the "you scratch my back and I'll scratch yours" nature of human societies at work. You are stuck on some assignment, you have three other assignments to hand in all of which look set to take up about 30% of your available time which leaves you needing more time and you can't afford to spend any more of it than absolutely necessary stuck in a quagmire. What do you do? Most students I know ask their friend who already solved the problem for advice and end up prodcuing a solution of their own that is, at least partly quite similar to their buddy's. The school authorities then let loose their new anti-plagarism software on the student's assignments and to their horror discover that **Gasp** the students "collaborate excessively". Having completely forgotten how things worked when they them selves were studying for their own degrees university staff express extreme concern at the level of "cheating" going on among modern university students. This was of course not the case when they them selves were students... how the world has changed!! I wonder what would happen if you retroactively ran this software on assignments and reports handed in by people who earned their degrees 10 and 20 years ago (some of it, things like BSc and MSc reports must still exist) ??
I remember one class, the stupid teacher would have the program posted to his website, but if you took of the CLASSName.HTML file you could get a listing of the directory, which had the completed programs for all the assignments. I had a friend in class that took the one of Teacher's program and handed it in as his own, and the teacher gave my friend a A on program, and I did it the hard way and got a B even though my program did everything that was needed. He even put a comment in the program saying he was using the teacher's code for the program. I hated the Teacher because he was never on consistent with the grades.
How does a student defend against a false positive in this environment?
If you're not looking at the code, how are you actually grading?
The same way code is checked in industry: unit testing. Unfortunately, this leads to a binary "pass/no pass" kind of grading, but at least it bears some resemblance to industry.
How can you help individual students improve their coding styles?
I can't believe I'm saying this, but computer science isn't the place to learn coding practice. Good coding style and architecture is an engineering problem, and should be taught as an engineering discipline. Not to mention, most of the instructors in CS aren't very good at it themselves, and wouldn't teach anything particularly helpful anyway.
Our big brains are deeply tied into our social matrix. Our value systems, our ethics and our morals, echo within our social system and inform our actions. Context informs values and actions. If disciplines like the hard sciences advertise their wares as facts and require students approach their studies with a "just the facts" attitude then that context will lend itself to a cut and past approach to homework that will more readily accommodate obvious borrowings from other students. If you're in an arts programme and your task is to display imagination and your core inner values in a medium and venue that accentuates individuality and creativeness then, ceteris paribus, it's more likely that context will not only encourage innovative output in homework but also encourage a more guarded attitude toward a peer borrowing your ideas. If you're a C.S. student and the world around you is rife with computer hacks and the news about those hacks inform you that you should be able to not only understand them but, possibly, be able to come up with something similar or better than to a considerable extent the ethics that inform your homework production will reflect the same ethics that inform the hacker culture.
If as educators you advertise your discipline as an empirical activity scrutinized by peer review then undergraduates just trying to fill out their curriculum with a few tasty bits for their upcoming resume are likely to think, well it's just facts, cut and paste. Let it wash out in the exams.
ideopath @ play
While it is almost certainly the case that comp sci assignments face the best algorithmic scrutiny(CS professors, shockingly enough, are probably more likely and better able than modern literature professors to subject them to such), there are similar algorithmic tools(albeit generally 3rd party contracted stuff) being used against writing assignments at many schools.
.com millionaire(or even just a workaday java monkey) dancing in your head, you'll be thinking "why do I need to know this crap about NP complete Turning machines and O complexity and stuff? I just want to write Facebook 2.0!". People smarter and/or wiser than you may well suggest that you are wrong; but you will still be tempted to cheat your way through the "irrelevant" material.
I suspect that there are other factors at work, as well. I'll put out the following conjectures(whether you would prefer to say that I "reasoned from first principles" or "pulled them out of my ass" is at you discretion):
1. Intro level courses, in all areas of study, will have higher rates of cheating than later courses. Two basic reasons: Intro level courses are much more likely to be mandated under "core curriculum" or "breadth requirements" or whatever the institution's term for the concept is. This makes them much more likely to have a substantial population of students who are deeply disinterested and/or very poorly suited to the subject. People who don't care, or who can't hack it, are the ones with the strongest motives to cheat.
2. The level of cheating, broadly speaking, will reflect how profitable the area of study is. Other than the accolades of your tiny group of peers, the rewards for being a world-renowned expert in late-middle Assyrian civic structures are basically fuck-all. If you work hard for a decade+, and get lucky, you might get a steady but not-especially lucrative tenured position, maybe a few advances from books, and that's about the best case. Therefore, only people with a genuine enthusiasm for the subject will bother to take more than "Intro to World History 101". There won't be zero cheating(putting your name on the output of your toiling grad students, for instance, is practically a best practice); but there will be less. Things like law, medicine, business, CS(more before the bubble burst than now; but still some) offer relatively good monetary rewards, and so are more likely to attract people who have comparatively little interesting the the subject and just want the diploma. You will therefore expect higher levels of cheating.
3. The level of cheating, broadly speaking, will reflect the student body's belief about "how relevant" the academic material is to the goals that they seek(this is partly covered by #2; but goes more broadly than that). If you, say, want to make it as an English professor, or in Real Serious Math, cheating is largely counterproductive. You learn to write by writing, so if you skip much of the writing, you won't know how to write at the end of the course. You gain facility in math by doing, so you won't be facile if you cheat rather than work. If, though, you are sitting through CS, with visions of being a
I suspect that Intro CS sits at the intersection of the worst of both worlds. On the one hand, since it's an intro course, you get all the people who aren't really cut out for it learning the hard way that programming isn't as easy as playing video games, even though they both involve computers, who then freak out and start cheating(either to pass at all, if they are really hopeless, or to pass without cutting into their drinking time too much). On the other hand, you have all the people who are seeking Technology riches, and don't want to hear this ivory-tower-crap, they just want to write some programs and get a job.
wrong. they may still look at the code for grading. but catching cheating is a much harder problem: in terms of complexity, grading is O(n) while verifying for similar submissions is O(n^2) or worse. also, in big classes you may have multiple TA, each grading a subset of the submissions. hence may be impossible for them to find such similarities.
weinersmith
We are arguing for arguments sake without more data. Is this "rise" based off comparisons of data that were gathered in the same fashion (I.e., computerized results vs computerized results or computer vs manual)? Either way, how do you measure the nature of success or growth? (Rhetorical) ... with the revolutionary and tangible results (I.e., transistor, vaccines, space exploration advancements, LHCs, etc).
It seems we'll reap the reflection of our values down the road when our science hopefuls have a backup career with American Idol.
L'esperienza de questa dolce vita (The experience of this sweet life) - Dante Alighieri, The Divine Comedy
How much of that would be frowned upon in the real world? If you can find an example on a web site, your manager isn't going to care if you lift it. As long as it doesn't cause a IP lawsuit. In fact, for probably 20 years since the introduction of object oriented design, the industry has preached "code reuse."
Think Deeply.
Cuz Captain Kirk showed them that cheating is not really cheating. http://en.wikipedia.org/wiki/Kobayashi_Maru
Sometimes the light at the end of the tunnel is the headlight of an oncoming train.
I'm European-trained, but working as a visiting professor in the USA. I hear a lot of people here throw out the "sense of entitlement" phrase, and it's almost always when talking of today's students.
Based on my experiences here and in Europe, I don't think that they exhibit that at all. Most of the students I work with put forth much effort, and don't expect anything other than to be taught the material properly, helped when needed, and graded fairly.
The only people I see with a "sense of entitlement" are the Boomers (I think that's the American term for people who are 50 to 65), and Indian students.
The Boomers always have the most absurd expectations, from getting the best parking spaces (even though they've been at the college for less time than even I have) to getting college-funded coffee makers in their offices to getting raises several times a year, while also getting more vacation time. The unionized folks are by far the worst. Even though some of them are merely janitors, with no special training or education beyond high school, they expect a wage and benefits in excess of those that we get as professors.
The Indians, and by Indians I mean the children of wealthy upper-class families in India, are perhaps the worst. Back in India they got everything and anything they wanted, I suppose. And they were used to treating others as being "lesser", due to their social classes. They bring this with them to America when they come to study here.
I see a whole bunch of people posting the most basic "for loop"
If this is your opinion of what CS is, and thats all there is to cheat on, then are you ever way off base. Although I grew up a "basement coder", I was pleasantly surprised that my university education consisted, in addition to the top three (programming, networking, databases), philosophy of pirating, algorithm analysis, history of databases, research into certain figures (Alan Turing, among others), future of AI, etc. I still see many areas for potential misconduct.
It's not about basic flow control.
Hi, I Boris. Hear fix bear, yes?
Lack of talent, this is a profession that can be taught but unless there is a underlying talent and real interest in it the student will not succeed. The best programmers and system administrators are born with the genetic makeup and thinking patterns required to succeed in this field.
Got Code?
The many examples here of array declarations or variable initializations are not sufficient to get you pegged as a cheater. But when you get multi-line programs of dozens of lines that are precisely the same, even including comments, THAT will ring alarm bells. I don't think anyone writing a simple 'Hello, world' program that is exactly like mine will get called out. If you turn in a hundred line program full of regression equations to plot the Fry Readability Index in a matrix graph that is precisely like mine? Busted!
How about a moderation of -1 pedantic.
One of the greater contrasts between work and college.
At work, you're expected to do all the things they consider wrong. If you can save time by finding the solution online, or delegating the task to someone else, than that just gives you more time to work on the things that haven't already been solved.
In fact if the first thing you do when you have a problem ISN'T googling the problem online to see if there's already a solution, than I'd have to seriously question your skills.
After all, the whole point of programming is to make life easier. Not over complicate it.
I definitely owe at least half my degree to my people skills, rather than to my academic ones.
So, back in the 'day (1989 or so), I was grading for the first data structures course for computer science majors, and wrote a very simple program that stripped comments out of programs and then counted the number of semi-colons, colons, parentheses and so in in each program's source code, then sorted them. When two programs were sufficiently close, I compared them side-by-side and came up with more obvious cheaters than I was expecting. (Including one from two roommates who happened to be alphabetically next to each other.) If those programs have advanced *at all* in 20 years, they're now comparing parse-trees.
The problem is that computer programs have structure, and it's impossible to copy somebody else's work and then 'only' replace the underlying structure. Instead, cheaters reorder their code, add a bunch of comments, rename variables, change indentation and so on. That sort of thing doesn't change the structure, so it's easy to catch.
And, yes, this method only works on sufficiently large programs -- there are only a handful of ways of doing "Hello World." But, nobody cheats on "Hello World."
This is not the first time I have seen this article on /. but hope it is the last. As others have pointed out, CS students cheat for the same reasons that every other student cheats. It just makes sense that CS professors have better tools and arguably better material (quickly searchable and compartmentalized source code) for which to catch cheaters.
When I was a CS student in the introductory classes, I had a lot of prior programming experience. I had a few peers who wanted to work together on projects (more-or-less do our own work, but they needed more hand-holding than was given by the instructor.) Simply by helping debug their code or explain "how-and-why" I tackled a problem in a specific way naturally caused their work be conceptually like mine. Even discussing the problem colored their solution toward my implementation.
It didn't help that the instructors self-written textbook was for Turbo C++ and we were the first class to switch to Visual C++ either.
What I found disturbing was how many students could pass CS 101 (with A's even) with rote memorization of the instructors programs and samples. They had no clue what was going on but could regurgitate what the instructor had used in their examples and do well (at least for a while). Students with experience (e.g. me) had issues because we used OOP or stdio, or Hungarian notation when the instructor was looking for iostreams and was hell-bent on variables 8 characters or less with no capitals.
Forgive my spelling from time to time. I'm often posting during short breaks.
I could swear they did this same article about 3 months ago on here. And yes im to lazy to search for it.
This was my biggest frustration in college CS. We got zero feedback on our code - you got a numerical grade, and that was it, most of the time. Rarely, you got back a categorical breakdown of that number (the points for 'correctness', 'comments', etc), and only a handful of times in the entire major did I actually get back comments (usually a relatively useless one-liner, such as "good comments", or my favorite, "this is so almost wrong, but not"). Then, as since, I've relied on my highschool experience for external suggestions and feedback - my highschool CS teacher went through and marked up every assignment turned in, giving you huge amounts of feedback on your coding practices. College CS was a huge waste on that front, which was a major dissappointment.
In my algorithms class, the code is submitted online and run through a bevvy of JUnit tests that we don't have access to, automatically graded using a custom framework assigning each test a point value, and logged in a database. They do spot-check certain people that they're curious about, outliers, and anything flagged by the cheat program.
In the TA-run programming labs of about 15 people, they do look at coding style - but they're more of the opinion that if it works and doesn't look like Perl, it's fine.
In any case, try implementing A* with a poor coding style and then debugging a problem. You learn really fast how to code properly.
I have developed a truly marvelous proof of this comment, which this signature is too narrow to contain.
"...thanks to automated tools that professors use to detect unauthorized code reuse, excessive collaboration and other forbidden ways of completing homework assignments."
Anyone working in industry who wants to reinvent the wheel every time they write code is a damned fool. Is it not the goal of a good programmer to write code that can be easily reused, and to work well as a team? These students are just practicing a workflow that reflects reality. If I were teaching a CS class, I would give points to students for reusing code and for collaborating, provided they could explain what each section of code did.
Comment removed based on user account deletion
A few years ago I was a computer science TA at UW and have used the above mentioned tools to detect plagirism. Replacing variable names and rearranging your methods doesn't help, because the tool builds abstract syntax trees (similar to what a compiler does) and compares portions of the subtrees to each other. When I TAed the Operating Systems course, we had one incidence of cheating on the first project. There were two students whose code was reported to have a 98% match, and it was blatantly obvious that they cheated - their submissions had different variable and function names, and the functions were rearranged, but otherwise their code was exactly the same - to the point of making the same mistakes in the same places. Nobody else's submissions had a match above 50%. And the submissions that did have matches in the 40-50% range were all in the "obvious" parts of the code - i.e. there are only so many ways to write a loop which prints the contents of an array, etc - so they were identified as false positives by manual examination.
After they were caught cheating and were given the option to be reported to the Dean for plagirism or drop the class (they dropped the class), nobody else cheated (or at least, got caught cheating) for the rest of the quarter.
6 Years ago, when I took my first college course in Java, my professor automated the checking of application output. We'd have a few hundred lines of output and if even one of them was off you started losing a point per line. So if you coded in extra whitespace output in your application you could receive a negative score. I couldn't deal with this guy after a few more courses where in one situation I received a -546 score that he was unwilling to review.
Now I'm a CCNA...
Makes me wonder though who is writing these automated checkers. How good are they at coding?
This is very much correct. When you have 40+ assignments to grade it's not always easy to remember "Hey paper #37 looks a lot like #2". Likewise extremely large classes with multiple TA's means it's hard for one TA to catch someone that cheated off a student being graded by a different TA.
Programming assignments are very time-consuming, especially if you are unfamiliar with the language. Much more so than any other subject I took in college.
I was a computer lab assistant, and there was a very easy way to deal with this problem: if you see 2 or more similar programs, ask each of the students to explain how the program works. Typically, only the original author can explain why everything was done that way. If somebody can't explain how and why the program they submitted functions, then they deserve an F.
I've abandoned my search for truth; now I'm just looking for some useful delusions.
Georgia Tech has had cheat-finders since at-least 2001 (some reports suggest 1997) I was at Tech in 2001 and almost 200 students were accused of cheating in the Introductory course. Some of them were acquitted but most pleaded guilty and dropped 1-2 letter grades.These tools are used to compare chunks of code between 2 submissions and check for strong correlations. Also the cheat-finders were not executed on trivial assignments.
Isn't this mentality sort of anti-agile / anti-peer-programming? I would think it would be encouraged since a large portion of the industry is moving in that direction? I remember being accused of cheating in an EE class because my lab partner (my roommate) and me had the same graph stapled to our assignments. The reality is that we sat in front of a laptop in the living room assembling the data together... which, to this day, I do not consider cheating.
Maybe not with simple problems, but for more complex ones, where code similarities would become suspect, I would not consider it cheating if student collaborate on the solution. This is how things work in the real world. At least it is how they should work. Students who study together and solve problems together are much more likely to come away from the exercise with a good understanding of the course work, as well as valuable real-world people skills.
Well, back when I was in university they didn't use these newfangled tools, or at least didn't advertise it, but I've seen an uncanny example of that in an exam.
There were these two people who... well, what they handed in, looked _identical_. Not only the same program, but same indenting, same variable names, heck, same line breaks in their text part. Cheating in an exam doesn't come any clearer than this, right? They must have copied from each other, right? Well, the professor thought the same too. Wanted to flunk both of them.
The problem is that these two guys had sat in the diagonally opposite corners of the room. They had been as far apart from each other as you can physically get within the constraints of the given space. Took a while to convince the professor of that, and I must say, seeing the sheets of paper side by side was enough to not just make the professor's point, but almost make me question my memory too.
A polar bear is a cartesian bear after a coordinate transform.
I don't know whether their statistics are correct or not, but computer science is one of those areas where cheating only hurts the cheater. If these people are taking it as an elective, who gives a shit? The only people this should be of concern is to people looking at it as a career option. If you're in it for the long haul and you cheat your way through, then on the other side you're going to be fucked because people will realize you don't know anything. My feeling has always been that schools shouldn't really concern themselves with cheating. The good students will want to learn the material and the bad students will look for shortcuts; this is true from elementary school on up through college. Hell, this applies to life in general. These people are adults and have to start taking responsibility for their actions. If they want to cheat their way through school, I say let them; they're the ones who will end up suffering in the end. Alternatively, life has proven again and again that assholes more often than not rise to the top; why should school be any different? Bottom line is that it doesn't matter; people never hold assholes accountable for their actions and so they will continue to be assholes. Such is life.
The truth of the matter is most people enrolling in CS these days aren't the same type of people who used to enroll. I enrolled and didn't goto class because I was actually INTERESTED in programming and was WAY beyond what they were teaching. As a result I got A+s in the class without studying at all.
The kind of people enrolling these days don't know a damn thing, entered because they heard programmers make money, and generally suck. I've seen these kinds of students before. They cheat and get away with it MOST of the time which ruins it for those of us who actually do their own work. At first I did't care since I was always getting A+s but in advanced courses like computer vision I would get a B and those asshat cheaters would get As and A+s since they submitted stolen material.
I absolutely hate CS cheaters.
"Anecdotally, we see a larger incidence of cheating among foreign students then domestic students, and I think part of that is that they are under extreme pressure to do well and succeed," Pitt says. "That pressure contributes to the idea that they need to do as well as possible even if it means taking some shortcuts."
From my experience in the 90s, there was always massive cheating among foreign students.
Why do you think testing "less than 11" would be more efficient than testing "less than or equal to 10"?
Many cpus (even risc ones like MIPS and ARM) have explicit instructions for testing "less than or equal to".
And where did THEY get the code to look for cheaters? Probably plagiarized!
I caught in numerous occasions that student copied code from others, in some cases they bother to change the variable names, some change indentation, and others without even bother to change the header (name, student ID).
Most people in a teaching role have office hours. Why didn't you go talk to them about what should have been done differently?
I don't want to burst your bubble guys, but most programs (biology, physics, liberal arts, etc.) require their students to take 1 (one) introductory course in computer science. Most students in these "introductory" classes are not even taking computer science... and since they suck at it, the incentive for them to cheat is greater.
The person who wrote the article hasn't pushed his reasoning far enough.
Me and a friend had taken a class on operating systems and gotten very good grades in it, especially the project, so we were invited to become graders for next semester. We accepted.
So one night we're grading a project, and my friend comes over and asks me "Hey, doesn't this look a bit familiar?".
Turns out a group had managed to get their hands on OUR code (it was a group of 5, and now we know who probably leaked it out) and plagarized it line for line. I am not sure if that class had automated plagarization checking, but if not, only we would have caught this since, well, we wrote that code.
Seriously? The exact same article, word-for-word, has been published before. Now let me go find it...
Reusing open Source or free software code snippets is the hallmark of modern coding. Is it plagiarism to re-use something that is meant to be re-used and for which the author asserts no proprietary right?
It seems like there needs to be a new standard here.
Yes, they'll catch the obvious cheaters. They'll also catch a lot of honest people. When I was an undergrad, there were class requirements for formatting, and quite a few of us knew about "indent". So spacing and indentation would be the same. Variable names tended to be the standard i,j,k which the texts used, along with the ever-popular "answer", "sum", "result", etc. And even the some of the errors people make are pretty common -- fencepost errors, for instance. So I think you're going to catch three classes of people
1) Stupid cheaters (who copy obviously wrong programs which don't even compile)
2) Smarter cheaters (who copy perfectly good programs and change the identifying information)
3) Honest people who know what they are doing (who write programs similar to each other).
I don't see any way an automated system (or a human, even) could distinguish between 2) and 3) just by looking at the code.
Good coding style and architecture is an engineering problem, and should be taught as an engineering discipline.
Why?
The engineers don't care, so long as the code works. The structuring of the code is a CS problem. The code monkeys can worry about that. The engineers only care that the math works.
> It's the easy assignments where that might be tempting--they're so mind-numbingnly dull.
Compilers! Supposedly one of the hardest courses in the department, it was boring and wrote and no more than long lines of code implemeting a particular compiler with nearly no room for creativity. We even had to remove some of the only cool stuff we did on the project--where by cool I mean insane and kind of awesome--like dynamically rewriting class instance pointers. It was wonderful, but of course it made the code helpelessly compiler-defendant. So we were drones.
Yes, it's not what you'd call robust code, but we weren't going for robust code. We just wanted to write fun code that happened to do what the assignment was.
-- IANAL, this isn't legal advice, and definitely isn't legal advice for you. Also, Squee!
In English or History, you can submit an essay full of BS and expect to get a passing mark. In Programming 101, you are out of luck if your program doesn't work.
You will submit an English essay and not know that it is BS and won't pass. In Programming 101, it is painfully obvious that your program doesn't work and you won't pass. The desperation factor for programming is higher than just about any other course I can think of. If you copy someone else's code, you might not be caught. It's worth a try. If they catch you, you flunk the course but you were going to fail anyway.
I've seen this exact same article, at least parts of it word-for-word, around before... no joke.
As the summary mentions, every field has cheaters, and there probably aren't tremendous differences in percentages between them. It makes sense evolutionarily, since it's beneficial to be a stealthy cheater. I've observed it personally at all stages of my academic career, and while it's more shocking at higher levels, I don't think the prevalence is decreasing.
I don't understand the mentality, but apparently some people just don't see a problem with academic dishonesty. The only justification that I have heard is that "everybody" [uses stolen tests / steals lunches / copies assignments / lies about credentials / "pirates" audio lectures, textbooks, and software / etc.]. It's sickening, but this trend continues even into professional careers.
Why redo the computation when you can utilize the Cache? I thought that's the we should do things in CS.
Please catch all of these sucky programmers before they graduate, my company hires them, and I have to work with them. Make them change their majors early to philosophy, animal husbandry, underwater basketweaving, or anything else. Especially, weed out the diligent and responsible types that have no knack for solving technical and logical problems. They can become project managers, which is also a high-paying job.
I remember when programming was a calling, not just a career. Those were better days.
The freshman and especially sophomore level courses I took were far and away the most difficult. They also caused me to pursue a minor in C.S. as opposed to majoring.
This includes curriculum requirements where grading on the curve meant scoring 40 on a test was an A. Yes, I'm staring at you sophomore physics. After my sophomore year, I didn't know up from down.
Challenging coursework should still be engaging and stoke a young mind. Unfortunately, mine was more of the demoralizing kind.
Posting to undo incorrect moderation.
Whereas when I taught, every single one of the 600+ student's submissions were hand marked for style (as well as machine marked for "gives the right answers to the hidden tests").
Of course style was pretty damn simple - use a loop instead of copy pasting the same line 20 times, actually use functions and not one large main(), use sane variable names. Could probably have been mostly covered with some lint variant, though feedback from a person marking is useful in itself.
No one is saying that almost every major makes "Intro to computing" compulsory now. Why is it that we are surprised? The more you require people that aren't interested, the more they'll cheat. The more widely compulsory you make these courses, the more dumbed-down they are; the kids that are good are going to be lazy on purpose. Why not? Finally, you have tools to check that your History prof doesn't. Three very compelling reasons why there would be more cheating, not even taking into account the ease at which it is done. Yet, when these same kids get out in the real world, we call them EXAMPLES and REPURPOSING, and we tell them to COPY things out of books and sites that are KNOWN TO WORK. In reality, there's not enough cheating going on.
When you're grading a large number of students you may not notice duplicated code unless you happen to go over the duplicates relatively close to each other. Furthermore, in the classes I TAed we had multiple TAs, and we would split the students amongst us. So even if two students' assignments were identical we still wouldn't necessarily notice, as different TAs might be looking at each one. Automated tools help even when you're already going over all the code manually.
~Herms
print "$_\n" for 1 .. 10;
My teacher in "Introduction to programming, VB6.0" just required us to turn in the apps compiled to .exe files so he could just run those to verify that they worked.
Oh god how much fun we had. "someone" *cough* wrote a little thing into their turned in work that installed a coo-coo clock.
A piece of code that would, every whole hour, go "coo coo" and open/close the cd-rom...
He did not figure out where it came from *cackles*
I knew I didn't want to be a programmer a week into my IT degree, so when I had to take an intro to C++ I paid a friend $5 for the homework, changed a few terms, then resold it to someone else for $10.
I have a big problem hiring anyone who ever cheated on anything anywhere. Cheating on a test, padding an expense account, driving with a radar detector in the car; they all indicate lack of integrity. I need to be able to trust my co-workers.
Therefore, I'm doubly horrified to contemplate the possibility of false positives. It is very hard to reconcile harsh treatment of cheaters, with the possibility of some being falsely accused without adequate opportunity to defend themselves.
OK, TFS is saying this is an introductory comp sci class, so maybe I'm giving the students too much credit. There is value in learning to walk before you can learn to run, but...
I personally would probably give extra-credit to such students. Researching the problem, finding an "open source" solution to the problem and writing modular code that can reuse already existing code is a big plus in The Real World (tm). One of the best pieces of professional advice I ever received was from a senior sys admin when I was but a wee green jr. sys admin: "Laziness is a virtue for a sys admin. Don't reinvent the wheel, and build things to be robust so you can do fun, new things rather than spend all of your time maintaining the things you have already built."
MCSE? No, sir...I don't do Windows. Yes, I am an idealist. What's your point?
Cheating is usually easy to spot. Because not only do they use the same algorithms and the same sequence of code, but also the same spacing. For example:
x = x +1;
printf(" %d", x);
Notice no space between +1, and 2 spaces between " , x". When you see this combined with the same essential algorithms. A high degree of similarity in the strings and in the comments.. the user has copied the code.
Most students don't do a great job of covering it up.
The article also mentions foreign students as being more likely to cheat. Note that cheating is fairly commonplace in high schools and even in Universities in many countries. Not all countries penalize students very harshly when caught. In some cases they only get points deducted or get an F in the assignment. So a culture of cheating emerges.
(I know.. I'm an instructor in South America.. :) )
That's why you use a token analyzer. You think CS profs do this BY HAND? They run all their students' source through a token analyzer looking for matching chunks. It's not hard.
With the first link, the chain is forged.
I remember well an analysis of algorithms course I took around 1981. I also took the advanced graduate version of that course, from the same professor, in 1982.
In the undergraduate course, much of the the work dealt with sequences, series, mathematical proofs, and, yes, analyzing algorithms in "big-O" notation (which required competence in the former).
We were told up front that half the class would either drop out or fail. The professor would not accept assignments handed in late (even five minutes), and assign an automatic zero. We could collaborate on homework, but, if (say) three of us collaborated (and secret collaboration was likely to be detected given the nature of the assignments), we were expected to provide three novel proofs, implementations, etc.
The course text was Donald Knuth's "The Art of Computer Programming". As I recall, much of the coursework for the undergraduate course was drawn from "Fundamental Algorithms" and "Seminumerical Algorithms" and the graduate course from "Sorting And Searching" (volumes 1 and 2, and 3, respectively), though there was some overlap.
All this was disclosed early enough in the semester for students to reconsider another course.
This particular professor was taken to making intentional errors in presenting the material, and berate students who did not catch them and speak up. Of course, pointing out an error that wasn't would be worse. Assignments in the graduate equivalent of this course always contained an unsolved problem in the field.
We learned to study and analyze algorithms as if our very lives depended on it.
This was not a required course for the Honours program. (Canadian Universities of the time typically had several specializations for undergraduate degree programs, and "Honours" was a particularly inclusive and difficult specialization among all the others -- basically, "all the other work and then some". One was also required to maintain an 80 or better course average over three years: the equivalent of being able to graduate "with honors" in other programs, either magna cum laude or summa cum laude. So to graduate "in Honours" meant you automatically graduated with honors.)
But, a handful of us were real masochists for which a 4.0 GPA alone was not enough to distinguish ourselves. (Crap, you could get that in the much maligned "business" major.)
I submit one does not see this "love of the art" anymore.
In Liberty, Rene
Back in the day when I did my Computer Science degree, (around 60 students, small department) there was a eastern european girl that was notorious for copying stuff. By the end of my first year, her new nickname was CopyMe.pas (first year code was done mainly in Turbo Pascal) given to her by me which stuck around till she left. I wonder if she graduated.
Tired of my customary (Score:1)
When I was working on my mechanical engineering degree I was required to take the intro CS class as opposed to my department having our own programming class. We did everything in C++ and I have not written a single line of C++ since I completed the class, in fact I haven't written anything more complicated then some simple Excel macros. I didn't personaly cheat in the CS class but I know at the small school that I went to there were more mechanincal eningeers in my class then CS majors.
I cheat all the time. I rework my old code. I steal code from the internet and copy and paste it into stuff I'm writing, sometimes only changing the comments, variable names and a few other tweaks to make it work in my infrastructure. I've reworked entire applications, morphing them to my purposes. Admittedly, they're unrecognizable by the time I'm done, but is that cheating?
Please do not read this sig. Thank you.
I didn't really think this was cheating, at least in the programming classes I am in/have taken the teachers encouraged using code databases and asking the TA or other students to give input on your code, as long as in the end you made the computer/microcontroller etc do what they asked then you got points for the assignment...
I have been a lab instructor for 5 years in my universities two first year comp sci classes. We submit more than 15-20 people each term to academic dishonesty. Classes usually range in size of 100-150 in first year.
We have had some odd cases of cheating. Sparing the details, some people are very creative in how they will obtain students work. The problem is they often 100% copy if and assume nobody will notice. I had one student who was cheating, somehow he stole a students assignment (the guy walked away from his PC unlocked) but did not bother to change the name at the top of each source code file the original student used. The ultimate of laziness I suppose.
The system is not stupid and the system simply flags papers and then a human analyzes the results. Don't be stupid and assume the professors think everyone should have a unique answer every time. Human analysis is always the next step after the machine says "This paper is X percent like another."
LOL, it's funny how you missed his point, and think you're smarter!
. . . by a few years, perhaps a few millennia. There have been similar tools used by English departments for over a decade. It might just be that the CS departments are better funded or get more press. It would be easier to spot plagiarism in a thesis than a code base, as originality often trumps concise prose in written works bound for humans.
Linus Torvalds was once accused of copying Andy Tanenbaum's MINIX to create Linux, a charge that both Linus and Andy deny. Many open source programmers have told me that it is 'easy' to refactor code without copying it. Everything from changing the naming conventions, dependencies, source ordering, and logic (e.g., a do-while instead of a for loop) are so obvious that I am sure someone has written a program to automate the process.
Isn't the point of shorthand to reduce the number of characters?
"c/p-ing" and "copying" have exactly the same number of characters, with the latter being easier to ready, so why shorten it with a just-as-long 'shorthand' version?
It's only an anecdote, but...
The first–and only–time I have ever plagiarized was for a project in the fifth grade. We were doing a project using the HyperCard clone HyperStudio, and instead of spending my time understanding the material, I copied a bunch of encyclopedia articles, substituted in some synonyms, changed some word order, pasted the resulting text into the project, then spent most of my time finding sound clips. Basically, I viewed the project more as a technology demonstration than an actual academic exercise. I'm not sure that it ever crossed my mind that I was doing something I should not have done.
Needless to say, my teacher was not amused. He informed me (correctly) that this sort of thing would have gotten me in serious trouble if I had done this the next year. The idea of cheating in my favor has never received consideration since then, and I would rather fail silently than turn in something in dishonesty; the experience was just that traumatizing. Of course, I respected the man, so disappointing him was much more likely to have had an effect on me.
Although our academic environments (ideally) attempt to convey the fact that cheating is wrong, the sad reality is that it happens all the time in the real world, and people who are able to lie, cheat, and steal yet get away with it are celebrated and envied, so people who are less gifted at the lie-cheat-steal game will doubtlessly try to duplicate these efforts with varying amounts of success.
My guess is that most teachers at the junior high / middle school level aren't detecting plagiarism at anywhere near the frequency with which it happens. Probably because they don't get paid enough to put up with teaching children of that age.
Meh, I'm just going to end up ranting aimlessly. I was not a typical student, so I should not expect that those things which worked for me will work for others.
It has always bothered me why CS assignments in some classes are so strangely off from what is supposedly being learned. Often there is some trick and the solution can be found only by not being deceived by the weaselly wording of the assignment, nor by being misled by the current subject matter in the class.
If you are already a successful programmer, these CS projects seem especially surreal given that "cheating" is the label given for all those things you would do in real life to learn and solve, including collaboration and seeking example code.
As an assignment in a computer ethics class I gave a talk on how the internet was going to bring college level CS education, especially self-education, to global masses. (Some universities even put their class materials online and available to everyone.) The idea was that once these useful information and materials got out there, they become part of a more advanced world culture.
During Q and A the teacher criticized that I didn't account for how hard it was to come up with new problems year after year to test and grade CS students, and that putting everything online made this only more difficult. The teacher was actually advocating holding information back to make it easier to rate students.
I answered by saying that there are two competing motivations for teaching methods in university classes: one is to enlighten, feed and grow minds, especially all the minds that paid through the nose for the service; the other was to "weed out," and to grade--like putting the class into a series of sifting screens--the course objects getting removed first and labeled low grade, and the finest ones coming out the end and getting labeled "academic excellence." I asked how much the former was to be sacrificed for the latter.
Didn't finish that class.
I say let 'em cheat on assignments/homework, and assign no grades to such work. Have all of the student's grade come from quizzes/tests.
If they cheat on their assignments/homework, they'll fail the quizzes and tests 'cause they didn't learn anything. If they don't cheat, they'll do good on the quizzes and tests.
Seems like 2 reasonable outcomes. Problem solved.
-Tony
As the article notes, there does not seem to be any reason to think that CS courses have more cheaters than other courses--just that more get caught. The article cites 1-2% cheaters in CS classes. When I teach lower level philosophy classes, I have the papers get handed in through turnitin.com. Result: About 2% of my students are found cheating. How many cheat and don't get caught, I don't know. It's really frustrating, because there is a lot of work with each case, and one wonders why someone would bother to lift a few sentences from a website when they're going to be uploading their paper to a plagiarism-checking service.
Anecdotally, it seems to be a bit worse in the classes where I have poorer rapport with the students.
In many places, the code is graded via automatic testing routines. The reason for this is that many big coding houses use automatic unit tests on their OWN code, so learning how to deal with automated testing helps you in the real world.
Why would you bother grading it by hand? If you're building a program that does anything other than "Hello World" complete testing is non-trivial.
Can you imagine hand grading and checking for cheating, when you're dealing with 1,200 submissions? For one class? That's not uncommon at big schools.
ad logicam Claiming a proposition is false because it was presented as the conclusion of a fallacious argument.
that even shittier programmers infect the already shitty pool?
course work should be designed to test if a student understands the material, not if they are memorized (or copied) code. if a student turns in a complex program but can't explain how or why it works then it doesn't matter if they copied it or not they should fail.
i chock this up to lazy professors. it's oh-so easy to ask students to turn in a compiled program + the source code. the professors then just needs to run the program and see if it gets the right output, and churn the source through their favorite plagiarism checker. all of that can be scripted so they probably don't need to do anything at all to get the papers graded.
I must work with a very different sort of engineer than you.
print *,(i,i=1,10)
Props to who can figure out which language that is ;)
1) Cheating is easy. Copy, Paste, Done.
2) When you start programming, it's hard. After a while things start to click, you understand how to use a loop to iterate through a list, you get how function calls work, why you should avoid side-effects and how powerful recursion can be in the right circumstances. Until you get to that point you feel surrounded by people who are talking gibberish and seem to be able to pull solutions out of the air (because they've been introduced to programming before).
3) On top of this you're having to use new tools which you've never seen before. Whether it's a unix shell or an MS Visual IDE it's a very complex piece of software with many options you don't understand the meaning of. If at any point you deviate from the tutorial you've been given then all hope is lost and you're stuck and confused with a very powerful tool that you have no clue how to use.
4) Half the class has done it all before. Basic programming is something that many students will have tried in their own time because they like it. They've already put in the hours with online tutorials or books and have learned how to break down a conceptual solution into something that's realisable with the tools their programming language gives them. Teachers rush through all this basic material in a bored voice without giving enough examples or explaining things in a way that someone who has no clue about programming can understand.
It's no wonder that students without any programming background who are finding the "introductory" courses hard are tempted to cheat. (Not that cheating will help them in the least. The skills required to do well in introductory programming are vital to most of the rest of the course.)
I wish to remain anomalous
What I've noticed is that a large percentage (50-60%) of students aren't really into computers(programming, hardware, or engineering), they just like playing computer games and think they can get by with that [Hmm, what should I do for a living, I really like computer games, maybe I can do something with them]. Then when they start getting into the real subject matter they just can't cut the work/understand the technology and panic. And don't give them that much credit, some of them can't even figure out how to change their names in a file.
A real entrance exam for these programs should ask the very simple questions: Have you ever built your own computer? Have you ever created your own webpage(facebook/myspace/"the like" don't count)? Do you know why "Hello World" is a joke?
Simple questions but I find that those people who have taken the initiative and gone out and learned on their own tend to make far more competent and worthy programmers, techs, admins and the like.
For what it's worth.
you seem to not understand that the cheating check is done by a computer. O(n^2) (wherever you got that arbitrary function, real cheating detection isn't so simple. . .) is done BY A COMPUTER. I don't know about you, but searching is fast, comparing is fast, and CS departments have available power that can be used during off peak hours.
So yeah, grading takes time, but you imply that it takes the same amount of time O(1) for a TA to grade a program as it takes a computer to compare it to another for similarities. no. wrong. fail.
I took a CS course some time ago in C. The instructor told us that it was perfectly okay to get help from another student on the assignment, because of how he constructed the exams: He would give you one additional feature to add to the program in class, and you had until the end of class to complete it. That way he would know if you really knew what you were doing, or whether you really copied someone else's work.
I helped another student with some of the assignments, including the last one. I knew what I was doing, they didn't. I went to check my grades a couple of weeks after the end of the semester, and there was a notification to come into the departmental office. It seems that the final assignment I turned in was very similar to another student's. My implementation of the final project was clean and quick, and adding the final feature took all of about 5 minutes. I said that the other student had cheated off of me, and I knew what I was doing: they didn't. Unfortunately, the other student had left town, already having a BS from another university (not in CS). This was a community college. The teacher himself never confronted me or made any comments that what was going on wasn't okay. In fact, he had specifically stated in class that it was okay, but the department chair said that he was 'on vacation, so unavailable'. I was furious, and fought it, but lost. I got an F on the final project, and my grade in the class was lowered an additional letter. It's been more than 10 years, and it still makes my blood boil.
I was talking to a friend who still lives in the same town recently and he told me that he has now heard this story 7 times from 7 different people who all had the same thing happen: no comments were made during the semester, and so while the teacher was on summer break, they had cheating charges leveled against them. It was the same teacher. His name is Scott Badman. He taught at Parkland Community College in Champaign, IL, and I think he's now finally retired.
So, did I cheat?
This strikes a chord with me. I program training software - modest stuff - and recently have gotten into more detailed user tracking. Every click a user makes is a web service call whose return value is required for the program to continue (without notifying the user). Previously, I would say our audience was used to software without an Internet component. They watched material and took a test. The PDF printout was the proof of use.
We get calls saying "the computer ate my homework." This can only be true for one transaction, but varying claims are made which don't agree with reality. I'm asked to inveigh in some circumstances, and it's hard to say "they're lying." Can I unequivically state (and logically convey) that they're wrong? Do I know every possible path of the program? I feel that I do, but I've had genuine glitches in the past.
"There's a lot of infrastructure that needs to be built and a lot of effort that goes into creating a homework problem. There's a disincentive for professors to change those problems every semester. So we tend to reassign similar problems, and that causes cheating because past solutions are available," Pitt says, adding that the University of Illinois checks homework against a repository of past solutions.
So the profs are lazy and don't want to make new assignments and re-use old ones. Slightly hypocritical to then penalize lazy students that do basically the same thing. If a prof can't be bothered to show an interest in the subject material and come up with new and creative ways of getting the ideas across, why should the students be expected to perform any differently?
The CS assignments I was given in University were never 'very' simple. The first assignment in JAVA was to simulate an x team football league, each team playing every other twice and randomly determining match scores, printing match results and final league table. The C and VB assignments were of similar complexity. It's very implausible that two people could write very similar programs, in face, exponentially more unlikely with each additional line of code. In relation to collaboration as cheating, as a teacher teaching CS at A-level (16-18 year-olds), I would absolutely love to do a big real collaborative project: break the students down into teams, assign roles, distribute modules, whatever, but it's not a good idea for several reasons: 1. Assigning roles. How do you divide responsibility equally to be fair, motivate the weak and strong students, and ensure that a project will actually produce some results? 2. Marking: how do you really know who did what? Has a weak student just rode on the backs of others? They might cover for him, they might not. There's no way to tell, and examiners don't like that. 3. Different ability and demotivation: if you're working with someone who can't write code and is destined to fail, how would you feel about your project? Yes your audio module might be perfect, but if you had nothing functional to plug it into you'd still be unhappy. There's more of course, but the idea of teaching students how to program (and at the same time how to manage a project) almost forces them to work individually. The best I can do is teach them how to write efficient, maintainable code and hope that they end up working with others who can do the same.
This comment is intentionally left blank.
So how do you suggest we check student's coding ability? Assign every one of the thousands of students a new, unique task?
Actually, that seems like a really good idea. You can have variants of a project that differ enough to make copying not practical. If you had a hundred or so different ones it would be more than enough to vary for every student, for at least a few generations of students before you had to repeat.
I used to be a CS lab assistant in college, helping out CS students with class work. I would not have had a problem helping people with a variety of different projects. Grading would be a little harder but not really, because you can easily tell the difference between stuff that is not working, only just works, works well, and guys that went way beyond the scope of the assignment just for fun.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Why are people enrolling in comp sci? they should have a grizzled veteran try to scare them off before they enroll, it's only humane.
This is a joke. I am joking. Joke joke joke.
So as usual, this is blowing one aspect out of proportion to make headlines and virtually ignoring other issues. Working in groups to answer homework questions is at best a yawner... especially when these very same kids pass their exams gloriously. Who gives a feathery, how you do your homework as long as you grasp the material, and can demonstrate mastery of the subject. At this particular level, as long as you are actually doing the homework and can so demonstrate by passing tests both written and oral, then who cares if they working in a 20 person study group.
In point of fact, the real concern is ethics and instilling a rich and lasting sense of personal integrity. This is so important (and from the article, it's clear the problem is just as bad or even worse in other disciplines), that a significant ground-work of ethics and personal integrity should be a required part of every discipline taught in our colleges today. Rather than teaching kids that cheating is bad for some vague ideological reason (or equally impotent for some religious reason), it should be made abundantly clear that integrity immediately equates to workability. That the lack of honesty, communication, discipline, forthrightness, compassion, and integrity, is directly responsible for the greatest and least problems facing humanity today, and that bringing ethical rigor to one's day to day practices (scholastic or professional), provides a foundation upon which one can build a future worth celebrating. Teach students not to cheat. Have them confront the schools' presumptions and regulations based in false presumptions, but have them aware that the world demands a high level of performance and that performance is ultimately built on integrity. A breach in integrity may provide short-term gain, but it invariably costs more in the long run.
This should be especially important to this crowd. These are the future professionals who will either honor Open Source Licenses or in the name of short term expedience, claim copyrighted code as their own, and try to stonewall legal IP holders through courtroom maneuvering. Big business has been ripping off inventors for a very long time (Flash of Genius) and we need only look at our current economic woes to see the depth and breadth of the ethical crisis facing our nation. We either do a better job teaching our children, or we face a dark and frightening future indeed.
"It'd be as if you told your kid to paint a room that had just been painted last week so that he'd learn how to do it, but instead he paid a guy down the street to do it for him."
Sounds like an A to me. Oh wait, this isn't Business 101?
My first Journal Entry ever, in 8 years! http://slashdot.org/journal/365947/aphelion-scifi-fantasy-horror-poetry-webzine
Student cheats way through college CS courses. Then cheats way into getting first software development job. Soon after that, colleagues discover he can't code worth a damn, but but bullshits with the bosses, gets promoted into management. Company pays for evening/weekend MBA program. Repeat cheating exercise, complete MBA. Get promoted to CIO.
Run and catch, run and catch, the lamb is caught in the blackberry patch.
I'm paying £3,000 a year for this degree! I don't expect to be told to read something in a book!
I am TheRaven on Soylent News
Leaving aside the usual nonsense that kids today are worthless and can't do anything right, the problem is more complicated than that. Many universities have stepped away from the idea of going to college as a way to get a well-rounded education and have positioned themselves as places to get a piece of paper that will let you get a good job. Combine this with the increasing number of positions requiring a college degree, and you get a lot more people more interested in just getting through and getting that piece of paper as quickly as possible than they are with actually learning anything.
College is quickly becoming like high school: It's a base requirement that everyone has to go through if they don't want to spend the rest of their lives picking lettuce, so people are going to go and try and get through it as quickly and painlessly as possible. There have always been people who do this of course, and cheating is certainly not a new problem, but the above-mentioned issues may make it more prevalent than it once was.
Remember, though, that our generation cheated as well. Every college in the country has an honor code, and many of them have been in place for decades (or longer). These codes wouldn't exist if no one was cheating before.
Undergrad diploma is the new HS diploma because companies can't depend on people having a HS diploma to mean that they are capable of critical thinking.
That's what happens when you give them out willy-nilly (big thanks to the folks that implemented no-child-left-behind, and the liberals that won't let us fail students; but both of these are passing the buck-- the real problem is the parents not engaging in their childrens' lives.)
So now an M.S. is the new B.S., but this whole education thing is approaching unsustainability due to the exorbitant cost, both fiscally time required. Quick example, my MicroEcon test that I aced today had 20 questions, took me 20 minutes, and if they gave me all the slides up front I could have learned the entire course in 2 days or less of studying. But this amount of work was spread out over an entire semester. Is that economically feasible? No, we do it for the paper that gets us a well-paying job. With the cost of post-secondary education running away from us, the supply of students getting degrees from legit schools (aka not DeVry, ITT Tech, or your local community college that passes everyone for the same reason the high school does-- because they need the money) will dwindle. Eventually the cost of employing those with legit degrees will be so high that it will be economically feasible to consider employing someone straight out of highschool and just train them yourself. The two requirements for this to work are
1). student is smart enough to teach self things if you gave him a book and the internet
2). student is either a). self-disciplined, or b). can be managed to do work.
You can devise a test for 1), and if you just hire people you know and trust (and have people you know and trust who can refer you to people that they know and trust) then 2) is solved as well.
The point I'm making is I could have learned all my circuits stuff a lot faster with proper documentation and material written down than it took me in the classroom. Further, frankly I didn't need chemistry and Calculus I-III & DiffEq to help me design circuits or code. And I certainly didn't need a semester each to learn the applicable parts. A much more efficient solution (and it's much more motivating) is to worry about that stuff when you need it-- when you run into the term "eigenvectors and eigenvalues" while learning on the job about applying neural networks to power systems, you go teach yourself the linear algebra. It's much more motivating when you're stuck at the job for 8 hours, can't surf the web all day, and the most entertaining thing you can do (and it's actually quite entertaining) is learning things. Even better, it's always need-based, never an arbitrary "you have to learn this so that y
It's the same reason dogs lick their balls.... Because they can.
Is this really something new? The problem is not just limited to "entry level courses" In one of my midlevel CS courses (Advanced Java Programming) we were given a half semester long project to develop a complex software program using some aspect of Java we had not learned in class previously. Of the twelve groups that formed,h nine presented & turned in programs that were example programs from a previous java programming course I audited from another college. Being the only single person group and having written the most complex program in the class I was kinda agitated when I learned about some of the programs so I "helpfully" showed the Professor, the programs I had already written, before the groups presented them... The real kicker was, several of the groups did not even bother changing the source code/comments and still had the old course/assignment numbers (and in one case other students names!. In the end I think the professor was way too lenient and no one actually failed the course...
In most the CS classes I took, grading was mostly done by some automated case testing program. No looking at code style.
Our course was easy. Given some inputs, make them match exactly via the diff command to the outputs. It was really pathetically easy to pass, unless you mis-implemented something (happens).
Code review was checked via a number of methods- usually more hype than reality, but it still happened.
I had a couple of different students submit the same code- different names, variables, orders, etc. What gave it up? They had extra spaces at the end of the lines. Usually two, sometimes three- as if the tab was replaced and rounded up. This matched, space for space, for each function regardless of the name of the function or the variables.
100$ fraudulent. Global search and replace.
Prof passed them both. No warnings, no nothing.
I stopped being a TA at that point.
CS courses by far have the highest rate of English as a Second Language speakers to Native English speakers. It usually takes most ESL students a year or two to get the language right where they can actually participate in the classes, by which time they are usually having to play catch up and because they've already fudged the fundamentals of the course they pass with unacceptably lower skills. This is why a lot of ESL CS graduates make mediocre workers. Yes, I know there ARE shining stars among them but I'm talking about the bottom end being much more over-represented than their English speaking native counter-parts.
Universities must be more strict on language criteria before accepting $tudent$.
The main reason students cheat is because they are under pressure to produce ... and it is ultimately easy and rarely caught. When they are caught, the penalties are rarely serious, typically no worse than a zero on the homework or exam. The universities have an obvious conflict of interest here ... they accept ~$50k per student in tuition per year, and it is my opinion that they consequently simply cannot take serious actions to stop this epidemic.
Of course, this is not new. At this point, there are even professors who have cheated as undergraduates, so that, sometimes, the fox is guarding the hen-house.
This also extends to students who are doing a double major (for example in Math) and don't really care about the second major as much. In my last semester of undergrad a friend of mine copied his take home final from me and was caught coz he had the same mistake as me in an extra credit problem. What's funny is that the code of ethics requires the professor to expel the student. Of course that did not happen and he ended up in Columbia for graduate studies. As for me, I am here, posting my sad story on /. ;^)
I never write from scratch anything I can call from a liabrary, or re factor from existing code, or cut and paste, or down load from open source, for find an example of via google. The whole reuse paradigm says don't re invent the wheel. I have been "cheating" sucessfully for 20 years! the more you program, the bigger the liabry of your own code you can cheat from without worrying about the idot original devloper ;-)
Cheating will only hurt oneself in the end. Cheating is simply covering up the fact that the perpetrator doesn't know shit and fortunately, for rest of society, doesn't fly with those of us who do. Message to cheaters: you might not get caught now, but when I ask you to code something and you can't do it, or learn how then: a) you won't even get hired in the first place; and/or b) you'll be out so fast your head will spin...
Answer the question above Roman_Mir, you illiterate GOOF!
They are simply ignorant of reality if they are claiming because they are in CS dept they somehow have access to anti-plagiarism resources other departments do not have. This is just as absurd is saying other departments don't have access to computers. Its quite common for submitted works to be checked against automated databases to check for commonalities between works. I guarantee you noone in the CS departments had a hand in writing any of this stuff..Its all cots/outsourced services.
Is the origions of source code easier to cloak than a few paragraphs of an eassay?
Isn't the fundamental problem in the way CS is taught? What if the coding were tested AS SOON as it's taught - with NO time to look things up -- and kept to a very short part of the course work. Once the basics are in their heads, quickly get them to learn how to assemble software in small teams. What if the students shared and collaborated ON PURPOSE? We could even them find code for algorithms on the web the glue things together for their projects - maybe even entire class projects? Only lazy teachers would find this approach abominable.
Wouldn't it be great if Test-First and Source Code Control and Documentation were all taught at the same time?
It's been said a million times - no decent programmer learns how to code in the classroom - they learn by doing. The classroom is where they learn how the algorithms work, not how to translate them into code. The classroom is where they should get to ASK questions about code not ANSWER them.
Every plumber learns their trade by learning to read and analyze blueprints and learning the math, the principles, the parts and supplies and walking through real buildings from new construction sites to run-down ghettos. The hone their pipe-cutting and soldering skills during the apprenticeship, NOT in the classroom.
In my nearly 30 yrs and some 17 computer languages I've hired the highest GPA students from CS and some know shit about code and others are brilliant -- the latter are the ones who learned coding by DOING, not by INSTRUCTION.
My grey-haired 2c worth.
Where the hell did you go that had a 90% drop, so I can remember never to hire someone from that University? The highest drop I have ever seen in 10 years of academia, at least in a CS dept is ~80% and that was when they were already losing their accreditation. Anything beyond 75% is a sign to GTFO before they lose their cred. You do realize that high of a drop rate has nothing to do with the students being dumb but it sure is a sign that the program is dysfunctional, the professors are sadistic/suck or the water is filled with neurotoxins.
An Education is the Font of All Liberty
>If you are already a successful programmer, these CS projects seem especially surreal given that "cheating" is the label given for all those things you would do in real life to learn and solve, including collaboration and seeking example code.
The mantra of the cut-and-paste code monkey. Coding assignments simply aren't that hard, Mr. "Successful Programmer".
This implies that actually looking at the code turned in is not common practice. There's your problem. If you're not looking at the code, how are you actually grading?
Given the dreadful shape of much of the code I've inherited from alleged "professional" developers, I can only assume the stuff created by many students is truly painful to read. While what you say about reading the code is true, I can understand how someone who's just waded through his 27th unreadable listing might be tempted to just check the output on the rest of them and call it a day.
In the modern world, where nearly every problem has a collaborative dimension (even rootkit developers exchange tips of the trade) the phrase "excess collaboration" reminds me of the line from Jack Nicholson's character in One Flew Over the Cuckoos Nest, "Who ever heard of a man getting too much poozle?"
[http://www.mtc.mb.ca/WorkArea/linkit.aspx?LinkIdentifier=id&ItemID=4786 McMurphy spars with the untroubled Dr Spivey]
It makes you wonder about the rampant NIH that has long existed in the software profession.
Maybe they should instead be teaching students to *never* work from scratch if they can source a more suitable starting point. Maybe they should deep six sitting in front of a droning professor. You can do that online these days from the close proximity of your residence bar fridge.
Maybe nearly 100% of computer class time should be having the students conduct group walk-throughs of proposed designs, algorithms, and implementation fragments. Maybe the CS professor should be assessing how the students are interacting rather than mindlessly reciting prepared solutions (if you can find enough CS professors with a facility for eye contact).
Maybe an obstacle-course education in emergency wheel-reinvention should be regarded as a commando level training option for elite troops only.
Maybe the curriculum should include a course in outsource management, where your project group is graded on the work quality of its very own team of docile and compliant Indian math geeks.
Maybe the education system as it now stands is part of the problem, rather than part of the solution.
"Enrollment in undergraduate computer science courses is at an all-time high at colleges nationwide."
It's not. Go check.
I encrypt all my essays...
You're underestimating the way the brain remembers things. When grading assignments in an intro level programming class, you come across weird ways of solving the problem that technically work, but are bad style, etc. These things stick out in your mind, and you notice when you see the same thing twice. For example, as a TA for an intro programming class, I once graded an assignment where a student had written code something like this:
while (x == 0) {
if (x == 0) {
do something;
x = 1;
}
}
When another assignment used the same construct, I thought "hey, this kid is using an if statement inside of a while loop with the same condition; didn't I see one like this before?" I didn't have to look at every previous assignment to know that this kid was cheating, I just remembered. Maybe this breaks down for larger classes, but it worked fine for my section of ~30 students.
In other words, checking a list for duplicates is O(n) if you use the right data structures (hash table or 10^10-unit neural network).
because Barak Hussain Obama is a dick sucking homo pervert.
His best Dick in the Guberment ... Dick Gates.
How did this Dick fucker get elected?
Is is sad that the first thing that comes to my mind reading this is "huh, sounds like a problem from my parallel processing class"? Incidentally, I wonder what the parallel speedup is over sequential execution (i.e. just one poor bastard grading everything)? In your analysis please remember to factor in locking over red pens and doritos. Dining philosophers eat your hearts out! :-D (yes I still sometimes get handwritten comments on code I turn in)
I had a student a few years back who had obviously copied some work as it had the same blindingly obvious error that I'd seen earlier. As my purpose wasn't to test their programming skills, only their understanding of the algorithms and concepts within image procesing, I'd award those who'd copied the work a 50% if they could explain to me what was going on and that they showed a general proficiency with the material and could understand what was wrong with the program. Oh, and this was on the provision that they admitted to copying the work. Anyway, one student steadfastly refused to admit the work had been copied or was involved in any frowned upon activity. His claim was that he wrote the program and it was coincidence that anyone else produced the same error (basically impossible). So to prove his claim I asked him to explain, line by line, what the program was doing. He insisted on skipping the first line before admitting he didn't know what it did while still insisting that it was his code. The first line in the program was clrscr.
Every cheater needs to get caught so that the industry stops being flooded with money grubbing assholes, rather than people who actually love coding and would be doing it even if they worked at a gas station or some other unrelated job.
Too many people see programming as the current hip job trend with which they can cash in. It's rather infuriating to those of us who actually give a shit.
As a computing science major, I have seen a number of people with absurdly high GPAs and work experience at major corporations (RIM, Business Objects, etc) that couldn't code a simple app if their life depended on it. So I would have to agree with the article...I hope more is done to catch such people who jeopardize honest peoples degrees.
As the article states, the classes being analyzed are just computer science introductory courses, and not necessarily introductory computer science majors[students]. At my current university, a whole batch of non-computer science students are given the ultimatum of CoSc 1010(Intro Cosc) or usually something that *sounds* much more difficult. Engineers can take a rigorous intro to all engineering topics with a heavy emphasis on physics, or intro to computer science. Also, math educators, varying scientists, business, and other majors are advised to take an introduction to computer science, or are otherwise required.
While I agree that a well-rounded person in the 21st century should be able to use a computer, I also understand that learning how to program is an up-hill battle at best for a lot of people -- Even some CS people have problems with it in the beginning. On top of that, the intro computer science course here fills two sections in a lecture hall of ~300 students(~600 students on a full semester), and the average amount of computer science majors(undergrads) is around 120 -- Freshmen through Senior!. Most of the people in these intro courses aren't computer science majors, possibly have little to no interest in programming, and probably expected it to be much easier than it is.
As if making a program to solve a sudoku board isn't stressful enough for these people(or other homework assignments), the word from the professors around here is that the upper class-men have no idea how to program, and the solution is to make the introductory courses more difficult.
Either more universities need to dial down the difficulty of these intro courses(for non-cosc majors), or offer alternative intro to computing courses...because I suspect my university isn't the only one doing this. Otherwise, these people will just keep getting pressured into cheating, will continue cheating, and will continue to get caught. As an example, the cs department here offers a class that is advertised almost exclusively as a business major class, where people learn the parts of a computer, do some Microsoft Office labs, and possibly learn a thing or two about computers.
...it has become obvious that cheating and lying has become the way of the world.
Anyone else notice this?
Well?
Do I need to repeat the question?
Perhaps I should rephrase that.
Liars and cheats please raise your hand.
EEE major here... but I did few programming modules in my undergrads. I abhor cheating, plagiarism, collusion and any form of illegal activities. But at the end of the day, we have to have allies within the class especially when big group projects come along. As a result, sometimes I had to give away my codes to others and change my own code to avoid getting caught. It was appalling, but given the circumstances, I didn't have much choice.
And now as a Graduate TA, I don't need a sophisticated plagiarism detection system to spot who is cheating and who is not. Moment you start talking with the particular student or read their code, it is quite visible who is breaking the rules. (One time I marked down a student, because he managed to get the code running and obtain the result. But before the official demo, he requested me to explain what's happening inside the code. Obvious right! However, later he complained to the lecturer and I was forced to give him full marks under the grounds "he did finish the lab assignment and got the right answer". I deliberately avoid TA-ing that class after that incident).
Also I agree that plagiarism detection systems are NOT "bullet proof". They can be mislead as well and all depends on the threshold you choose.
Despite all this frustration, I think I have a solution. Why not make the assignments darn-super-hard ? My 2nd year C-programming unit had this horrible 4 page long assignments. Essentially, the lecturer wanted us to write a fully functional MIPS emulator using C/C++, which can take in machine-code and churn out the results. It was a tough assignment (especially when you haven't ever used C/C++ before). But that assignment had two major merits, 1) you will try all possible tricks in C/C++.. hence a good hands on programming experience, 2) you will learn processor architecture pretty well. I completed the advanced version of that course in the final year, which required us to introduce memory heirarchies and pipelining to the existing code base.
When you are given such a massive assignment, only handful can finish the assignment. Rest have to fall-back halfway through.. as the assignment is not all about programming. Underneath there is lot more (in the above case, processor architecture) you must know to finish the assignment. On top of that, massive assignment enable student to learn more things than a small ones. And most of all, it is the most fair system for all the hard working honest students!
I love You too.
You can't handle the truth.
And therefore the smallest error results in zero marks.
Seriously, when I was in IT school, you could not go on a website without seeing at least 3 if not 4 times the same code for your problem. If the app they are using does a compare var to var instead of name of var to name of var, i can say that 99% of code is plagerised. Why....because if I need a function that adds x to y or x to z and returns an integer, no matter how i write it, at the base of things...you will end up having x = ...., y = ...., x + y = .... retutn ...., so if everybody has the same project , think of how many variations you really can have for that function.
Instead I would ask to have a working application that does what it is supposed to, then change the code up in that person's project then tell them to find the problem and fix it....or better yet, have some projects that other students have made, have a second student change the code all around, and then send it back to the first one to fix so it does what it is supposed to....
You have to remember in this case that the position one will fill in the REAL world is simple, if they do not know the answer, know where to look to get it. If the hardware,software does not work, fix it, and if you can't get a consultant in to help you....
not everyone knows assembler or how to configure an old pbx system, does not mean the programmer or network admin is useless because he does not know EVERYTHING.
Roman_Mir didn't do so well here http://developers.slashdot.org/comments.pl?sid=1622780&cid=31904240 just judging by his lame off topic trolling reply, as well as his inability to disprove what was written there.
Roman_Mir didn't do so well here http://developers.slashdot.org/comments.pl?sid=1622780&cid=31904240 just judging by his lame off topic trolling reply, as well as his inability to disprove what was written there.
at making clear to newbies what distinguishes programmers from script kiddies. They're used to copypasting code, and in their narrow use cases and minds, that's good enough. Beware letting them anywhere near a production system because they will apply the same logic.
They all need to watch this. "You don't learn by gliding". I'm in love with that guy.
When I was in college, we had to turn in our assignments by dropping off a floppy disk on the professor's desk with the source code and compiled executable on it. Our teacher was and older gentleman, and would frequently leave the class to go to the restroom, leaving the collection of floppies vulnerable to anyone wanting to grab one.
When it came time for our class to turn in our final projects, I was asked to stay after class. The teacher handed me two stacks of paper and told me to take a look at them, The first stack was the source code from my final project. The second stack was the source code of one of my classmates.
For the exception of a few changed variable names and comments, the code was exactly the same.
The teacher wanted to hear my side of the story before confronting the other student. He recognized my programming style and knew that I would never do something like this, and if I did, I wouldn't be stupid enough to use the same ascii drawings as code separators. I told him I turned in the assignment over a week ago, and assumed that at some point during that time the disk was taken from his desk. He agreed, and told me I was free to go.
The other student was dropped from the course.
Back in introductory CS - I'd been programming already for a few years and had read through all of the local college CS texts (not many - but the music ones were neat). The instructor used my code as a basis to spot both cheaters and those who would ask for help. Apparently he could always tell both....
I still don't know what was so distinctive about my code.
I will say though that my favourite instructor marked based on how I planned out, documented and finished my code regardless of how well it fit the course. 1989, first year CS while I was finishing my grade 12 - and my final project was a fully functional text-based word processor with built in simple encryption (variation of playfair cypher).
How many unique ways are there to write a hello world program? And the whole idea of programming is to use code examples, everybody does and is suppose to do that, even the biggest companies, in fact everybody including mayor distributors of SDK's and compilers andsoforth, they also create whole dedicated sites to providing plug-in example code for people to use. That's what programing is, composing the parts into a whole and building on cleverness of the community.
I used to TA a compiler course and 50% of students cheated. I caught them without using code analysis tools.
A very simple way of doing so is to create lots of test cases. In my case, I created 130+ test cases that tested all aspect of the program. It made both grading and catching cheaters incredibly easy.
I just needed to look at the scores and compare the scoring matrix. People having the identical score and the scoring matrix are very likely having the same code. Then I did manual inspection to confirm. Except two people who had the same score with different scoring matrices, all other people with the same score pretty much copied one another.
The funny part was, I gave them the tests (and the testing script) before hand, but none of the students even tried to using simple "printf" statements that mimic the test results :) Instead, they tried more complicated stuff like fake variables, string replacements etc.
I feel like along with the obvious reason that more CS students get caught in entry level classes due to such automated systems that check for duplicate code, etc. the main reason that students cheat in these classes is because many of the people who may or may not be computer science students have no idea how to write code and are therefore absolutely confused. They try to find someone in their class who has a better idea of what they are doing than they do and then use that student's code as an example or simply copy it. Some people simply have a higher aptitude for understanding programming and code than others and that causes the issue.
I think standing on the shoulders of giants is NOT plagiarism.
I'd like to buy homeland for our 10 million people. http://twitter.com/mahadiga
Comment removed based on user account deletion
I once made an experiment: the assignment was to write a program that downloads a file via HTTP. Prior to that, they had another assignment which illustrated how one can send and receive stuff via a TCP socket (see Lab#1 and Lab#2 on this page http://info.railean.net/index.php?title=List_of_SIPC_labs%2C_2010).
Assuming that people are lazy and they don't like to read, I decided to make a video tutorial that explains how HTTP downloads a file. The difference between the first assignment and the last one was very small - it is the same "send and receive stuff via TCP sockets", but this time what you send is a string specified by the protocol. I told them about the RFC, of course, but again - I assumed they wouldn't look at it.
The video tells one everything they need to know to download a file and implement resume support. Unfortunately, there were quite a few of those who didn't add that feature, even though it was an easy thing to do (especially that I explained everything in class, in much more detail).
My conclusion is that it is not a matter of lazyness (I can understand not reading a 200 page RFC, but watching a 10min video is easy), it is a matter of making the right choice when going to a university. Most people simply don't belong here. They should have taken another course in another field, one they would be genuinely interested in.
An alternative explanation is that people are afraid to ask questions; I invest a lot of efforts in reducing the distance between us, to make them feel free and express their curiosity. Sometimes I make lists of FUQs - "Frequantly Unasked Questions", where I offer responses to questions they didn't ask, but which I did ask myself when I was in their shoes. Sometimes I also ask them to write anonymous feedback about the classes, an example can be seen here: http://railean.net/index.php/2010/04/18/metafeedback_on_education
A feature that I use is a special grading policy (you can see it in the description of those assignments). One has to do X to get 80%, and the extra effort needed to get to 90% is usually very small. And the delta between 90% and 100% is also trivial.
In other words, if you really worked on the assignment, you'd figure out that if X if "effort points" got you to 80%, X+eps will get you to 90%.
So I know that if someone went just for the 80% result, they most likely cheated, because if they didn't - they'd obviously go for the 90%, and eventually 100%.
For instance, the only difference between "downloading a file via HTTP" and "downloading a file via HTTP with resume support" is a "Range: offset-length" string in your GET request. If a student doesn't realize that, I sincerely doubt the fact that they implemented the "usual download" themselves.
Here's the video I'm talking about, if you're patient enough, you will see how the part about "Range" is explained: http://www.vimeo.com/10011691
So - if people fail to write a nice program after getting so many hints, they don't deserve any credit.
My final "feature" is that they can only get their grade after I interview them - they have to walk me through their code and answer various questions I ask them about their implementation.
This approach takes a lot of time and it doesn't scale well (my group is made of 20 students, so I can afford to dedicate a lot of time to each of them), but it allows me to make sure that those who really know what they are doing will be rewarded, and that those who don't will get a chance to improve.
The saddest poem