Share-Ebooks.com

This book is for people who are interested in how Scheme works, or people who are interested in Scheme in terms of programming language design--as well as people who are just interested in using Scheme.

There's not much conflict between these goals, since one of the best ways to learn Scheme--and important principles of language design--is to see how to implement Scheme, in Scheme. I'll illustrate the power of Scheme by showing a couple of simple interpreters for subsets of Scheme, and a simple compiler. A compiler for Scheme can be surprisingly simple and understandable.

This is a fairly traditional approach, pioneered by Abelson and Sussman in Structure and Interpretation of Computer Programs, which is a widely used and excellent introductory programming text. This approach has been followed, more or less, in several other introductory books on Scheme programming. Most of those books, though, are for beginning programmers. While I think Scheme is a great first language, there are many people out there who've had to suffer through C or Pascal or whatever, and don't want to wade through an introductory programming book just to learn Scheme.

My approach is different from most of the current books on Scheme, in several ways. [When it's finished, this book will be hypertext, and can be kept online in online for handy reference in any of several cross-indexed formats...]

I will breeze through basic programming ideas--for example, I assume you have some idea what a variable is, and what recursion is.

I take a more concrete approach than many Scheme writers do, because I've found many students find it easier to understand. Every now and then I'll dip below the language level, and tell you how most actual implementations of the language work. I find that this concreteness helps disambiguate things in many students' minds--as well as in my own.

I do not start from a functional programming perspective that pretends that Scheme executes by rewriting expressions. (If that doesn't mean anything to you, definitely don't worry about it!)

I take Scheme to be a special case of a weakly object-oriented procedural language. By weakly object oriented, I don't mean that it's object-oriented in the sense of having inheritance and so on--though several extended versions of Scheme do. I just mean that the values in the language are data objects (records, etc.) whose identities may be significant--that is, you can compare pointers to two objects to see whether they are the very same object, not just and whether they have the same state--and objects may have mutable (changable) state. (This view is developed further in RScheme, which is a fully object-oriented language that happens also to be Scheme. But that's a different book, not yet written.)

To Download this E-Book Click Here.