Scheme as an introductory programming language 
Author Message
 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
approach.

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
person.

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
      (McGraw-Hill).

   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.


The Invisible City of Kitezh ihnp4    |
Camosun College              seismo   |!ubc-vision!instr.camosun.bcc.cdn!manis
3100 Foul Bay Road           uw-beaver|      


------------------------------------------------------------

------------------------------------------------------------

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!).


  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.)

------------------------------------------------------------

------------------------------------------------------------

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
Oxford

------------------------------------------------------------

------------------------------------------------------------

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
nothing.  

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
so!!

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 de{*filter*}s are just terrible.  Mit scheme gives errors
in hex.  T assumes you can program continuation-style to read the de{*filter*}.
while this might be true, the freshmen will get blown away...

MacScheme has a lovely de{*filter*}, 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.

------------------------------------------------------------

------------------------------------------------------------

Places that I know that use Scheme are Brandies, UC Berkeley, Univ of Oregon
(at Eugene). Contact Harry Mairson at ...

read more »



Mon, 17 Aug 1992 19:35:00 GMT  
 Scheme as an introductory programming language
I'm responding rather late to your inquiry on Scheme use.

We use scheme and SICP in our first course here at Delaware.  We follow it
with a course which uses Modula2.  Together, they seem to provide a good
basis for the rest of the program.  We don't push extremely hard.  From,
Ableson and Sussman we cover the first 3 chapters, and introduce the
interpreter of chapter 4 in the last week.  Some of the students' mathematics
backgrounds are weak, but that has not been a major obsticle. Many take the
course concurrently with Calculus and that works fine.  The use of "big O"
and logs gives trouble too, but that is essential CS and we regard it as
our job to build a modicum of skill with those things.  Actually, I think
that scheme/lisp is much gentler in its mathematical demands on novices
than pascal.  It allows them to get to the essence of programming without
having to fight past artificial distinctions about types of numbers.
The students program in C-scheme on a vax.
-david saunders



Mon, 17 Aug 1992 17:50:00 GMT  
 
 [ 2 post ] 

 Relevant Pages 

1. Scheme as an introductory programming language

2. Smalltalk as introductory programming language?

3. Logic Programming as an Introductory Programming Paradigm

4. Logic Programming an Introductory Programming Paradigm

5. Logic Programming as an introductory programming paradigm

6. Logic Programming as an Introductory Programming Paradigm

7. Logic Programming as an Introductory Programming Paradigm

8. Scheme Introductory article

9. What is good introductory Scheme book?

10. New introductory Scheme text

11. Scheme Introductory article

12. Eiffel as introductory language

 

 
Powered by phpBB® Forum Software