TITLE: A Little Zen, A Little Course Prep
AUTHOR: Eugene Wallingford
DATE: July 03, 2012 3:28 PM
I listened to about 3/4 of Zen and the Art of Motorcycle
Maintenance on a long-ish drive recently. It's been a
while since I've read the whole book, but I listen to it on
tape once a year or so. It always gets my mind in the mood
to think about learning to read, write, and debug programs.
This fall, I will be teaching our third course for first time
since became head seven years ago. In that time, we changed
the name of the course from "Object-Oriented Programming" to
"Intermediate Computing". In many ways, the new name is an
improvement. We want students in this course to learn a
number of skills and tools in the service of writing larger
programs. At a fundamental level, though OOP remains the
centerpiece of everything we do in the course.
As I listened to Pirsig make his way across the Great Plains,
a few ideas stood out as prepare to teach one of my favorite
• The importance of making your own thing, not
just imitating others. This is always a challenge
in programming courses, but for most people it is essential
if we hope for students to maximize their learning. It
underlies several other parts of Pirsig's zen and art, such
as caring about our artifacts, and the desire to go beyond
what something is to what it means.
• The value of reading code, both good and
bad. Even after only one year of programming,
most students have begun to develop a nose for which is
which, and nearly all have enough experience that they can
figure out the difference with minimal interference from the
instructor. If we can get them thinking about what features
of a program make it good or bad, we can move on to the more
important question: How can we write good programs? If we
can get students to think about this, then they can see the
"rules" we teach them for what they really are: guidelines,
heuristics that point us in the direction of good code.
They can learn the rules with an end in mind, and not as an
end in themselves.
• The value of grounding abstractions in everyday
life. When we can ground our classwork in their own
experiences, they are better prepared to learn from it. Note
that this may well involve undermining their naive ideas about
how something works, or turning a conventional wisdom from
their first year on its head. The key is to make what they
see and do matter to them.
One idea remains fuzzy in my head but won't let me go. While
defining the analytic method, Pirsig talks briefly about the
difference between analysis by composition and
analysis by function. Given that this course is
teaches object-oriented programming in Java, there are so many
ways in which this distinction could matter: composition and
inheritance, instance variables and methods, state and behavior.
I'm not sure whether there is anything particular useful in
Pirsig's philosophical discussion of this, so I'll think some
more about it.
I'm also thinking a bit about a non-Zen idea for the
course: Mark Guzdial's method of
worked examples and self-explanation.
My courses usually include a few worked examples, but Mark has
taken the idea to another level. More important, he pairs it
with an explicit step in which students explain examples to
themselves and others. This draws on results from research in
CS education showing that learning and retention are improved
when students explain something in their own words. I think
this could be especially valuable in a course that asks students
to learn a new style of writing code.
One final problem is on my mind right now, a more practical
matter: a textbook for the course. When I last taught this
course, I used Tim Budd's
Understanding Object-Oriented Programming with Java.
I have written in the past that
I don't like textbooks much,
but I always liked this book. I liked the previous
multi-language incarnation of the book
Unfortunately, one of the purposes of this course is to have
students learn Java reasonably well.
Also unfortunate is that Budd's OOP/Java book is now twelve
years old. A lot has happened in the Java world in the
meantime. Besides, as I found while
looking for a compiler textbook last fall,
the current asking price of over $120 seems steep --
especially for a CS textbook published in 2000!
So I persist in my quest. I'd love to find something that
looks like it is from this century, perhaps even reflecting
the impending evolution of the textbook
we've all been anticipating. Short of that, I'm looking for
a modern treatment of both OO principles and Java.
Of course, I'm a guy who still listens to books on tape, so
take my sense of what's modern with a grain of salt.
As always, any
pointers and suggestions