Why aren't we all speaking LISP now?

Laura Creighton lac at cd.chalmers.se
Wed May 9 13:53:11 CEST 2001


Datapoint:
	Most people in the late 1970s and early 1980s at the University
of Toronto were not in the computer science program because they wanted
to become academics, computer scientists, but rather because they wanted
to become programmers.  They were in there for the same reason that
people studied Dentistry, or Law -- they wanted a Profession, not to be
a Law Professor or a Professor of Dentistry.  

The Computer Science department, at the University of Toronto, on the
other hand, was not staffed by Professional Programmers, indeed, as far
as I know they did not have a single one on the staff. (But it would
be hard for me to find out, as I will explain in a bit.)  And as a result,
the required Lisp course at U of T was taught by Computer Scientists,
who more-or-less Math Academics, to a student body which was comprised
of what would become Tim O'Reilly's customer base -- the people who
buy all the O'Reilly books.

This is an incredibly bad fit.  The students, almost without exception,
wanted hands-on-experience.  They wanted examples.  And they wanted to
write code.  The professors wanted to talk about concepts -- they wanted
to do computer science, and (in my view quite reasonably), took the
position that if you didn't like this sort of stuff, then you didn't
like computer science, and maybe you should do something else.  The
problem was that although there was, and still is a desparate need for
a Professional Faculty of Programming -- there wasn't one.  The students
had no place else to go.

I found all of this out by accident.  I was a _physics_ undergraduate major.
By the end of first year, all undergraduate physics years had about
45 students in them. (The rest of the 200 people who started out
first year had found something else to do.)  You knew everybody in your 
year, the other years, all the grad students and the professors.  We had 
our own study area, a huge room, which had a lock, which we had keys to,
where we could keep our stuff, and most of us had  keys to the physics 
buildings,  cause we were all supposed to be doing research in them --
the sorts of things that I only later realised other undergraduates
did not have at all, and were privledges only given to graduate students.
To all extent and purposes we *were* grad students, except that we
didn't know all that much.

Then something unexpected and interesting happened.  The computer science 
building burnt down.  And the computer science grad students had no home.
(Some of them had no research as well, that having burnt as well.)  So 
various parts of the rest of the university had to make room for groups of 
them.  In physics, we undergrads got the AI students.  They hadn't lost their
research, it being done on the DEC 10 where we physicists worked (before we 
bought our vaxen) so they could use Stanford AI Lisp -- SAIL.  So they were
happy, and indeed said their new digs were an improvement on the old ones
in many ways.  And in something like 3 weeks they had transformed absolutely
every physicist there who had any interest in computational physics at
all into a passionate Lisp enthusiast. 

But after hacking LISP for a year or so I thought, hmm, I really ought to 
go take some computer science courses.  So I did.  BIG SHOCK. There were
_thousands_ of computer science undergraduates in every year.  Courses were 
taught in classrooms of size 200.  And there were dozens of professors who were
all teaching the same course in slightly different ways so that the students
produced booklets which ranked them on teaching ability so you could avoid
teachers who were considered hard.  I only found out about the booklets
later, because I used a different strategy -- I asked the AI people `which one
of these guys knows the most cool stuff?' and thus ended up in the course
taught by the guy with one of the lowest student rankings.

I had a great time.  Acing the course helped, and having computer
science professors suggesting that I change my major to computer science
made my already over-large ego swell to unbelievable proportions.  
(Which made later discovering that nobody outside of the University of Toronto
gave a damn about my Lisp Macros a very good thing for me, though
unbelievably painful at the time.)  But I could immediately recognise
that just about every other student in the course was having a very hard
time because they needed, not a stiff dose of theory right off the bat,
but lessons in how to program in LISP.  Most of these people had only
ever programmed in one language before, a PL-1 like thing that some
U of T professors had written for teaching.  And to top it off, the
University was just converting from teaching undergraduate computing
on punch cards to using terminals. <I think as a result of the fire,
but the timing might be coincidental> How on earth they taught LISP
on punch cards, which they _did_ is beyong me.  The very idea is obscene.

So we were split into study groups of about 15 and I took mine up to
`my office' (desk) and gave a short course in HOW TO PROGRAM in LISP.
And discovered that I could not live without my Macro library.  And
that I had no idea whatsoever what was standard LISP, what was the
extentions the AI heads used, and what were physics macros Tim,
Mark, Brian and I had made over the summer.  But after we worked that
out, the rest of the people in my study group didn't have that much trouble
with the course, because they could concentrate on the theory and not
on how to code.

I think that it is very very difficult to learn how to code in LISP
if you have only used PL-1, and that only for 6 months at most 
while getting stiff doses of theory in all your courses at the same
time.  I remember compiler-writing was a concurrent course, and that
they were supposed to write it in the PL-1 variant.  (I took that course,
but later, and I brought my own physicist friends with me, and we
point-blank said that we weren't interested in writing a compiler 
unless we could do so in LISP.  Which the department allowed, in
hindsight I think out of astonishment.)

If this experience is in any way typical of computer science teaching,
no wonder we aren't all using LISP today.  I haven't used LISP in 15 years,
but I still _dream_ in LISP sometime, and this whole thread has 
reminded me how much I miss it.  I got an incredible rush of pleasure, and
_memories_ when I first disovered that in python I could write _this_

         apply(eval('widget.' + d['functionName']),(), d['functionArgs'])

What sort of teaching did the rest of you that took computer science
courses get?

Laura Creighton
lac at cd.chalmers.se




More information about the Python-list mailing list