Scheme Language

Lisp done right, according to some. Others prefer Common Lisp, right at the other end of the oversimplified/baroque - or, if you prefer, elegant/full-featured - axis. Standard Scheme as defined by the Revised Report On Algorithmic Language Scheme is deliberately minimalistic. Scheme Requests For Implementation provide de facto standards for often needed (and often requested) features and extensions, like record types, multi-threading, exception handling and localization.

Given its small size and minimalistic nature, some ask Is Scheme Suitable For Developing Larger Systems?

Scheme was originally inspired by Carl Hewitt's Actors Model. It served as a proof by example that Actors' message-passing model of execution was equivalent to the more common function-call model. Gerald Sussman and Guy Steele, the original creators of Scheme, discovered that when implementing both models, they ended up with identical functions doing the work.

In the words of Guy Steele ( ): The Scheme programming language was born from an attempt in 1975 to explicate Object Oriented Programming in terms that Gerald Sussman and I could understand. In particular, we wanted to restate Carl Hewitt's theory of actors in words of one syllable, so to speak. One of the conclusions that we reached was that "object" need not be a primitive notion in a programming language; one can build objects and their behavior from little more than assignable value cells and good old Lambda Expressions. Moreover, most of the objects in Hewitt's theory were stateless and unchanging once created; for those, lambda expressions alone were sufficient.

One outcome of this insight is that standard-compliant Scheme Implementations are required to support Proper Tail Calls.

Scheme is seen by some as the Algol of the Lisp Family (see Algol Language and Language Families), because:

It has a considerably less dynamic feel than for example Common Lisp

It introduced Lexical Scoping into the Lisp Family of Programming Languages, a feature subsequently adopted by Common Lisp

It's a small language in the same way that Algol 60 was a small language.

It lacks the ability to print an s-expression and parse it back in.

The compiler operates on text, not s-expressions/forms

The single namespace for variables and functions

External links:

General information:

Scheme Requests For Implementation, the Scheme library standards system:

SLIB, a portable Scheme library:

CSAN (Comprehensive Scheme Archive Network):

Meet schemers in your area through Meet Up:

Online bibliography of Scheme-related research at (maintained by Jim Bender)

Online Scheme Oriented wiki at

PLEAC has a partial cookbook for (at least) Guile:

John Lennon's "Imagine" song as re-imagined by a Schemer:

On getting the code for a procedure:

R5RS does not define an external representation for procedure objects and closures, so there is no portable answer. However, depending on the implementation techniques used and the sophistication of its run time system or debugger environment a given Scheme implementation may let you inspect the machine code or Byte Code representation and the bindings/environment for a given procedure object.

Also, it is possible without too much effort to redefine 'define' to store the definitions in a global map, thus making any non-primitive function's source available. With a little 'magic', it's actually quite easy to make an inspector with formatting, versioning, browsing, etc... :)

Moved from LearningScheme

An excellent way to learn Scheme (and a lot more besides!) is to read Structure And Interpretation Of Computer Programs. Reading SICP is not however something you can do in a weekend, so to get a taste you may like to read a Web Scheme Tutorial. To play around, you'll need an interpreter like Dr Scheme.

If you read a "LISP" tutorial, be mindful that there are many dialects of LISP of which Scheme is one, and while they are similar you will not be able to run (for example) Common Lisp code in a Scheme interpreter. Generally things that relate to Scheme will say so directly, but if you're in doubt then a good rule of thumb is that names like null?, zero?, define are Schemey, whereas zerop, defun, and setq are more Common Lispy.

Scheme bears roughly the same relationship to Mac Lisp and Common Lisp as Java Language does to Cee Language and Cee Plus Plus - or to be a bit more accurate, the same relationship Pascal Language has to Algol Sixty Eight and Ada Language, in that Scheme improved on Mac Lisp by simplifying and regularizing it, and was designed in the early 1970s by a small group of developers for a specific purpose (testing the relationship between Actors and closures, initially, and later, as a language for teaching), whereas Common Lisp improved on Mac Lisp by vastly expanding it and modernizing it, and was designed in the late 1970s and early 1980s by a large committee to support large project development across diverse platforms. - Jay Osako

Evaluator in Silicon

See original on