 |
By R. Kent Dybvig (504 pages)
Scheme is now a complete general-purpose programming language, though it still derives its power from a small set of key concepts.
This book is intended to provide an introduction to the Scheme programming language but not an introduction to programming in general. The reader needs some experience programming and be familiar with terms commonly associated with computers and programming languages. This book covers the language of the Revised 6 Report.
- Introduction – describes the properties and features of Scheme that make it a useful and enjoyable language to use and describes Scheme’s notational conventions and the typographical conventions employed in this book
- Getting Started – an introduction to Scheme programming for the novice Scheme programmer that leads the reader through a series of examples, beginning with simple Scheme expressions and working toward progressively more difficult ones
- Going Further – covers more advanced features and concepts such as syntactic extension, continuations, and libraries
- Procedures and Variable Bindings – describes operations for creating procedures and variable bindings including variable references, lambda, case-lambda, local binding and more
- Control Operations – examines program control operations
- Operations on Objects – operations on the various object types (including lists, numbers, and strings)
- Input and Output – transcoders, opening files, standard ports, string and bytevector ports, opening custom ports, port operations, input operations, output operations, convenience I/O, filesystem operations, and bytevector/string conversions
- Syntactic Extension – looks at keyword bindings, syntax-rules transformers, syntax-case transformers
- Records – record-type definitions
- Libraries and Top-Level Programs – standard libraries, defining new libraries, and top-level programs
- Exceptions and Conditions
- Extended Examples
|
 |
By Brian Harvey, Matthew Wright (611 pages)
This introduction to computer science and computer programming in Scheme is for non-computer science majors with a strong interest in the subject and for computer science majors who lack prior programming experience.
The text allows the student to experience the computer as a tool for expressing ideas, not as a frustrating set of mathematical obstacles. This goal is supported by the use of Scheme, a modern dialect of Lisp, designed to emphasize symbolic programming.
Chapters cover:
- Introduction – introduces the Scheme programming language. It provides a collection of short Scheme programs, presented to show off what Scheme can do
- Composition of Functions – explores functions in some detail. This chapter separate she idea of functions from the complexities of programming language notation
- Functions as Data – looks at higher-order functions, lambda, as well as a tic-tac-toe example
- Recursion – Introduction to recursion, moves on to build up to a recursive procedure by writing a number of special-case non-recursive procedures, starting with small arguments and working toward larger ones. Later chapters look at recursion in more detail, common patterns in recursive procedures, with an extended example showing off what the reader has been learning to accomplish
- Abstraction – takes a closer look at two specific kinds of abstraction. One is data abstraction, which means the invention of new data types. The other is the implementation of higher-order functions, an important category of the same process abstraction of which third-person is a trivial example
- Sequential Programming – input and output, an example: the functions program, files, vectors, a further example: a spreadsheet program
|
 |
By Max Hailperin, Barbara Kaiser, and Karl Knight (686 pages)
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
|
 |
By Richard K Elsey, William Clinger, Jonathan Rees (90 pages)
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
|
 |
By Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler (HTML)
How to Use Scheme bridges the gap between the basic steps of how to design programs and how to design large programs that interact with all kinds of items in our computer and the network to which it is connected. It introduces the reader to some pretty basic ideas, such as file input and output, to more advanced things, such simple GUI design and Web scripting.
Chapters cover:
- File Input and Output
- S-expressions
- XML and X-expressions
- The Conventional Way
- Reading and Writing Binary Data
- Ports:
- Ports
- Files and Ports
- Strings and Ports
- Networking and Ports
- Creating Your Own Ports
- Strings and Regular Expressions
- Scheme Programs and Shell Scripts
- Files and Directories
- CGI Scripts
- Threads and Custodians
- Modules and Collections
- Classes and Interfaces
- The Graphics Toolbox
- COM Scripting and Dynamic HTML
The Web tree is the publisher-endorsed, on-line version of the book. |
 |
By Dorai Sitaram (105 pages)
Teach Yourself Scheme in Fixnum Days is an introductory book 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)
|
Very helpful – thank you!