2 The programmers of old were mysterious and profound. We
3 cannot fathom their thoughts, so all we do is describe their
5 Aware, like a fox crossing the water. Alert, like a general
6 on the battlefield. Kind, like a hostess greeting her guests.
7 Simple, like uncarved blocks of wood. Opaque, like black
8 pools in darkened caves.
9 Who can tell the secrets of their hearts and minds?
10 The answer exists only in the Tao.
11 -- Geoffrey James, "The Tao of Programming"
16 SBCL is derived from the 18b version of CMU CL.
18 Most of CMU CL was originally written as part of the CMU Common Lisp
19 project at Carnegie Mellon University. According to the documentation
21 Organizationally, CMU Common Lisp was a small, mostly autonomous
22 part within the Mach operating system project. The CMU CL project
23 was more of a tool development effort than a research project.
24 The project started out as Spice Lisp, which provided a modern
25 Lisp implementation for use in the CMU community.
27 CMU CL has been under continuous development since the early 1980's
28 (concurrent with the Common Lisp standardization effort.)
29 Apparently most of the CMU Common Lisp implementors moved on to
30 work on the Gwydion environment for Dylan.
32 CMU CL's CLOS implementation is derived from the PCL reference
33 implementation written at Xerox PARC.
35 CMU CL's implementation of the LOOP macro was derived from code
36 from Symbolics, which was derived from code from MIT.
38 CMU CL had many individual author credits in the source files. In the
39 sometimes-extensive rearrangements which were required to make SBCL
40 bootstrap itself cleanly, it was tedious to try keep such credits
41 attached to individual source files, so they have been moved here
44 William Harold Newman <william.newman@airmail.net> did this
45 transformation, and so any errors made are probably his. Corrections
49 MORE DETAILS ON SBCL'S CLOS CODE
51 The original headers of the PCL files contained the following text:
53 ;;; Any person obtaining a copy of this software is requested to send their
54 ;;; name and post office or electronic mail address to:
55 ;;; CommonLoops Coordinator
57 ;;; 3333 Coyote Hill Rd.
58 ;;; Palo Alto, CA 94304
59 ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
61 ;;; Suggestions, comments and requests for improvements are also welcome.
63 This was intended for the original incarnation of the PCL code as a
64 portable reference implementation. Since our version of the code has
65 had its portability hacked out of it, it's no longer particularly
66 relevant to any coordinated PCL effort (which probably doesn't exist
67 any more anyway). Therefore, this contact information has been deleted
68 from the PCL file headers.
70 A few files in the original CMU CL 18b src/pcl/ directory did not
71 carry such Xerox copyright notices:
72 * Some code was originally written by Douglas T. Crosher for CMU CL:
73 ** the Gray streams implementation
74 ** the implementation of DOCUMENTATION as methods of a generic
76 * generic-functions.lisp seems to have been machine-generated.
78 The comments in the CMU CL 18b version of the PCL code walker,
79 src/pcl/walk.lisp, said in part
80 ;;; a simple code walker, based IN PART on: (roll the credits)
81 ;;; Larry Masinter's Masterscope
82 ;;; Moon's Common Lisp code walker
83 ;;; Gary Drescher's code walker
84 ;;; Larry Masinter's simple code walker
87 ;;; boy, thats fair (I hope).
90 MORE DETAILS ON SBCL'S LOOP CODE
92 The src/code/loop.lisp file from CMU CL 18b had the following
93 credits-related information in it:
95 ;;; The LOOP iteration macro is one of a number of pieces of code
96 ;;; originally developed at MIT for which free distribution has been
97 ;;; permitted, as long as the code is not sold for profit, and as long
98 ;;; as notification of MIT's interest in the code is preserved.
100 ;;; This version of LOOP, which is almost entirely rewritten both as
101 ;;; clean-up and to conform with the ANSI Lisp LOOP standard, started
102 ;;; life as MIT LOOP version 829 (which was a part of NIL, possibly
105 ;;; A "light revision" was performed by me (Glenn Burke) while at
106 ;;; Palladian Software in April 1986, to make the code run in Common
107 ;;; Lisp. This revision was informally distributed to a number of
108 ;;; people, and was sort of the "MIT" version of LOOP for running in
111 ;;; A later more drastic revision was performed at Palladian perhaps a
112 ;;; year later. This version was more thoroughly Common Lisp in style,
113 ;;; with a few miscellaneous internal improvements and extensions. I
114 ;;; have lost track of this source, apparently never having moved it to
115 ;;; the MIT distribution point. I do not remember if it was ever
118 ;;; The revision for the ANSI standard is based on the code of my April
119 ;;; 1986 version, with almost everything redesigned and/or rewritten.
121 The date of the M.I.T. copyright statement falls around the time
122 described in these comments. The dates on the Symbolics copyright
123 statement are all later -- the earliest is 1989.
126 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
128 CMU CL's symbol (but not package) code (code/symbol.lisp) was
129 originally written by Scott Fahlman and updated and maintained
132 The CMU CL reader (code/reader.lisp) was originally the Spice Lisp
133 reader, written by David Dill and with support for packages added by
134 Lee Schumacher. David Dill also wrote the sharpmacro support
137 CMU CL's package code was rewritten by Rob MacLachlan based on an
138 earlier version by Lee Schumacher. It also includes DEFPACKAGE by Dan
139 Zigmond, and WITH-PACKAGE-ITERATOR written by Blaine Burks. William
140 Lott also rewrote the DEFPACKAGE and DO-FOO-SYMBOLS stuff.
142 CMU CL's string code (code/string.lisp) was originally written by
143 David Dill, then rewritten by Skef Wholey, Bill Chiles, and Rob
146 Various code in the system originated with "Spice Lisp", which was
147 apparently a predecessor to the CMU CL project. Much of that was
148 originally written by Skef Wholey:
149 code/seq.lisp, generic sequence functions, and COERCE
150 code/array.lisp, general array stuff
152 code/list.lisp, list functions (based on code from Joe Ginder and
154 The CMU CL seq.lisp code also gave credits for later work by Jim Muller
157 The modules system (code/module.lisp, containing REQUIRE, PROVIDE,
158 and friends, now deprecated by ANSI) was written by Jim Muller and
159 rewritten by Bill Chiles.
161 The CMU CL garbage collector was credited to "Christopher Hoover,
162 Rob MacLachlan, Dave McDonald, et al." in the CMU CL code/gc.lisp file,
163 with some extra code for the MIPS port credited to Christopher Hoover
166 Guy Steele wrote the original character functions
168 They were subsequently rewritten by David Dill, speeded up by Scott Fahlman,
169 and rewritten without fonts and with a new type system by Rob MachLachlan.
171 Lee Schumacher made the Spice Lisp version of backquote. The comment
172 in the CMU CL sources suggests he based it on someone else's code for
173 some other Lisp system, but doesn't say which. A note in the CMU CL
174 code to pretty-print backquote expressions says that unparsing support
175 was provided by Miles Bader.
177 The CMU implementations of the Common Lisp query functions Y-OR-N-P
178 and YES-OR-NO-P were originally written by Walter van Roggen, and
179 updated and modified by Rob MacLachlan and Bill Chiles.
181 The CMU CL sort functions (code/sort.lisp) were written by Jim Large,
182 hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles.
184 Most of the internals of the Python compiler seem to have been
185 originally written by Robert MacLachlan:
186 the type system and associated "cold load hack magic"
191 the lexical environment database
192 compiler/globaldb.lisp, etc.
193 the IR1 representation and optimizer
194 compiler/ir1*.lisp, etc.
195 the IR2 representation and optimizer
196 compiler/ir2*.lisp, etc.
197 many concrete optimizations
198 compiler/srctran.lisp (with some code adapted from
199 CLC by Wholey and Fahlman)
200 compiler/float-tran.lisp, etc.
201 information about optimization of known functions
203 debug information representation
204 compiler/debug.lisp, compiler/debug-dump.lisp
205 memory pools to reduce consing by reusing compiler objects
207 toplevel interface functions and drivers
209 Besides writing the compiler, and various other work mentioned elsewhere,
210 Robert MacLachlan was also credited with tuning the implementation of
211 streams for Unix files, and writing
212 various floating point support code
213 code/float-trap.lisp, floating point traps
214 code/float.lisp, misc. support a la INTEGER-DECODE-FLOAT
215 low-level time functions
218 William Lott is also credited with writing or heavily maintaining some
219 parts of the CMU CL compiler. He was responsible for lifting
220 compiler/meta-vmdef.lisp out of compiler/vmdef.lisp, and also wrote
221 various optimizations
222 compiler/array-tran.lisp
223 compiler/saptran.lisp
224 compiler/seqtran.lisp (with some code adapted from an older
225 seqtran written by Wholey and Fahlman)
226 the separable compiler backend
227 compiler/backend.lisp
228 compiler/generic/utils.lisp
229 the implementation of LOAD-TIME-VALUE
231 the most recent version of the assembler
232 compiler/new-assem.lisp
233 vop statistics gathering
234 compiler/statcount.lisp
235 centralized information about machine-dependent and..
236 ..machine-independent FOO, with
237 compiler/generic/vm-fndb.lisp, FOO=function signatures
238 compiler/generic/vm-typetran.lisp, FOO=type ops
239 compiler/generic/objdef.lisp, FOO=object representation
240 compiler/generic/primtype.lisp, FOO=primitive types
241 Also, Christopher Hoover and William Lott wrote compiler/generic/vm-macs.lisp
242 to centralize information about machine-dependent macros and constants.
244 Sean Hallgren converted compiler/generic/primtype.lisp for the Alpha.
246 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
247 was written by Miles Bader.
249 Parts of the CMU CL system were credited to Skef Wholey and Rob
250 MacLachlan jointly, perhaps because they were originally part of Spice
251 Lisp and were then heavily modified:
252 code/load.lisp, the loader, including all the FASL stuff
253 code/macros.lisp, various fundamental macros
254 code/mipsstrops.lisp, primitives for hacking strings
255 code/purify.lisp, implementation of PURIFY
256 code/stream.lisp, stream functions
257 code/lispinit.lisp, cold startup
258 code/profile.lisp, the profiler
260 Bill Chiles also modified code/macros.lisp. Much of the implementation
261 of PURIFY was rewritten in C by William Lott.
263 The CMU CL number functions (code/number.lisp) were written by Rob
264 MacLachlan, but acknowledge much code "derived from code written by
265 William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc."
267 CMU CL's weak pointer support (code/weak.lisp) was written by
270 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
271 Lott and Skef Wholey jointly.
273 The FDEFINITION system for handling arbitrary function names (a la
274 (SETF FOO)) was originally written by Rob MacLachlan. It was modified
275 by Bill Chiles to add encapsulation, and modified more by William Lott
276 to add FDEFN objects.
278 The CMU CL condition system (code/error.lisp) was based on
279 some prototyping code written by Ken Pitman at Symbolics.
281 The CMU CL HASH-TABLE system was originally written by Skef Wholey
282 for Spice Lisp, then rewritten by William Lott, then rewritten
283 again by Douglas T. Crosher.
285 The support code for environment queries (a la LONG-SITE-NAME),
286 the DOCUMENTATION function, and the DRIBBLE function was written
287 and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott
288 Fahlman, Dan Aronson, and Steve Handerson did stuff here too."
289 The same credit statement was given for the original Mach OS interface code.
291 The CMU CL printer, print.lisp, was credited as "written by
292 Neal Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and
293 modified by various CMU Common Lisp maintainers."
295 The comments in the main body of the CMU CL debugger
297 say that it was written by Bill Chiles. Some other related files
298 code/debug-int.lisp, programmer's interface to the debugger
299 code/ntrace.lisp, tracing facility based on breakpoints
300 say they were written by Bill Chiles and Rob MacLachlan.
302 src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
303 was written by William Lott.
305 The CMU CL GENESIS cold load system,
306 compiler/generic/new-genesis.lisp, was originally written by Skef
307 Wholey, then jazzed up for packages by Rob MacLachlan, then completely
308 rewritten by William Lott for the MIPS port.
310 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
313 Various CMU CL support code was written by William Lott:
314 the bytecode interpreter
315 code/byte-interp.lisp
316 bitblt-ish operations a la SYSTEM-AREA-COPY
319 code/fd-stream.lisp, Unix file descriptors as Lisp streams
320 code/filesys.lisp, other Unix filesystem interface stuff
321 handling errors signalled from assembly code
323 compiler/generic/interr.lisp
324 finalization based on weak pointers
326 irrational numeric functions
330 predicates (both type predicates and EQUAL and friends)
332 saving the current Lisp image as a core file
334 handling Unix signals
339 The ALIEN facility seems to have been written largely by Rob
340 MacLachlan and William Lott. The CMU CL comments say "rewritten again,
341 this time by William Lott and Rob MacLachlan," but don't identify who
342 else might have been involved in earlier versions.
344 The comments in CMU CL's code/final.lisp say "the idea really was
345 Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm
346 stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp
347 say "with lots of stuff stolen from the previous version by David Adam
348 and later rewritten by Bill Maddox."
350 Jim Muller was credited with fixing seq.lisp.
352 CMU CL's time printing logic, in code/format-time.lisp, was written
355 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
357 The CMU CL machine/filesystem-independent pathname functions
358 (code/pathname.lisp) were written by William Lott, Paul Gleichauf, and
359 Rob MacLachlan, based on an earlier version written by Jim Large and
362 Besides writing the original versions of the things credited to him
363 above, William Lott rewrote, updated, and cleaned up various stuff:
365 code/serve-event.lisp
367 The INSPECT function was originally written by Blaine Burks.
369 The CMU CL DESCRIBE facility was originally written by "Skef Wholey or
370 Rob MacLachlan", according to the comments in the CMU CL sources. It
371 was cleaned up and reorganized by Blaine Burks, then ported and
372 cleaned up more by Rob MacLachlan. Also, since the split from CMU CL,
373 the SBCL DESCRIBE facility was rewritten as a generic function and so
374 become entangled with some DESCRIBE code which was distributed as part
377 The implementation of the Mersenne Twister RNG used in SBCL is based
378 on an implementation written by Douglas T. Crosher and Raymond Toy,
379 which was placed in the public domain with permission from M.
382 Comments in the CMU CL version of FreeBSD-os.c said it came from
383 an OSF version by Sean Hallgren, later hacked by Paul Werkowski,
384 with generational conservative GC support added by Douglas Crosher.
386 Comments in the CMU CL version of linux-os.c said it came from the
387 FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996.
389 Comments in the CMU CL version of backtrace.c said it was "originally
390 from Rob's version" (presumably Robert Maclachlan).
392 Comments in the CMU CL version of purify.c said it had stack direction
393 changes, x86/CGC stack scavenging, and static blue bag stuff (all for
394 x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code
395 movement support, and x86/gencgc stack scavenging by Douglas Crosher,
398 According to comments in the source files, much of the CMU CL version
399 of the x86 support code
400 assembly/x86/alloc.lisp
401 assembly/x86/arith.lisp
402 assembly/x86/array.lisp
403 assembly/x86/assem-rtns.lisp
404 compiler/x86/alloc.lisp
405 compiler/x86/arith.lisp
406 compiler/x86/c-call.lisp
407 compiler/x86/call.lisp
408 compiler/x86/cell.lisp
409 compiler/x86/char.lisp
410 compiler/x86/debug.lisp
411 compiler/x86/float.lisp
412 compiler/x86/insts.lisp
413 compiler/x86/macros.lisp
414 compiler/x86/memory.lisp
415 compiler/x86/move.lisp
416 compiler/x86/nlx.lisp
417 compiler/x86/parms.lisp
418 compiler/x86/pred.lisp
419 compiler/x86/print.lisp
420 compiler/x86/sap.lisp
421 compiler/x86/static-fn.lisp
422 compiler/x86/subprim.lisp
423 compiler/x86/system.lisp
424 compiler/x86/type-vops.lisp
425 compiler/x86/values.lisp
427 was originally written by William Lott, then debugged by Paul
428 Werkowski, and in some cases later enhanced and further debugged by
429 Douglas T. Crosher; and the x86 runtime support code,
431 was written by Paul F. Werkowski and Douglas T. Crosher.
433 The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86
434 FreeBSD port was originally contributed by Paul Werkowski, and Peter
435 VanEynde took the FreeBSD port and created a Linux version.
437 According to comments in src/code/bsd-os.lisp, work on the generic BSD
438 port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan
439 Aronson, and Steve Handerson.
441 Douglas Crosher wrote code to support Gray streams, added X86 support
442 for the debugger and relocatable code, wrote a conservative
443 generational GC for the X86 port, and added X86-specific extensions to
444 support stack groups and multiprocessing.
446 The CMU CL user manual credits Robert MacLachlan as editor. A chapter
447 on the CMU CL interprocess communication extensions (not supported in
448 SBCL) was contributed by William Lott and Bill Chiles.
450 Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
451 to CMU CL, to provide additional safety, especially through runtime
452 checking on various tricky cases of standard functions (e.g. MAP with
453 complicated result types, and interactions of various variants of
456 Raymond Toy wrote the propagate-float-type extension and various
457 other floating point optimizations.
459 CMU CL's long float support was written by Douglas T. Crosher.
461 Paul Werkowski turned the Mach OS support code into Linux OS support code.
463 Versions of the RUN-PROGRAM extension were written first by David
464 McDonald, then by Jim Healy and Bill Chiles, then by William Lott.
467 MORE DETAILS ON THE TRANSITION FROM CMU CL
469 Bill Newman did the original conversion from CMU CL 18b to a form
470 which could bootstrap itself cleanly, on Linux/x86 only. Although they
471 may not have realized it at the time, Rob Maclachlan and Peter Van
472 Eynde were very helpful, RAM by posting a clear explanation of what
473 GENESIS is supposed to be doing and PVE by maintaining a version of
474 CMU CL which worked on Debian, so that I had something to refer to
475 whenever I got stuck.
478 CREDITS SINCE THE RELEASE OF SBCL
481 He contributed sblisp.lisp, a set of patches to make SBCL
482 play nicely with ILISP. (Those patches have since disappeared from the
483 SBCL distribution because ILISP has since been patched to play nicely
484 with SBCL.) He also figured out how to get the CMU CL dynamic object
485 file loading code to work under SBCL.
488 They hired William Newman to do some consulting for them,
489 including the implementation of EQUALP hash tables for CMU CL;
490 then agreed to release the EQUALP code into the public domain,
491 giving SBCL, and CMU CL, EQUALP hash tables.
494 He wrestled the CLISP test suite into a portable test suite which
495 can be used on SBCL, and submitted many other bug reports as well.
498 His O(N) implementation of the general case of MAP, posted on the
499 cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
500 code added in sbcl-0.6.8.
503 He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
504 CMU CL support for FreeBSD and updating it for the changes made
505 from FreeBSD version 3 to FreeBSD version 4. He also ported the
506 CMU CL extension RUN-PROGRAM, and related code, to SBCL.