manis%instr.camosun.bcc.CDN@ean.ubc.ca (Vincent Manis) (02/24/88)
I'd like to get some information on the experiences of people who have used Scheme as the programming language for introductory, first-year, courses in Computer Science (at, e.g., the ACM CS-1/CS-2 level). I'm particularly interested in building a list of institutions which offer introductory programming courses using Scheme, but I'm also interested in textbooks and other resources they use, or any other information which might be available. Experience with in-class use of the various Scheme implementations which are generally available would also be helpful. If you looked at Scheme and then decided on Pascal or something instead, I'd be interested in your rationale, too. I'm well aware of Abelson and Sussman (with Sussman), as well as the Friedman and Dybvig books. I've also used PC Scheme extensively and MacScheme a little bit. I'm less interested in other Lisp dialects than Scheme (though T would certainly be of great interest). I will of course post a summary of the replies. AtDhVaAnNkCxE 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
manis%instr.camosun.bcc.CDN@ean.ubc.ca (Vincent Manis) (03/08/88)
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. 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 Oxford ------------------------------------------------------------ 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 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 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 secondary. 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 program. [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 ------------------------------------------------------------
saunders@UDEL.EDU (David Saunders) (03/25/88)
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