This book's structure reflects its tutorial intent, rather than any strong grouping of concepts. In the next three chapters, ideas are introduced in the order that we think they're easiest to learn. Each chapter introduces a few more or less related ideas, with small code examples, and ends with more examples of Scheme programs to show why the ideas are useful. The later chapters introduce relatively independent topics.
section Introduction describes some basic features of Scheme, including a little syntax, and gives code examples to show that Scheme can be used like most programming languages--you don't give up much when using Scheme, and it's not hard to switch.
section Using Scheme (A Tutorial) gives a tutorial on Scheme programming, intended to be used while sitting at a running Scheme system and trying examples interactively.
section Writing an Interpreter presents an simple interpreter for a subset of Scheme.
section Environments and Procedures describes Scheme's binding environments and procedures, and shows how procedural abstraction can be very powerful in a language with first-class procedures, block structure indefinite extent (garbage collection). It then shows an implementation of binding environements and procedures for the interpreter from the previous chapter, and shows how to use Scheme's binding and procedure-defining constructs in fairly sophisticated ways.
section Recursion in Scheme discusses recursion, and especially tail recursion.
section Quasiquotation and Macros presents quasiquotation, a means of constructing complex data structures and variants of stereotyped data structures, and then presents macros, a facility for defining your own "special forms" in Scheme. Macros let you define your own control constructs, data-structuring systems such as object systems, etc. (If you've ever been daunted by problems with C or Lisp macros, don't worry--Scheme macros fix the major problems with older macro systems.) Macros are also interesting because they're often used in the implementation of Scheme itself. They allow the language implementation to be structured in a layers, with most of the language written in the language itself, by bootstrapping up from a very small core language understood by the compiler.
section Records and Object Orientation discusses advanced extensions of Scheme such as records (similar to C structs) and object-oriented features such as classes and inheritance.
section Other Useful Features presents a variety of miscellaneous features of Scheme that are useful in writing real programs. They're not part of the conceptual core of Scheme, but any useful language should have them.
section call-with-current-continuation discusses first-class continuations,
the most powerful control construct in Scheme. Continuations allow you
to capture the state of the activation stack (sort of), and return to
that state to resume at a given point in a program's execution.
Continuations are conceptually weird, and are not to be used casually,
but tremendously expressive for things like backtracking, threads, etc.
section A Simple Scheme Compiler presents an example Scheme program that happens to be a simple compiler for Scheme. It's a "toy" compiler, but a real compiler nonetheless, with all of the basic features of any Scheme compiler, but minimal boring "support" hacks to perform tokenization, storage management, etc.