# My Department is Slashdotted

Posted by cayhorstmann on June 15, 2009 at 9:12 PM PDT

I teach computer science at San Jose State University. My department just
ended up on href="http://news.slashdot.org/story/09/06/13/123211/Student-Who-Released-Code-From-Assignments-Accused-of-Cheating">Slashdot.
One of my colleagues, Dr. Beeson—who, to his great credit, makes
beginning students write lots of little homework programs until they get
them right
—got into a tussle with href="http://www.kyle-brady.com/2009/06/10/how-i-won-a-copyfight/">Kyle
his answers on the internet. I don't want to get into the personalities
here. Beeson can be irascible and a bit overbearing, and the student's claim
that he is doing this to increase his chances for employment rings a bit
hollow. When is the last time you hired someone because of their href="http://projects.kyle-brady.com/svn/filedetails.php?repname=sjsuProjects&path=%2Fcs146%2FTicTacToe%2Ftrunk%2FTicTacToe.java">TicTacToe
program? Even if I did, I'd be wary about candidates who write

``if(foundEmpty == false)``
instead of `if (!foundEmpty)`...

Sure, instructors
should vary their problems from one semester to the next, but there are only so
many ways in which you can vary the basics. Consider TicTacToe. There are maybe
ten ways of changing it. Of course, there is no intrinsic merit to TicTacToe.
It's just a vehicle to test nested loops over a 2D array. We like it because
doesn't require a long backstory—students are familiar with it. But let's
ditch TicTacToe if all variations are on Google. What else is there? Magic
squares. Row and column totals. Counting zeroes. Making shapes with ASCII art:
squares, diamonds, spirals. Floodfill. Escaping from a maze. The game of life.
But all of these are on the internet too.

So, what does it mean for teaching and learning programming when the
solution to every beginner problem is available on the internet?

I am all for more code reading by students. Too many students just write
code, and if googling an answer makes them read more code, that's great.

When I learn new stuff, I set myself little tasks to solve. I don't just
google for the answer since that would defeat the purpose of learning. Are our
students like that? Kyle Brady probably is. But I have met a few who just want
to get a good grade, get their degree, and start making money. Others are
willing to do the right thing but lack the self-discipline. Quite a few work a
job or two to put themselves through college, and limited time and financial
necessity makes them go to Google when they shouldn't.

That brings me to the issue of “certification”. When you hire
someone, you want to see that college transcript because you expect some
correlation with ability. So, we as instructors need to give grades, and to
give grades, we give homeworks and exams. All of whose solutions are available
on Google. So, how can we certify that students know what they are supposed
to?

Strategy
#1. Shut off the internet. Herd everyone in a room with lead walls and make
them do their work there. Or (gasp) go back to paper and pencil. Personally, I
hate doing that. I give bring-your-laptop, open-book, open-notes exams because
I want my students to build up skills that they can use later.

Strategy #2. Starve them for time. That's what href="http://www.topcoder.com/">TopCoder and href="http://www.betterprogrammer.com/">betterprogrammer do. Sure, you
could google for hints, but then you would not be able to finish in time. My
students will argue that I use that approach as well, and they do not like
it.

code. Unfortunately, this is incredibly time-consuming and impractical on a
large scale. (After all, if this was easy, we wouldn't have the href="http://www.sun.com/training/certification/java/scjp.xml">SCPJ.)

Strategy #4. Forget about coding and evaluate students on their ability to
be creative, express themselves, resolve conflicts in a non-confrontational
way, etc. etc. These are all wonderful traits, of course. But I am reminded of
a faculty summit at, of all places, Google, where eager professors from
reputable institutions shared the latest thinking in computer science
education. At the closing session, one of the Google managers said that this
was all good and well, as long as the graduates can code.

So, as
you read those Slashdot comments, have some pity for the poor CS instructors.
Not for having to come up with a neverending stream of practice
problems—that's part of the job. But for having to teach students to be
ever more disciplined. In the past, we could rely on a reward system for
homework assignments. Do a good job, get an A. Thanks to Google, it has become
too expensive to give a fair reward for the kind of routine practice homeworks
that one really needs to build up skills. Now we must train students to do
their homework without resorting to Google, show them nicely what happens when
they don't, and then tighten the screws by the end of the semester, all without
demotivating those students whom we want to attract to the major. This is not

What you don't hear in Slashdot is that Dr. Beeson is actually doing a good
job. He built a system where students can submit their problems until they get
the right answer, and for a lot of students that is pretty motivational in
itself. Obviously motivational enough to get Kyle Brady to come up with answers
that he is proud to share with the world.

nice to see that you guys can confront your teacher like that, and really have a healthy discussion, in my institute, do something like this and get ready for something real bad, you won't know what expect , as for the discussion I must say that certainly Kyle doesn't have the understanding of what this post is all about, I am also a student, and in his defense I tried as hard as I can think of but there is not certainly a thing I can figure out, as for Mr. Hortsmann I certainly respect him because he is the author who taught me really how to use Java and introduced to the Javadoc so I may be biased, but I find nothing in the article that can go against him or Kyle although Kyle comment is something he should not do, not taking sides , he should at-least have some respect for teacher, there is nothing he do that should made you feel agitated, I agree with dwschulze that university system should be over-hauled but that is another point.
Good points, Alex. At my institution, we've used both of your strategies successfully in the past. However, we've recently switched to an assessment regime in which all summative assessment takes place under examination conditions, at the end of the year. The many programs that students write throughout the year are assessed formatively and have no direct impact on the final grade obtained - although failing to make a reasonable attempt at them will obviously compromise learning and affect the final grade indirectly. This strategy is akin to Cay's "starve them of time" approach. The complexity of the problems we can set in the final exam is limited by the exam duration (3 or 4 hours, typically), but we compensate for that partly through our choice of programming language (Python) and partly also by basing the exam questions on a module of code that is made available to students a couple of weeks before the exam. They can read & understand the code and figure out how it is used as part of their revision.
I will readily agree that the problem of "everything is available on the web" is very real (referring to code for introductory programming assignments), and will only get worse with time. But our chances of reverting this trend are about the same as our chances of taming the forthcoming waves, armed with a couple of buckets. I have been teaching introductory programming courses for some time now, and I have found that there's only two complementary strategies that work: * Change the assignments every single time you give them out, and make sure that each time you add that extra little something that makes them different to their "generic" incarnations (with abundantly available solutions). This at least ensures that even if people start with something they got off the net, they will still need to understand the code and modify it to accommodate the different requirements you set. I personally even provide students with an "official" reference implementation for every assignment after the submission deadline - so that they can compare it with what they did, and hopefully learn from this comparison also. Yes, this is not an easy task; yes, it requires considerable amounts of work every single semester; and, yes, it requires that one has to go off the trodden path for new ideas. Yet, this *is* part of what we are paid for, isn't it? * Use one of the several (and good) code plagiarism solutions available, and make sure you feed them not only with the students' submissions, but also with the most prevalent related solutions from the web. I can tell from experience that this even brings up those cases where people "got their inspiration" from the same source, whatever that might have been. I can also attest to the fact that knowledge among the student population that such measures are in place and effective, is an immensely strong demotivating factor for plagiarism. Admittedly, the above are not a basis for a long-term solution. This is a problem that is by no means related only to introductory programming courses - and, therefore, can't be solved at this level. Humanity as a whole may soon have to redefine what constitutes "knowledge" and how it is acquired, in the presence of rich reference material for practically any question one might think of, and available anywhere and at any time. And, for my person, I doubt the solution is to wall off students, physically or through the sheer power of regulations and punishment, from either accessing, or contributing to this sea of knowledge. My 2c, Alex
Sorry Kyle, but I think you need to take a deep breath, then go back and read Cay's post a bit more carefully. He's saying that he *doesn't* think you just Google for code, but that many other students do! He certainly isn't slandering you, calling you a cheater, etc.
I'm Kyle, FYI. In my defense: 1) You picked a problem that was given with a handful of others as a start-of-semester "pass these or be dropped from the class" test. The goal was not to have good or beautiful code, but to get them working as fast as possible. Maybe next time you shouldn't pick an example that you know to be both trivial and non-representative. 2) These all had contexts with them, and you would have known this had Beeson not demanded I pull down all related docs. They're being reworked and reposted soon. 3) This was my first semester using Java. And any employer that's going to be worried about == false vs. ! should find something better to do with their time than pick apart code semantics. 4) I'm sure the department (and some administration higherups) would love to know about you slandering me, calling me a cheater, by implying I just search for all my code. Maybe I should archive this page and pass it on... 5) Never once did I say that Beeson was a bad professor. In fact, I even commented a few times on different sites and to different people that I found his class to be as enjoyable as one could be about data structures and algorithms. I think he's a nice guy, when he's not being pissed at me, and I really liked his class - the homework submission system is a perfect way to mix code viability with "learn to debug properly". His class was also hard as crap, and when I completed the assignments I felt accomplished (except for the one that I couldn't figure out to get working fully and took a B because it didn't expand to a huge data set). You're right in that this was part of the motivation in posting the code... if I busted my ass on it, why should I not put it on display to prove that I did? In all of the articles, posts, discussions, etc. I did not attack Beeson, or criticize him as a person - only his now infamous request and reactions to my code. I find it interesting that you, a fellow SJSU CS Professor, saw fit to criticize me as a person, a programmer, and a student. Not exactly setting the bar high, are we? --Kyle
Dr. Horstmann, Saw you on DZone!!! You likely do not remember me, but I took CS 160 with you two years ago at SJSU. I absolutely did not like your class and passionately hated JSF during our class, but now, after two years of working as a junior software engineer, I realize that your class was one of the most helpful classes in my career. Thank for forcing us to learn practical programming. Thank you for THE most useful class at CS SJSU. Your practical introduction to SVN (and forcing us to check-in stuff during exams) saved my life during the job interview. Thank you so much.