Review of Introduction to Programming

This is my 1999 review of a proposed Wiley college text book by Felleisen, Findler, Flatt, and Krishnamurthi.

Reviewed by Richard J. Wagner, Ph.D.
Lecturer, Computer Science Department
University of Southern California

This text appears to be intended for first-year computer science students (freshman college level). The discussion of numbers on pages 6 and 7 seems to imply that the students have had some mathematics beyond high school algebra and calculus: students are assumed to know the distinction between real and rational numbers. That might include some sophomores and juniors. Yet in exercise 2.2.1 on page nine the authors feel it necessary to suggest that the student look up the formula for the area of a square, which might imply many students have not completed high school.

The intent of the text is to optimize the process of learning computing (programming is the specification of a computation). To do so, the authors utilize the Scheme programming language because it allows the students and instructor to focus on the conceptual aspects of computation and to avoid the distractions of a clumsy syntax such as that found in the C programming language.

This intent is admirable and well thought out and executed. (The "fragmentary draft" I have seems to have several missing sections, A4.1, for example.) Scheme is certainly a clean and elegant language and is well suited for an introduction to programming. It should be noted that the BASIC language was invented for just such a purpose, but has fallen into disuse at the college level. Common Lisp, which is the predecessor of Scheme, is certainly still used, but only at the advanced level for AI programming, not for an introduction. The current practice at USC is to use the C language in our introductory programming course (CSci 101, see http://www-scf.usc.edu/~csci101/). The introductory programming course at USC is required for all engineering students, not just computer science majors, so using a purer language like Scheme is not feasible with the current curriculum at USC.

An example of the benefit to the authors' approach is the early introduction to the benefits of structured design and code reuse on pages 20 and 21. This is an extremely important topic and being able to introduce it early is certainly a major advantage of using Scheme as the pedagogical language. For example, the topic of functions and reuse are not even introduced until approximately 100 pages into the text I am currently using in my introductory programming course.

One question that presents itself is how well will the programming skills developed by working with Scheme transfer to another language such as C. My impression is that good habits learned with Scheme will persist. The explicit use of design recipes (figures 2, 5, 7, and 10, for example) is helpful. Following the recipes can help students overcome inertia (the programmer's version of writer's block).

The text's focus is in keeping with its own recommendation on teaching beginning programming. That is, of the three major knowledge areas engaged in programming, domain (math and science), computation, and computer interfaces, the focus is on principles of programming and computation. User (and system) interface design is properly taught in more advanced courses, yet some rudimentary user interaction is necessary in most useful programs. In many cases in the text's examples, the interaction is with the programmer himself who hard codes domain knowledge into the program in order to sidestep the interface issue. In some exercises a graphical user interface is assumed, such as in the pong game. Details of programming this interface are not provided in the text, so I can only assume that it's an extremely easy to use property of DrScheme and is self-explanatory once one gets into the environment.

Market

This book is appropriate for an introductory course (freshman college) in programming for computer science majors. As the introductory programming course (csci101) at USC is also intended for all engineering majors, this book is not appropriate for any of the current courses at USC.

The level of the text is quite appropriate for an undergraduate level. I am using Structured C for Engineering and Technology by Tom Adamson et al. (Prentice-Hall). As mentioned, it's not fair to compare the two texts because the focus of the reviewed book is much narrower. However, if USC were to create a new introductory course specifically for computer science majors, the book would have to be seriously considered. The DrScheme programming environment seems fun and the book's approach might develop students more rapidly and consistently than our current approach. This needs to be looked into carefully, of course.

Your marketing message for this book should follow the philosophy outlined in the preface, that an introductory programming course should focus on principles of programming and computation.

Approach

The authors' approach is different from that of any other programming book I have read, in that it generally follows the philosopy of focus on programming principles. Their choice of Scheme as the pedagogical language makes this degree of abstraction possible. It remains to be seen how students will react to this approach, but it should make an interesting experiment.

What's Missing?

The preface should address three additional areas of interest to a potential user of the book: the type of course for which the book is intended (and the background and educational objectives of the students taking the course), how the book should be used in courses in quarter and semester systems, and some background about the evolution of Scheme and how and why it was developed. The preface has a section on "The Choice of Scheme?" and a major reason cited is that "...students do not need to learn anything about the vagaries of input and output or the arcane rules of syntax and computation that so often plague approaches based on other languages." yet there seems to be no getting away from a large number of examples of syntax (cons, rest, cond, etc.).

The preface should also make clear that the exercises are designed for use with the programming environment DrScheme which must be available to all students.

Conclusion

On the whole this is an excellent book for teaching an introduction to programming with Scheme. As the authors note, an introduction to programming should focus on computer science (computation and specifying computation). Because of the pedagogical requirement for numerous examples, some programming language must be taught in parallel. This, I think, is the key dilemma confronting any teacher of the subject: we want to teach algorithms in the abstract, but to give experience we must pull the students down into the everyday realities of syntax of a particular language. If a teacher can say at the outset "I have chosen Scheme as my pedagogical language" then I can unreservedly recommend this book. However, the pragmatics of the situation at USC, where many professors assume their students will come into their classes knowing C programming (and the preparation C gives for learning C++ and Java), requires that we teach C at the introductory level.

WileyReview99.html; This hand crafted HTML page established July 1, 2010; last updated July 1, 2010 by Rick Wagner.