CREDITS

   1
   2       The programmers of old were mysterious and profound.  We
   3    cannot fathom their thoughts, so all we do is describe their
   4    appearance.
   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"
  12
  13
  14 BROAD OUTLINE
  15
  16 SBCL is derived from the 18b version of CMU CL.
  17
  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
  20 in CMU CL 18b,
  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.
  26 and
  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.
  31
  32 CMU CL's CLOS implementation is derived from the PCL reference
  33 implementation written at Xerox PARC.
  34
  35 CMU CL's implementation of the LOOP macro was derived from code
  36 from Symbolics, which was derived from code from MIT.
  37
  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
  42 instead.
  43
  44 William Harold Newman <william.newman@airmail.net> did this
  45 transformation, and so any errors made are probably his. Corrections
  46 would be appreciated.
  47
  48
  49 MORE DETAILS ON SBCL'S CLOS CODE
  50
  51 The original headers of the PCL files contained the following text:
  52
  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
  56 ;;;   Xerox PARC
  57 ;;;   3333 Coyote Hill Rd.
  58 ;;;   Palo Alto, CA 94304
  59 ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
  60 ;;;
  61 ;;; Suggestions, comments and requests for improvements are also welcome.
  62
  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.
  69
  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
  75        function
  76   * generic-functions.lisp seems to have been machine-generated.
  77
  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
  85 ;;;      .
  86 ;;;      .
  87 ;;;      boy, thats fair (I hope).
  88
  89
  90 MORE DETAILS ON SBCL'S LOOP CODE
  91
  92 The src/code/loop.lisp file from CMU CL 18b had the following
  93 credits-related information in it:
  94
  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.
  99 ;;;
 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
 103 ;;;   never released).
 104 ;;;
 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
 109 ;;;   Common Lisp.
 110 ;;;
 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
 116 ;;;   distributed.
 117 ;;;
 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.
 120
 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.
 124
 125
 126 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
 127
 128 CMU CL's symbol (but not package) code (code/symbol.lisp) was
 129 originally written by Scott Fahlman and updated and maintained
 130 by Skef Wholey.
 131
 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
 135 (code/sharpm.lisp).
 136
 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.
 141
 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
 144 MacLachlan.
 145
 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
 151         SXHASH
 152         code/list.lisp, list functions (based on code from Joe Ginder and
 153                 Carl Ebeling)
 154 The CMU CL seq.lisp code also gave credits for later work by Jim Muller
 155 and Bill Chiles.
 156
 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.
 160
 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
 164 alone.
 165
 166 Guy Steele wrote the original character functions
 167         code/char.lisp
 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.
 170
 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.
 176
 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.
 180
 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.
 183
 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"
 187                 code/typedefs.lisp
 188                 code/class.lisp
 189                 code/type-init.lisp
 190                 etc.
 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
 202                 compiler/fndb.lisp
 203         debug information representation
 204                 compiler/debug.lisp, compiler/debug-dump.lisp
 205         memory pools to reduce consing by reusing compiler objects
 206                 compiler/alloc.lisp
 207         toplevel interface functions and drivers
 208                 compiler/main.lisp
 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
 216                 code/time.lisp
 217
 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
 230                 compiler/ltv.lisp
 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.
 243
 244 Sean Hallgren converted compiler/generic/primtype.lisp for the Alpha.
 245
 246 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
 247 was written by Miles Bader.
 248
 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
 259
 260 Bill Chiles also modified code/macros.lisp. Much of the implementation
 261 of PURIFY was rewritten in C by William Lott.
 262
 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."
 266
 267 CMU CL's weak pointer support (code/weak.lisp) was written by
 268 Christopher Hoover.
 269
 270 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
 271 Lott and Skef Wholey jointly.
 272
 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.
 277
 278 The CMU CL condition system (code/error.lisp) was based on
 279 some prototyping code written by Ken Pitman at Symbolics.
 280
 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.
 284
 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.
 290
 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."
 294
 295 The comments in the main body of the CMU CL debugger
 296         code/debug.lisp
 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.
 301 The related file
 302         src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
 303 was written by William Lott.
 304
 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.
 309
 310 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
 311 MacLachlan.
 312
 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
 317                 code/bit-bash.lisp
 318         Unix interface
 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
 322                 code/interr.lisp
 323                 compiler/generic/interr.lisp
 324         finalization based on weak pointers
 325                 code/final.lisp
 326         irrational numeric functions
 327                 code/irrat.lisp
 328         the pretty printer
 329                 code/pprint.lisp
 330         predicates (both type predicates and EQUAL and friends)
 331                 code/pred.lisp
 332         saving the current Lisp image as a core file
 333                 code/save.lisp
 334         handling Unix signals
 335                 code/signal.lisp
 336         implementing FORMAT
 337                 code/format.lisp
 338
 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.
 343
 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."
 349
 350 Jim Muller was credited with fixing seq.lisp.
 351
 352 CMU CL's time printing logic, in code/format-time.lisp, was written
 353 by Jim Healy.
 354
 355 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
 356
 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
 360 Rob MacLachlan.
 361
 362 Besides writing the original versions of the things credited to him
 363 above, William Lott rewrote, updated, and cleaned up various stuff:
 364         code/array.lisp
 365         code/serve-event.lisp
 366
 367 The INSPECT function was originally written by Blaine Burks.
 368
 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
 375 of PCL.
 376
 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.
 380 Matsumoto.
 381
 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.
 385
 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.
 388
 389 Comments in the CMU CL version of backtrace.c said it was "originally
 390 from Rob's version" (presumably Robert Maclachlan).
 391
 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,
 396 1996, 1997, 1998.
 397
 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
 426         compiler/x86/vm.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,
 430         x86-assem.S
 431 was written by Paul F. Werkowski and Douglas T. Crosher.
 432
 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.
 436
 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.
 440
 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.
 445
 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.
 449
 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
 454 STREAM).
 455
 456 Raymond Toy wrote the propagate-float-type extension and various
 457 other floating point optimizations.
 458
 459 CMU CL's long float support was written by Douglas T. Crosher.
 460
 461 Paul Werkowski turned the Mach OS support code into Linux OS support code.
 462
 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.
 465
 466
 467 MORE DETAILS ON THE TRANSITION FROM CMU CL
 468
 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.
 476
 477
 478 CREDITS SINCE THE RELEASE OF SBCL
 479
 480 Martin Atzmueller:
 481   He reported many bugs in SBCL, helped clean up various stale
 482   bug data in SBCL, and ported many patches from CMU CL.
 483
 484 Daniel Barlow:
 485   He contributed sblisp.lisp, a set of patches to make SBCL
 486   play nicely with ILISP. (Those patches have since disappeared from the
 487   SBCL distribution because ILISP has since been patched to play nicely
 488   with SBCL.) He also figured out how to get the CMU CL dynamic object
 489   file loading code to work under SBCL.
 490
 491 Cadabra, Inc.:
 492   They hired William Newman to do some consulting for them,
 493   including the implementation of EQUALP hash tables for CMU CL;
 494   then agreed to release the EQUALP code into the public domain,
 495   giving SBCL, and CMU CL, EQUALP hash tables.
 496
 497 Douglas Crosher:
 498   He continued to improve CMU CL after SBCL forked from it, creating
 499   many patches which were directly applicable to SBCL. Notable examples
 500   include fixes for various compiler bugs, and a generalization
 501   of the type system's handling of the CONS type to allow ANSI-style
 502   (CONS FOO BAR) types.
 503
 504 Robert MacLachlan:
 505   He has continued to answer questions about, and contribute fixes to,
 506   the CMU CL project. Some of these fixes, especially for compiler
 507   problems, has been invaluable to the CMU CL project and, by
 508   porting, invaluable to the SBCL project as well.
 509
 510 Peter Van Eynde:
 511   He wrestled the CLISP test suite into a portable test suite which
 512   can be used on SBCL, and submitted many other bug reports as well.
 513
 514 Colin Walters:
 515   His O(N) implementation of the general case of MAP, posted on the
 516   cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
 517   code added in sbcl-0.6.8.
 518
 519 Raymond Wiker:
 520   He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
 521   CMU CL support for FreeBSD and updating it for the changes made
 522   from FreeBSD version 3 to FreeBSD version 4. He also ported the
 523   CMU CL extension RUN-PROGRAM, and related code, to SBCL.
 524