Scheme is a LISP "dialect" that is relatively small, nicely supports tail recursion, provides block structure and lexical scoping, and gives a variety of object types "first-class" status (e.g. - first class objects are namable and can be passed around as function arguments, results, or as list elements).
If Common LISP is considered analogous to C++ (which is not entirely unreasonable), Scheme would comparatively be analogous to C. Where Common LISP requires that the "rich functionality" (such as a wide variety of data structures and the Common Lisp Object System (CLOS)) come as an intrinsic part of the language, Scheme encourages the use of "libraries" to provide these sorts of additional functionality.
The Scheme libraries are small enough that programmers commonly construct functionality using primitive functions, where a LISP system might have something already defined. This gives additional opportunity either to tune performance or shoot oneself in the foot by reimplementing it poorly...
Scheme web site at Rice University
Commercial Scheme web site
Successful Scheme - Programming language still going strong after 25 years
The Rice University implementation of Scheme; has cross-platform GUI using wxWindows, as well as extensions for processing XML and SrPersist to connect to relational databases using ODBC/SQL-CLI, and, with a more "Schemely" approach, SchemeQL. There are other PLT Scheme Libraries and Extensions, a FastCGI interface, an XML-RPC client, and likely more...
Racket is the new naming for what used to be MzScheme.
A Scheme implementation that does separate compilation of Scheme modules in much the same fashion as one would do with C modules. This allows linking C and Scheme code together.
Implements several SRFIs, and has some support for DSSSL, and an IDE called Bee. It has Yet Another Object System providing CLOS-like generic functions, but no MOP .
Including interfaces to PostgreSQL , CGI , LDAP , GTK , and an XML parser.
A Scheme implementation implemented in C++ and intended to be easy to imbed into C++ applications. Available under the zlib license.
Pizza - a Scheme-to-Java-Bytecode compiler
Stalin: An optimizing compiler for Scheme
A highly optimizing compiler of Scheme written by Jeffrey Siskind to handle relatively static code. It turns Scheme code into C.
An implementation of Lisp/Scheme for the PalmComputing Platform
People at University of Indiana have taken an approach described in SICP (Structure and Interpretation of Computer Programs, describing a Scheme implementation in hardware form. It is not clear that they have actually built the chip...
The University of Montreal implementation of Scheme.
TinyScheme is a small implementation of Scheme written in C that is intended to be readily customized and embedded into applications. The "sample application" is the Altera SQL Server.
Swindle is an object oriented environment based on Xerox TinyCLOS built atop MzScheme.
SRFI-20 - A Simple Object System for Scheme
This SRFI presents an object system to define classes, generic functions as well as to support some level of introspection. This object system is based on Meroon -V3 which is itself inspired by CLOS .
An apparently-really-fast Scheme (at least compared to SCM and Guile ) implemented in C and available under the GPL. Supports GTK and Glade.
S2 - a Scheme to Scheme Compiler
Transforming Scheme in various dialects into standard R5RS form.
Supported dialects include Bigloo, Larceny, MzScheme , Scheme48.
This would, looking at a "Blue Sky" for instance, allow the gentle user to write an application using Bigloo's dependancy management scheme, and then transform it into a more standard form that could be compiled using STALIN into an insanely fast binary form.
Infer: A Statically-typed Dialect of Scheme
Infer combines many (though not all) of the best features of Scheme and ML. Compared with latently-typed languages, such as Scheme , statically-typed languages, such as ML and Infer, sacrifice some expressive power in exchange for the ability to catch many errors at compile time, the possibility of more efficient execution, and some system-verified program documentation.
By supporting all of the forms and primitives procedures of Scheme , with a Scheme-like syntax, it is hoped Infer will prove accessible to Scheme programmers. Efficient compilation of Infer into Scheme is possible, thereby providing compatibility with Scheme programming environments.
Since Infer supports many features of the ML type system, plus a number of others, Infer may also be an attractive alternative to other languages supporting ML-style polymorphism.
The present Infer implementation, written in Infer, is well suited as a test bed for experimentation with a wide range of modern type systems that are based on "core" ML.
Apparently, Graham preferred this version of Scheme to Common Lisp.
An R5RS Scheme implementation intended to be efficient for writing small scripts.
Mostly R6RS...
Probably notable for running on Plan 9
An implementation of Scheme (R7RS) running atop the Section 10.1 virtual machine.
Implemented in C++
A dialect of Scheme implemented in Haskell
Schlep - a simple, not-fully-general Scheme-to-C compiler for SCM
CHICKEN: a Scheme-to-C compiler
The garbage-collection algorithm used is a copying generational collection scheme with a young generation on the C-stack and a large static heap for the old generation. This follows mostly Henry Baker's approach as mentioned in his paper "Cheney on the MTA".
An environment for Win32 Scheme development that generates C code
Structure and Interpretation of Computer Programs (SICP)
I have this book; it is a wonderful introduction to the study of computer science, using Scheme as the implementation language for the computational approaches that it examines.
Structure and Interpretation of Computer Programs ; Harold Abelson, et al; Hardcover
It is also available on the web in full text form!
The Little Schemer ; Daniel P. Friedman, et al; Paperback
I have this book. Pedagogically interesting; you can learn from it, but it's not exactly going to lead you to "how to do mundane database stuff in Scheme."
This continues the story started in [ The Little Schemer]. Again, academically interesting, though a little bit shallow.
The Scheme Programming Language : ANSI Scheme ; R. Kent Dybvig; Paperback
I have this book, in both editions.
The Scheme Programming Language, 2nd Edition (Online copy of Dybvig's book)
Rice PLT TeachScheme Project: Lecture Notes - Designed for use with MzScheme.
PLT mailing lists - for MzScheme.
mzscheme -g makes symbols case sensitive.
So does evaluating (read-case-sensitive #t)
Concrete Abstractions: An Introduction to Computer Science Using Scheme
A book on programming from the makers of PLT Scheme
From the makers of PLT Scheme
An old set of MacTech columns on Scheme
RDBMS Interface to Scheme CBBROWNE note: A similar approach can be taken with scripting languages such as Perl.
Vector mapping functions
;;; The fast version
(define vmap-1
(lambda (proc v)
(let ((len (vector-length v)))
(let ((new-v (make-vector len)))
(let lp ((i 0))
(if (= i len)
new-v
(begin
(vector-set! new-v i (proc (vector-ref v i)))
(lp (+ i 1)))))))))
;;;; Slower and simpler...
(define vmap
(lambda (proc v)
(list->vector
(map proc (vector->list v))))) |
ScmOS - Object System for Scheme
Similar to CLOS, lacks Meta Object Protocol, portable to quite a few Scheme implementations via SLIB as well as working directly with MzScheme.
Scheme object system that resembles CLOS, allows "native" Scheme objects to be seen as Meroon objects, which is portable to quite a few Scheme implementations via SLIB.
Implements a core subset of CLOS in Scheme based on a core MOP; only known to run atop MIT Scheme.
The standard way of encoding style sheet controls in the recent "DSSSL" system happens to be as Scheme code. This is advantageous as Scheme is a fairly small, readily parsed, fairly efficient and readily embeddable language.
SRFI - Scheme Requests For Implementation
An approach to try to build more portable and useful libraries that are better coordinated between Scheme implementations.
They expect, among others, SRFIs for list handling, records, exception handling, foreign function interfaces, and object systems in the near future.
This package allows the programmer to write Scheme code that generates anything expressible in Postscript, and thereby generate Postscript output.
SLIB is a portable scheme library providing compatibility and utility functions for standard Scheme implementations.
FramerD is a portable distributed object-oriented database designed to support the maintenance and sharing of knowledge bases. Unlike other object-oriented databases, FramerD is optimized for the sort of pointer-intensive data structures used by semantic networks, frame systems, and many intelligent agent applications. FramerD databases readily include millions of searchable frames and may be distributed over multiple networked machines. FramerD includes an extensive scripting language based on Scheme with special support for web-based interfaces.
A project of the MIT Media Lab, with code available as free software under the GPL.
A discussion of ideas/issues in the design of module systems for Scheme.
Essence, an LR parser generator for Scheme
Essence is a generator for LR(k) and SLR(k) parsers in Scheme. The generated parsers perform error recovery, and are highly efficient. Testing and debugging a parser does not require an edit-generate-compile-test cycle.
Rather, the parser generator results from a general parser which takes the input grammar as a parameter; no generation and recompilation is necessary to try out changes to a grammar.
The generated parsers result from the general parser by an automatic program transformation called partial evaluation. This guarantees consistency and ensures correctness. However, no specific knowledge of partial evaluation is required to use Essence.
AL - Animation Language - implemented in Scheme.
Article on doing formal reasoning with a "meta-language" using Scheme.
A delegation language to request weather products and a scheme of its interpretation
MetaCast - Distributing Weather Products through an HTTP pipe
An application of Environments (like Apple Newton soups) to formulate complex, many-parameter queries for weather products.
The environment is like a "database" (or soup in NewtonScript). It does not follow any static scope of Scheme expressions, nor a dynamic scope of Scheme procedure activations. It is a (hierarchical) repository that any procedure may deposit things into, or request values associated with a name (a key-symbol).
The beginnings of a TeX implementation in Scheme . Further work has been done in OCAML .
A package that provides Prolog functionality atop Scheme.
This is a description of the Scmutils system, an integrated library of procedures, embedded in the programming language Scheme, and intended to support teaching and research in mathematical physics and electrical engineering. Scmutils and Scheme are particularly effective in work where the almost- functional nature of Scheme is advantageous, such as classical mechanics, where many of the procedures are most easily formulated as quite abstract manipulations of functions.
Lisp as an Alternative to Java
A research study considering the implementation time and performance of programs solving a particular problem, implemented in Common Lisp and Scheme.
Results were generally better than with C or Java. The interesting thing was that variability of both performance and of programming time was far less with Lisp.
Lisp as an Alternative to Java - Peter Norvig implements solutions to the Lisp-as-Alternative-to-Java problems in Common Lisp
This is a CGI script to retrieve SIGMET Advisories and translate the OMF XML document into a simple HTML page; implemented in MzScheme as a sort of "ASP-like" application...
This Apache module provides a mean for communication between Apache server and an external process using Unix pipes. The idea behind is inspired by Oleg Kiselyov's work Writing agents in sh: conversing through a pipe and mod_pipe depends on his tool exec_with_piped.
The mod_pipe is designed for the inclusion of Scheme language instructions in the Apache -processed HTML files. Using mod_pipe Scheme interpreter may be started once and when acts as Scheme servlet engine.
Such an architecture reduces the per-request overhead, as the expensive start-up process is not required. Thus it possible, for example, to load a bulk of data at the interpreters start and query this data later including the reply in the pre-build HTML pages. The example provided includes in the HTML page the value of the variable scm-interpreter which is bound at the Scheme interpreter initialization time.
This project is devoted to the construction of high quality libraries for the Scheme language, and PLT Scheme in particular.
WB - Wanna B-tree
WB is a disk based, sorted associative array C library. WB has an optional interface to the SCM Scheme implementation which supports SLIB relational databases.
Guile, The Guile Architecture for Ubiquitous Computing, is a language based on Scheme that is targeted as an embeddable scripting language for applications by the FSF. There is both a Scheme-like syntax as well as a C-like syntax (that it appears that nobody uses).
Directory of /pub/guile at red-bean.com
This is the "official" location where experimental Guile source code resides.
Guile sample...
Top-level Environments in Guile - a draft proposal for a new datatype for representing top-level environments in Guile.
guile-fltk is a module for Guile that binds the Fltk widget library to scheme.
The Gossip Simulation Environment
A Guile -based simulation system for communications engineering and digital signal processing. Includes:
Simulation engine
Simulation components/blocks
Schematic capture tool using GTK
Extension to allow Gossip to read VHDL files
(hosted at SourceForge )
This contains Scheme code (as well as code in various other languages) to perform the same functions found in "Perl Cookbook: Tips and Tricks for Perl Programmers" by Tom Christiansen and Nathan Torkington
Editing Sound using Snd - which uses Guile
Coldstore proposes a Guile binding for the Coldstore persistent object database.