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 Bill Newman <william.newman@airmail.net> did this transformation, and
45 so any errors made are probably his. Corrections would be appreciated.
48 MORE DETAILS ON SBCL'S CLOS CODE
50 The original headers of the PCL files contained the following text:
52 ;;; Any person obtaining a copy of this software is requested to send their
53 ;;; name and post office or electronic mail address to:
54 ;;; CommonLoops Coordinator
56 ;;; 3333 Coyote Hill Rd.
57 ;;; Palo Alto, CA 94304
58 ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
60 ;;; Suggestions, comments and requests for improvements are also welcome.
62 This was intended for the original incarnation of the PCL code as a
63 portable reference implementation. Since our version of the code has
64 had its portability hacked out of it, it's no longer particularly
65 relevant to any coordinated PCL effort (which probably doesn't exist
66 any more anyway). Therefore, this contact information has been deleted
67 from the PCL file headers.
69 A few files in the original CMU CL 18b src/pcl/ directory did not
70 carry such Xerox copyright notices:
71 * Some code was originally written by Douglas T. Crosher for CMU CL:
72 ** the Gray streams implementation
73 ** the implementation of DOCUMENTATION as methods of a generic
75 * generic-functions.lisp seems to have been machine-generated.
77 The comments in the CMU CL 18b version of the PCL code walker,
78 src/pcl/walk.lisp, said in part
79 ;;; a simple code walker, based IN PART on: (roll the credits)
80 ;;; Larry Masinter's Masterscope
81 ;;; Moon's Common Lisp code walker
82 ;;; Gary Drescher's code walker
83 ;;; Larry Masinter's simple code walker
86 ;;; boy, thats fair (I hope).
89 MORE DETAILS ON SBCL'S LOOP CODE
91 The src/code/loop.lisp file from CMU CL 18b had the following
92 credits-related information in it:
94 ;;; The LOOP iteration macro is one of a number of pieces of code
95 ;;; originally developed at MIT for which free distribution has been
96 ;;; permitted, as long as the code is not sold for profit, and as long
97 ;;; as notification of MIT's interest in the code is preserved.
99 ;;; This version of LOOP, which is almost entirely rewritten both as
100 ;;; clean-up and to conform with the ANSI Lisp LOOP standard, started
101 ;;; life as MIT LOOP version 829 (which was a part of NIL, possibly
104 ;;; A "light revision" was performed by me (Glenn Burke) while at
105 ;;; Palladian Software in April 1986, to make the code run in Common
106 ;;; Lisp. This revision was informally distributed to a number of
107 ;;; people, and was sort of the "MIT" version of LOOP for running in
110 ;;; A later more drastic revision was performed at Palladian perhaps a
111 ;;; year later. This version was more thoroughly Common Lisp in style,
112 ;;; with a few miscellaneous internal improvements and extensions. I
113 ;;; have lost track of this source, apparently never having moved it to
114 ;;; the MIT distribution point. I do not remember if it was ever
117 ;;; The revision for the ANSI standard is based on the code of my April
118 ;;; 1986 version, with almost everything redesigned and/or rewritten.
120 The date of the M.I.T. copyright statement falls around the time
121 described in these comments. The dates on the Symbolics copyright
122 statement are all later -- the earliest is 1989.
125 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
127 CMU CL's symbol (but not package) code (code/symbol.lisp) was
128 originally written by Scott Fahlman and updated and maintained
131 The CMU CL reader (code/reader.lisp) was originally the Spice Lisp
132 reader, written by David Dill and with support for packages added by
133 Lee Schumacher. David Dill also wrote the sharpmacro support
136 CMU CL's package code was rewritten by Rob MacLachlan based on an
137 earlier version by Lee Schumacher. It also includes DEFPACKAGE by Dan
138 Zigmond, and WITH-PACKAGE-ITERATOR written by Blaine Burks. William
139 Lott also rewrote the DEFPACKAGE and DO-FOO-SYMBOLS stuff.
141 CMU CL's string code (code/string.lisp) was originally written by
142 David Dill, then rewritten by Skef Wholey, Bill Chiles, and Rob
145 Various code in the system originated with "Spice Lisp", which was
146 apparently a predecessor to the CMU CL project. Much of that was
147 originally written by Skef Wholey:
148 code/seq.lisp, generic sequence functions, and COERCE
149 code/array.lisp, general array stuff
151 code/list.lisp, list functions (based on code from Joe Ginder and
153 The CMU CL seq.lisp code also gave credits for later work by Jim Muller
156 The modules system (code/module.lisp, containing REQUIRE, PROVIDE,
157 and friends, now deprecated by ANSI) was written by Jim Muller and
158 rewritten by Bill Chiles.
160 The CMU CL garbage collector was credited to "Christopher Hoover,
161 Rob MacLachlan, Dave McDonald, et al." in the CMU CL code/gc.lisp file,
162 with some extra code for the MIPS port credited to Christopher Hoover
163 alone. The credits on the original "gc.c", "Stop and Copy GC based
164 on Cheney's algorithm", said "written by Christopher Hoover".
166 Guy Steele wrote the original character functions
168 They were subsequently rewritten by David Dill, speeded up by Scott
169 Fahlman, and rewritten without fonts and with a new type system by Rob
172 Lee Schumacher made the Spice Lisp version of backquote. The comment
173 in the CMU CL sources suggests he based it on someone else's code for
174 some other Lisp system, but doesn't say which. A note in the CMU CL
175 code to pretty-print backquote expressions says that unparsing support
176 was provided by Miles Bader.
178 The CMU implementations of the Common Lisp query functions Y-OR-N-P
179 and YES-OR-NO-P were originally written by Walter van Roggen, and
180 updated and modified by Rob MacLachlan and Bill Chiles.
182 The CMU CL sort functions (code/sort.lisp) were written by Jim Large,
183 hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles.
185 Most of the internals of the Python compiler seem to have been
186 originally written by Robert MacLachlan:
187 the type system and associated "cold load hack magic"
192 the lexical environment database
193 compiler/globaldb.lisp, etc.
194 the IR1 representation and optimizer
195 compiler/ir1*.lisp, etc.
196 the IR2 representation and optimizer
197 compiler/ir2*.lisp, etc.
198 many concrete optimizations
199 compiler/srctran.lisp (with some code adapted from
200 CLC by Wholey and Fahlman)
201 compiler/float-tran.lisp, etc.
202 information about optimization of known functions
204 debug information representation
205 compiler/debug.lisp, compiler/debug-dump.lisp
206 memory pools to reduce consing by reusing compiler objects
208 toplevel interface functions and drivers
210 Besides writing the compiler, and various other work mentioned elsewhere,
211 Robert MacLachlan was also credited with tuning the implementation of
212 streams for Unix files, and writing
213 various floating point support code
214 code/float-trap.lisp, floating point traps
215 code/float.lisp, misc. support a la INTEGER-DECODE-FLOAT
216 low-level time functions
219 William Lott is also credited with writing or heavily maintaining some
220 parts of the CMU CL compiler. He was responsible for lifting
221 compiler/meta-vmdef.lisp out of compiler/vmdef.lisp, and also wrote
222 various optimizations
223 compiler/array-tran.lisp
224 compiler/saptran.lisp
225 compiler/seqtran.lisp (with some code adapted from an older
226 seqtran written by Wholey and Fahlman)
227 the separable compiler backend
228 compiler/backend.lisp
229 compiler/generic/utils.lisp
230 the implementation of LOAD-TIME-VALUE
232 the most recent version of the assembler
233 compiler/new-assem.lisp
234 vop statistics gathering
235 compiler/statcount.lisp
236 centralized information about machine-dependent and..
237 ..machine-independent FOO, with
238 compiler/generic/vm-fndb.lisp, FOO=function signatures
239 compiler/generic/vm-typetran.lisp, FOO=type ops
240 compiler/generic/objdef.lisp, FOO=object representation
241 compiler/generic/primtype.lisp, FOO=primitive types
242 Also, Christopher Hoover and William Lott wrote compiler/generic/vm-macs.lisp
243 to centralize information about machine-dependent macros and constants.
245 Sean Hallgren is credited with most of the Alpha backend. Julian
246 Dolby created the CMU CL Alpha/linux port. Douglas Crosher added
247 complex-float support.
249 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
250 was written by Miles Bader.
252 Parts of the CMU CL system were credited to Skef Wholey and Rob
253 MacLachlan jointly, perhaps because they were originally part of Spice
254 Lisp and were then heavily modified:
255 code/load.lisp, the loader, including all the FASL stuff
256 code/macros.lisp, various fundamental macros
257 code/mipsstrops.lisp, primitives for hacking strings
258 code/purify.lisp, implementation of PURIFY
259 code/stream.lisp, stream functions
260 code/lispinit.lisp, cold startup
261 code/profile.lisp, the profiler
263 Bill Chiles also modified code/macros.lisp. Much of the implementation
264 of PURIFY was rewritten in C by William Lott.
266 The CMU CL number functions (code/number.lisp) were written by Rob
267 MacLachlan, but acknowledge much code "derived from code written by
268 William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc."
270 CMU CL's weak pointer support (code/weak.lisp) was written by
273 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
274 Lott and Skef Wholey jointly.
276 The FDEFINITION system for handling arbitrary function names (a la
277 (SETF FOO)) was originally written by Rob MacLachlan. It was modified
278 by Bill Chiles to add encapsulation, and modified more by William Lott
279 to add FDEFN objects.
281 The CMU CL condition system (code/error.lisp) was based on
282 some prototyping code written by Ken Pitman at Symbolics.
284 The CMU CL HASH-TABLE system was originally written by Skef Wholey
285 for Spice Lisp, then rewritten by William Lott, then rewritten
286 again by Douglas T. Crosher.
288 The support code for environment queries (a la LONG-SITE-NAME),
289 the DOCUMENTATION function, and the DRIBBLE function was written
290 and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott
291 Fahlman, Dan Aronson, and Steve Handerson did stuff here too."
292 The same credit statement was given for the original Mach OS interface code.
294 The CMU CL printer, print.lisp, was credited as "written by Neal
295 Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and modified
296 by various CMU Common Lisp maintainers." The comments on the float
297 printer said specifically that it was written by Bill Maddox. The
298 comments on bignum printing said specifically that it was written by
299 Steven Handerson (based on Skef's idea), and that it was rewritten by
300 William Lott to remove assumptions about length of fixnums on the MIPS
303 The comments in the main body of the CMU CL debugger
305 say that it was written by Bill Chiles. Some other related files
306 code/debug-int.lisp, programmer's interface to the debugger
307 code/ntrace.lisp, tracing facility based on breakpoints
308 say they were written by Bill Chiles and Rob MacLachlan.
310 src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
311 was written by William Lott.
313 The CMU CL GENESIS cold load system,
314 compiler/generic/new-genesis.lisp, was originally written by Skef
315 Wholey, then jazzed up for packages by Rob MacLachlan, then completely
316 rewritten by William Lott for the MIPS port.
318 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
321 Various CMU CL support code was written by William Lott:
322 the bytecode interpreter
323 code/byte-interp.lisp
324 bitblt-ish operations a la SYSTEM-AREA-COPY
327 code/fd-stream.lisp, Unix file descriptors as Lisp streams
328 code/filesys.lisp, other Unix filesystem interface stuff
329 handling errors signalled from assembly code
331 compiler/generic/interr.lisp
332 finalization based on weak pointers
334 irrational numeric functions
338 predicates (both type predicates and EQUAL and friends)
340 saving the current Lisp image as a core file
342 handling Unix signals
347 The ALIEN facility seems to have been written largely by Rob
348 MacLachlan and William Lott. The CMU CL comments say "rewritten again,
349 this time by William Lott and Rob MacLachlan," but don't identify who
350 else might have been involved in earlier versions.
352 The comments in CMU CL's code/final.lisp say "the idea really was
353 Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm
354 stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp
355 say "with lots of stuff stolen from the previous version by David Adam
356 and later rewritten by Bill Maddox."
358 Jim Muller was credited with fixing seq.lisp.
360 CMU CL's time printing logic, in code/format-time.lisp, was written
363 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
365 The CMU CL machine/filesystem-independent pathname functions
366 (code/pathname.lisp) were written by William Lott, Paul Gleichauf, and
367 Rob MacLachlan, based on an earlier version written by Jim Large and
370 Besides writing the original versions of the things credited to him
371 above, William Lott rewrote, updated, and cleaned up various stuff:
373 code/serve-event.lisp
375 The INSPECT function was originally written by Blaine Burks.
377 The CMU CL DESCRIBE facility was originally written by "Skef Wholey or
378 Rob MacLachlan", according to the comments in the CMU CL sources. It
379 was cleaned up and reorganized by Blaine Burks, then ported and
380 cleaned up more by Rob MacLachlan. Also, since the split from CMU CL,
381 the SBCL DESCRIBE facility was rewritten as a generic function and so
382 become entangled with some DESCRIBE code which was distributed as part
385 The implementation of the Mersenne Twister RNG used in SBCL is based
386 on an implementation written by Douglas T. Crosher and Raymond Toy,
387 which was placed in the public domain with permission from M.
390 Comments in the CMU CL version of FreeBSD-os.c said it came from
391 an OSF version by Sean Hallgren, later hacked by Paul Werkowski,
392 with generational conservative GC support added by Douglas Crosher.
394 Comments in the CMU CL version of linux-os.c said it came from the
395 FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996.
397 Comments in the CMU CL version of backtrace.c said it was "originally
398 from Rob's version" (presumably Robert Maclachlan).
400 Comments in the CMU CL version of purify.c said it had stack direction
401 changes, x86/CGC stack scavenging, and static blue bag stuff (all for
402 x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code
403 movement support, and x86/gencgc stack scavenging by Douglas Crosher,
406 According to comments in the source files, much of the CMU CL version
407 of the x86 support code
408 assembly/x86/alloc.lisp
409 assembly/x86/arith.lisp
410 assembly/x86/array.lisp
411 assembly/x86/assem-rtns.lisp
412 compiler/x86/alloc.lisp
413 compiler/x86/arith.lisp
414 compiler/x86/c-call.lisp
415 compiler/x86/call.lisp
416 compiler/x86/cell.lisp
417 compiler/x86/char.lisp
418 compiler/x86/debug.lisp
419 compiler/x86/float.lisp
420 compiler/x86/insts.lisp
421 compiler/x86/macros.lisp
422 compiler/x86/memory.lisp
423 compiler/x86/move.lisp
424 compiler/x86/nlx.lisp
425 compiler/x86/parms.lisp
426 compiler/x86/pred.lisp
427 compiler/x86/print.lisp
428 compiler/x86/sap.lisp
429 compiler/x86/static-fn.lisp
430 compiler/x86/subprim.lisp
431 compiler/x86/system.lisp
432 compiler/x86/type-vops.lisp
433 compiler/x86/values.lisp
435 was originally written by William Lott, then debugged by Paul
436 Werkowski, and in some cases later enhanced and further debugged by
437 Douglas T. Crosher; and the x86 runtime support code,
439 was written by Paul F. Werkowski and Douglas T. Crosher.
441 The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86
442 FreeBSD port was originally contributed by Paul Werkowski, and Peter
443 VanEynde took the FreeBSD port and created a Linux version.
445 According to comments in src/code/bsd-os.lisp, work on the generic BSD
446 port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan
447 Aronson, and Steve Handerson.
449 Douglas Crosher wrote code to support Gray streams, added X86 support
450 for the debugger and relocatable code, wrote a conservative
451 generational GC for the X86 port, and added X86-specific extensions to
452 support stack groups and multiprocessing.
454 The CMU CL user manual credits Robert MacLachlan as editor. A chapter
455 on the CMU CL interprocess communication extensions (not supported in
456 SBCL) was contributed by William Lott and Bill Chiles.
458 Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
459 to CMU CL, to provide additional safety, especially through runtime
460 checking on various tricky cases of standard functions (e.g. MAP with
461 complicated result types, and interactions of various variants of
464 Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various
465 other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE
466 entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went
467 away completely as the code became an unconditional part of the
470 CMU CL's long float support was written by Douglas T. Crosher.
472 Paul Werkowski turned the Mach OS support code into Linux OS support code.
474 Versions of the RUN-PROGRAM extension were written first by David
475 McDonald, then by Jim Healy and Bill Chiles, then by William Lott.
478 MORE DETAILS ON THE TRANSITION FROM CMU CL
480 Bill Newman did the original conversion from CMU CL 18b to a form
481 which could bootstrap itself cleanly, on Linux/x86 only. Although they
482 may not have realized it at the time, Rob Maclachlan and Peter Van
483 Eynde were very helpful, RAM by posting a clear explanation of what
484 GENESIS is supposed to be doing and PVE by maintaining a version of
485 CMU CL which worked on Debian, so that I had something to refer to
486 whenever I got stuck.
489 CREDITS SINCE THE RELEASE OF SBCL
491 (Note: (1) This is probably incomplete, since there's no systematic
492 procedure for updating it. (2) Some more details are available in the
493 NEWS file, in the project's CVS change logs, and in the archives of
494 the sbcl-devel mailing list. (3) In this, as in other parts of
495 SBCL, patches are welcome.)
498 He reported many bugs, fixed many bugs, ported various fixes
499 from CMU CL, and helped clean up various stale bug data. (He has
500 been unusually energetic at this. As of sbcl-0.6.9.10, the
501 total number of bugs involved likely exceeds 100.)
504 He contributed sblisp.lisp, a set of patches to make SBCL
505 play nicely with ILISP. (Those patches have since disappeared from the
506 SBCL distribution because ILISP has since been patched to play nicely
507 with SBCL.) He figured out how to get the CMU CL dynamic object
508 file loading code to work under SBCL. He ported CMU CL's support for
509 Alpha and PPC CPUs to SBCL. He wrote code (e.g. grovel_headers.c and
510 stat_wrapper stuff) to handle machine-dependence and OS-dependence
511 automatically, reducing the amount of hand-tweaking required to
512 keep ports synchronized. He's also provided support for SBCL (as
513 well as for free Common Lisp in general) through his CLiki website.
515 Cadabra, Inc. (later merged into GoTo.com):
516 They hired Bill Newman to do some consulting for them,
517 including the implementation of EQUALP hash tables for CMU CL;
518 then agreed to release the EQUALP code into the public domain,
519 giving SBCL (and CMU CL) EQUALP hash tables.
522 He continued to improve CMU CL after SBCL forked from it, creating
523 many patches which were directly applicable to SBCL. Notable examples
524 include fixes for various compiler bugs, and a generalization
525 of the type system's handling of the CONS type to allow ANSI-style
526 (CONS FOO BAR) types.
529 He has fixed many bugs in SBCL. There's no single summary theme, but
530 he's fixed about a dozen different bugs in LOOP alone, and it appears
531 that a lot of his fixes there and elsewhere reflect systematic
532 public-spiritedness, fixing bugs as they show up in sbcl-devel or as
533 archived in the BUGS file.
536 He has reported bugs and ported fixes from CMU CL.
539 He has continued to answer questions about, and contribute fixes to,
540 the CMU CL project. Some of these fixes, especially for compiler
541 problems, has been invaluable to the CMU CL project and, by
542 porting, invaluable to the SBCL project as well.
545 He continued to maintain SBCL after the fork, increasing ANSI
546 compliance, fixing bugs, regularizing the internals of the
547 system, deleting unused extensions, improving performance in
548 some areas (especially sequence functions and non-simple vectors),
549 updating documentation, and even, for better or worse, getting
550 rid of various functionality (e.g. the byte interpreter).
553 He continued to work on CMU CL after the SBCL fork, especially on
554 floating point stuff. Various patches and fixes of his have been
558 He wrestled the CLISP test suite into a portable test suite
559 (clocc ansi-test) which can be used on SBCL, provided a slew of
560 of bug reports resulting from that, and submitted many other bug
564 His O(N) implementation of the general case of MAP, posted on the
565 cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
566 code added in sbcl-0.6.8.
569 He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
570 CMU CL support for FreeBSD and updating it for the changes made
571 from FreeBSD version 3 to FreeBSD version 4. He also ported the
572 CMU CL extension RUN-PROGRAM, and related code, to SBCL.
575 INITIALS GLOSSARY (helpful when reading comments, commit notes, etc.)
577 MNA Martin Atzmueller
582 RAM Robert MacLachlan