[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Scheme as an introductory programming language

About two weeks ago, I posted a request for information on the use of
Scheme in first-year computer science courses.  I've had a sense for a
while that the Pascal paradigm isn't really suitable for introductory
students (BC post-secondary institutions generally report combined
failure/attrition rates of 30-40% in these courses, higher than for most
other non-honours courses), and that Scheme might provide a better

One obvious criticism of this approach is that not all students are as
smart as MIT students.  (I quite often have to deal with students who
have completed Grade 12 Algebra/Trigonometry/Calculus yet are
functioning on about a Grade 9 or 10 level.  Such students find
evaluating a Pascal expression such as 3 + 4 DIV 5 * 2 a challenge.) If
in fact such poorer students found Scheme completely mystifying, then it
could immediately be ruled out.  (One might have extensive arguments
about whether such students should be in a post-secondary institution at
all, but probably not in this mailing list.  A propos marginal students,
one of my colleagues said to me, "I only teach to that fraction of the
students which doesn't suffer from 100% rigor mortis.")

I did *not* receive any responses of the form "We tried it, and it was
an unmitigated disaster". A few respondents had a few qualms, but
nothing which argued that the use of Scheme was *worse* than the status
quo. Obviously, one should take the responses below with a grain of
salt: if anyone had found Scheme completely unsuitable, such a person
wouldn't be terribly likely to continue reading here. 

I've edited the responses, mostly in the interests of brevity. On a few
occasions, I've combined two or more separate messages from the same

One note: the books referred to in the following are:
   Abelson, Harold, and Gerald Sussman, with Julie Sussman.
      "Structure and Interpretation of Computer Programs". MIT Press, 
      1985. ISBN 0-262-01077-1 (MIT Press) or 0-07-000-422-6
   Dybvig, R. Kent. "The Scheme Programming Language", Prentice-Hall,
      1987. ISBN 0-13-791864-X.
   Friedman, Daniel P., and Matthias Felleisen. "The Little LISPer (2nd 
      ed.)". Science Research Associates, 1986. [This is also available
      in a Trade Edition from some other publisher, but I don't know the
      difference between the two editions.]

If I get any followup responses, I'll post a summary.

Vincent Manis                manis@instr.camosun.bcc.cdn
The Invisible City of Kitezh ihnp4    |
Camosun College              seismo   |!ubc-vision!instr.camosun.bcc.cdn!manis
3100 Foul Bay Road           uw-beaver|      
Victoria, BC V8P 4X8         manis%instr.camosun.bcc.cdn@ubc.csnet
(604) 592-1281 x480          manis%instr.camosun.bcc.cdn%ubc.csnet@relay.cs.net

From:        Franklyn Turbak <lyn@basel.ai.mit.edu>

In addition to using the Sussman and Abelson book in the core computer
course at MIT, several instructors have prepared a number of useful
class notes. (These notes introduce new models and examples, extend
and clarify some of the main themes of the book, and introduce some
new material.)  I have prepared several such handouts and hope to
combine them with other instructor's materials to form a student workbook in
the not-too-distant future (i.e. this summer).  

Other notes of interest (which you may or may not know):

* There is a (very useful) Instructor's Manual available for the
  Sussman and Abelson book. [This book is published by McGraw-Hill, 
  not MIT Press. -- vm]

* You can obtain from MIT a data base of all the problem sets 
  ever used for the course (eight year's worth!).

* Mike Eisenberg (duck%oz.ai.mit.edu@xx.lcs.mit.edu) is in the final stages
  of preparing a new book on programming in Scheme. (It's a gentler
  introduction to Scheme than Sussman and Abelson, intended primarily for 
  a high school audience.)

* The Center for Advanced Engineering Study (CAES) at MIT offers the
  whole 6.001 course on videotape (with Gerry Sussman and Hal Abelson as
  lecturers).  These tapes are excellent for seeing how well the course
  can be taught; however, I hear they're expensive.  Call CAES
  Information at (617) 253-7400 to find out more information.  (In
  addition to the tapes, I believe that other course materials are also
  available from CAES.)

From: Martin Ward <martin@EASBY.DUR.AC.uk>

I was involved (in 1986) in teaching a computing option to 2nd year
mathematicians at Oxford University (they choose 8 options from ^25 for the
second year). T was the language used because of the simple semantics, the
ability to get started quickly (using the interpreter) and the ability
to write recursive functions, data directed programs etc. and not worry
about details of syntax, arithmetic overflow etc. Since 1987 there has been
a joint honours course in maths and computing, I rhink using T.

For more up to date information try:

Bernard Sufren,
Programming Research Group
Oxford University
8-11 Keble Rd

From: Simon Kaplan <uiucdcs!kaplan.cs.uiuc.edu!kaplan@ihnp4.uucp>

I'm currently well into the first iteration of teaching scheme as an intro
language here for the first time.  The course is an ``experiment'', open
only to selected students.  The class size is around 35 students;  we get
around 300 students taking our intro course for majors each semester.  
The experience of the students ranges from >10 years programming to

The students really seem to enjoy the course, I'm loving teaching it, and
the sort of work you can cover is just amazing.  In regular Pascal courses,
you spend far too much time on the language and not enough on principles;
examples tend to illustrate language constructs, not concepts.  With
Scheme, all that vanishes, and we focus on the concepts.  Within 2 weeks,
students are writing fairly complex recursive routines, and after a month
are working with upward and downward funargs, and learned a lot about
control abstractions.  Next I plan to cover data abstractions, and then
modules, object-oriented programming, and so forth.  More or less I cover
the first 2.5 chapters of A,S&S, and a significant part of a data
structures text such as Reingold and Hansen (data structures in pascal
(except i dont use pascal)).  Also a fair amount on orders of evaluation
and correctness.

Why scheme?  because there are a small number of orthognal constructs out
of which almost all the programming structures the students need can be
built.  This allows a focus on what I think is the single most important
message to give to the students, viz. the concept of building layuers of
abstraction.  In an article in this month's byte, A&S call this ``adding to
the language'' or some such and they have a good point

I am using A,S&S as the text, primarily because there is nothing else
available right now (dybvig is a reference manual and doesnt count).  It
is not a good book for an intro course.  It covers too much, gets too cute,
and focuses too much on numeric examples.  I think that the examples in
chapter 2 are a good example of this:  while they are good examples, the
average student is likely to just be bored to death by them, not seeing the
relevence of all this number crunching.  And thereby miss the entire point
of the chapter.  Another problem is their use of the (define (name args) ...)
form in their examples, which makes iontroducing lambda awkward.  I use the
form (define name (lambda (args) ...))

I built my own notes for the course.  I follow A,S&S closely in the
beginning (was more nervous then) and then branch off.  The skeleton of the
course resembles A,S&S but the details are mostly mine own.  Specifically i
do a lot more on non-numeric data abstraction, and object-oriented
programming.  And then there's a lot of stuff on data structures and
algorithms that they dont get into.

I believe that George Springer at Indiana is workking on a book, which
should be finished soon. I'm looking forward to seeing what he has done.

To conclude:  I firmly believe that a better job of introducing students to
programming can be done in scheme.  Just read A,S&S to see that this is

On the software side, we use MacScheme.  I highly recommend this.  It's
good, reliable, easy to use.  The students would find operating system +
editor + language as we usually do with unix/pascal a bit of a mouthful;
using the macs obviates this.  Some students use PC-scheme (this is just
ti-scheme) and like it, but of course have to learn the edwin editor,
almost emacs, and dos, almost unix.  So the mac is the route of least
resistance for the students.  DONT use mit scheme or T if you can avoid it,
mostly because their debuggers are just terrible.  Mit scheme gives errors
in hex.  T assumes you can program continuation-style to read the debugger.
while this might be true, the freshmen will get blown away...

MacScheme has a lovely debugger, and a good compiler also.

Some personal background:  I am not an AI type;  I work in programming
environments.  And did all my work in C/pascal till last summer.  I was put
on a committee to revise the 1st year courses and read abelson & sussman as
part of that, and came away a convert.

Would I use scheme in the future?  you bet!  I hope the rest of the
department agrees and adopts the experimental course.

From:    Richard Pattis <pattis@june.cs.washington.edu>

Places that I know that use Scheme are Brandies, UC Berkeley, Univ of Oregon
(at Eugene). Contact Harry Mairson at Brandeis, Mike Clancy at Berkeley, and
I don't know who at Oregon.

I think off and on about teaching Scheme (we teach Modula-2 here) and would
be interested in getting the list that you make up of other people already
teaching it.

Rich Pattis

From:    Joel Spolsky <spolsky@eniac.seas.upenn.edu>

The U. of Pennsylvania Computer Science and Engineering curiculum teaches
Abelson and Sussman Scheme (using TI Scheme on IBM-AT's and CScheme on a
VAX) as the *second* part of the introductory programming course; the first
semester is designated "Pascal and Data Structures". They also teach some
ML in this second course.

Of course, MIT uses A&S as their *first* course.

From: Stephen Robbins <Stever@waikato.s4cc.symbolics.com>

I learned SCHEME at MIT in 6.001, "The Structure and Interpretation of Computer
Programs."  A year later, the course notes came out in now-famous book form.

6.001 is one of the most popular courses at MIT, and seems to give people an
excellent (though sometimes grueling) introduction to CS.  

Now, I work at Symbolics as an instructor.  Two weeks ago, I taught my first
Common Lisp One course.

The SICP approach is one I'm very fond of:  use SCHEME as a vehicle for
teaching people to \think/.  That you're learning SCHEME, in particular, is

At Symbolics, we teach students a mental model for understanding the Lisp World
before they ever sit down at a terminal.  That seems to work far better than
the approach that most Lisp texts (e.g. LISP by Winston & Horn) take.

Overall:  teach students how to THINK.  And SCHEME is flexible enough that it
doesn't get in your way a whole lot when you try to translate thought into

[Stephen goes on to compare Scheme with C and Pascal as an introductory
language. I've omitted that in the interests of space, but would be
happy to forward the details to those interested. He argues that it's
possible to teach the basics of the language in about a day. -- vm]

From: Erik Talvola <laba-5ac%widow.Berkeley.EDU@violet.berkeley.edu>

At UC Berkeley, the introductory CS class for EE and CS majors is CS60A -
namely, Scheme.  We use Abelson & Sussman for the textbook, and MIT Scheme
running on Sun 3/50's for the language.  I found it to be an interesting
approach, since, as the teacher pointed out, everyone is pretty much equal
going into the class since nobody learns Scheme/Lisp in high school. 

In A&S, we covered up to the Meta-Circular Evaluator and some of the logic
programming stuff.  This year, they are doing the entire logic programming
section and are doing a little on the register-machine simulator.  Who
knows?  Maybe next year they will cover the whole book in CS60A.  To 
summarize, I enjoyed the class because I was expecting a boring Pascal
class (that is what the course catalog says about 60A!) - instead, I got
a chance to use a language I had virtually no experience with (I used
Lisp a little on an Apple II - but that was it).

The CS60A class at Berkeley is intended for incoming freshman in their
first semester.  Math 1A (Calculus) is listed as a prerequisite, but no
math is really necessary in the course - maybe a little knowledge of
what integration and differentiation are, but that's it. 

From:	     Dan Grim <grim@louie.udel.edu>

The Electrical Engineering Department at the University of Delaware uses
Abelson & Sussman (with Sussman) to teach our first-term freshman course
in programming concepts and algorithms.  We did this for the first time
last fall and have not had sufficient experience to decide whether it has
been more successful than the Pascal programming course that we taught
previously.  However, from the instructors point of view (mine), I found
it much easier to concentrate on the ideas of programs and algorithms
rather than the details of programming.  We used CScheme on a Pyramid
98-XE for the associated lab!

I think that the student reaction was somewhat negative which was not
unexpected.  However, the good students, who would have been bored
silly by Pascal were challenged by Scheme, while the poorer students
had to work harder.  We made an explicit decision to try to challenge
the good students rather than cater to the poorer ones.  Much of what
is in Abelson & Sussman is quite subtle and I was surprised how many
students got it!

End of summary