Teach Yourself Scheme in Fixnum Days is an introductory
book by Dorai Sitaram on the Scheme programming language using the
Racket Scheme implementation.
It is intended as a quick-start guide, something a
novice can use to get a non-trivial working knowledge of the language,
before moving on to more comprehensive and in-depth texts.
Chapters explore:
Enter Scheme
Data types - simple and compound data types, other
data types, and S-expressions
Forms - procedures, apply, and sequencing
Conditionals - when and unless, cond, case, and and or
Lexical Variables - let and let, fluit-let
Recursion - letrec, Named let, Iteration, and mapping
a procedure across a list
I/O - input/output (I/O) procedures that
will let you read from an input port or write to an output port
Macros - a macro is defined using the special form
define‑macro
Structures - default initializations, defstruct
defined
Alists and tables - alist is a Scheme
list of a special format
System interface - checking for and deleting files,
calling operating-system commands, environment variables
Objects and classes - a simple object system, classes
are instances too, multiple inheritance
Jumps - Scheme allows program control to jump to
arbitrary locations in the program, in contrast to the more
restrained forms of program control flow allowed by
conditionals and procedure calls. This chapter shows how the
call-with-current-continuation operator can be used to create a
breathtaking variety of control idioms
Nondeterminism - description of amb, implementing amb
in Scheme, using amb in Scheme, and logic puzzles
Engines - represents computation that is
subject to timed preemption
Shell scripts - Hello, World!, again, Scripts with
arguments
CGI scripts - scripts that reside on a
web server and can be run by a client (browser)
5. Concrete Abstractions - An Introduction to Computer
Science Using Scheme
Concrete Abstractions - An Introduction to Computer
Science Using Scheme covers the basics of programming
and data structures, and gives first-time computer science students the
opportunity to not only write programs, but to prove theorems and
analyze algorithms as well.
The book features thorough integration of theory and
practice, and presents theory as an essential component of practice,
rather than in contrast to it.
Chapters cover:
Computer Science and Programming - examines
procedures from several different viewpoints. It shows the reader how
to write simple, non-recursive procedures in Scheme
Recursion and Induction - introduces students to
recursion as a way of generating processes of varying sizes
Iteration and Invariants - introduce iteration as an
alternative to recursion, and show how an iterative process uses less
memory than a recursive one
Orders of Growth and Tree Recursion - orders of
growth, tree recursion and digital signatures, an application: fractal
curves
Higher-Order Procedures - procedures taking
procedural parameters, then later by writing procedures that return
procedures (procedure factories), uncomputability, procedures that make
procedures, an application: verifying ID numbers
Compound Data and Data Abstraction - uses the
game of Nim to introduce data abstraction as a method for
dealing with compound data
Lists - explains Scheme lists through the
two-part list viewpoint, and
illustrate them using box-and-pointer diagrams. Construct simple
lists, both explicitly and procedurally, and explain and reinforce
basic list processing idioms (cdring down a list, consing up a list,
map, filter, iteration, and tree recursion)
through numerous examples and exercises
Trees - binary search trees, efficiency issues with
binary search trees, expression trees. The application
section develops an automated phone book using the data retrieval
radix trees know as tries
Generic Operations - multiple representations, and
exploiting commonality. The application section illustrates generic
operations by having the reader implement a computer graphics system
Implementing Programming Languages - writing two
different Scheme evaluators (Micro-Scheme and Mini-Scheme) in Scheme
using the pattern/action system
Computers with Memory - use vectors to program a
simulator for our RISC architecture in Scheme
Dynamic Programming - shows how storage, in the form
of vectors, can be used to dramatically improve the efficiency of
algorithms through the closely related techniques of memoization and
dynamic programming
Object-Based Abstractions - RA-Stack Implementations
and Representation Invariants, Queues, Binary Search Trees Revisited,
An Application: Dictionaries
Object-Oriented Programming - extend object-based
programming to true object-oriented programming
Java, Applets and Concurrency - shows how the
object-oriented programming ideas from the Object-Oriented Programming
chapter can be transplanted into another programming language, Java
6. Revised Report on the Algorithmic Language Scheme
Revised Report on the Algorithmic Language
Scheme gives a defining description of the programming
language Scheme.
Chapters cover:
Introduction - provides a brief history of Scheme and
the report, with an overview of Scheme's semantics
Lexical conventions - an informal account of some of
the lexical conventions used in writing Scheme programs looking at
identifiers, whitespace and comments, and other notations
Basic concepts - variables, syntactic keywords, and
regions, external representations, storage model, and proper tail
recursion
Expressions - describes the syntax and semantics of
primitive and derived expressions
Program Structure - describes the syntax and
semantics of programs and definitions
Standard Procedures - describes Scheme's built-in
procedures, including all of Scheme's data manipulation and
input/output primitives
Formal Syntax and Semantics - provides a formal
syntax for Scheme written in
extended BNF, along with a formal denotational semantics.
An example of the use of the language follows the formal
syntax and semantics
