paco@sbcs.sunysb.edu (Francisco J Romero) (07/20/88)
I am looking for a program which detects similarities between/among C programs, and can be used to detect cheaters. I am just too busy and lazy to reinvent the wheel, so I hope somebody out there has something interesting to share. I am thinking of a line-counter, keyword-counter, identifier-counter, loop-counter, etc combined together into a unique program that provides a <degree of similarity> among programs. Maybe there are more sophisticated ways of detecting cheaters I am not aware of. Any help will be appreciated. ............................................................................ Francisco J. Romero (paco) | csnet: paco@sbcs.csnet Department of Computer Science | arpa : paco@sbcs.sunysb.edu State University of New York at Stony Brook | bitnet: romero@sbccvm.bitnet Stony Brook, NY 11794 (USA) | phone: (516)689-6953 .............................................!..............................
wbralick@icc.afit.arpa (William A. Bralick Jr.) (07/20/88)
In article <1403@sbcs.sunysb.edu> paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am looking for a program which detects similarities between/among C > programs, and can be used to detect cheaters. I am just too busy and [the rest deleted] I like to think our honor code obviates the use of such. Will
nather@utastro.UUCP (Ed Nather) (07/21/88)
In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am looking for a program which detects similarities between/among C > programs, and can be used to detect cheaters. > Maybe > there are more sophisticated ways of detecting cheaters I am not aware of. > Any help will be appreciated. > What on earth are you teaching? A class on re-inventing the wheel? Perhaps your students would benefit from a course on how to "cheat" -- how to find and use code someone else has written and debugged. That's what ALL professional programmers do if they can manage it. The proof of a program is running it, and if they stole the program in its entirety, and it meets the program requirements entirely, then more power to them! They'll have no trouble finding a job. -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
dewey@execu.UUCP (Dewey Henize) (07/22/88)
In article <420@afit-ab.arpa> wbralick@icc.UUCP (William A. Bralick Jr.) writes: }In article <1403@sbcs.sunysb.edu> paco@sbcs.sunysb.edu (Francisco J Romero) writes: }> }> I am looking for a program which detects similarities between/among C }> programs, and can be used to detect cheaters. I am just too busy and } } [the rest deleted] } }I like to think our honor code obviates the use of such. } }Will Obviously, given the history of the Air Force Academy, Will must have simply forgotten the following. :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) -- =============================================================================== | execu!dewey Dewey Henize @ Execucom Systems Corp 512/346-3008 | | You don't think my employer APPROVES of these ideas, do you?? Sheesh! | ===============================================================================
jrk@ingr.UUCP (Robert Kennedy) (07/23/88)
In article <1403@sbcs.sunysb.edu> paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am thinking of a line-counter, keyword-counter, > identifier-counter, loop-counter, etc combined together into a unique > program that provides a <degree of similarity> among programs. Maybe > there are more sophisticated ways of detecting cheaters I am not aware of. > Any help will be appreciated. Look at procedure and function call topology (number of parameters, when call takes place, type of function result, other functions/procedures called, etc). You could pretty easily write a C program to look for isomorphism between call trees... This is a pretty good indicator, I would think. Robert Kennedy ..!uunet!ingr!jrk
pst@comdesign.uucp (Paul Traina) (07/23/88)
In article <1403@sbcs.sunysb.edu> paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am looking for a program which detects similarities between/among C > programs, and can be used to detect cheaters. I am just too busy and > ... Having been on both sides (student/grader), it the long run, I felt that if the student could hide his program enough so that a human couldn't figure it out, he's won the game. A copy-discovery program is incredibly complex and quite easy to fool. If you were at the latest USENIX, you saw the presentation on SPIFF and how difficult that sort of context-diff program was to develop. *Commentary* Let them cheat. If they're smart & learn, it's no big deal. If they're stupid, they'll blow their final and they won't do well in courses that build upon the material presented in your course. I will assume that you are teaching a large freshman class, otherwise you'd know that it would take more time to compare "diff" listings than just remember-as-you-go-along-grading. Since you are teaching a large freshman class (data structures maybe?) you'd realize that their programs are so simple it's almost impossible not to have two programs constructed in just the same way with just the same algorithms. -- Paul Traina - {uunet|pyramid}!comdesign!pst - comdesign!pst@pyramid.com To believe that what is true for you in your private heart is true for all men, that is genius.
narten@cs.purdue.EDU (Thomas Narten) (07/23/88)
In article <405@comdesign.UUCP> pst@comdesign.uucp (Paul Traina) writes: >A copy-discovery program is incredibly complex and quite easy to fool. >If you were at the latest USENIX, you saw the presentation on SPIFF and >how difficult that sort of context-diff program was to develop. > >*Commentary* Let them cheat. If they're smart & learn, it's no big > deal. If they're stupid, they'll blow their final and > they won't do well in courses that build upon the > material presented in your course. > Cheating is a matter of ethics; it is a "big deal". Second, a relatively simple analysis program can snag a lot "similar" programs, where similar means that if one looks at the programs side by side, there is no doubt that collaboration has taken place. I know, because I wrote one once. I was shocked at: 1) the number of programs that had been collaborated on (20% in a course of 750) 2) the simplicity of the algorithm that netted similar programs. Counters of specific keywords, control structures, subroutines and variable names were the only thing checked. The program did little more than lexical analysis. 3) the difficulty in convincing students that what they were doing was wrong. Roommates swore up and down that they had not shared code, yet it was obvious to the instructors involved that nuances in the finished assignments could not have occurred by chance. Moral of the story: it's relatively easy to catch cheaters; the hard part is figuring out what to do with them once they're in your office. -- Thomas Narten narten@cs.purdue.edu or {ucbvax,decvax,ihnp4}!purdue!narten
nather@utastro.UUCP (Ed Nather) (07/23/88)
In article <4513@medusa.cs.purdue.edu>, narten@cs.purdue.EDU (Thomas Narten) writes: > Moral of the story: it's relatively easy to catch cheaters; the hard > part is figuring out what to do with them once they're in your office. Indeed. Try to explain to them that what they did -- take someone else's debugged code and use it themselves -- is wrong. It's what they'll do when they grow up, and it isn't called "cheating." It's called "smart programming." I think it's unprofessional to short-change the real education of your students to make your teaching job easier. But I recognize that this is a minority opinion. -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
paco@sbcs.sunysb.edu (Francisco J Romero) (07/23/88)
In article <2920@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > [my original posting deleted] > > What on earth are you teaching? A class on re-inventing the wheel? Perhaps > your students would benefit from a course on how to "cheat" > and use code someone else has written and debugged. That's what ALL > professional programmers do if they can manage it. The proof of a program > is running it, and if they stole the program in its entirety, and it meets > the program requirements entirely, then more power to them! They'll have > no trouble finding a job. > > -- > Ed Nather > Astronomy Dept, U of Texas @ Austin > {backbones}!{noao,ut-sally}!utastro!nather > nather@astro.as.utexas.edu [I don't see a smiley face anywhere, so I assume you're serious. Here we go] Now wait a minute. There is a difference between reusability of software by professional developers and unauthorized copying or sharing of student programs. I don't believe that cheating is beneficial just because the final product meets the program requirements: it is unethical to use somebody else's code without her permission. In our course it is not permitted to share code. Why? Because students should learn how to solve problems themselves before they can appreciate the need for teamwork. The course I am teaching this summer is an introduction to machine organization and systems programming. Students are required to write a small interpreter for Tanembaum's Mac-1 machine (see "Structured Computer Organization") And since you mentioned using somebody else's code, I should say that students are provided with symbol table routines and a simple parser. This code is made public and all students are encouraged to use it. Now, if they want to learn the organization of an assembler they'd better write the rest by themselves. That's the whole point: LEARNING. My course is not a software house whose ultimate goal is selling programs. Learning is what we are all about, and ethics is part of it: if you are told to use your own ingenuity to solve a problem and you use somebody else's without permission, should you get an A on the assignment? You tell me. Finally, I'd like to point out that computers make it very easy for students (and others) to cheat. It's just too tempting to walk all over the file system just for fun. After all, files are not protected, right? You just have to look around you and see the frequency with which computer-related fraud occurs. If we don't teach our freshmen to respect their fellow students' intellectual property, how are they going to learn? Thanks to those of you who provided useful ideas. Paco ............................................................................ Francisco J. Romero (paco) | csnet: paco@sbcs.csnet Department of Computer Science | arpa : paco@sbcs.sunysb.edu State University of New York at Stony Brook | bitnet: romero@sbccvm.bitnet Stony Brook, NY 11794 (USA) | phone: (516)689-6953 .............................................!..............................
g-rh@cca.CCA.COM (Richard Harter) (07/24/88)
In article <2927@utastro.UUCP> nather@utastro.UUCP (Ed Nather) writes: >In article <4513@medusa.cs.purdue.edu>, narten@cs.purdue.EDU (Thomas Narten) writes: >> Moral of the story: it's relatively easy to catch cheaters; the hard >> part is figuring out what to do with them once they're in your office. >Indeed. Try to explain to them that what they did -- take someone else's >debugged code and use it themselves -- is wrong. It's what they'll do >when they grow up, and it isn't called "cheating." It's called "smart >programming." It all depends. If they don't have rights to use that code it is called 'theft'. If it is proprietary code under license it is called 'see you in court, buddy'. The issue in the classroom is that the instructor has asked for original work, or at least has operated on the assumption that she has asked for original work. For a student to present a collaboration as original work is dishonest. As another point, nobody has questioned the ethics of home assignments. Is it really right for the instructor to say "Here go do this; by the way do it by yourself without any outside help." If the objective is to drill the student in a particular task, so as to acquire a skill by drill, then yes. In the particular case of programming one ought to, as Ed says, draw on outside knowledge. Indeed, a programmer who insists on doing everything as original work is a bad programmer. And one might well argue that an instructor who insists upon and teaches bad programming practice is a bad instructor and that, if she does it knowingly, is unethical. I'm not very serious about this, but it is something to think about. -- In the fields of Hell where the grass grows high Are the graves of dreams allowed to die. Richard Harter, SMDS Inc.
pst@comdesign.uucp (Paul Traina) (07/24/88)
From article <4513@medusa.cs.purdue.edu>, by narten@cs.purdue.EDU (Thomas Narten):
- In article <405@comdesign.UUCP> pst@comdesign.uucp (Paul Traina) writes:
->*Commentary* Let them cheat. If they're smart & learn, it's no big
-> deal. If they're stupid, they'll blow their final and
-> they won't do well in courses that build upon the
-> material presented in your course.
-
- Cheating is a matter of ethics; it is a "big deal".
My response might not belong here (depending upon your definition of comp.edu)
so I'll just request followups go directly to me.
Hmmm, maybe I have become too cynical, but if student's haven't learned
ethics by the time they're in a University, what's the point?
One could cop-out and say "I'm here to teach computer science, not ethics!"
or one could say "I'm here to teach students." Personally, I have a lot
more respect for the person who say statement #2. However, it's oh so hard
to live up to that standard. Is one to become a police-officer as well as a
teacher? I couldn't deal with that.
If I saw two people blatantly cheating on an assignment, I'd pull both of them
in, and explain that they aren't going to learn a damned thing about computer
science or engineering if they can't think for themselves. Then I'd consider
flunking them (on that assignment), not so much for the ethical reasons, as
because one of them was stupid enough to not even think about what s/he
was doing--that they didn't put in any effort at all.
If I saw two people who used the same concepts and ideas, but with different
approaches to the problem, I would think to myself:
"They probably talked to each other about how they would do
this program. One or both got advise from the other, and
settled down to write the program."
I'd be happy to see this. This is the way the real world works. Now that
I'm out in it, when I have a problem or want to hash over an idea, what
do I do? I go talk to my office-mate, or walk down the hall to ask advise
from a fellow programmer.
So, you have on one side "I'm not here to teach ethics" and on the other
side "I'm here to teach them how to think like engineers." You have
to decide for yourself the dividing line between "sharing" and "stealing."
--
Paul Traina - {uunet|pyramid}!comdesign!pst - comdesign!pst@pyramid.com
To believe that what is true for you in your private heart is true for all
men, that is genius.gvcormack@watdragon.waterloo.edu (Gordon V. Cormack) (07/24/88)
In article <2920@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > > > I am looking for a program which detects similarities between/among C > > programs, and can be used to detect cheaters. > > > > What on earth are you teaching? A class on re-inventing the wheel? Perhaps This is a bit unfair. One can spend a lot of effort deriving just the right set of labs to illustrate the material in the class. Of course, they are re-inventing the wheel, but why shouldn't they be in undergraduate classes? Ad hoc assignments made up every term just to be different are unlikely to be as good as ones that are carefully thought out by competent course designers. The only problem is in encouraging students to *do* the assignments. This is why I give marks for them, and try to discourage cheating. It is well and good to say "they do it for their own good -- they will fail the exam if they don't", but I do not think a responsible educator can fail 50% of the class just to make this point -- especially not in a vacuum. If our society chose to wean the students from this hand holding throughout the educational process, then maybe this could work. Maybe the universities on the honour system have successfully done so. -- Gordon V. Cormack CS Dept, University of Waterloo, Canada N2L 3G1 gvcormack@waterloo { .CSNET or .CDN or .EDU } gvcormack@water { UUCP or BITNET }
nather@utastro.UUCP (Ed Nather) (07/25/88)
In article <31313@cca.CCA.COM>, g-rh@cca.CCA.COM (Richard Harter) writes: > For a student to present a collaboration > as original work is dishonest. No argument. My question was directed at why they were asked to do it in the first place. I should have phrased it more carefully. > As another point, nobody has questioned the ethics of home assignments. For what it's worth, I teach a course on electronic techniques in astronomy, which has largely become a course in real-time programming. All of the tests and exercises are out-of-class assignments, with only one restriction: students should not collaborate with any other student given the same assignment. They are free to consult anyone else, and are urged to do so. I've been pleased with the results. Students really seem to learn the techniques best when they have to apply them to a real problem -- and the exercises are tough, chosen for their possible use in astronomy later on, not for ease in grading. I never fail to learn something new when I grade them, so I don't resent the time spent. As part of an introductory lecture I discuss cheating, point out they can fool me into giving them a high grade by scarfing some other student's work, and dwell on the consequences: they'll have spent time in class that was totally wasted, since they didn't learn its content. I also mention how much of a disservice they would do other students by letting them copy their work, thus "cheating" them of knowledge they may well need later. I don't know if this stops "cheating" in its usual academic definition or not, and I really don't much care. If I had wanted to be a policeman I would have joined a different organization. But I am very happy to see my students graduate and do good research in astronomy -- and hear that many of them teach the same way I do -- the reality, not the artificiality of memorizing to get a "grade." -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
tlh@cs.purdue.EDU (Tom "Hey Man" Hausmann) (07/25/88)
In article <2920@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > > > I am looking for a program which detects similarities between/among C ... > > ... The proof of a program > is running it, and if they stole the program in its entirety, and it meets > the program requirements entirely, then more power to them! They'll have > no trouble finding a job. > Ed Nather I think this is a joke. Sarcasm is hard to commmunicate in writing (obviously.) -Tom ------------------------------------------------------------------------------- Tom Hausmann Dept. of Computer Sciences Purdue University tlh@medusa.cs.purdue.edu | My ideas? There has never been an original ...!purdue!tlh | thought since Plato.
webber@athos.rutgers.edu (Bob Webber) (07/25/88)
In article <2936@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > ... > For what it's worth, I teach a course on electronic techniques in astronomy, > which has largely become a course in real-time programming. All of the > tests and exercises are out-of-class assignments, with only one restriction: > students should not collaborate with any other student given the same > assignment. They are free to consult anyone else, and are urged to do so. > > I've been pleased with the results.... I do a similar thing with grad students in computer science, with the further stipulation that they have to cite all their external sources on the answer page. I also stipulate that they can only consult sources that are equally available to everyone, i.e., the published literature. In a small seminar of dedicated graduate students it works well. In a class of 30 or so grad students it starts to wear thin and requires validation of in-class exams. In an undergraduate class of a hundred? If all university was about was learning, undergraduates would just be sent to the library for four years. ----- BOB (webber@athos.rutgers.edu ; rutgers!athos.rutgers.edu!webber)
mauney@cscadm.ncsu.edu (Jon Mauney) (07/25/88)
In article <2920@utastro.UUCP> nather@utastro.UUCP (Ed Nather) writes: > >What on earth are you teaching? A class on re-inventing the wheel? Perhaps >your students would benefit from a course on how to "cheat" -- how to find >and use code someone else has written and debugged. Besides all the ethical and pedagogical points already raised in response to this, there is another very important difference between the class assignment and the "real world". In a classroom there is no challenge to finding a program that is ostensibly written to your specifications. Thus, a student that copies a program has not gained experience from the challenge of writing it from scratch, nor from the challenge of tracking down a suitable program and modifying it to suit. All he or she does is ask a friend, or scavenge the file system or trash cans, and then make some cosmetic changes to the variables and comments. There is value in individual assignments, in collaboration, and in creative reuse of code. There is no value in simple program copying. Jon Mauney mauney@cscadm.ncsu.edu
bulko@cs.utexas.edu (Bill Bulko) (07/25/88)
In article <2927@utastro.UUCP> nather@utastro.UUCP (Ed Nather) writes: > It's what they'll do >when they grow up, and it isn't called "cheating." It's called "smart >programming." Ed, I don't agree with your viewpoint that students in programming classes should not be expected "to reinvent the wheel" and should not be prohibited from borrowing code from other students. I think you're missing the point of homework assignments. Your main argument has been that in the real world, reusing code is a normal and smart thing to do. This may be true, but doing an assignment for a programming class is NOT the real world. What would happen if elementary school children were allowed to use calculators in their arithmetic classes? [Note: "arithmetic", not "algebra".] They'd never learn to add and subtract, that's what. Sure, they'll be using calculators when they grow up, but that's no excuse for not learning how to do arithmetic in the first place. Programming is an acquired skill. You improve with practice, just like reading, writing, and arithmetic. The intended purpose of these programming assignments is to have the student practice writing a program from scratch: to design, plan, and debug. Borrowing code defeats this purpose. In your defense, I think this discussion should clarify exactly what classes we're talking about. If we're talking about first-year programming classes, then I think you're dead wrong: students have to learn how to program by themselves sometime. However, if we're talking about upper-division or graduate classes, then I concede a few inches to you: by then, a student shouldn't be expected to write every sort algorithm or stack utility from scratch, when a great amount of time and paper has been spent documenting the most efficient ways to do these things. The difference here, though, is that the student is expected to have already learned how to write this stuff by himself already (probably in the first-year classes I'm talking about) and that writing these routines would NOT be the main point of the homework. If that still isn't what you're talking about, then I can't support you. Why in the world would anyone write a simple Pascal compiler for his compiler class when he can simply "borrow" a working one? Bill _______________________________________________________________________________ Artificial Intelligence: the art of making computers that behave like the ones in movies Bill Bulko The University of Texas bulko@cs.utexas.edu Department of Computer Sciences _______________________________________________________________________________ _______________________________________________________________________________ Artificial Intelligence: the art of making computers that behave like the ones in movies Bill Bulko The University of Texas
hjespers@attcan.UUCP (Hans Jespersen) (07/25/88)
In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes:
:>
:> I am looking for a program which detects similarities between/among C
:> programs, and can be used to detect cheaters. I am just too busy and
:> lazy to reinvent the wheel, so I hope somebody out there has something
:> interesting to share. I am thinking of a line-counter, keyword-counter,
:> identifier-counter, loop-counter, etc combined together into a unique
:> program that provides a <degree of similarity> among programs. Maybe
:> there are more sophisticated ways of detecting cheaters I am not aware of.
:> Any help will be appreciated.
:>
From a students perspective, GO FOR IT. You're the kind of Prof that makes
cheating fun!!! It's ten times more satisfying to cheat a computer than some
stupid TA that took the course 8 months before you did.
-----------------------------------------------------------------------------
Hans Jespersen |
Associate Technical Consultant | PLACE SILLY TEXT BASED
(Read: Co-op Student) | GRAPHIC DOODAD HERE.
AT&T Canada Inc. |
PHONE : (416)499-9400 |
UUCP : {uunet | ihnp4}!attcan!hjespers |
-----------------------------------------------------------------------------nather@utastro.UUCP (Ed Nather) (07/25/88)
In article <7971@watdragon.waterloo.edu>, gvcormack@watdragon.waterloo.edu (Gordon V. Cormack) writes: > It is well and good to say "they do it for their own good -- they will > fail the exam if they don't", but I do not think a responsible educator > can fail 50% of the class just to make this point -- especially not > in a vacuum. If you mean without support from your academic colleagues, I agree. But look where the current system has led us: to students (and, yes, professors) who honestly believe "getting a good grade" is equivalent to "learning the course material." As a (somewhat cruel) test, I once offered to give everyone in the class an A grade, and not hold any lectures at all, if the majority of the class voted for it -- offering them the grade without any content at all. I wasn't surprised at the result, only a bit sick. No, I didn't do it -- I explained it was a test, to illustrate the difference. Several students promptly dropped the course when they realized I intended to play the "grade game" in a way different from their expectations. I insisted they learn, they just wanted to "get by." > If our society chose to wean the students from this hand > holding throughout the educational process, then maybe this could work. > Maybe the universities on the honour system have successfully done so. I don't know, but I'm curious. Can anyone with experience comment? -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
karam@sce.UUCP (Gerald Karam) (07/26/88)
In article <2927@utastro.UUCP> nather@utastro.UUCP (Ed Nather) writes: >In article <4513@medusa.cs.purdue.edu>, narten@cs.purdue.EDU (Thomas Narten) writes: >> Moral of the story: it's relatively easy to catch cheaters; the hard >> part is figuring out what to do with them once they're in your office. > >Indeed. Try to explain to them that what they did -- take someone else's >debugged code and use it themselves -- is wrong. It's what they'll do >when they grow up, and it isn't called "cheating." It's called "smart >programming." > >I think it's unprofessional to short-change the real education of your >students to make your teaching job easier. But I recognize that this is a >minority opinion. Both original programming and reuse are exercises that students should experience, here's why: The development of good software engineering skills requires maturity coupled with staged levels of knowledge. Typically the 1st year student learning a programming language has little maturity or knowledge to handle anything beyond writing new software to exercise new programming skills. You can beat the words design and reusability into them all you want but it simply cannot be appreciated at this time (yes these are generalizations). As the 4 yrs of eng or compsci progress the student no longer grapples with the details of syntax and "coming up with the algorithm"; at this point the more abstract concepts of design, requirements testing, reuse and other issues are introduced. In the end the student should have an understanding of the "real world" spoken of above. If he doesn't then his education hasn't been completed, which is unfortunate. Someone had to write the program that gets re-used in the real-world, it didn't write itself, however that's for comp.ai :-) gerald karam
larry@hcr.UUCP (Larry Philps) (07/26/88)
In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am looking for a program which detects similarities between/among C > programs, and can be used to detect cheaters. > Maybe > there are more sophisticated ways of detecting cheaters I am not aware of. > Any help will be appreciated. When I was at the University of Toronto, a rather ambitious Grad student wrote a program that processed the parse tree of a compiled program in the Turing language. It used the hcr to generate the parse trees for all the programs in the class, then compared each of those trees with each of the others and generated a metric reflecting how similar they were. The output was sorted in order of decreasing metrics. It was incredibly interesting to go looking for the listing of two progams that had a 100% comparison metric, go through them line by line, and see the industriousness of a student who had changed every variable name, all the formatting, and all the comments, yet still had not changed the operation of a single line of code. As someone else in this discussion mentioned however, it is much more of a problem to decide what to do with cheaters once you have caught them.
steve@oakhill.UUCP (steve) (07/26/88)
Ed Nather does have a point that most real programmers lift their code from other sources. But there is a difference. When I (or any other programmer) lift code, I make sure I understand the code I am working on. Quite often I have to resturcture or debug something subtle that wasn't needed in the original. If I had not writen such code once upon a time in course work (by myself) there is no way I could do this. When a student copies the code from another source, they don't get this background. I have helped with introductary CS courses, and it is amazing how many students cheat. They are not only cheating themselves, but harming the reputation of every other graduate of the CS department. The asumption should be that once you graduate you should know how to program. Employers no longer assume this. In my initial job interviews every employer had some sort of quiz on knowledge. Some even had paper exams that had to be taken. What I mean to say is that the job of a CS program is to teach the the basic theories of programming to students. It has long been assumed (rightly or wrongly) that hands on programming is an important part of this. Because you are doing a basic algorithm done 10,000,000 times before makes no difference. You need to learn the basics of the algorithm, and programming is an important part of this (I remember when doing the Milikin oil drop experiment, one of my classmates complained that we knew the charge of an electron and didn't have to repeat the experiment. Would you condone this too?). Cheating shows that the student is not learning, and thus should not make the grade. Another question should be what is to be done to students who aid cheating. I remember TAing introductary programing and finding out one of the students had posted on his dorm room his finished assignment. Listed on the side of the assignment were ways to take his program and make it look original (Incidently, a simple cheating detector (check of keywords, their order, hierarchy, etc.) would have detected the cheating). To a student having trouble, this temptation is large. I'd be interested in your replies. (Incidently, I do not know what diciplinary action was taken in this case). Your mooncalf - Steve P.S. What are we going to do when some of our basic algorithms wear-out :-). Will we have to resort to bubble-sort when quick-sort dies?
shea@bnrmtv.UUCP (Ray Shea) (07/27/88)
In article <2920@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > ...about cheating... > > What on earth are you teaching? A class on re-inventing the wheel? Perhaps > your students would benefit from a course on how to "cheat" -- how to find > and use code someone else has written and debugged. That's what ALL > professional programmers do if they can manage it. The proof of a program > is running it, and if they stole the program in its entirety, and it meets > the program requirements entirely, then more power to them! They'll have > no trouble finding a job. Oh, good. If everybody teaches a course like that, in a few years we won't have anybody who knows how to program; not that it'll matter, we can always just lift code from old stuff. :-) God forbid any of the students want to get advanced degrees: "Well, hey, this Knuth guy knows his stuff, I'll just use this as my thesis." Then again, maybe you were kidding? Ray
ncgus@ndsuvax.UUCP (Jim Gustafson) (07/27/88)
>In article <1405@devsys.oakhill.UUCP> steve@oakhill.UUCP (steve) writes: >Ed Nather does have a point that most real programmers lift their code >from other sources. But there is a difference. When I (or any other >programmer) lift code, I make sure I understand the code I am working >on. Quite often I have to resturcture or debug something subtle that ^^^^^^^^^^^^^^^ [ more on why one needs to understand, not cheat ] A THOT FROM THE PRAIRIE: The only way to learn the art and craft of debugging is by doing it. It's gotta be one of the most difficult skills to acquire. Through lack of practice, a student who cheats usually fails to learn how to quickly debug, port, etc. So the next time someone suggests academic cheaters should be treated in some 'real-world' sense, consider how much *real-world* time is spent testing and debugging code. You've got to practice the piano to play it well. -- -- Jim Gustafson UUCP: uunet!ndsuvax!ncgus North Dakota State University Bitnet: ncgus@ndsuvax Fargo, North Dakota 58105 Internet: ncgus@plains.nodak.edu
nather@utastro.UUCP (Ed Nather) (07/27/88)
In article <1405@devsys.oakhill.UUCP>, steve@oakhill.UUCP (steve) writes: > > Ed Nather does have a point that most real programmers lift their code > from other sources. But there is a difference. When I (or any other > programmer) lift code, I make sure I understand the code I am working > on. Quite often I have to resturcture or debug something subtle that > wasn't needed in the original. If I had not writen such code once upon > a time in course work (by myself) there is no way I could do this. But imagine how much more valuable that course would have been had you been given an assignment to take some published code (out of K&R, maybe) and then modify it to do a better job, or an extended job, or even a totally different job. Yes, you'd *have* to learn how it worked. I've learned a whole lot by just that process -- and it's amazing to look at swatches of code, often uncommented (shame!), and realize you can see the tracks of two or more different programmers there, because of subtle but clearly detectable differences in style ... but I digress. > I have helped with introductary CS courses, and it is amazing > how many students cheat. *sigh* I know -- that's where we've failed. The students are confusing the GRADE with the COURSE CONTENT and don't realize they've shot themselves in the foot. But that's a whole different topic (really!) from a discussion about what should be in a good CS course -- my original posting tried to raise the question of course content, and has digressed into a wide-ranging discussion of cheating, which I've been accused of condoning. I don't. We (academics) are often guilty of this same confusion. Once in a while I meet ex-students, who mention they once took a course from me. When I ask "Did you learn anyhting?" they usually respond "Well, I got a B." They are then confused when I repeat the question, since I don't feel it was answered, but they obviously do. I know of NO problem more serious than this one in our educational process ... but I digress (again). > Because you are doing a basic algorithm done 10,000,000 > times before makes no difference. I think it does -- it's one way, but I'm convinced it's not the only way, or even the best way, for students to learn to program. In this case you *know* it can be done, which is part of the artificiality of the schooling process. If you are given code and asked to make it faster -- or include a case it now doesn't handle (as examples) -- you have to think about it quite a lot harder. K&R has many such problems, and I (and my students) have learned a lot from them. I feel "rote repitition" in almost any form is wasting time. It *is* easier to grade, of course ... > I remember when doing the Milikin oil drop experiment, one of my classmates > complained that we knew the charge of an electron and didn't have to > repeat the experiment. Would you condone this too?). My physics prof had me do it, too, but *also* insisted that I measure, and write a report on, the various sources of error. That taught me a lot more about experiments in physics than just a rote repitition of the procedure whould ever have done. I did get two cases where the charge came out just 1/2 (or maybe 2/3?) what it should be, but I thew away those results (and maybe a Nobel prize) because I *knew* what the answer was. -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
nather@utastro.UUCP (Ed Nather) (07/28/88)
In article <3666@bnrmtv.UUCP>, shea@bnrmtv.UUCP (Ray Shea) writes: > In article <2920@utastro.UUCP>, nather@utastro.UUCP (Ed Nather) writes: > > In article <1403@sbcs.sunysb.edu>, paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > > ...about cheating... > > > > What on earth are you teaching? A class on re-inventing the wheel? > > Then again, maybe you were kidding? No, I wasn't kidding. I was suggesting (in a deliberately provocative way) that rote programming assignments, re-doing what has been done thousands of times before, might not be the best way to teach programming. It makes life easier for the teacher, of course, both in making up useful assignments and in the grading process -- but actually encourages cheating, since the student knows he will learn nothing whatever about the feasibility of doing the assignment; he *knows* it's been done before so it must be possible. If he is diligent, and doesn't confuse "getting a grade" with "learning to program" he will do the assignment just to gain the experience. If, like most students and many professors, he confuses the two, the temptation to cheat will be very great. As an alternative, give a few assignments that -- Ed Nather Astronomy Dept, U of Texas @ Austin {backbones}!{noao,ut-sally}!utastro!nather nather@astro.as.utexas.edu
rbl@nitrex.UUCP ( Dr. Robin Lake ) (07/28/88)
In article <1403@sbcs.sunysb.edu> paco@sbcs.sunysb.edu (Francisco J Romero) writes: > > I am looking for a program which detects similarities between/among C > programs, and can be used to detect cheaters. I am just too busy and > lazy to reinvent the wheel, so I hope somebody out there has something > interesting to share. I am thinking of a line-counter, keyword-counter, > identifier-counter, loop-counter, etc combined together into a unique > program that provides a <degree of similarity> among programs. Maybe > there are more sophisticated ways of detecting cheaters I am not aware of. > Any help will be appreciated. > >Francisco J. Romero (paco) | csnet: paco@sbcs.csnet There is a sample routine in the earlier (Version 6/Version 7) UNIX manuals from AT&T called "tree()". It counts the occurrence of words in an input stream. You can get a word-frequency histogram for each program and diff the two histograms. Posting tree() would seem wasteful. -- Rob Lake BP Research International - Research Center Warrensville uunet!nitrex!rbl mandrill.CWRU.EDU!nitrex!rbl
brad@looking.UUCP (Brad Templeton) (07/28/88)
Really people! How many of you would suggest that a good practice for math courses would be to assign a problem, and then have everybody look up the answer in the literature? (Actually, both CS and Math programs should deal with *how* to look up proofs and algorithms in the literature, but that shouldn't be the thrust of the course.) Number theorists don't prove old theorems every day, either, and they look up the proof if they need it, but I've never heard anybody suggest that students not rework previously solved problems in class before. -- Brad Templeton, Looking Glass Software Ltd. -- Waterloo, Ontario 519/884-7473
work@dragos.UUCP (Dragos Ruiu) (07/29/88)
In article <Jul.25.03.00.48.1988.20114@athos.rutgers.edu>, webber@athos.rutgers.edu (Bob Webber) writes: > If all university was about was learning, undergraduates would just be > sent to the library for four years. This might not be such a bad idea. Unfortunately, there is a proven market demand for learn-by-rote memorization drones. I wonder if the industry is willing to give them up for the mere handful of creative people who would be motivated enough to learn by themselves. > ----- BOB (webber@athos.rutgers.edu ; rutgers!athos.rutgers.edu!webber) -- Dragos Ruiu ruiu@dragos.UUCP Uh-oh, I see IBM ads with UNIX in big ...alberta!dragos!ruiu bold letters. Could we be DOOMED? Disclaimer: SaskPower R&D is in not responsible for my opinions or machine.