Path: utzoo!attcan!utgpu!jarvis.csri.toronto.edu!rutgers!iuvax!purdue!bu-cs!dartvax!sunapee!hugo
From: hugo@sunapee.dartmouth.edu (Peter Su)
Newsgroups: comp.edu
Subject: Re: Which language to teach first?
Message-ID: <15004@dartvax.Dartmouth.EDU>
Date: 13 Aug 89 14:45:31 GMT
References: <8514@batcomputer.tn.cornell.edu> <207100002@s.cs.uiuc.edu>
Reply-To: hugo@sunapee (Peter Su)
Organization: Dartmouth College
Lines: 61

In article <207100002@s.cs.uiuc.edu> mccaugh@s.cs.uiuc.edu writes:
>
> For anyone interested in keeping tally, of the preceding 24 responses to this
> note, PASCAL was the clear winner, with ML faring the worst.

I think this is a sad testimony to the state of CS education.  Having
seen intro students suffer through courses in Pascal, I can say that I
think the language is just too complicated.  Pascal courses spend all
their time teaching people Pascal and *not* concepts useful for
programming (or computer science) in general.

Here are somethings you can't teach in Pascal

1) General procedural absraction...procedure are not first class
objects.
2) Data abstraction 
3) The whole idea of virtual machines and the relationship between the
language and the computer.

Of course, maybe I'm biased, because Scheme provides good mechanisms
for all of these concepts, and Abelson and Sussman's book is organized
around these lines.  I happen to think this is the right way to do
things, you may disagree with me.

Computer science (and progrmaming) is about abstraction, and every
program that we use presents us with a vitual machine representing a
different abstraction.  I think this is the important thing for people
to learn, and once you have learned it, you can apply the idea
independently of the language that you happen to be using in the real
world. But, in learning these ideas, you have to have a language that
makes the expression of them as easy as possible, and I think
Scheme/Lisp does for a few reasons:

1) Simple syntax.  Lisp's syntax takes a day to learn, maybe less.  In
comparison, at CMU they use complex structure editing systems to try
and shield the students from Pascal's complex syntax.  And Pascal is
pretty simple compared to, say, Ada or C++.

2) Simple semantics.  You don't have to teach two different kinds of
paramter passing.  You don't have to teach them about pointers,
allocating memory, records and all that nonsense before they can do
useful things. I think the only semantic problem with Lisp is the idea
of a special form, i.e. a form that does not evaluate its arguments,
but that can be covered pretty easily.

3) Interpreters are good for easy debugging.  

4) Functions are first class objects.  Student written abstractions
become part of the language just as naturally as the builtin
abstractions.

5) I/O is easy.  Teaching people how to do I/O in Pascal is a pain in
the &*^%$.

Anyway, I've rambled long enough.  Keep in mind that these are just
the ideas of a mixed up grad. student who knows very little about
teaching in general.  I just want to see more intro the CS classes
that are about programming and not about Pascal/Fortran/whatever.

Pete
hugo@sunapee.dartmouth.edu