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 Bill Newman <william.newman@airmail.net> did this transformation, and
  45 so any errors made are probably his. Corrections would be appreciated.
  46
  47
  48 MORE DETAILS ON SBCL'S CLOS CODE
  49
  50 The original headers of the PCL files contained the following text:
  51
  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
  55 ;;;   Xerox PARC
  56 ;;;   3333 Coyote Hill Rd.
  57 ;;;   Palo Alto, CA 94304
  58 ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
  59 ;;;
  60 ;;; Suggestions, comments and requests for improvements are also welcome.
  61
  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.
  68
  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
  74        function
  75   * generic-functions.lisp seems to have been machine-generated.
  76
  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
  84 ;;;      .
  85 ;;;      .
  86 ;;;      boy, thats fair (I hope).
  87
  88
  89 MORE DETAILS ON SBCL'S LOOP CODE
  90
  91 The src/code/loop.lisp file from CMU CL 18b had the following
  92 credits-related information in it:
  93
  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.
  98 ;;;
  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
 102 ;;;   never released).
 103 ;;;
 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
 108 ;;;   Common Lisp.
 109 ;;;
 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
 115 ;;;   distributed.
 116 ;;;
 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.
 119
 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.
 123
 124
 125 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
 126
 127 CMU CL's symbol (but not package) code (code/symbol.lisp) was
 128 originally written by Scott Fahlman and updated and maintained
 129 by Skef Wholey.
 130
 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
 134 (code/sharpm.lisp).
 135
 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.
 140
 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
 143 MacLachlan.
 144
 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
 150         SXHASH
 151         code/list.lisp, list functions (based on code from Joe Ginder and
 152                 Carl Ebeling)
 153 The CMU CL seq.lisp code also gave credits for later work by Jim Muller
 154 and Bill Chiles.
 155
 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.
 159
 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".
 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
 169 Fahlman, and rewritten without fonts and with a new type system by Rob
 170 MachLachlan.
 171
 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.
 177
 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.
 181
 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.
 184
 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"
 188                 code/typedefs.lisp
 189                 code/class.lisp
 190                 code/type-init.lisp
 191                 etc.
 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
 203                 compiler/fndb.lisp
 204         debug information representation
 205                 compiler/debug.lisp, compiler/debug-dump.lisp
 206         memory pools to reduce consing by reusing compiler objects
 207                 compiler/alloc.lisp
 208         toplevel interface functions and drivers
 209                 compiler/main.lisp
 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
 217                 code/time.lisp
 218
 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
 231                 compiler/ltv.lisp
 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.
 244
 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.
 248
 249 The original PPC backend was the work of Gary Byers.  Some bug fixes
 250 and other changes to update it for current CMUCL interfaces were made
 251 by Eric Marsden and Douglas Crosher
 252
 253 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
 254 was written by Miles Bader.
 255
 256 Parts of the CMU CL system were credited to Skef Wholey and Rob
 257 MacLachlan jointly, perhaps because they were originally part of Spice
 258 Lisp and were then heavily modified:
 259         code/load.lisp, the loader, including all the FASL stuff
 260         code/macros.lisp, various fundamental macros
 261         code/mipsstrops.lisp, primitives for hacking strings
 262         code/purify.lisp, implementation of PURIFY
 263         code/stream.lisp, stream functions
 264         code/lispinit.lisp, cold startup
 265         code/profile.lisp, the profiler
 266
 267 Bill Chiles also modified code/macros.lisp. Much of the implementation
 268 of PURIFY was rewritten in C by William Lott.
 269
 270 The CMU CL number functions (code/number.lisp) were written by Rob
 271 MacLachlan, but acknowledge much code "derived from code written by
 272 William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc."
 273
 274 CMU CL's weak pointer support (code/weak.lisp) was written by
 275 Christopher Hoover.
 276
 277 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
 278 Lott and Skef Wholey jointly.
 279
 280 The FDEFINITION system for handling arbitrary function names (a la
 281 (SETF FOO)) was originally written by Rob MacLachlan. It was modified
 282 by Bill Chiles to add encapsulation, and modified more by William Lott
 283 to add FDEFN objects.
 284
 285 The CMU CL condition system (code/error.lisp) was based on
 286 some prototyping code written by Ken Pitman at Symbolics.
 287
 288 The CMU CL HASH-TABLE system was originally written by Skef Wholey
 289 for Spice Lisp, then rewritten by William Lott, then rewritten
 290 again by Douglas T. Crosher.
 291
 292 The support code for environment queries (a la LONG-SITE-NAME),
 293 the DOCUMENTATION function, and the DRIBBLE function was written
 294 and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott
 295 Fahlman, Dan Aronson, and Steve Handerson did stuff here too."
 296 The same credit statement was given for the original Mach OS interface code.
 297
 298 The CMU CL printer, print.lisp, was credited as "written by Neal
 299 Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and modified
 300 by various CMU Common Lisp maintainers." The comments on the float
 301 printer said specifically that it was written by Bill Maddox. The
 302 comments on bignum printing said specifically that it was written by
 303 Steven Handerson (based on Skef's idea), and that it was rewritten by
 304 William Lott to remove assumptions about length of fixnums on the MIPS
 305 port.
 306
 307 The comments in the main body of the CMU CL debugger
 308         code/debug.lisp
 309 say that it was written by Bill Chiles. Some other related files
 310         code/debug-int.lisp, programmer's interface to the debugger
 311         code/ntrace.lisp, tracing facility based on breakpoints
 312 say they were written by Bill Chiles and Rob MacLachlan.
 313 The related file
 314         src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
 315 was written by William Lott.
 316
 317 The CMU CL GENESIS cold load system,
 318 compiler/generic/new-genesis.lisp, was originally written by Skef
 319 Wholey, then jazzed up for packages by Rob MacLachlan, then completely
 320 rewritten by William Lott for the MIPS port.
 321
 322 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
 323 MacLachlan.
 324
 325 Various CMU CL support code was written by William Lott:
 326         the bytecode interpreter
 327                 code/byte-interp.lisp
 328         bitblt-ish operations a la SYSTEM-AREA-COPY
 329                 code/bit-bash.lisp
 330         Unix interface
 331                 code/fd-stream.lisp, Unix file descriptors as Lisp streams
 332                 code/filesys.lisp, other Unix filesystem interface stuff
 333         handling errors signalled from assembly code
 334                 code/interr.lisp
 335                 compiler/generic/interr.lisp
 336         finalization based on weak pointers
 337                 code/final.lisp
 338         irrational numeric functions
 339                 code/irrat.lisp
 340         the pretty printer
 341                 code/pprint.lisp
 342         predicates (both type predicates and EQUAL and friends)
 343                 code/pred.lisp
 344         saving the current Lisp image as a core file
 345                 code/save.lisp
 346         handling Unix signals
 347                 code/signal.lisp
 348         implementing FORMAT
 349                 code/format.lisp
 350
 351 The ALIEN facility seems to have been written largely by Rob
 352 MacLachlan and William Lott. The CMU CL comments say "rewritten again,
 353 this time by William Lott and Rob MacLachlan," but don't identify who
 354 else might have been involved in earlier versions.
 355
 356 The comments in CMU CL's code/final.lisp say "the idea really was
 357 Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm
 358 stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp
 359 say "with lots of stuff stolen from the previous version by David Adam
 360 and later rewritten by Bill Maddox."
 361
 362 Jim Muller was credited with fixing seq.lisp.
 363
 364 CMU CL's time printing logic, in code/format-time.lisp, was written
 365 by Jim Healy.
 366
 367 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
 368
 369 The CMU CL machine/filesystem-independent pathname functions
 370 (code/pathname.lisp) were written by William Lott, Paul Gleichauf, and
 371 Rob MacLachlan, based on an earlier version written by Jim Large and
 372 Rob MacLachlan.
 373
 374 Besides writing the original versions of the things credited to him
 375 above, William Lott rewrote, updated, and cleaned up various stuff:
 376         code/array.lisp
 377         code/serve-event.lisp
 378
 379 The INSPECT function was originally written by Blaine Burks.
 380
 381 The CMU CL DESCRIBE facility was originally written by "Skef Wholey or
 382 Rob MacLachlan", according to the comments in the CMU CL sources. It
 383 was cleaned up and reorganized by Blaine Burks, then ported and
 384 cleaned up more by Rob MacLachlan. Also, since the split from CMU CL,
 385 the SBCL DESCRIBE facility was rewritten as a generic function and so
 386 become entangled with some DESCRIBE code which was distributed as part
 387 of PCL.
 388
 389 The implementation of the Mersenne Twister RNG used in SBCL is based
 390 on an implementation written by Douglas T. Crosher and Raymond Toy,
 391 which was placed in the public domain with permission from M.
 392 Matsumoto.
 393
 394 Comments in the CMU CL version of FreeBSD-os.c said it came from
 395 an OSF version by Sean Hallgren, later hacked by Paul Werkowski,
 396 with generational conservative GC support added by Douglas Crosher.
 397
 398 Comments in the CMU CL version of linux-os.c said it came from the
 399 FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996.
 400
 401 Comments in the CMU CL version of backtrace.c said it was "originally
 402 from Rob's version" (presumably Robert Maclachlan).
 403
 404 Comments in the CMU CL version of purify.c said it had stack direction
 405 changes, x86/CGC stack scavenging, and static blue bag stuff (all for
 406 x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code
 407 movement support, and x86/gencgc stack scavenging by Douglas Crosher,
 408 1996, 1997, 1998.
 409
 410 According to comments in the source files, much of the CMU CL version
 411 of the x86 support code
 412         assembly/x86/alloc.lisp
 413         assembly/x86/arith.lisp
 414         assembly/x86/array.lisp
 415         assembly/x86/assem-rtns.lisp
 416         compiler/x86/alloc.lisp
 417         compiler/x86/arith.lisp
 418         compiler/x86/c-call.lisp
 419         compiler/x86/call.lisp
 420         compiler/x86/cell.lisp
 421         compiler/x86/char.lisp
 422         compiler/x86/debug.lisp
 423         compiler/x86/float.lisp
 424         compiler/x86/insts.lisp
 425         compiler/x86/macros.lisp
 426         compiler/x86/memory.lisp
 427         compiler/x86/move.lisp
 428         compiler/x86/nlx.lisp
 429         compiler/x86/parms.lisp
 430         compiler/x86/pred.lisp
 431         compiler/x86/print.lisp
 432         compiler/x86/sap.lisp
 433         compiler/x86/static-fn.lisp
 434         compiler/x86/subprim.lisp
 435         compiler/x86/system.lisp
 436         compiler/x86/type-vops.lisp
 437         compiler/x86/values.lisp
 438         compiler/x86/vm.lisp
 439 was originally written by William Lott, then debugged by Paul
 440 Werkowski, and in some cases later enhanced and further debugged by
 441 Douglas T. Crosher; and the x86 runtime support code,
 442         x86-assem.S
 443 was written by Paul F. Werkowski and Douglas T. Crosher.
 444
 445 The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86
 446 FreeBSD port was originally contributed by Paul Werkowski, and Peter
 447 VanEynde took the FreeBSD port and created a Linux version.
 448
 449 According to comments in src/code/bsd-os.lisp, work on the generic BSD
 450 port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan
 451 Aronson, and Steve Handerson.
 452
 453 Douglas Crosher wrote code to support Gray streams, added X86 support
 454 for the debugger and relocatable code, wrote a conservative
 455 generational GC for the X86 port, and added X86-specific extensions to
 456 support stack groups and multiprocessing.
 457
 458 The CMU CL user manual credits Robert MacLachlan as editor. A chapter
 459 on the CMU CL interprocess communication extensions (not supported in
 460 SBCL) was contributed by William Lott and Bill Chiles.
 461
 462 Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
 463 to CMU CL, to provide additional safety, especially through runtime
 464 checking on various tricky cases of standard functions (e.g. MAP with
 465 complicated result types, and interactions of various variants of
 466 STREAM).
 467
 468 Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various
 469 other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE
 470 entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went
 471 away completely as the code became an unconditional part of the
 472 system.)
 473
 474 CMU CL's long float support was written by Douglas T. Crosher.
 475
 476 Paul Werkowski turned the Mach OS support code into Linux OS support code.
 477
 478 Versions of the RUN-PROGRAM extension were written first by David
 479 McDonald, then by Jim Healy and Bill Chiles, then by William Lott.
 480
 481
 482 MORE DETAILS ON THE TRANSITION FROM CMU CL
 483
 484 Bill Newman did the original conversion from CMU CL 18b to a form
 485 which could bootstrap itself cleanly, on Linux/x86 only. Although they
 486 may not have realized it at the time, Rob Maclachlan and Peter Van
 487 Eynde were very helpful, RAM by posting a clear explanation of what
 488 GENESIS is supposed to be doing and PVE by maintaining a version of
 489 CMU CL which worked on Debian, so that I had something to refer to
 490 whenever I got stuck.
 491
 492
 493 CREDITS SINCE THE RELEASE OF SBCL
 494
 495 (Note: (1) This is probably incomplete, since there's no systematic
 496 procedure for updating it. (2) Some more details are available in the
 497 NEWS file, in the project's CVS change logs, and in the archives of
 498 the sbcl-devel mailing list. (3) In this, as in other parts of SBCL,
 499 patches are welcome. Don't be shy.)
 500
 501 Martin Atzmueller:
 502   He reported many bugs, fixed many bugs, ported various fixes
 503   from CMU CL, and helped clean up various stale bug data. (He has
 504   been unusually energetic at this. As of sbcl-0.6.9.10, the
 505   total number of bugs involved likely exceeded 100. Since then,
 506   I've lost count. See the CVS logs.)
 507
 508 Daniel Barlow:
 509   He made SBCL play nicely with ILISP. He figured out how to get the
 510   CMU CL dynamic object file loading code to work under SBCL. He
 511   ported CMU CL's support for Alpha and PPC CPUs to SBCL, and then
 512   continued to improve the ports. He wrote code (e.g. grovel_headers.c
 513   and stat_wrapper stuff) to handle machine-dependence and
 514   OS-dependence automatically, reducing the amount of hand-tweaking
 515   required to keep ports synchronized. He's also provided support
 516   for SBCL (as well as for free Common Lisp in general) through
 517   his CLiki website.
 518
 519 Cadabra, Inc. (later merged into GoTo.com):
 520   They hired Bill Newman to do some consulting for them,
 521   including the implementation of EQUALP hash tables for CMU CL;
 522   then agreed to release the EQUALP code into the public domain,
 523   giving SBCL (and CMU CL) its EQUALP hash tables.
 524
 525 Douglas Crosher:
 526   He continued to improve CMU CL after SBCL forked from it, creating
 527   many patches which were directly applicable to SBCL. Notable examples
 528   include fixes for various compiler bugs, the implementation of
 529   CL:DEFINE-SYMBOL-MACRO, and a generalization of the type system's
 530   handling of the CONS type to allow ANSI-style (CONS FOO BAR) types.
 531
 532 Alexey Dejneka:
 533   He has fixed many, many bugs. There's no single summary theme, but
 534   he's fixed about a dozen different bugs in LOOP alone, and more
 535   in the compiler itself. It appears that a lot of his fixes there
 536   and elsewhere reflect systematic public-spiritedness, fixing bugs
 537   as they show up in sbcl-devel or as archived in the BUGS file.
 538
 539 Nathan Froyd:
 540   He has fixed various bugs, and also done a lot of internal
 541   cleanup, not visible at the user level but important for
 542   maintenance. (E.g. converting the PCL code to use LOOP instead
 543   of the old weird pre-ANSI ITERATE macro so that the code can be
 544   read without being an expert in ancient languages and so that
 545   can delete a thousand lines of implement-ITERATE macrology.)
 546
 547 Matthias Hoelzl:
 548   He reported and fixed COMPILE's misbehavior on macros.
 549
 550 Espen S Johnsen:
 551   He provided an ANSI-compliant version of CHANGE-CLASS for PCL.
 552
 553 Arthur Lemmens:
 554   He found and fixed a number of SBCL bugs while partially porting
 555   SBCL to bootstrap under <some other Common Lisp system -- LispWorks
 556   for Windows? -- which could probably be found in the sbcl-devel
 557   archives>.
 558
 559 Robert MacLachlan:
 560   He has continued to answer questions about, and contribute fixes to,
 561   the CMU CL project. Some of these fixes, especially for compiler
 562   problems, has been invaluable to the CMU CL project and, by
 563   porting, invaluable to the SBCL project as well.
 564
 565 Pierre Mai:
 566   He has continued to work on CMU CL since the SBCL fork, and also
 567   patched code to SBCL to enable dynamic loading of object files
 568   under OpenBSD.
 569
 570 Dave McDonald:
 571   He made a lot of progress toward getting SBCL to be bootstrappable
 572   under CLISP.
 573
 574 William ("Bill") Newman:
 575   He continued to maintain SBCL after the fork, increasing ANSI
 576   compliance, fixing bugs, regularizing the internals of the
 577   system, deleting unused extensions, improving performance in
 578   some areas (especially sequence functions and non-simple vectors),
 579   updating documentation, and even, for better or worse, getting
 580   rid of various functionality (e.g. the byte interpreter).
 581
 582 Christophe Rhodes:
 583   He ported SBCL to SPARC, made various port-related and SPARC-related
 584   changes (like *BACKEND-SUBFEATURES*), made many fixes and
 585   improvements in the compiler's type system, has done a substantial
 586   amount of work on bootstrapping SBCL under unrelated (non-SBCL,
 587   non-CMU-CL) Common Lisps, and contributed in other ways as well.
 588
 589 Stig Erik Sandoe:
 590   He showed how to convince the GNU toolchain to build SBCL in a way
 591   which supports callbacks from C code into SBCL.
 592
 593 Brian Spilsbury:
 594   He wrote Unicode-capable versions of SBCL's character, string, and
 595   stream types and operations on them.
 596
 597 Raymond Toy:
 598   He continued to work on CMU CL after the SBCL fork, especially on
 599   floating point stuff. Various patches and fixes of his have been
 600   ported to SBCL.
 601
 602 Peter Van Eynde:
 603   He wrestled the CLISP test suite into a mostly portable test suite
 604   (clocc ansi-test) which can be used on SBCL, provided a slew of
 605   of bug reports resulting from that, and submitted many other bug
 606   reports as well.
 607
 608 Colin Walters:
 609   His O(N) implementation of the general case of MAP, posted on the
 610   cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
 611   code added in sbcl-0.6.8.
 612
 613 Raymond Wiker:
 614   He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
 615   CMU CL support for FreeBSD and updating it for the changes made
 616   from FreeBSD version 3 to FreeBSD version 4. He also ported the
 617   CMU CL extension RUN-PROGRAM, and related code, to SBCL.
 618
 619
 620 INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.)
 621
 622 AL   Arthur Lemmens
 623 MNA  Martin Atzmueller
 624 DB   Daniel Barlow
 625 DTC  Douglas Crosher
 626 APD  Alexey Dejneka
 627 NJF  Nathan Froyd
 628 RAM  Robert MacLachlan
 629 WHN  William ("Bill") Newman
 630 CSR  Christophe Rhodes
 631 PVE  Peter Van Eynde