🚀 go-pugleaf

In article <1990Feb2.0...@cs.rochester.edu> k...@cs.rochester.edu writes:
>The solution I came up with was to take the correct printout, overlay
>it with the suspect printout, align the letters and hold both against
>the light.  It worked.

I love it!  "Analog software tools"!

The closest thing to that that I can recall was a case of the most primitive
conceivable graphical output.  The output was in tabbed columns of left-
justified numbers.  Some genius got the idea of scaling the output so that
the cutoff between "significant" values and "normal" values was a power of 10,
so that all the significant points "hung off the end" of the column...

-- 
        David M. Tate       | "The logarithms of 1,2,...,10 to base 10^(1/40)
  dt...@unix.cis.pitt.edu   |  are conveniently close to whole numbers, which 
                            |  when you think about it, is why there are 12
 "A Man for all Seasonings" |  semitones in an octave." -- I. J. Good.  

In article <22...@unix.cis.pitt.edu> dt...@unix.cis.pitt.edu (David M Tate) writes:
>In article <1990Feb2.0...@cs.rochester.edu> k...@cs.rochester.edu writes:
>>The solution I came up with was to take the correct printout, overlay
>>it with the suspect printout, align the letters and hold both against
>>the light.  It worked.
>
>I love it!  "Analog software tools"!

The overlay technique is VERY useful!  It is even downward-compatible to documents
existing only in printed form.  And it doesn't even use electricity in daylight.

The _Scientific_American_ computer column (I forget its name at the time) discussed
some algorithms like that for sorting.  My favorite was the "Spaghetti Sort":
  1. cut dry spaghetti to lengths representing the values to sort
  2. grasp these lengths in your hand vertically over a flat surface
A constant-time sorting algorithm!

Then, there was also the "Volkswagen Sort":
  1. Get as many Volkswagen Bugs as there are values to sort
  2. Fill their gas tanks with amounts of gas proportional to the values to sort.
  3. Line them up, and start them running.
  4. The order in which they stop produces an ascending sort.

Any others like this?


Dan Ross			dr...@cs.wisc.edu	..!uwvax!cs.wisc.edu!dross

In article <1990Feb2.0...@cs.rochester.edu>, k...@cs.rochester.edu (Ken
Yap) writes:
> I was once working on a Perkin-Elmer 3200 running Fortran and little
> else.  Somewhere in my program was a small typo.  What do you do when
> you don't have diff handy? Software Tools, you say. Well that was
> exactly what I was trying to get working on this machine.
> 
> The solution I came up with was to take the correct printout, overlay
> it with the suspect printout, align the letters and hold both against
> the light.  It worked.

	We had a really suspicious lecturer in college who used to take the printouts
which we had handed in as assignments and hold them up to the light in batches,
looking for programs which were the same.

	He obviously didn't realize that the Pascal (well it was designed as a
teaching language!) `prettier' which we had available allowed you to customize
the indentation etc., though we cottoned on pretty quickly. A global replace on
a few variable names also defeated his system.

Philip Katz,                          :|: PK...@axion.bt.co.uk
British Telecom Research Laboratories :|: + 44 473 642682
RT3141, SSTF 310, Martlesham Heath    :|: "Well you can bump & grind
Ipswich, Suffolk, England IP5 7RE     :|:   ... if it's good for your mind"

In article <1990Feb5.2...@axion.bt.co.uk> PK...@axion.bt.co.uk writes:
>
>	We had a really suspicious lecturer in college who used to take the printouts
>which we had handed in as assignments and hold them up to the light in batches,
>looking for programs which were the same.
>
>	He obviously didn't realize that the Pascal (well it was designed as a
>teaching language!) `prettier' which we had available allowed you to customize
>the indentation etc., though we cottoned on pretty quickly. A global replace on
>a few variable names also defeated his system.

Oh, God.  Now it's going to be *impossible* to separate the lowlife scum from 
the real students...

FORTRAN was great.  Any indentation at all by the students would show up cases
of cheating in an instant.  Line labels were even better, since you have to be
psychic to make your labels sequential and evenly-spaced on the first try, and
students never make a second try :-).  Global replaces on variable names often
led to integer/floating point type mismatches, which the students failed to
catch, and there were so many ways to construct a "test-and-branch" statement
that it was practically an admission of guilt to use one.  Cheating was harder
than doing the assignment.

Now, of course, we live in an age of software tools, which allow reasonably
clever scum to sabotage the grading without even thinking hard...  I guess
output formatting is the last place that's still a dead giveaway.


-- 
        David M. Tate       | "The logarithms of 1,2,...,10 to base 10^(1/40)
  dt...@unix.cis.pitt.edu   |  are conveniently close to whole numbers, which 
                            |  when you think about it, is why there are 12
 "A Man for all Seasonings" |  semitones in an octave." -- I. J. Good.  

In article <22...@unix.cis.pitt.edu> dt...@unix.cis.pitt.edu (David M Tate) writes:
>Now, of course, we live in an age of software tools, which allow reasonably
>clever scum to sabotage the grading without even thinking hard...  I guess
>output formatting is the last place that's still a dead giveaway.

It's easy to pick out the low-life scum by other means.  A large number
of them can't spell.  The rest of them have idiosyncrasies (for example,
saying in Pascal "if <boolean variable>=true").  Encouraging them to
write a lot of small procedures helps too, because there's typically a
million and one ways of doing this, so there are very rarely duplications.
In summary, cheaters typically do dumb things, and there are more horrible
solutions than elegant ones, so the cheaters stand out like sore thumbs.
Besides, most experienced graders are adept at picking out the "obvious"
ploys - changing identifier names, reversing the "then" and "else"
clauses of if-statements, making repeat-loops into while-loops etc.

Since this is alt.folklore.computers, here's some folklore.  Back in
the Dark Ages I TA'd a Pascal course which used a much hacked-about
version of Wirth's original Pascal compiler.  Unfortunately, it had
the most horrendous and obscure bugs.  Fortunately, it was written
most beautifully (by and large).  So the obvious solution was to take
a listing of the compiler to Lab sessions.  The third most obscure bug
I found was the following.  A student had written
  writeln("=");
which compiled and when executed produced the output
  true
A quick look at the compiler code indicated that the double-quote
character was a hexadecimal operator, and the hexadecimal number was
read in by a while loop after it was spotted.  So, "=" was interpreted
as hex-zero equals hex-zero, which of course is a boolean expression
which is true.  Since neither the hex operator nor he printing of boolean
variables was documented (rather, the first was undocumented and the
second discouraged), the only way of finding the bug was using the listing.

Needless to say the students were impressed by my knowledge, but
unimpressed by the compiler.  Personally, I'd rather have good source
code than good documentation any day.  But I guess that's mostly true of
something as small and simple as a Pascal compiler.  For anything larger
I'd like good documentation, a book, AND good source code.
____
Ian Parberry  i...@theory.cs.psu.edu  ian@psuvax1.UUCP  ian@psuvax1.BITNET
Dept of Computer Science, Penn State Univ, University Park, Pa 16802, USA
"Bureaucracy is expanding to meet the needs of an expanding bureaucracy"

In article <C_&...@cs.psu.edu> i...@theory.cs.psu.edu (Ian Parberry) writes:

>It's easy to pick out the low-life scum by other means....  
>In summary, cheaters typically do dumb things, and there are more horrible
>solutions than elegant ones, so the cheaters stand out like sore thumbs.
>Besides, most experienced graders are adept at picking out the "obvious"
>ploys 

In 6.111, the digital systems lab, one year there was a particularly
careless cheater.  The lab assignments required designing a system to
the given specifications and then building it.  Students would
sometimes cheat by using the design of a student who'd taken the
course in a previous term.  One year, someone wired up his kit from
someone else's old lab 3 design *without noticing that the new lab 3
had entirely different specs*.  He was caught when he asked the TA to
help him figure out why his kit wasn't working.

>From article <1990Feb2.0...@cs.rochester.edu>, by k...@cs.rochester.edu (Ken Yap):
> What do you do when you don't have diff handy?

Cross my eyes and look at both pages at once.  Any differences jump
right out at you.

peace.  -- Ed

Once when I realized that two students had handed essentially the same
program I took the two listings, put them side by side on a table and
wrote a note across the two of them (so you had to line them up
together to read the note), asking the two students to come see me.

I think they knew why. I told them the program was quite well done so
gave them each 50%, unfortunately a failing grade.
-- 
        -Barry Shein

Software Tool & Die    | {xylogics,uunet}!world!bzs | b...@world.std.com
Purveyors to the Trade | Voice: 617-739-0202        | Login: 617-739-WRLD

In article <1990Feb15.2...@world.std.com> b...@world.std.com (Barry Shein) writes:
>
> [two students handing in essentially the same program]
>
>I think they knew why. I told them the program was quite well done so
>gave them each 50%, unfortunately a failing grade.

I just give zeroes to all parties involved.  I find that usually one of the
parties has done most if not all of the work, and is usually smart enough to
be able to recover, grade-wise, from a single zero, and the relatively sharp
penalty will make that person think twice about letting an incompetent yo-yo
copy his work.  The incompetent yo-yo's involved are generally utter parasites,
to whom I wish to give no credit at all if I can help it.  Hence zeroes for all.

Think about it.  At the college level, is there ANY excuse at all for the sort
of pernicious nonsense that such copying represents?  I say kick 'em out of
the program.

yrs,

Malcolm "Burn 'em at the stake" Carlock
-- 

"Dad, what's that building?"
"That's an ancient Norman watchtower... where they would watch for Norman!
 They haven't spotted him yet..." -- actual conversation between my Dad & me

Why not give full credit to the guy who did the copying and zero credit
to the dude he copied from?  After all, the source has demonstrated his
stupidity, and the parasite has shown his qualifications for employment in
management or as an attorney.
	- Gadfly

I remember my first experience writing a program on a UNIX system at
school.  I didn't know that I had to set some permissions so that others
couldn't copy or read my files!

When I got my program back, it had some small fraction of a grade since
several other people handed in the same program.  Luckily I was able to
prove that I wrote the program and conviced the TA that I was just a 
stupid EE who didn't know UNIX (this was a CS class).

-- 
   /   George D. Nincehelser           \  uunet!swbatl!george       \
  / /   Southwestern Bell Telephone     \  Phone: (314) 235-6544     \
 / / /   Advanced Technology Laboratory  \  Fax:  (314) 235-5797      \
/ / / /\  1010 Pine, St. Louis, MO 63101  \  de asini umbra disceptare \

b...@world.std.com (Barry Shein) writes:
>I think they knew why. I told them the program was quite well done so
>gave them each 50%, unfortunately a failing grade.

My technique is to mark one and then divide by the number of copies
and assign that to each perpitrator. As someone else pointed out,
isn't odd how people always copy a program with a weird bug/feature in
it (like arrays dimensioned 1:10000000000)

Lindsay

--
MAIL : Lindsay....@newcastle.ac.uk (UUCP: s/\(.*\)/...!ukc!\1/)
POST : Computing Laboratory, The University, Newcastle upon Tyne, UK NE1 7RU
VOICE: +44-91-222-8267 		FAX: +44-91-222-8232

In article <35...@tahoe.unr.edu>, ma...@tahoe.unr.edu (Vampire In The Sun)
writes:
> In article <1990Feb15.2...@world.std.com> b...@world.std.com
(Barry Shein) writes:
> >
> > [two students handing in essentially the same program, gives them each 50%]
> I just give zeroes to all parties involved.  I find that usually one of the
> 
> Think about it.  At the college level, is there ANY excuse at all for
the sort
> of pernicious nonsense that such copying represents?  I say kick 'em out of
> the program.

Hmm. We solved this problem in a rather simpler, more effective and realistic
way. First, accept the fact that in nearly every area of human endeavor, 
some people like to work together. This is also the way that most projects in
the real world work. Second, accept the fact that students are going to
work together. It is how many people can learn best. Solution: simply have
group assignments. Tell the class that they can work together in any size
group that they wish, but that they have to tell you who was responsible
for what (at least approximately), and that the larger the group, the better
you expect the program to be. 

We found that people tended to work in groups of 2-4 and quickly became
self-policing. If there was one person who did not do much work, nobody
wanted to work in a group with them, and they ended up doing everything
themselves.

Is there any excuse for maintaining the sanctity of individual work 
at the college level?

		=brian

br...@ima.isc.com
US 617-661-7474 x206
near the last bend in the Charles River

My philosopy was: if you share the work you share the grade.

Example: Three people submit identical work that would be worth a grade of
90%.  90/3=30, so each gets a grade of 30%.

Tom Almy
to...@tekgvs.labs.tek.com
Standard Disclaimers Apply

> Is there any excuse for maintaining the sanctity of individual work 
> at the college level?

Is there any excuse for a prospective employer asking the college
for the INDIVIDUAL grades of the job applicant?
--
  Gerald A. Edgar          
  Department of Mathematics             Bitnet:    EDGAR@OHSTPY
  The Ohio State University             Internet:  ed...@mps.ohio-state.edu
  Columbus, OH 43210   ...!{att,pyramid}!osu-cis!shape.mps.ohio-state.edu!edgar

In article <15...@haddock.ima.isc.com> br...@ima.isc.com writes:
>
>Hmm. We solved this problem in a rather simpler, more effective and realistic
>way. First, accept the fact that in nearly every area of human endeavor, 
>some people like to work together. This is also the way that most projects in
>the real world work. Second, accept the fact that students are going to
>work together. It is how many people can learn best. Solution: simply have
>group assignments. Tell the class that they can work together in any size
>group that they wish, but that they have to tell you who was responsible
>for what (at least approximately), and that the larger the group, the better
>you expect the program to be. 
>
> [...]
>
>Is there any excuse for maintaining the sanctity of individual work 
>at the college level?

Yes.  I teach at Pitt, which has a *large* commuter population.  Many of my
students work at home most of the time, and don't really know any of their
classmates.  These students are at a tremendous disadvantage in any group-
project environment, and usually end up getting stuck with the deadweights of
the class as partners.

I agree that many people learn better in groups, and so on.  Unfortunately,
there is no way to provide even approximately equal group environments for 
all the people in the class.  Also, not all groups are as "self-policing" as
yours seemed to be.  I had considerable difficulties last semester with one
student who was attempting to get his/her friend through school by doing his/
her work... 

The idea of expecting higher quality from larger groups is a good one, but in
practice it could be a nightmare trying to compare essentially incomparable
projects, and assign an equitable grade to each.


-- 
        David M. Tate       | "The concept of weight of evidence was central 
  dt...@unix.cis.pitt.edu   |  to my first book, and occurred also in at least
                            |  32 other publications [of mine].  What I say 33
 "A Man for all Seasonings" |  times is true."          -- I. J. Good.  

In article <22...@unix.cis.pitt.edu> dt...@unix.cis.pitt.edu (David M Tate) writes:
>Oh, God.  Now it's going to be *impossible* to separate the lowlife scum from 
>the real students...
>
>FORTRAN was great.  Any indentation at all by the students would show up cases
>of cheating in an instant.          [...]

Why not just run the students programs thru a cb, or indent, or whatever
the Pascal version is?  In fact you could even write a version that strips
out comments, renames the variables, and does the compare itself (why think
when you can let the computer do it?)
-- 
           str...@wam.umd.edu          "Security for Unix is like
      Josh_Osborne@Real_World,The          Mutitasking for MS-DOS"
      "The dyslexic porgramer"                  - Kevin Lockwood
    Who needs friends when you can sit alone in your room and drink?

I worked on a VM/370 system where the student users were forced into a
restricted shell based on EXEC programs.  This restricted shell prevented the
major method to copy programs which was to link/access another students user
disk and do a copy command.  However, it didn't stop anyone who knew something
about VM/CMS, or was willing to experiment.

At one point, a pair of "guru" students made the mistake of helping a couple of
students (X and Y) copy programs between their disks.  The "gurus" created a
virtual punch on the X's account, created a virtual reader on the Y's and
punched the file over.  Their opinion was that all they did was save Y about
three hours of typing in a hardcopy of X's program.

Well the "gurus" got dragged into the Systems Programmer's Office and were
offered the chance to confess.  What had nailed them was the fact that student
Y, who couldn't program his was out of paper bag, had submitted a infinite loop
job to the student partition.  The System Programmer was looking over Y's code
when he discovered the unmodified copy of the program from X.  It didn't take
long to trace the trail to the "gurus".

I look at it this way, follow the school's policy...  If they allow copying,
then fine...  if not, then not.

Cheers,
--------------------------------------------------------------------------------
John "Fast Eddie" McMahon                          FAST...@DFTNIC.GSFC.NASA.GOV
Code 630.4 - Advanced Data Flow Technology Office        SDCDCL::FASTEDDY (SPAN)
NASA Goddard Space Flight Center in Greenbelt, MD                 (301) 286-2045

"Living a 9600 Baud Lifestyle in a 1200 Baud World" - R.A.J.                 

In article <1990Feb17.1...@eng.umd.edu> str...@eng.umd.edu (Joshua Osborne) writes:
>In article <22...@unix.cis.pitt.edu> dt...@unix.cis.pitt.edu (David M Tate) writes:
>>Oh, God.  Now it's going to be *impossible* to separate the lowlife scum from 
>>the real students...
>>
>>FORTRAN was great.  Any indentation at all by the students would show up cases
>>of cheating in an instant.          [...]
>
>Why not just run the students programs thru a cb, or indent, or whatever
>the Pascal version is?  In fact you could even write a version that strips
>out comments, renames the variables, and does the compare itself (why think
>when you can let the computer do it?)

Well, just compile the thing.  If it is a p-code Pascal compiler, the code
should result the the exact same p-code, even though the variables and
comments and indenting style is different.

/----------------------------------------------------------------------\
|      /// Michael Sinz -- CATS/Amiga Software Engineer                |
|     ///  PHONE 215-431-9422  UUCP ( uunet | rutgers ) !cbmvax!mks    |
|    ///                                                               |
|\\\///          "I don't think so," said Ren'e Descartes.             |
| \XX/                    Just then, he vanished.                      |
\----------------------------------------------------------------------/

In article <1990Feb16.1...@newcastle.ac.uk> Lindsay....@newcastle.ac.uk (Lindsay F. Marshall) writes:
{b...@world.std.com (Barry Shein) writes:
{>I think they knew why. I told them the program was quite well done so
{>gave them each 50%, unfortunately a failing grade.
{
{My technique is to mark one and then divide by the number of copies
{and assign that to each perpitrator. As someone else pointed out,
{isn't odd how people always copy a program with a weird bug/feature in
{it (like arrays dimensioned 1:10000000000)

When I was a student and someone was taking cards from the hopper
to copy them. This got annoying enough that I would get the program 
working quickly (maybe two whole days before it was due :-) ), then
leave a "doctored" version around to be copied. Naturally the doctored
version had all kinds of interesting bugs.

After they found out what I did the TAs thought it was hilarious!

           *Mike Waters    AA4MW/7  wat...@dover.sps.mot.com *
Human beings were created by water to transport it uphill.

In article <20...@dover.sps.mot.com>, wat...@darla.sps.mot.com (Strawberry
Jammer) says:
>When I was a student and someone was taking cards from the hopper
>to copy them. This got annoying enough that I would get the program
>working quickly (maybe two whole days before it was due :-) ), then
>leave a "doctored" version around to be copied. Naturally the doctored
>version had all kinds of interesting bugs.
>
>After they found out what I did the TAs thought it was hilarious!
>
>           *Mike Waters    AA4MW/7  wat...@dover.sps.mot.com *
>Human beings were created by water to transport it uphill.

Back in my high school Pascal class, there was a guy who would always
ask for a copy of your program to turn in (usually 2 days late).  One of
the first times he asked me, I told him no because our teacher would
find out.  He said, "No she won't, she's too stupid."  Well, it turned
out that she was standing behind us at the time....

The one time I let him copy my program, I put a little line in that said
something like "I am stupid, I copied this program directly from Tom
Collins."  He didn't remove the line before turning it in....

-Shark
-------
Tom "Shark" Collins       Since ICS is comprised of 2 people, my views
tbc...@psuvm.psu.edu      are the opinion of at least 50% of the company.

In article <9...@dftsrv.gsfc.nasa.gov>, fast...@dftnic.gsfc.nasa.gov (John 'Fast-Eddie' McMahon) writes:
> I worked on a VM/370 system where the student users were forced into a
> restricted shell based on EXEC programs.  This restricted shell prevented the
> major method to copy programs which was to link/access another students user
> disk and do a copy command.  However, it didn't stop anyone who knew something
> about VM/CMS, or was willing to experiment.

This reminds me. Back in the old days of VMS, you could hit ^Y if you were
really fast before it executed the login file. Here at USU, things like
checking to make certain that your account actually has money it are done
in the login file. In those days you could log in anyway by hitting ^Y before
the login file got to its first command, $SET NOCONTROLY.

One facility for which I worked did a lot of real-time device driver type
munging of the system. It was therefore important for them to be able to
easily and quickly shut down the machine. They installed an account called
SHUTDOWN that had no password. Of course, the first instruction in the 
login file was $SET NOCONTROLY. I once took advantage of this feature of
VMS to break into the machine and create myself an account which could do
various interesting things. The account that I created had no privileges,
but its UIC was [1,4]; it therefore owned all of the system files including
SYSUAF.DAT (the user authorization file).

This explains why VMS now has a flag in the UAF that can be used to 
disable ^Ys at login before executing the login command file.

===============================================================================
Roger Ivie

35 S 300 W
Logan, Ut.  84321
(801) 752-8633
===============================================================================

  This probably isn't going to add much to the conversation in terms of
things that people can laugh at or find amusing, but I just need to say
that I think that students who would copy source code from other
students' accounts without permission and without telling them, and then
turn in that source code as their own work, are one of the lowest form
of scum of the earth, and deserve to be expelled.  Quickly and without mercy.

  And there's a pretty good chance that that's what would happen if
somebody tried to do that here at MIT, at least.  We have a pretty
strong policy about academic honesty here, and something like that would
really would be a real obvious application of it.

Jonathan Kamens			              USnail:
MIT Project Athena				11 Ashford Terrace
j...@Athena.MIT.EDU				Allston, MA  02134
Office: 617-253-8495			      Home: 617-782-0710

In article <1990Feb22....@athena.mit.edu> j...@athena.mit.edu (Jonathan I. Kamens) writes:
>that I think that students who would copy source code from other
>students' accounts without permission and without telling them, and then
>turn in that source code as their own work, are one of the lowest form
>of scum of the earth, and deserve to be expelled.  Quickly and without mercy.

Probably the only lower form is the scum that steals the code.  I started
school when programs were submitted on punched cards.  The output was returned
several hours later to a bin, one for each class.  Near assignment deadlines,
these vultures would wait at the output bins pretending to look for their
output, but they took the first output that had the correct answers.  They then
would replace the job card with their own and submit it as their job.  Not only
did they get a program they didn't write, but the good programmers lost all
their work.  Grrrrrr.  After the first time this happened to me, I took all my
blank cards and punched my initials in the last two columns of the sequence
field.  I told the professor what I had done.  The second assignment after
that, an assignment was turn in with "KD" in the last two columns of every card
except the job card.  Caught the vile creature.  An appropriate example was
made of this student.  But, would you believe, my final program for that course
also was stolen!  I guess the second student skipped the class when the capture
of the first student was announced and the method was explained so others could
protect themselves.  Then similar miscreants took to copying the stolen decks
and hitting the skip key before the sequence field.  Such activity at the
keypunch (whether done manually or semi-automatically with a drum-card) was
fairly obvious and a good TA could spot the characteristic sound across the
room.  Such low lifes were not smart enough to create a plug-board for the tab
machine reproducing punch which would have done the job much faster and with
much less chance of getting caught.  (We did look for plug-boards programmed to
reproduce everything except the sequence field.)

As an undergraduate during the late '70's, I had three experiences with
people cheating based on my work.  Interestingly, they all have different
characteristics wrt blame and motivation (in my opinion).

The first example occurred in my first programming class, Fortran taught
on an IBM 370 using punched cards.  Our first assignment was to write
a simple quadratic equation solver that would check for imaginary solutions
and print something appropriate.  I imagine that I could write this program
now in about 10 lines of C code in 30 seconds, but being my first program
I came up with about 75 cards of Fortran riddled with GOTOs and junk, and
spent about a day on it (including time figuring out how to use the $%^$&^%
keypunch).  A neighbor of mine who was in the class was really struggling,
and asked (the night before it was due) to see my listing.  Being a nice
(and naive) guy, I let him borrow it.  Well, he simply typed in the program
verbatim (variable names, labels, spacing, everything), so we wound up each
getting half-credit for it.  I managed to convince the teacher that I was
essentially blameless and deserved the credit, but I learned an important
lesson from it about caution.  I think the motivation for the cheating in
this case was desparation, not actual malice.

The second case occurred in a systems analysis class.  I took this class
as a junior, and did quite well on the final exam (98, I think).  It was 
an open-book, open-notes exam.  The following year, a friend was taking 
the class and asked to borrow my exam to study from.  I let him have it,
since I didn't really see any harm.  He then proceeded to distribute
photocopies of it to most of the other 20+ people in the class (the CS
majors at my school (Bradley) were a fairly small and tight-knit group).
I discovered later (to my horror) that the professor had given an essentially
identical test (right down to the essay questions).  Since it was open-notes,
almost the entire class had a copy of the "key" (my test) with them, and
thus gave the identical correct answers (including the essay questions!).
Well, the professor apparently didn't believe in the hundredth monkey
effect (see sci.skeptic for details), so he investigated and found that
my name was in everyone's notes (and probably near the top, given the
outcome), so he called my and we talked about it.  He decided that it
wasn't really my fault, and also decided to vary his tests a bit more in
the future.  I think that he might have also just disregarded the final grades
of the few unfortunates (two or three of them) who didn't have a copy
of the "key".  This instance was more of a teaching error than an instance
of actual cheating - I don't think anyone involved had any malice in their
intentions at all.

The final case was by far the worst, and the one that still galls me ten
years later by its blatant nature and the weak response of the professor.
I had, by the end of my senior year, a reputation as a good source of
advice on programming problems (partly because I worked as a consultant
for the Computer Center helping students out).  One day, I was working
in the terminal room when a guy came up to me with a problem on his
third-semester COBOL program.  It was one of those gory 1000-line multi-level
report things that COBOL does so well at, complete with sorts and searches
and such.  The guy didn't have a clue as to what was wrong, so he asked me
to help debug it.  Well, as I read the program, I started to get the feeling
that it looked familiar.  Soon, I had convinced myself that this was a program
that I had written the previous year (for the same class), with the variables
and paragraph labels changed!  At this point I told the guy that I didn't
know what was wrong to get rid of him, then got a listing of my  old program
and headed for the professor's office to turn him in (I was pretty p.o.'ed
about this, and amazed at the stupidity of someone who would ask the author
of his ripped-off program for help).  I convinced the professor that the
guy was a blatant cheater.  She said that he was taking the class for the
third time, needed it to graduate at the end of the semester, and was
doing pretty poorly this time and might fail again, but that she would take
appropriate action.  Anyway, the guy showed up at graduation a few weeks
later (and got a diploma), so I assume that she wimped out and didn't do
anything about it.  This was pretty hard for me to take - I had caught the
guy red-handed, he was a mediocre student, but the professor let him pass
anyway.  I think that this one will bother me for a long, long time.  I
hope that I never cross paths with this guy again.  (I later determined
that he had gotten a listing of my program off of the table in the prof's
office in which she would leave the graded homework for people to pick up.)
Lesson learned from this one:  don't leave homework out in public (whether
you are a teacher or a student).

In article <1990Feb16....@zaphod.mps.ohio-state.edu>,
ed...@function.mps.ohio-state.edu (Gerald Edgar) says:
>
>> Is there any excuse for maintaining the sanctity of individual work
>> at the college level?
>
>Is there any excuse for a prospective employer asking the college
>for the INDIVIDUAL grades of the job applicant?

I think college grades should reflect not only personaly ability, but the
ability to work in a group.  To do this, a student must have *some* group
projects.  Otherwise, he may get a perfect 4.0, get hired by a wonderful
company with a nice starting salary, and piss everybody off and get fired
in 3 months.

*Individual* grades, yes, but in technical fields, people almost always
work in a group, and it would be in the employer's interest to look into
an applicant's social abilities as well.


Virtually,
- Charles Martin Hannum II       "Klein bottle for sale ... inquire within."
    (That's Charles to you!)     "To life immortal!"
  cmh117@psuvm.{bitnet,psu.edu}  "No noozzzz izzz netzzzsnoozzzzz..."
  c9h@psuecl.{bitnet,psu.edu}    "Mem'ry, all alone in the moonlight ..."

From: j...@athena.mit.edu (Jonathan I. Kamens)
>  And there's a pretty good chance that that's what would happen if
>somebody tried to do that here at MIT, at least.  We have a pretty
>strong policy about academic honesty here, and something like that would
>really would be a real obvious application of it.

I certainly agree in principle.

When I was an undergrad at Cornell it was mostly run on the honor
system. It wasn't unusual to have unproctored exams or take homes
where clearly you could copy someone else's work (like in math or
physics classes.) But the understanding was quite clear, you were
trusted, and if you betrayed the trust you were history. There was
also no fooling around by profs, by and large an incident of cheating
was sent right to the Academic Ethics Committee (something like that)
or not raised at all.

Unfortunately, not all schools subscribe to that and it requires the
support of the faculty and administration, one faculty member can't
adopt such a noble approach unilaterally unless they're willing to
face some quixotic battling (more likely, simple loss of job.)

I wonder if it's still like that at Cornell or other schools
(apparently it is at MIT.) I think it was the best policy all around.

None of this treating students like amoral idiots who can't help
themselves but cheat. Treat them like adults, and require adult
responsibility (and consequences) in return.
-- 
        -Barry Shein

Software Tool & Die    | {xylogics,uunet}!world!bzs | b...@world.std.com
Purveyors to the Trade | Voice: 617-739-0202        | Login: 617-739-WRLD

In article <90053.133...@psuvm.psu.edu> CMH...@psuvm.psu.edu (Charles Hannum) writes:

>In article <1990Feb16....@zaphod.mps.ohio-state.edu>,
>ed...@function.mps.ohio-state.edu (Gerald Edgar) says:

>>> Is there any excuse for maintaining the sanctity of individual work
>>> at the college level?

>>Is there any excuse for a prospective employer asking the college
>>for the INDIVIDUAL grades of the job applicant?

>I think college grades should reflect not only personaly ability, but the
>ability to work in a group.  To do this, a student must have *some* group
>projects.  Otherwise, he may get a perfect 4.0, get hired by a wonderful
>company with a nice starting salary, and piss everybody off and get fired
>in 3 months.

I strongly agree.  When I think back to my time at MIT and list the
most valuable courses I took they are

15.301 (Management Psychology Lab - 4 person groups)
15.313 (Long meaningless name.  It was an MBA level 15.301.  Groups of
	6 or 7, negotiating excercises, projects, role playing games.)
6.170  (Software Engineering Lab - 3 or 4 person final project)
6.033  (System Design - no coding.  Lot's of case studies, essays on
	systems.)
6.035  (Compiler Design - 3 or 4 people write a compiler together.)

Four of these five courses involved group projects.  Three of them had
absolutely nothing to do with my official job responsibilities.  (One
thing 6.035 taught me was that I never want to write a compiler.)
What they taught me about working in groups was immensely important.

>*Individual* grades, yes, but in technical fields, people almost always
>work in a group, and it would be in the employer's interest to look into
>an applicant's social abilities as well.

I do a job interview about once a month now.  I don't make hiring
decisions but I have input.  So far we haven't extended an offer to
someone I gave a negative on.  Anyway, one thing I always look for is
involvement in group projects of some kind.  Either work experience or
in school.  I won't veto someone for not having this kind of
experience, but having it is a big plus.

Working in a group is different from working alone.
--
The passing of Marxism-Leninism first from China and then from the
Soviet Union will mean is death as a living ideology ... .  For while
there may be some isolated true believers left in places like Managua,
Pyongyang, or Cambridge, MA ...   - Francis Fukuyama

In article <22...@unix.cis.pitt.edu> dt...@unix.cis.pitt.edu (David M Tate) writes:
>In article <15...@haddock.ima.isc.com> br...@ima.isc.com writes:
>>Is there any excuse for maintaining the sanctity of individual work 
>>at the college level?
>
>Yes.  [ ... talking about commuters etc. ... ] 

  I really think that *both* individual and group work is important at
the college level (assuming that a lot of students come in without
having had reasonable pre-college courses).

  For introductory courses, it makes a lot of sense to have projects
be entirely individual; in fact, even a lot of higher-level courses
have small projects (for instance, an OS course which starts by
having students write a parallel merge sort).

  However, it's really important for students to learn to work in
groups for the real world--it's a different set of skills.  Until all
schools have software engineering courses, it's especially important
to have a few large group projects in upper-level classes.

>Also, not all groups are as "self-policing" as yours seemed to be.

  The larger the group, the better it seems to work, in my experience.
A 4-person group (quite reasonable for project courses) generally
seems to do pretty well at "self-policing".  The one time I was in a
20-person group (or so), we managed quite well.

>The idea of expecting higher quality from larger groups is a good one, but in
>practice it could be a nightmare trying to compare essentially incomparable
>projects, and assign an equitable grade to each.

  It's hard, but the same can be said for large individual projects.
I think giving students the experience of working in groups is more
important.

		Anton (still a student :-)
   
+---------------------------+------------------+-------------+
| Anton Rang (grad student) | ra...@cs.wisc.edu | UW--Madison |
+---------------------------+------------------+-------------+

All this discussion about cheating and honor systems prompts me to
post two items from my past.

First, honor.  My undergrad school was Rice University (actually I
started at Rice Institute, but since they changed names in 1960 I
wouldn't admit that for fear of giving my age away ...).  Rice had
(and as far as I know still has) an incredible honor system.  Any exam
or homework that was covered by the honor system included a signed
"pledge" saying (I still remember it after all these years) "On my
honor, I have neither given nor received any aid on this exam."
Any work which was NOT pledged was fair game for anything you could
sneak by the TA's.  Anyway, the up side of the honor system was
wonderful:  Taking an exam and the room is too hot?  Take it over to
the air-conditioned library and bring it back at the end of the hour;
no questions asked.  I even had some timed, closed-book take-home
exams!

Unfortunately, the down side was that if you were caught in ANY breach
of honor (and NOT only pledged work) then there was one and only one
punishment: you were out of school.  It rarely happened, but it did
happen often enough to keep everybody well aware of the consequences.
The most interesting example was my senior year, when a friend and his
girl were both among the Top Ten Seniors, up for election by fellow
students for some yearbook honor or the other.  Since my friend was an
editor of the yearbook, he took the opportunity to stuff the ballot
box so his girl would be among the winners.  Unfortunately, he got
caught, and poof, OUT!  The last semester of a cum laude career, and
he is gone!  The guy showed amazing guts, though, and came back a year
later (the expulsion was only for one year), took all of his senior
year courses over again (all courses were full-year courses, not
individual semesters), and graduated.  A bit like the old joke about
the farmer that counts to three and shoots his horse, then turns to
his complaining wife and says "That's one."  Sure the penalty was
gross, but believe me, nobody I knew ever even THOUGHT of cheating!

Now one on the other side.  I teach part time in the graduate school
of a local private university (that I'll leave nameless for obvious
reasons).  A couple of quarters ago I had a student say he was going
to be out of town for a couple of weeks around the mid-term, and could
he take the exam late?  Sure, says I, I'll leave a copy with the
department and you can take it there when you get back.  Note however,
says I, this will be the SAME exam as everybody else got, so be sure
to NOT talk to anybody about it.  Okay, he says.  Then I get the exam:
it is OBVIOUS that he has cheated.  How do I know?  Well, I always
hand out a complete solution to my exams the week after, when I return
the graded ones.  And his paper contained some of my solutions almost
verbatim!!!  (Talk about STUPID!)  (And by the way, I also hand out
this same solution BEFORE the mid-term the following quarter, to help
those who are NOT privy to the "archives" of previous exams!)  Anyway,
I went to the department head and asked him what he wanted to do about
this.  There IS some concept of an honor system, although nothing as
formal as at Rice, so I wanted to see if the guy was going to be
expelled or if an F would be sufficient.  The department head's
reaction?  He actually suggested that I give the guy a make-up exam!!!
Needless to say I was LIVID, and the cheater got an immediate F.  And
I still haven't resurrected any respect for the (now ex-) department
head.

wayne

  Wayne Hathaway            
  Ultra Network Technologies     domain: wa...@Ultra.COM
  101 Daggett Drive            Internet: ultra!wa...@Ames.ARC.NASA.GOV
  San Jose, CA 95134               uucp: ...!ames!ultra!wayne
  408-922-0100