-*- coding: utf-8; mode: text; -*-

      The programmers of old were mysterious and profound.  We
   cannot fathom their thoughts, so all we do is describe their
   appearance.
      Aware, like a fox crossing the water.  Alert, like a general
   on the battlefield.  Kind, like a hostess greeting her guests.
      Simple, like uncarved blocks of wood.  Opaque, like black
   pools in darkened caves.
      Who can tell the secrets of their hearts and minds?
      The answer exists only in the Tao.
         -- Geoffrey James, "The Tao of Programming"


BROAD OUTLINE

SBCL is derived from the 18b version of CMU CL.

Most of CMU CL was originally written as part of the CMU Common Lisp
project at Carnegie Mellon University. According to the documentation
in CMU CL 18b,
    Organizationally, CMU Common Lisp was a small, mostly autonomous
  part within the Mach operating system project. The CMU CL project
  was more of a tool development effort than a research project.
  The project started out as Spice Lisp, which provided a modern
  Lisp implementation for use in the CMU community.
and
  CMU CL has been under continuous development since the early 1980's
  (concurrent with the Common Lisp standardization effort.)
Apparently most of the CMU Common Lisp implementors moved on to
work on the Gwydion environment for Dylan.

CMU CL's CLOS implementation is derived from the PCL reference
implementation written at Xerox PARC.

CMU CL's implementation of the LOOP macro was derived from code
from Symbolics, which was derived from code from MIT.

CMU CL had many individual author credits in the source files. In the
sometimes-extensive rearrangements which were required to make SBCL
bootstrap itself cleanly, it was tedious to try keep such credits
attached to individual source files, so they have been moved here
instead.

Bill Newman <william.newman@airmail.net> did this transformation, and
so any errors made are probably his. Corrections would be appreciated.


MORE DETAILS ON SBCL'S CLOS CODE

The original headers of the PCL files contained the following text:

;;; Any person obtaining a copy of this software is requested to send their
;;; name and post office or electronic mail address to:
;;;   CommonLoops Coordinator
;;;   Xerox PARC
;;;   3333 Coyote Hill Rd.
;;;   Palo Alto, CA 94304
;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
;;;
;;; Suggestions, comments and requests for improvements are also welcome.

This was intended for the original incarnation of the PCL code as a
portable reference implementation. Since our version of the code has
had its portability hacked out of it, it's no longer particularly
relevant to any coordinated PCL effort (which probably doesn't exist
any more anyway). Therefore, this contact information has been deleted
from the PCL file headers.

A few files in the original CMU CL 18b src/pcl/ directory did not
carry such Xerox copyright notices:
  * Some code was originally written by Douglas T. Crosher for CMU CL:
    ** the Gray streams implementation
    ** the implementation of DOCUMENTATION as methods of a generic
       function
  * generic-functions.lisp seems to have been machine-generated.

The comments in the CMU CL 18b version of the PCL code walker,
src/pcl/walk.lisp, said in part
;;;   a simple code walker, based IN PART on: (roll the credits)
;;;      Larry Masinter's Masterscope
;;;      Moon's Common Lisp code walker
;;;      Gary Drescher's code walker
;;;      Larry Masinter's simple code walker
;;;      .
;;;      .
;;;      boy, thats fair (I hope).


MORE DETAILS ON SBCL'S LOOP CODE

The src/code/loop.lisp file from CMU CL 18b had the following
credits-related information in it:

;;;   The LOOP iteration macro is one of a number of pieces of code
;;;   originally developed at MIT for which free distribution has been
;;;   permitted, as long as the code is not sold for profit, and as long
;;;   as notification of MIT's interest in the code is preserved.
;;;
;;;   This version of LOOP, which is almost entirely rewritten both as
;;;   clean-up and to conform with the ANSI Lisp LOOP standard, started
;;;   life as MIT LOOP version 829 (which was a part of NIL, possibly
;;;   never released).
;;;
;;;   A "light revision" was performed by me (Glenn Burke) while at
;;;   Palladian Software in April 1986, to make the code run in Common
;;;   Lisp. This revision was informally distributed to a number of
;;;   people, and was sort of the "MIT" version of LOOP for running in
;;;   Common Lisp.
;;;
;;;   A later more drastic revision was performed at Palladian perhaps a
;;;   year later. This version was more thoroughly Common Lisp in style,
;;;   with a few miscellaneous internal improvements and extensions. I
;;;   have lost track of this source, apparently never having moved it to
;;;   the MIT distribution point. I do not remember if it was ever
;;;   distributed.
;;;
;;;   The revision for the ANSI standard is based on the code of my April
;;;   1986 version, with almost everything redesigned and/or rewritten.

The date of the M.I.T. copyright statement falls around the time
described in these comments. The dates on the Symbolics copyright
statement are all later -- the earliest is 1989.


MORE DETAILS ON OTHER SBCL CODE FROM CMU CL

CMU CL's symbol (but not package) code (code/symbol.lisp) was
originally written by Scott Fahlman and updated and maintained
by Skef Wholey.

The CMU CL reader (code/reader.lisp) was originally the Spice Lisp
reader, written by David Dill and with support for packages added by
Lee Schumacher. David Dill also wrote the sharpmacro support
(code/sharpm.lisp).

CMU CL's package code was rewritten by Rob MacLachlan based on an
earlier version by Lee Schumacher. It also includes DEFPACKAGE by Dan
Zigmond, and WITH-PACKAGE-ITERATOR written by Blaine Burks. William
Lott also rewrote the DEFPACKAGE and DO-FOO-SYMBOLS stuff.

CMU CL's string code (code/string.lisp) was originally written by
David Dill, then rewritten by Skef Wholey, Bill Chiles, and Rob
MacLachlan.

Various code in the system originated with "Spice Lisp", which was
apparently a predecessor to the CMU CL project. Much of that was
originally written by Skef Wholey:
	code/seq.lisp, generic sequence functions, and COERCE
	code/array.lisp, general array stuff
	SXHASH
	code/list.lisp, list functions (based on code from Joe Ginder and
		Carl Ebeling)
The CMU CL seq.lisp code also gave credits for later work by Jim Muller
and Bill Chiles.

The modules system (code/module.lisp, containing REQUIRE, PROVIDE,
and friends, now deprecated by ANSI) was written by Jim Muller and
rewritten by Bill Chiles.

The CMU CL garbage collector was credited to "Christopher Hoover,
Rob MacLachlan, Dave McDonald, et al." in the CMU CL code/gc.lisp file,
with some extra code for the MIPS port credited to Christopher Hoover
alone. The credits on the original "gc.c", "Stop and Copy GC based
on Cheney's algorithm", said "written by Christopher Hoover".

Guy Steele wrote the original character functions
	code/char.lisp
They were subsequently rewritten by David Dill, speeded up by Scott
Fahlman, and rewritten without fonts and with a new type system by Rob
MachLachlan.

Lee Schumacher made the Spice Lisp version of backquote. The comment
in the CMU CL sources suggests he based it on someone else's code for
some other Lisp system, but doesn't say which. A note in the CMU CL
code to pretty-print backquote expressions says that unparsing support
was provided by Miles Bader.

The CMU implementations of the Common Lisp query functions Y-OR-N-P
and YES-OR-NO-P were originally written by Walter van Roggen, and
updated and modified by Rob MacLachlan and Bill Chiles.

The CMU CL sort functions (code/sort.lisp) were written by Jim Large,
hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles.

Most of the internals of the Python compiler seem to have been
originally written by Robert MacLachlan:
	the type system and associated "cold load hack magic"
		code/typedefs.lisp
		code/class.lisp
		code/type-init.lisp
		etc.
	the lexical environment database
		compiler/globaldb.lisp, etc.
	the IR1 representation and optimizer
		compiler/ir1*.lisp, etc.
	the IR2 representation and optimizer
		compiler/ir2*.lisp, etc.
	many concrete optimizations
		compiler/srctran.lisp (with some code adapted from
			CLC by Wholey and Fahlman)
		compiler/float-tran.lisp, etc.
	information about optimization of known functions
		compiler/fndb.lisp
	debug information representation
		compiler/debug.lisp, compiler/debug-dump.lisp
	memory pools to reduce consing by reusing compiler objects
		compiler/alloc.lisp
	toplevel interface functions and drivers
		compiler/main.lisp
Besides writing the compiler, and various other work mentioned elsewhere,
Robert MacLachlan was also credited with tuning the implementation of
streams for Unix files, and writing
	various floating point support code
		code/float-trap.lisp, floating point traps
		code/float.lisp, misc. support a la INTEGER-DECODE-FLOAT
	low-level time functions
		code/time.lisp

William Lott is also credited with writing or heavily maintaining some
parts of the CMU CL compiler. He was responsible for lifting
compiler/meta-vmdef.lisp out of compiler/vmdef.lisp, and also wrote
	various optimizations
		compiler/array-tran.lisp
		compiler/saptran.lisp
		compiler/seqtran.lisp (with some code adapted from an older
			seqtran written by Wholey and Fahlman)
	the separable compiler backend
		compiler/backend.lisp
		compiler/generic/utils.lisp
	the implementation of LOAD-TIME-VALUE
		compiler/ltv.lisp
	the most recent version of the assembler
		compiler/new-assem.lisp
	vop statistics gathering
		compiler/statcount.lisp
	centralized information about machine-dependent and..
	..machine-independent FOO, with
		compiler/generic/vm-fndb.lisp, FOO=function signatures
		compiler/generic/vm-typetran.lisp, FOO=type ops
		compiler/generic/objdef.lisp, FOO=object representation
		compiler/generic/primtype.lisp, FOO=primitive types
Also, Christopher Hoover and William Lott wrote compiler/generic/vm-macs.lisp
to centralize information about machine-dependent macros and constants.

Sean Hallgren is credited with most of the Alpha backend.  Julian
Dolby created the CMU CL Alpha/Linux port. Douglas Crosher added
complex-float support.

The original PPC backend was the work of Gary Byers.  Some bug fixes
and other changes to update it for current CMUCL interfaces were made
by Eric Marsden and Douglas Crosher

The CMU CL machine-independent disassembler (compiler/disassem.lisp)
was written by Miles Bader.

Parts of the CMU CL system were credited to Skef Wholey and Rob
MacLachlan jointly, perhaps because they were originally part of Spice
Lisp and were then heavily modified:
	code/load.lisp, the loader, including all the FASL stuff
	code/macros.lisp, various fundamental macros
	code/mipsstrops.lisp, primitives for hacking strings
	code/purify.lisp, implementation of PURIFY
	code/stream.lisp, stream functions
	code/lispinit.lisp, cold startup
	code/profile.lisp, the profiler

Bill Chiles also modified code/macros.lisp. Much of the implementation
of PURIFY was rewritten in C by William Lott.

The CMU CL number functions (code/number.lisp) were written by Rob
MacLachlan, but acknowledge much code "derived from code written by
William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc."

CMU CL's weak pointer support (code/weak.lisp) was written by
Christopher Hoover.

The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
Lott and Skef Wholey jointly.

The FDEFINITION system for handling arbitrary function names (a la
(SETF FOO)) was originally written by Rob MacLachlan. It was modified
by Bill Chiles to add encapsulation, and modified more by William Lott
to add FDEFN objects.

The CMU CL condition system (code/error.lisp) was based on
some prototyping code written by Kent Pitman at Symbolics.

The CMU CL HASH-TABLE system was originally written by Skef Wholey
for Spice Lisp, then rewritten by William Lott, then rewritten
again by Douglas T. Crosher.

The support code for environment queries (a la LONG-SITE-NAME),
the DOCUMENTATION function, and the DRIBBLE function was written
and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott
Fahlman, Dan Aronson, and Steve Handerson did stuff here too."
The same credit statement was given for the original Mach OS interface code.

The CMU CL printer, print.lisp, was credited as "written by Neal
Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and modified
by various CMU Common Lisp maintainers." The comments on the float
printer said specifically that it was written by Bill Maddox. The
comments on bignum printing said specifically that it was written by
Steven Handerson (based on Skef's idea), and that it was rewritten by
William Lott to remove assumptions about length of fixnums on the MIPS
port.

The comments in the main body of the CMU CL debugger
	code/debug.lisp
say that it was written by Bill Chiles. Some other related files
	code/debug-int.lisp, programmer's interface to the debugger
	code/ntrace.lisp, tracing facility based on breakpoints
say they were written by Bill Chiles and Rob MacLachlan.
The related file
	src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
was written by William Lott.

The CMU CL GENESIS cold load system,
compiler/generic/new-genesis.lisp, was originally written by Skef
Wholey, then jazzed up for packages by Rob MacLachlan, then completely
rewritten by William Lott for the MIPS port.

The CMU CL IR1 interpreter was written by Bill Chiles and Robert
MacLachlan.

Various CMU CL support code was written by William Lott:
	the bytecode interpreter
		code/byte-interp.lisp
	bitblt-ish operations a la SYSTEM-AREA-COPY
		code/bit-bash.lisp
	Unix interface
		code/fd-stream.lisp, Unix file descriptors as Lisp streams
		code/filesys.lisp, other Unix filesystem interface stuff
	handling errors signalled from assembly code
		code/interr.lisp
		compiler/generic/interr.lisp
	finalization based on weak pointers
		code/final.lisp
	irrational numeric functions
		code/irrat.lisp
	the pretty printer
		code/pprint.lisp
	predicates (both type predicates and EQUAL and friends)
		code/pred.lisp
	saving the current Lisp image as a core file
		code/save.lisp
	handling Unix signals
		code/signal.lisp
	implementing FORMAT
		code/format.lisp

The ALIEN facility seems to have been written largely by Rob
MacLachlan and William Lott. The CMU CL comments say "rewritten again,
this time by William Lott and Rob MacLachlan," but don't identify who
else might have been involved in earlier versions.

The comments in CMU CL's code/final.lisp say "the idea really was
Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm
stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp
say "with lots of stuff stolen from the previous version by David Adam
and later rewritten by Bill Maddox."

Jim Muller was credited with fixing seq.lisp.

CMU CL's time printing logic, in code/format-time.lisp, was written
by Jim Healy.

Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.

The CMU CL machine/filesystem-independent pathname functions
(code/pathname.lisp) were written by William Lott, Paul Gleichauf, and
Rob MacLachlan, based on an earlier version written by Jim Large and
Rob MacLachlan.

Besides writing the original versions of the things credited to him
above, William Lott rewrote, updated, and cleaned up various stuff:
	code/array.lisp
	code/serve-event.lisp

The INSPECT function was originally written by Blaine Burks.

The CMU CL DESCRIBE facility was originally written by "Skef Wholey or
Rob MacLachlan", according to the comments in the CMU CL sources. It
was cleaned up and reorganized by Blaine Burks, then ported and
cleaned up more by Rob MacLachlan. Also, since the split from CMU CL,
the SBCL DESCRIBE facility was rewritten as a generic function and so
become entangled with some DESCRIBE code which was distributed as part
of PCL.

The implementation of the Mersenne Twister RNG used in SBCL is based
on an implementation written by Douglas T. Crosher and Raymond Toy,
which was placed in the public domain with permission from M.
Matsumoto.

Comments in the CMU CL version of FreeBSD-os.c said it came from
an OSF version by Sean Hallgren, later hacked by Paul Werkowski,
with generational conservative GC support added by Douglas Crosher.

Comments in the CMU CL version of linux-os.c said it came from the
FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996.

Comments in the CMU CL version of backtrace.c said it was "originally
from Rob's version" (presumably Robert Maclachlan).

Comments in the CMU CL version of purify.c said it had stack direction
changes, x86/CGC stack scavenging, and static blue bag stuff (all for
x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code
movement support, and x86/gencgc stack scavenging by Douglas Crosher,
1996, 1997, 1998.

According to comments in the source files, much of the CMU CL version
of the x86 support code
	assembly/x86/alloc.lisp
	assembly/x86/arith.lisp
	assembly/x86/array.lisp
	assembly/x86/assem-rtns.lisp
	compiler/x86/alloc.lisp
	compiler/x86/arith.lisp
	compiler/x86/c-call.lisp
	compiler/x86/call.lisp
	compiler/x86/cell.lisp
	compiler/x86/char.lisp
	compiler/x86/debug.lisp
	compiler/x86/float.lisp
	compiler/x86/insts.lisp
	compiler/x86/macros.lisp
	compiler/x86/memory.lisp
	compiler/x86/move.lisp
	compiler/x86/nlx.lisp
	compiler/x86/parms.lisp
	compiler/x86/pred.lisp
	compiler/x86/print.lisp
	compiler/x86/sap.lisp
	compiler/x86/static-fn.lisp
	compiler/x86/subprim.lisp
	compiler/x86/system.lisp
	compiler/x86/type-vops.lisp
	compiler/x86/values.lisp
	compiler/x86/vm.lisp
was originally written by William Lott, then debugged by Paul
Werkowski, and in some cases later enhanced and further debugged by
Douglas T. Crosher; and the x86 runtime support code,
	x86-assem.S
was written by Paul F. Werkowski and Douglas T. Crosher.

The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86
FreeBSD port was originally contributed by Paul Werkowski, and Peter
VanEynde took the FreeBSD port and created a Linux version.

According to comments in src/code/bsd-os.lisp, work on the generic BSD
port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan
Aronson, and Steve Handerson.

Douglas Crosher wrote code to support Gray streams, added X86 support
for the debugger and relocatable code, wrote a conservative
generational GC for the X86 port.  He also added X86-specific
extensions to support stack groups and multiprocessing, but these are
not present in SBCL

The CMU CL user manual credits Robert MacLachlan as editor. A chapter
on the CMU CL interprocess communication extensions (not supported in
SBCL) was contributed by William Lott and Bill Chiles.

Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
to CMU CL, to provide additional safety, especially through runtime
checking on various tricky cases of standard functions (e.g. MAP with
complicated result types, and interactions of various variants of
STREAM).

Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various
other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE
entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went
away completely as the code became an unconditional part of the
system.)

CMU CL's long float support was written by Douglas T. Crosher.

Paul Werkowski turned the Mach OS support code into Linux OS support code.

Versions of the RUN-PROGRAM extension were written first by David
McDonald, then by Jim Healy and Bill Chiles, then by William Lott.


MORE DETAILS ON THE TRANSITION FROM CMU CL

Bill Newman did the original conversion from CMU CL 18b to a form
which could bootstrap itself cleanly, on Linux/x86 only. Although they
may not have realized it at the time, Rob Maclachlan and Peter Van
Eynde were very helpful, RAM by posting a clear explanation of what
GENESIS is supposed to be doing and PVE by maintaining a version of
CMU CL which worked on Debian, so that I had something to refer to
whenever I got stuck.


CREDITS SINCE THE RELEASE OF SBCL

(Note: (1) This is probably incomplete, since there's no systematic
procedure for updating it. (2) Some more details are available in the
NEWS file, in the project's CVS change logs, and in the archives of
the sbcl-devel mailing list. (3) In this, as in other parts of SBCL,
patches are welcome. Don't be shy.)

Martin Atzmueller:
  He reported many bugs, fixed many bugs, ported various fixes
  from CMU CL, and helped clean up various stale bug data. (He has
  been unusually energetic at this. As of sbcl-0.6.9.10, the
  total number of bugs involved likely exceeded 100. Since then,
  I've lost count. See the CVS logs.)

Daniel Barlow:
  His contributions have included support for shared object loading
  (from CMUCL), the Cheney GC for non-x86 ports (from CMUCL), Alpha
  and PPC ports (from CMUCL), control stack exhaustion checking (new),
  native threads support for x86 Linux (new), and the initial x86-64
  backend (new).  He also refactored the garbage collectors for
  understandability, wrote code (e.g. grovel-headers.c and
  stat_wrapper stuff) to find machine-dependent and OS-dependent
  constants automatically, and was original author of the asdf,
  asdf-install, sb-bsd-sockets, sb-executable, sb-grovel and sb-posix
  contrib packages.

Zach Beane:
  He provided a number of additions to SB-POSIX, implemented the
  original timer facility on which SBCL's timers are based. and also
  contributed the :SAVE-RUNTIME-OPTIONS support for SAVE-LISP-AND-DIE.

James Bielman:
  He assisted in work on the port to the Windows operating system, and
  was instrumental in :EXECUTABLE support for SAVE-LISP-AND-DIE.

Alastair Bridgewater:
  He contributed a port of the system to the Windows operating system.

Robert E. Brown:
  He has reported various bugs and submitted several patches,
  especially improving removing gratuitous efficiencies in the
  standard library.

Cadabra, Inc. (later merged into GoTo.com):
  They hired Bill Newman to do some consulting for them,
  including the implementation of EQUALP hash tables for CMU CL;
  then agreed to release the EQUALP code into the public domain,
  giving SBCL (and CMU CL) its EQUALP hash tables.

Douglas Crosher:
  He continued to improve CMU CL after SBCL forked from it, creating
  many patches which were directly applicable to SBCL. Notable examples
  include fixes for various compiler bugs, the implementation of
  CL:DEFINE-SYMBOL-MACRO, and a generalization of the type system's
  handling of the CONS type to allow ANSI-style (CONS FOO BAR) types.

Larry D'Anna:
  He provided several parts of SB-CLTL2 environment access, and has
  also worked on bugs in the IR2 conversion stage of the compiler.

Alexey Dejneka:
  He fixed many, many bugs on various themes, and has done a
  tremendous amount of work on the compiler in particular, fixing
  bugs and refactoring.

Paul Dietz:
  He is in the process of writing a comprehensive test suite
  for the requirements of the ANSI Common Lisp standard. Already, at
  the halfway stage, it has caught hundreds of bugs in SBCL, and
  provided simple test cases for them. His random crash tester has
  caught an old deep problem in the implementation of the stack
  analysis phase in the compiler.

Brian Downing:
  He fixed the linker problems for building SBCL on Mac OS X.  He
  found and fixed the cause of backtraces failing for undefined
  functions and assembly routines. He wrote the core of SBCL's 
  alternative interpreter-based EVAL.

Miles Egan:
  He creates binary packages of SBCL releases for Red Hat and other
  (which?) platforms.

Helmut Eller:
  A lot of the code in the SB-INTROSPECT and SB-COVER contrib modules
  was originally written by him for Slime/Swank.

Lutz Euler:
  He made a large number of improvements to the x86-64 disassembler.

Andreas Fuchs:
  He provides infrastructure for monitoring build and performance
  regressions of SBCL.  He assisted with the integration of the
  Unicode work.

Stephan Frank:
  He contributed the SB-GMP contrib to exploit libgmp in bignum and
  ratio arithmetic.

Nathan Froyd:
  He has fixed various bugs, and also done a lot of internal
  cleanup, not visible at the user level but important for
  maintenance. (E.g. converting the PCL code to use LOOP instead
  of the old weird pre-ANSI ITERATE macro so that the code can be
  read without being an expert in ancient languages and so that we
  can delete a thousand lines of implement-ITERATE macrology from
  the codebase.)

Bruno Haible:
  He devised an accurate continued-fraction-based implementation of
  RATIONALIZE, replacing a less-accurate version inherited from
  primordial CMUCL.

Cyrus Harmon:
  He fixed many PPC FFI and callback bugs.  He ported Raymond Toy's
  work on the generational garbage collector for PPC to Linux, finding
  and fixing other SBCL bugs in the process.

Matthias Hoelzl:
  He reported and fixed COMPILE's misbehavior on macros.

Daisuke Homma:
  He added support for SunOS on x86 processors.

ITA Software:
  They hired Juho Snellman as a consultant to work on improvements to
  SBCL, to be released into the public domain. The work they've funded
  includes faster compilation, various improvements to the statistical
  profiler, the SB-COVER code coverage tool, the interpreter-based
  evaluator and the IR2-based single-stepper.

Espen S Johnsen:
  He provided an ANSI-compliant version of CHANGE-CLASS for PCL.

Teemu Kalvas:
  He worked on Unicode support for SBCL, including parsing the Unicode
  character database, restoring the FAST-READ-CHAR optimization and
  developing external format support.

Dmitry Kalyanov:
  His work was crucial in bringing the Windows backend forward; he
  implemented pthreads and ported SB-THREAD to this platform.

Yaroslav Kavenchuk:
  He implemented several missing features and fixed many bugs in
  the win32 port. He also worked on external-format support for
  SB-ALIEN.

Anton Kovalenko:
  He introduced a safepoint-based stop-the-world protocol and greatly
  contributed to features and bugfixes related to the Windows port.

Richard M Kreyter:
  He added documentation support for CLOS slot readers and writers,
  provided several SB-POSIX and NetBSD patches, and cleaned up
  several of the filesystem/pathname interfaces.

Frederik Kuivinen:
  He showed how to implement the DEBUG-RETURN functionality.

Arthur Lemmens:
  He found and fixed a number of SBCL bugs while partially porting
  SBCL to bootstrap under Lispworks for Windows.

David Lichteblau:
  He repeatedly failed to update his entry in this file.

Robert MacLachlan:
  He has continued to answer questions about, and contribute fixes to,
  the CMU CL project. Some of these fixes, especially for compiler
  problems, has been invaluable to the CMU CL project and, by
  porting, invaluable to the SBCL project as well.

Pierre Mai:
  He has continued to work on CMU CL since the SBCL fork, and also
  patched code to SBCL to enable dynamic loading of object files
  under OpenBSD.  He contributed to the port of SBCL to MacOS X,
  implementing the Lisp side of the PowerOpen ABI.

Eric Marsden:
  Some of his fixes to CMU CL since the SBCL fork have been ported
  to SBCL.  He also maintains the cl-benchmark package, which gives
  us some idea of how our performance changes compared to earlier
  releases and to other implementations.  He assisted in development
  of Unicode support for SBCL.

Antonio Martinez-Shotton:
  He has contributed a number of bug fixes and bug reports to SBCL.

Brian Mastenbrook:
  He contributed to and extensively maintained the port of SBCL to
  MacOS X. His contributions include overcoming binary compatibility
  issues between different versions of dlcompat on Darwin, other
  linker fixes, and signal handler bugfixes.

Dave McDonald:
  He made a lot of progress toward getting SBCL to be bootstrappable
  under CLISP.

Gabor Melis:
  He mainly worked on robustness related to signal handling, threads,
  timers with small excursions to constraint propagation, weak hash
  tables (based on CMUCL code) and optimizing x86/x86-64 calling
  convention.

Perry E. Metzger:
  He ported SBCL to NetBSD with newer signals, building on the
  work of Valtteri Vuorikoski.  He also provided various cleanups to
  the C runtime.

Gerd Moellman:
  He has made many cleanups and improvements, small and large, in
  CMU CL (mostly in PCL), which we have gratefully ported to SBCL.  Of
  particular note is his ctor MAKE-INSTANCE optimization, which is both
  faster in the typical case than the old optimizations in PCL and
  less buggy.

Timothy Moore:
  He designed and implemented the original CMUCL linkage-table, on
  which the SBCL implementation thereof is based.

William ("Bill") Newman:
  He continued to maintain SBCL after the fork, increasing ANSI
  compliance, fixing bugs, regularizing the internals of the
  system, deleting unused extensions, improving performance in
  some areas (especially sequence functions and non-simple vectors),
  updating documentation, and even, for better or worse, getting
  rid of various functionality (e.g. the byte interpreter).

NIIMI Satoshi:
  He contributed a number of fixes to the FreeBSD port, implemented
  some external-formats and JOIN-THREAD, and also worked on
  the :EXECUTABLE support.

Patrik Nordebo:
  He contributed to the port of SBCL to MacOS X, finding solutions for
  ABI and assembly syntax differences between Darwin and Linux.

Luís Oliveira:
  He contributed to the port of SBCL to the Windows operating system,
  particuarly in the area of FFI.

Scott Parish:
  He ported SBCL to OpenBSD-with-ELF.

Timothy Ritchey:
  He implemented SB-BSD-SOCKETS support for the win32 port.

Tobias Rittweiler
  He has made several contributions relating to source locations,
  pretty printing, SB-INTROSPECT, and the reader.

Kevin M. Rosenberg:
  He provided the ACL-style toplevel (sb-aclrepl contrib module), and
  a number of MOP-related bug reports.  He also creates the official
  Debian packages of SBCL.

Joshua Ross:
  He fixed some bugs relating to foreign calls and callbacks on the
  Linux PowerPC platform.

Christophe Rhodes:
  He ported SBCL to SPARC (based on the CMUCL backend), made various
  port-related and SPARC-related changes (like *BACKEND-SUBFEATURES*),
  made many fixes and improvements in the compiler's type system, has
  essentially completed the work to enable bootstrapping SBCL under
  unrelated (non-SBCL, non-CMU-CL) Common Lisps.  He participated in
  the modernization of SBCL's CLOS implementation, implemented the
  treatment of compiler notes as restartable conditions, provided
  optimizations to compiler output, and contributed in other ways as
  well.

Stig Erik Sandø:
  He showed how to convince the GNU toolchain to build SBCL in a way
  which supports callbacks from C code into SBCL.

Rudi Schlatte:
  He ported Paul Foley's simple-streams implementation from cmucl,
  converted the sbcl manual to Texinfo and wrote a documentation
  string extractor that keeps function documentation in the manual
  current.

Thiemo Seufer:
  He modernized the MIPS backend, fixing many bugs, and assisted in
  cleaning up the C runtime code.

Julian Squires:
  He worked on Unicode support for the PowerPC platform.

Nikodemus Siivola:
  He provided build fixes, in particular to tame the SunOS toolchain,
  implemented package locks, ported the linkage-table code from CMUCL,
  reimplemented STEP, implemented the compare-and-swap interface, and
  has fixed many bugs besides.

Juho Snellman:
  He provided a number of bug fixes and performance enhancements to
  the compiler, the standard library functions, and to the garbage
  collector. He ported and enhanced the statistical profiler written
  by Gerd Moellmann for CMU CL. He completed the work on the x86-64
  port of SBCL.

Brian Spilsbury:
  He wrote Unicode-capable versions of SBCL's character, string, and
  stream types and operations on them.  (These versions did not end up
  in the system, but did to a large extent influence the support which
  finally did get merged.)

Robert Swindells:
  He ported SBCL to NetBSD/Sparc.

Raymond Toy:
  He continued to work on CMU CL after the SBCL fork, especially on
  floating point stuff. Various patches and fixes of his have been
  ported to SBCL, including his Sparc port of linkage-table.

Larry Valkama:
  He resurrected the HPUX port, and worked on the HPPA backend in
  general.

Peter Van Eynde:
  He wrestled the CLISP test suite into a mostly portable test suite
  (clocc ansi-test) which can be used on SBCL, provided a slew of
  of bug reports resulting from that, and submitted many other bug
  reports as well.

Valtteri Vuorikoski:
  He ported SBCL to NetBSD, and also fixed a long-standing bug in
  DEFSTRUCT with respect to colliding accessor names.

Colin Walters:
  His O(N) implementation of the general case of MAP, posted on the
  cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
  code added in sbcl-0.6.8.

Cheuksan Edward Wang:
  He assisted in debugging the SBCL x86-64 backend.

Raymond Wiker:
  He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
  CMU CL support for FreeBSD and updating it for the changes made
  from FreeBSD version 3 to FreeBSD version 4. He also ported the
  CMU CL extension RUN-PROGRAM, and related code, to SBCL.


INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.)

AB   Alastair Bridgewater
AK   Anton Kovalenko
AL   Arthur Lemmens
APD  Alexey Dejneka
CLH  Cyrus Harmon
CSR  Christophe Rhodes
DB   Daniel Barlow (also "dan")
DFL  David Lichteblau
DTC  Douglas Crosher
JES  Juho Snellman
JRXR Joshua Ross
LAV  Larry Valkama
LEU  Lutz Euler
MG   Gabor Melis
MNA  Martin Atzmueller
NJF  Nathan Froyd
NS   Nikodemus Siivola
PFD  Paul F. Dietz
PRM  Pierre Mai
PVE  Peter Van Eynde
PK/PVK Paul-Virak Khuong
PW   Paul Werkowski
RAM  Robert MacLachlan
RLT  Raymond Toy
TCR  Tobias Rittweiler
THS  Thiemo Seufer
VJA  Vincent Arkesteijn
WHN  William ("Bill") Newman
