CREDITS

   1 -*- coding: utf-8; mode: text; -*-
   2
   3       The programmers of old were mysterious and profound.  We
   4    cannot fathom their thoughts, so all we do is describe their
   5    appearance.
   6       Aware, like a fox crossing the water.  Alert, like a general
   7    on the battlefield.  Kind, like a hostess greeting her guests.
   8       Simple, like uncarved blocks of wood.  Opaque, like black
   9    pools in darkened caves.
  10       Who can tell the secrets of their hearts and minds?
  11       The answer exists only in the Tao.
  12          -- Geoffrey James, "The Tao of Programming"
  13
  14
  15 BROAD OUTLINE
  16
  17 SBCL is derived from the 18b version of CMU CL.
  18
  19 Most of CMU CL was originally written as part of the CMU Common Lisp
  20 project at Carnegie Mellon University. According to the documentation
  21 in CMU CL 18b,
  22     Organizationally, CMU Common Lisp was a small, mostly autonomous
  23   part within the Mach operating system project. The CMU CL project
  24   was more of a tool development effort than a research project.
  25   The project started out as Spice Lisp, which provided a modern
  26   Lisp implementation for use in the CMU community.
  27 and
  28   CMU CL has been under continuous development since the early 1980's
  29   (concurrent with the Common Lisp standardization effort.)
  30 Apparently most of the CMU Common Lisp implementors moved on to
  31 work on the Gwydion environment for Dylan.
  32
  33 CMU CL's CLOS implementation is derived from the PCL reference
  34 implementation written at Xerox PARC.
  35
  36 CMU CL's implementation of the LOOP macro was derived from code
  37 from Symbolics, which was derived from code from MIT.
  38
  39 CMU CL had many individual author credits in the source files. In the
  40 sometimes-extensive rearrangements which were required to make SBCL
  41 bootstrap itself cleanly, it was tedious to try keep such credits
  42 attached to individual source files, so they have been moved here
  43 instead.
  44
  45 Bill Newman <william.newman@airmail.net> did this transformation, and
  46 so any errors made are probably his. Corrections 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. The credits on the original "gc.c", "Stop and Copy GC based
 165 on Cheney's algorithm", said "written by Christopher Hoover".
 166
 167 Guy Steele wrote the original character functions
 168         code/char.lisp
 169 They were subsequently rewritten by David Dill, speeded up by Scott
 170 Fahlman, and rewritten without fonts and with a new type system by Rob
 171 MachLachlan.
 172
 173 Lee Schumacher made the Spice Lisp version of backquote. The comment
 174 in the CMU CL sources suggests he based it on someone else's code for
 175 some other Lisp system, but doesn't say which. A note in the CMU CL
 176 code to pretty-print backquote expressions says that unparsing support
 177 was provided by Miles Bader.
 178
 179 The CMU implementations of the Common Lisp query functions Y-OR-N-P
 180 and YES-OR-NO-P were originally written by Walter van Roggen, and
 181 updated and modified by Rob MacLachlan and Bill Chiles.
 182
 183 The CMU CL sort functions (code/sort.lisp) were written by Jim Large,
 184 hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles.
 185
 186 Most of the internals of the Python compiler seem to have been
 187 originally written by Robert MacLachlan:
 188         the type system and associated "cold load hack magic"
 189                 code/typedefs.lisp
 190                 code/class.lisp
 191                 code/type-init.lisp
 192                 etc.
 193         the lexical environment database
 194                 compiler/globaldb.lisp, etc.
 195         the IR1 representation and optimizer
 196                 compiler/ir1*.lisp, etc.
 197         the IR2 representation and optimizer
 198                 compiler/ir2*.lisp, etc.
 199         many concrete optimizations
 200                 compiler/srctran.lisp (with some code adapted from
 201                         CLC by Wholey and Fahlman)
 202                 compiler/float-tran.lisp, etc.
 203         information about optimization of known functions
 204                 compiler/fndb.lisp
 205         debug information representation
 206                 compiler/debug.lisp, compiler/debug-dump.lisp
 207         memory pools to reduce consing by reusing compiler objects
 208                 compiler/alloc.lisp
 209         toplevel interface functions and drivers
 210                 compiler/main.lisp
 211 Besides writing the compiler, and various other work mentioned elsewhere,
 212 Robert MacLachlan was also credited with tuning the implementation of
 213 streams for Unix files, and writing
 214         various floating point support code
 215                 code/float-trap.lisp, floating point traps
 216                 code/float.lisp, misc. support a la INTEGER-DECODE-FLOAT
 217         low-level time functions
 218                 code/time.lisp
 219
 220 William Lott is also credited with writing or heavily maintaining some
 221 parts of the CMU CL compiler. He was responsible for lifting
 222 compiler/meta-vmdef.lisp out of compiler/vmdef.lisp, and also wrote
 223         various optimizations
 224                 compiler/array-tran.lisp
 225                 compiler/saptran.lisp
 226                 compiler/seqtran.lisp (with some code adapted from an older
 227                         seqtran written by Wholey and Fahlman)
 228         the separable compiler backend
 229                 compiler/backend.lisp
 230                 compiler/generic/utils.lisp
 231         the implementation of LOAD-TIME-VALUE
 232                 compiler/ltv.lisp
 233         the most recent version of the assembler
 234                 compiler/new-assem.lisp
 235         vop statistics gathering
 236                 compiler/statcount.lisp
 237         centralized information about machine-dependent and..
 238         ..machine-independent FOO, with
 239                 compiler/generic/vm-fndb.lisp, FOO=function signatures
 240                 compiler/generic/vm-typetran.lisp, FOO=type ops
 241                 compiler/generic/objdef.lisp, FOO=object representation
 242                 compiler/generic/primtype.lisp, FOO=primitive types
 243 Also, Christopher Hoover and William Lott wrote compiler/generic/vm-macs.lisp
 244 to centralize information about machine-dependent macros and constants.
 245
 246 Sean Hallgren is credited with most of the Alpha backend.  Julian
 247 Dolby created the CMU CL Alpha/Linux port. Douglas Crosher added
 248 complex-float support.
 249
 250 The original PPC backend was the work of Gary Byers.  Some bug fixes
 251 and other changes to update it for current CMUCL interfaces were made
 252 by Eric Marsden and Douglas Crosher
 253
 254 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
 255 was written by Miles Bader.
 256
 257 Parts of the CMU CL system were credited to Skef Wholey and Rob
 258 MacLachlan jointly, perhaps because they were originally part of Spice
 259 Lisp and were then heavily modified:
 260         code/load.lisp, the loader, including all the FASL stuff
 261         code/macros.lisp, various fundamental macros
 262         code/mipsstrops.lisp, primitives for hacking strings
 263         code/purify.lisp, implementation of PURIFY
 264         code/stream.lisp, stream functions
 265         code/lispinit.lisp, cold startup
 266         code/profile.lisp, the profiler
 267
 268 Bill Chiles also modified code/macros.lisp. Much of the implementation
 269 of PURIFY was rewritten in C by William Lott.
 270
 271 The CMU CL number functions (code/number.lisp) were written by Rob
 272 MacLachlan, but acknowledge much code "derived from code written by
 273 William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc."
 274
 275 CMU CL's weak pointer support (code/weak.lisp) was written by
 276 Christopher Hoover.
 277
 278 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
 279 Lott and Skef Wholey jointly.
 280
 281 The FDEFINITION system for handling arbitrary function names (a la
 282 (SETF FOO)) was originally written by Rob MacLachlan. It was modified
 283 by Bill Chiles to add encapsulation, and modified more by William Lott
 284 to add FDEFN objects.
 285
 286 The CMU CL condition system (code/error.lisp) was based on
 287 some prototyping code written by Kent Pitman at Symbolics.
 288
 289 The CMU CL HASH-TABLE system was originally written by Skef Wholey
 290 for Spice Lisp, then rewritten by William Lott, then rewritten
 291 again by Douglas T. Crosher.
 292
 293 The support code for environment queries (a la LONG-SITE-NAME),
 294 the DOCUMENTATION function, and the DRIBBLE function was written
 295 and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott
 296 Fahlman, Dan Aronson, and Steve Handerson did stuff here too."
 297 The same credit statement was given for the original Mach OS interface code.
 298
 299 The CMU CL printer, print.lisp, was credited as "written by Neal
 300 Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and modified
 301 by various CMU Common Lisp maintainers." The comments on the float
 302 printer said specifically that it was written by Bill Maddox. The
 303 comments on bignum printing said specifically that it was written by
 304 Steven Handerson (based on Skef's idea), and that it was rewritten by
 305 William Lott to remove assumptions about length of fixnums on the MIPS
 306 port.
 307
 308 The comments in the main body of the CMU CL debugger
 309         code/debug.lisp
 310 say that it was written by Bill Chiles. Some other related files
 311         code/debug-int.lisp, programmer's interface to the debugger
 312         code/ntrace.lisp, tracing facility based on breakpoints
 313 say they were written by Bill Chiles and Rob MacLachlan.
 314 The related file
 315         src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints
 316 was written by William Lott.
 317
 318 The CMU CL GENESIS cold load system,
 319 compiler/generic/new-genesis.lisp, was originally written by Skef
 320 Wholey, then jazzed up for packages by Rob MacLachlan, then completely
 321 rewritten by William Lott for the MIPS port.
 322
 323 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
 324 MacLachlan.
 325
 326 Various CMU CL support code was written by William Lott:
 327         the bytecode interpreter
 328                 code/byte-interp.lisp
 329         bitblt-ish operations a la SYSTEM-AREA-COPY
 330                 code/bit-bash.lisp
 331         Unix interface
 332                 code/fd-stream.lisp, Unix file descriptors as Lisp streams
 333                 code/filesys.lisp, other Unix filesystem interface stuff
 334         handling errors signalled from assembly code
 335                 code/interr.lisp
 336                 compiler/generic/interr.lisp
 337         finalization based on weak pointers
 338                 code/final.lisp
 339         irrational numeric functions
 340                 code/irrat.lisp
 341         the pretty printer
 342                 code/pprint.lisp
 343         predicates (both type predicates and EQUAL and friends)
 344                 code/pred.lisp
 345         saving the current Lisp image as a core file
 346                 code/save.lisp
 347         handling Unix signals
 348                 code/signal.lisp
 349         implementing FORMAT
 350                 code/format.lisp
 351
 352 The ALIEN facility seems to have been written largely by Rob
 353 MacLachlan and William Lott. The CMU CL comments say "rewritten again,
 354 this time by William Lott and Rob MacLachlan," but don't identify who
 355 else might have been involved in earlier versions.
 356
 357 The comments in CMU CL's code/final.lisp say "the idea really was
 358 Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm
 359 stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp
 360 say "with lots of stuff stolen from the previous version by David Adam
 361 and later rewritten by Bill Maddox."
 362
 363 Jim Muller was credited with fixing seq.lisp.
 364
 365 CMU CL's time printing logic, in code/format-time.lisp, was written
 366 by Jim Healy.
 367
 368 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
 369
 370 The CMU CL machine/filesystem-independent pathname functions
 371 (code/pathname.lisp) were written by William Lott, Paul Gleichauf, and
 372 Rob MacLachlan, based on an earlier version written by Jim Large and
 373 Rob MacLachlan.
 374
 375 Besides writing the original versions of the things credited to him
 376 above, William Lott rewrote, updated, and cleaned up various stuff:
 377         code/array.lisp
 378         code/serve-event.lisp
 379
 380 The INSPECT function was originally written by Blaine Burks.
 381
 382 The CMU CL DESCRIBE facility was originally written by "Skef Wholey or
 383 Rob MacLachlan", according to the comments in the CMU CL sources. It
 384 was cleaned up and reorganized by Blaine Burks, then ported and
 385 cleaned up more by Rob MacLachlan. Also, since the split from CMU CL,
 386 the SBCL DESCRIBE facility was rewritten as a generic function and so
 387 become entangled with some DESCRIBE code which was distributed as part
 388 of PCL.
 389
 390 The implementation of the Mersenne Twister RNG used in SBCL is based
 391 on an implementation written by Douglas T. Crosher and Raymond Toy,
 392 which was placed in the public domain with permission from M.
 393 Matsumoto.
 394
 395 Comments in the CMU CL version of FreeBSD-os.c said it came from
 396 an OSF version by Sean Hallgren, later hacked by Paul Werkowski,
 397 with generational conservative GC support added by Douglas Crosher.
 398
 399 Comments in the CMU CL version of linux-os.c said it came from the
 400 FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996.
 401
 402 Comments in the CMU CL version of backtrace.c said it was "originally
 403 from Rob's version" (presumably Robert Maclachlan).
 404
 405 Comments in the CMU CL version of purify.c said it had stack direction
 406 changes, x86/CGC stack scavenging, and static blue bag stuff (all for
 407 x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code
 408 movement support, and x86/gencgc stack scavenging by Douglas Crosher,
 409 1996, 1997, 1998.
 410
 411 According to comments in the source files, much of the CMU CL version
 412 of the x86 support code
 413         assembly/x86/alloc.lisp
 414         assembly/x86/arith.lisp
 415         assembly/x86/array.lisp
 416         assembly/x86/assem-rtns.lisp
 417         compiler/x86/alloc.lisp
 418         compiler/x86/arith.lisp
 419         compiler/x86/c-call.lisp
 420         compiler/x86/call.lisp
 421         compiler/x86/cell.lisp
 422         compiler/x86/char.lisp
 423         compiler/x86/debug.lisp
 424         compiler/x86/float.lisp
 425         compiler/x86/insts.lisp
 426         compiler/x86/macros.lisp
 427         compiler/x86/memory.lisp
 428         compiler/x86/move.lisp
 429         compiler/x86/nlx.lisp
 430         compiler/x86/parms.lisp
 431         compiler/x86/pred.lisp
 432         compiler/x86/print.lisp
 433         compiler/x86/sap.lisp
 434         compiler/x86/static-fn.lisp
 435         compiler/x86/subprim.lisp
 436         compiler/x86/system.lisp
 437         compiler/x86/type-vops.lisp
 438         compiler/x86/values.lisp
 439         compiler/x86/vm.lisp
 440 was originally written by William Lott, then debugged by Paul
 441 Werkowski, and in some cases later enhanced and further debugged by
 442 Douglas T. Crosher; and the x86 runtime support code,
 443         x86-assem.S
 444 was written by Paul F. Werkowski and Douglas T. Crosher.
 445
 446 The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86
 447 FreeBSD port was originally contributed by Paul Werkowski, and Peter
 448 VanEynde took the FreeBSD port and created a Linux version.
 449
 450 According to comments in src/code/bsd-os.lisp, work on the generic BSD
 451 port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan
 452 Aronson, and Steve Handerson.
 453
 454 Douglas Crosher wrote code to support Gray streams, added X86 support
 455 for the debugger and relocatable code, wrote a conservative
 456 generational GC for the X86 port.  He also added X86-specific
 457 extensions to support stack groups and multiprocessing, but these are
 458 not present in SBCL
 459
 460 The CMU CL user manual credits Robert MacLachlan as editor. A chapter
 461 on the CMU CL interprocess communication extensions (not supported in
 462 SBCL) was contributed by William Lott and Bill Chiles.
 463
 464 Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
 465 to CMU CL, to provide additional safety, especially through runtime
 466 checking on various tricky cases of standard functions (e.g. MAP with
 467 complicated result types, and interactions of various variants of
 468 STREAM).
 469
 470 Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various
 471 other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE
 472 entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went
 473 away completely as the code became an unconditional part of the
 474 system.)
 475
 476 CMU CL's long float support was written by Douglas T. Crosher.
 477
 478 Paul Werkowski turned the Mach OS support code into Linux OS support code.
 479
 480 Versions of the RUN-PROGRAM extension were written first by David
 481 McDonald, then by Jim Healy and Bill Chiles, then by William Lott.
 482
 483
 484 MORE DETAILS ON THE TRANSITION FROM CMU CL
 485
 486 Bill Newman did the original conversion from CMU CL 18b to a form
 487 which could bootstrap itself cleanly, on Linux/x86 only. Although they
 488 may not have realized it at the time, Rob Maclachlan and Peter Van
 489 Eynde were very helpful, RAM by posting a clear explanation of what
 490 GENESIS is supposed to be doing and PVE by maintaining a version of
 491 CMU CL which worked on Debian, so that I had something to refer to
 492 whenever I got stuck.
 493
 494
 495 CREDITS SINCE THE RELEASE OF SBCL
 496
 497 (Note: (1) This is probably incomplete, since there's no systematic
 498 procedure for updating it. (2) Some more details are available in the
 499 NEWS file, in the project's CVS change logs, and in the archives of
 500 the sbcl-devel mailing list. (3) In this, as in other parts of SBCL,
 501 patches are welcome. Don't be shy.)
 502
 503 Martin Atzmueller:
 504   He reported many bugs, fixed many bugs, ported various fixes
 505   from CMU CL, and helped clean up various stale bug data. (He has
 506   been unusually energetic at this. As of sbcl-0.6.9.10, the
 507   total number of bugs involved likely exceeded 100. Since then,
 508   I've lost count. See the CVS logs.)
 509
 510 Daniel Barlow:
 511   His contributions have included support for shared object loading
 512   (from CMUCL), the Cheney GC for non-x86 ports (from CMUCL), Alpha
 513   and PPC ports (from CMUCL), control stack exhaustion checking (new),
 514   native threads support for x86 Linux (new), and the initial x86-64
 515   backend (new).  He also refactored the garbage collectors for
 516   understandability, wrote code (e.g. grovel-headers.c and
 517   stat_wrapper stuff) to find machine-dependent and OS-dependent
 518   constants automatically, and was original author of the asdf,
 519   asdf-install, sb-bsd-sockets, sb-executable, sb-grovel and sb-posix
 520   contrib packages.
 521
 522 Zach Beane:
 523   He provided a number of additions to SB-POSIX and implemented the
 524   original timer facility on which SBCL's timers are based.
 525
 526 James Bielman:
 527   He assisted in work on the port to the Windows operating system, and
 528   was instrumental in :EXECUTABLE support for SAVE-LISP-AND-DIE.
 529
 530 Alastair Bridgewater:
 531   He contributed a port of the system to the Windows operating system.
 532
 533 Robert E. Brown:
 534   He has reported various bugs and submitted several patches,
 535   especially improving removing gratuitous efficiencies in the
 536   standard library.
 537
 538 Cadabra, Inc. (later merged into GoTo.com):
 539   They hired Bill Newman to do some consulting for them,
 540   including the implementation of EQUALP hash tables for CMU CL;
 541   then agreed to release the EQUALP code into the public domain,
 542   giving SBCL (and CMU CL) its EQUALP hash tables.
 543
 544 Douglas Crosher:
 545   He continued to improve CMU CL after SBCL forked from it, creating
 546   many patches which were directly applicable to SBCL. Notable examples
 547   include fixes for various compiler bugs, the implementation of
 548   CL:DEFINE-SYMBOL-MACRO, and a generalization of the type system's
 549   handling of the CONS type to allow ANSI-style (CONS FOO BAR) types.
 550
 551 Alexey Dejneka:
 552   He fixed many, many bugs on various themes, and has done a
 553   tremendous amount of work on the compiler in particular, fixing
 554   bugs and refactoring.
 555
 556 Paul Dietz:
 557   He is in the process of writing a comprehensive test suite
 558   for the requirements of the ANSI Common Lisp standard. Already, at
 559   the halfway stage, it has caught hundreds of bugs in SBCL, and
 560   provided simple test cases for them. His random crash tester has
 561   caught an old deep problem in the implementation of the stack
 562   analysis phase in the compiler.
 563
 564 Brian Downing:
 565   He fixed the linker problems for building SBCL on Mac OS X.  He
 566   found and fixed the cause of backtraces failing for undefined
 567   functions and assembly routines. He wrote the core of SBCL's
 568   alternative interpreter-based EVAL.
 569
 570 Miles Egan:
 571   He creates binary packages of SBCL releases for Red Hat and other
 572   (which?) platforms.
 573
 574 Helmut Eller:
 575   A lot of the code in the SB-INTROSPECT and SB-COVER contrib modules
 576   was originally written by him for Slime/Swank.
 577
 578 Lutz Euler:
 579   He made a large number of improvements to the x86-64 disassembler.
 580
 581 Andreas Fuchs:
 582   He provides infrastructure for monitoring build and performance
 583   regressions of SBCL.  He assisted with the integration of the
 584   Unicode work.
 585
 586 Nathan Froyd:
 587   He has fixed various bugs, and also done a lot of internal
 588   cleanup, not visible at the user level but important for
 589   maintenance. (E.g. converting the PCL code to use LOOP instead
 590   of the old weird pre-ANSI ITERATE macro so that the code can be
 591   read without being an expert in ancient languages and so that we
 592   can delete a thousand lines of implement-ITERATE macrology from
 593   the codebase.)
 594
 595 Bruno Haible:
 596   He devised an accurate continued-fraction-based implementation of
 597   RATIONALIZE, replacing a less-accurate version inherited from
 598   primordial CMUCL.
 599
 600 Cyrus Harmon:
 601   He fixed many PPC FFI and callback bugs.  He ported Raymond Toy's
 602   work on the generational garbage collector for PPC to Linux, finding
 603   and fixing other SBCL bugs in the process.
 604
 605 Matthias Hoelzl:
 606   He reported and fixed COMPILE's misbehavior on macros.
 607
 608 Daisuke Homma:
 609   He added support for SunOS on x86 processors.
 610
 611 ITA Software:
 612   They hired Juho Snellman as a consultant to work on improvements to
 613   SBCL, to be released into the public domain. The work they've funded
 614   includes faster compilation, various improvements to the statistical
 615   profiler, the SB-COVER code coverage tool, the interpreter-based
 616   evaluator and the IR2-based single-stepper.
 617
 618 Espen S Johnsen:
 619   He provided an ANSI-compliant version of CHANGE-CLASS for PCL.
 620
 621 Teemu Kalvas:
 622   He worked on Unicode support for SBCL, including parsing the Unicode
 623   character database, restoring the FAST-READ-CHAR optimization and
 624   developing external format support.
 625
 626 Yaroslav Kavenchuk:
 627   He implemented several missing features and fixed many bugs in
 628   the win32 port. He also worked on external-format support for
 629   SB-ALIEN.
 630
 631 Richard M Kreyter:
 632   He added documentation support for CLOS slot readers and writers,
 633   provided several SB-POSIX and NetBSD patches, and cleaned up
 634   several of the filesystem/pathname interfaces.
 635
 636 Frederik Kuivinen:
 637   He showed how to implement the DEBUG-RETURN functionality.
 638
 639 Arthur Lemmens:
 640   He found and fixed a number of SBCL bugs while partially porting
 641   SBCL to bootstrap under Lispworks for Windows.
 642
 643 David Lichteblau:
 644   He came up with a more memory-efficient representation for
 645   structures with raw slots.
 646
 647 Robert MacLachlan:
 648   He has continued to answer questions about, and contribute fixes to,
 649   the CMU CL project. Some of these fixes, especially for compiler
 650   problems, has been invaluable to the CMU CL project and, by
 651   porting, invaluable to the SBCL project as well.
 652
 653 Pierre Mai:
 654   He has continued to work on CMU CL since the SBCL fork, and also
 655   patched code to SBCL to enable dynamic loading of object files
 656   under OpenBSD.  He contributed to the port of SBCL to MacOS X,
 657   implementing the Lisp side of the PowerOpen ABI.
 658
 659 Eric Marsden:
 660   Some of his fixes to CMU CL since the SBCL fork have been ported
 661   to SBCL.  He also maintains the cl-benchmark package, which gives
 662   us some idea of how our performance changes compared to earlier
 663   releases and to other implementations.  He assisted in development
 664   of Unicode support for SBCL.
 665
 666 Antonio Martinez-Shotton:
 667   He has contributed a number of bug fixes and bug reports to SBCL.
 668
 669 Brian Mastenbrook:
 670   He contributed to and extensively maintained the port of SBCL to
 671   MacOS X. His contributions include overcoming binary compatibility
 672   issues between different versions of dlcompat on Darwin, other
 673   linker fixes, and signal handler bugfixes.
 674
 675 Dave McDonald:
 676   He made a lot of progress toward getting SBCL to be bootstrappable
 677   under CLISP.
 678
 679 Perry E. Metzger:
 680   He ported SBCL to NetBSD with newer signals, building on the
 681   work of Valtteri Vuorikoski.  He also provided various cleanups to
 682   the C runtime.
 683
 684 Gerd Moellman:
 685   He has made many cleanups and improvements, small and large, in
 686   CMU CL (mostly in PCL), which we have gratefully ported to SBCL.  Of
 687   particular note is his ctor MAKE-INSTANCE optimization, which is both
 688   faster in the typical case than the old optimizations in PCL and
 689   less buggy.
 690
 691 Timothy Moore:
 692   He designed and implemented the original CMUCL linkage-table, on
 693   which the SBCL implementation thereof is based.
 694
 695 William ("Bill") Newman:
 696   He continued to maintain SBCL after the fork, increasing ANSI
 697   compliance, fixing bugs, regularizing the internals of the
 698   system, deleting unused extensions, improving performance in
 699   some areas (especially sequence functions and non-simple vectors),
 700   updating documentation, and even, for better or worse, getting
 701   rid of various functionality (e.g. the byte interpreter).
 702
 703 NIIMI Satoshi:
 704   He contributed a number of fixes to the FreeBSD port, implemented
 705   some external-formats and JOIN-THREAD, and also worked on
 706   the :EXECUTABLE support.
 707
 708 Patrik Nordebo:
 709   He contributed to the port of SBCL to MacOS X, finding solutions for
 710   ABI and assembly syntax differences between Darwin and Linux.
 711
 712 Luís Oliveira:
 713   He contributed to the port of SBCL to the Windows operating system,
 714   particuarly in the area of FFI.
 715
 716 Scott Parish:
 717   He ported SBCL to OpenBSD-with-ELF.
 718
 719 Timothy Ritchey:
 720   He implemented SB-BSD-SOCKETS support for the win32 port.
 721
 722 Kevin M. Rosenberg:
 723   He provided the ACL-style toplevel (sb-aclrepl contrib module), and
 724   a number of MOP-related bug reports.  He also creates the official
 725   Debian packages of SBCL.
 726
 727 Joshua Ross:
 728   He fixed some bugs relating to foreign calls and callbacks on the
 729   Linux PowerPC platform.
 730
 731 Christophe Rhodes:
 732   He ported SBCL to SPARC (based on the CMUCL backend), made various
 733   port-related and SPARC-related changes (like *BACKEND-SUBFEATURES*),
 734   made many fixes and improvements in the compiler's type system, has
 735   essentially completed the work to enable bootstrapping SBCL under
 736   unrelated (non-SBCL, non-CMU-CL) Common Lisps.  He participated in
 737   the modernization of SBCL's CLOS implementation, implemented the
 738   treatment of compiler notes as restartable conditions, provided
 739   optimizations to compiler output, and contributed in other ways as
 740   well.
 741
 742 Stig Erik Sandø:
 743   He showed how to convince the GNU toolchain to build SBCL in a way
 744   which supports callbacks from C code into SBCL.
 745
 746 Rudi Schlatte:
 747   He ported Paul Foley's simple-streams implementation from cmucl,
 748   converted the sbcl manual to Texinfo and wrote a documentation
 749   string extractor that keeps function documentation in the manual
 750   current.
 751
 752 Thiemo Seufer:
 753   He modernized the MIPS backend, fixing many bugs, and assisted in
 754   cleaning up the C runtime code.
 755
 756 Julian Squires:
 757   He worked on Unicode support for the PowerPC platform.
 758
 759 Nikodemus Siivola:
 760   He provided build fixes, in particular to tame the SunOS toolchain,
 761   implemented package locks, ported the linkage-table code from CMUCL,
 762   reimplemented STEP, implemented the compare-and-swap interface, and
 763   has fixed many bugs besides.
 764
 765 Juho Snellman:
 766   He provided a number of bug fixes and performance enhancements to
 767   the compiler, the standard library functions, and to the garbage
 768   collector. He ported and enhanced the statistical profiler written
 769   by Gerd Moellmann for CMU CL. He completed the work on the x86-64
 770   port of SBCL.
 771
 772 Brian Spilsbury:
 773   He wrote Unicode-capable versions of SBCL's character, string, and
 774   stream types and operations on them.  (These versions did not end up
 775   in the system, but did to a large extent influence the support which
 776   finally did get merged.)
 777
 778 Robert Swindells:
 779   He ported SBCL to NetBSD/Sparc.
 780
 781 Raymond Toy:
 782   He continued to work on CMU CL after the SBCL fork, especially on
 783   floating point stuff. Various patches and fixes of his have been
 784   ported to SBCL, including his Sparc port of linkage-table.
 785
 786 Peter Van Eynde:
 787   He wrestled the CLISP test suite into a mostly portable test suite
 788   (clocc ansi-test) which can be used on SBCL, provided a slew of
 789   of bug reports resulting from that, and submitted many other bug
 790   reports as well.
 791
 792 Valtteri Vuorikoski:
 793   He ported SBCL to NetBSD, and also fixed a long-standing bug in
 794   DEFSTRUCT with respect to colliding accessor names.
 795
 796 Colin Walters:
 797   His O(N) implementation of the general case of MAP, posted on the
 798   cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
 799   code added in sbcl-0.6.8.
 800
 801 Cheuksan Edward Wang:
 802   He assisted in debugging the SBCL x86-64 backend.
 803
 804 Raymond Wiker:
 805   He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
 806   CMU CL support for FreeBSD and updating it for the changes made
 807   from FreeBSD version 3 to FreeBSD version 4. He also ported the
 808   CMU CL extension RUN-PROGRAM, and related code, to SBCL.
 809
 810
 811 INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.)
 812
 813 AB   Alastair Bridgewater
 814 AL   Arthur Lemmens
 815 APD  Alexey Dejneka
 816 CLH  Cyrus Harmon
 817 CSR  Christophe Rhodes
 818 DB   Daniel Barlow (also "dan")
 819 DFL  David Lichteblau
 820 DTC  Douglas Crosher
 821 JES  Juho Snellman
 822 JRXR Joshua Ross
 823 MG   Gabor Melis
 824 MNA  Martin Atzmueller
 825 NJF  Nathan Froyd
 826 NS   Nikodemus Siivola
 827 PFD  Paul F. Dietz
 828 PRM  Pierre Mai
 829 PVE  Peter Van Eynde
 830 PW   Paul Werkowski
 831 RAM  Robert MacLachlan
 832 THS  Thiemo Seufer
 833 VJA  Vincent Arkesteijn
 834 WHN  William ("Bill") Newman