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 15BROAD OUTLINE 16 17SBCL is derived from the 18b version of CMU CL. 18 19Most of CMU CL was originally written as part of the CMU Common Lisp 20project at Carnegie Mellon University. According to the documentation 21in 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. 27and 28 CMU CL has been under continuous development since the early 1980's 29 (concurrent with the Common Lisp standardization effort.) 30Apparently most of the CMU Common Lisp implementors moved on to 31work on the Gwydion environment for Dylan. 32 33CMU CL's CLOS implementation is derived from the PCL reference 34implementation written at Xerox PARC. 35 36CMU CL's implementation of the LOOP macro was derived from code 37from Symbolics, which was derived from code from MIT. 38 39CMU CL had many individual author credits in the source files. In the 40sometimes-extensive rearrangements which were required to make SBCL 41bootstrap itself cleanly, it was tedious to try keep such credits 42attached to individual source files, so they have been moved here 43instead. 44 45Bill Newman <william.newman@airmail.net> did this transformation, and 46so any errors made are probably his. Corrections would be appreciated. 47 48 49MORE DETAILS ON SBCL'S CLOS CODE 50 51The 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 63This was intended for the original incarnation of the PCL code as a 64portable reference implementation. Since our version of the code has 65had its portability hacked out of it, it's no longer particularly 66relevant to any coordinated PCL effort (which probably doesn't exist 67any more anyway). Therefore, this contact information has been deleted 68from the PCL file headers. 69 70A few files in the original CMU CL 18b src/pcl/ directory did not 71carry 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 78The comments in the CMU CL 18b version of the PCL code walker, 79src/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 90MORE DETAILS ON SBCL'S LOOP CODE 91 92The src/code/loop.lisp file from CMU CL 18b had the following 93credits-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 121The date of the M.I.T. copyright statement falls around the time 122described in these comments. The dates on the Symbolics copyright 123statement are all later -- the earliest is 1989. 124 125 126MORE DETAILS ON OTHER SBCL CODE FROM CMU CL 127 128CMU CL's symbol (but not package) code (code/symbol.lisp) was 129originally written by Scott Fahlman and updated and maintained 130by Skef Wholey. 131 132The CMU CL reader (code/reader.lisp) was originally the Spice Lisp 133reader, written by David Dill and with support for packages added by 134Lee Schumacher. David Dill also wrote the sharpmacro support 135(code/sharpm.lisp). 136 137CMU CL's package code was rewritten by Rob MacLachlan based on an 138earlier version by Lee Schumacher. It also includes DEFPACKAGE by Dan 139Zigmond, and WITH-PACKAGE-ITERATOR written by Blaine Burks. William 140Lott also rewrote the DEFPACKAGE and DO-FOO-SYMBOLS stuff. 141 142CMU CL's string code (code/string.lisp) was originally written by 143David Dill, then rewritten by Skef Wholey, Bill Chiles, and Rob 144MacLachlan. 145 146Various code in the system originated with "Spice Lisp", which was 147apparently a predecessor to the CMU CL project. Much of that was 148originally 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) 154The CMU CL seq.lisp code also gave credits for later work by Jim Muller 155and Bill Chiles. 156 157The modules system (code/module.lisp, containing REQUIRE, PROVIDE, 158and friends, now deprecated by ANSI) was written by Jim Muller and 159rewritten by Bill Chiles. 160 161The CMU CL garbage collector was credited to "Christopher Hoover, 162Rob MacLachlan, Dave McDonald, et al." in the CMU CL code/gc.lisp file, 163with some extra code for the MIPS port credited to Christopher Hoover 164alone. The credits on the original "gc.c", "Stop and Copy GC based 165on Cheney's algorithm", said "written by Christopher Hoover". 166 167Guy Steele wrote the original character functions 168 code/char.lisp 169They were subsequently rewritten by David Dill, speeded up by Scott 170Fahlman, and rewritten without fonts and with a new type system by Rob 171MachLachlan. 172 173Lee Schumacher made the Spice Lisp version of backquote. The comment 174in the CMU CL sources suggests he based it on someone else's code for 175some other Lisp system, but doesn't say which. A note in the CMU CL 176code to pretty-print backquote expressions says that unparsing support 177was provided by Miles Bader. 178 179The CMU implementations of the Common Lisp query functions Y-OR-N-P 180and YES-OR-NO-P were originally written by Walter van Roggen, and 181updated and modified by Rob MacLachlan and Bill Chiles. 182 183The CMU CL sort functions (code/sort.lisp) were written by Jim Large, 184hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles. 185 186Most of the internals of the Python compiler seem to have been 187originally 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 211Besides writing the compiler, and various other work mentioned elsewhere, 212Robert MacLachlan was also credited with tuning the implementation of 213streams 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 220William Lott is also credited with writing or heavily maintaining some 221parts of the CMU CL compiler. He was responsible for lifting 222compiler/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 243Also, Christopher Hoover and William Lott wrote compiler/generic/vm-macs.lisp 244to centralize information about machine-dependent macros and constants. 245 246Sean Hallgren is credited with most of the Alpha backend. Julian 247Dolby created the CMU CL Alpha/Linux port. Douglas Crosher added 248complex-float support. 249 250The original PPC backend was the work of Gary Byers. Some bug fixes 251and other changes to update it for current CMUCL interfaces were made 252by Eric Marsden and Douglas Crosher 253 254The CMU CL machine-independent disassembler (compiler/disassem.lisp) 255was written by Miles Bader. 256 257Parts of the CMU CL system were credited to Skef Wholey and Rob 258MacLachlan jointly, perhaps because they were originally part of Spice 259Lisp 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 268Bill Chiles also modified code/macros.lisp. Much of the implementation 269of PURIFY was rewritten in C by William Lott. 270 271The CMU CL number functions (code/number.lisp) were written by Rob 272MacLachlan, but acknowledge much code "derived from code written by 273William Lott, Dave Mcdonald, Jim Large, Scott Fahlman, etc." 274 275CMU CL's weak pointer support (code/weak.lisp) was written by 276Christopher Hoover. 277 278The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William 279Lott and Skef Wholey jointly. 280 281The FDEFINITION system for handling arbitrary function names (a la 282(SETF FOO)) was originally written by Rob MacLachlan. It was modified 283by Bill Chiles to add encapsulation, and modified more by William Lott 284to add FDEFN objects. 285 286The CMU CL condition system (code/error.lisp) was based on 287some prototyping code written by Kent Pitman at Symbolics. 288 289The CMU CL HASH-TABLE system was originally written by Skef Wholey 290for Spice Lisp, then rewritten by William Lott, then rewritten 291again by Douglas T. Crosher. 292 293The support code for environment queries (a la LONG-SITE-NAME), 294the DOCUMENTATION function, and the DRIBBLE function was written 295and maintained "mostly by Skef Wholey and Rob MacLachlan. Scott 296Fahlman, Dan Aronson, and Steve Handerson did stuff here too." 297The same credit statement was given for the original Mach OS interface code. 298 299The CMU CL printer, print.lisp, was credited as "written by Neal 300Feinberg, Bill Maddox, Steven Handerson, and Skef Wholey, and modified 301by various CMU Common Lisp maintainers." The comments on the float 302printer said specifically that it was written by Bill Maddox. The 303comments on bignum printing said specifically that it was written by 304Steven Handerson (based on Skef's idea), and that it was rewritten by 305William Lott to remove assumptions about length of fixnums on the MIPS 306port. 307 308The comments in the main body of the CMU CL debugger 309 code/debug.lisp 310say 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 313say they were written by Bill Chiles and Rob MacLachlan. 314The related file 315 src/debug-vm.lisp, low-level support for :FUNCTION-END breakpoints 316was written by William Lott. 317 318The CMU CL GENESIS cold load system, 319compiler/generic/new-genesis.lisp, was originally written by Skef 320Wholey, then jazzed up for packages by Rob MacLachlan, then completely 321rewritten by William Lott for the MIPS port. 322 323The CMU CL IR1 interpreter was written by Bill Chiles and Robert 324MacLachlan. 325 326Various 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 352The ALIEN facility seems to have been written largely by Rob 353MacLachlan and William Lott. The CMU CL comments say "rewritten again, 354this time by William Lott and Rob MacLachlan," but don't identify who 355else might have been involved in earlier versions. 356 357The comments in CMU CL's code/final.lisp say "the idea really was 358Chris Hoover's". The comments in CMU CL's code/pprint.lisp say "Algorithm 359stolen from Richard Waters' XP." The comments in CMU CL's code/format.lisp 360say "with lots of stuff stolen from the previous version by David Adam 361and later rewritten by Bill Maddox." 362 363Jim Muller was credited with fixing seq.lisp. 364 365CMU CL's time printing logic, in code/format-time.lisp, was written 366by Jim Healy. 367 368Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller. 369 370The CMU CL machine/filesystem-independent pathname functions 371(code/pathname.lisp) were written by William Lott, Paul Gleichauf, and 372Rob MacLachlan, based on an earlier version written by Jim Large and 373Rob MacLachlan. 374 375Besides writing the original versions of the things credited to him 376above, William Lott rewrote, updated, and cleaned up various stuff: 377 code/array.lisp 378 code/serve-event.lisp 379 380The INSPECT function was originally written by Blaine Burks. 381 382The CMU CL DESCRIBE facility was originally written by "Skef Wholey or 383Rob MacLachlan", according to the comments in the CMU CL sources. It 384was cleaned up and reorganized by Blaine Burks, then ported and 385cleaned up more by Rob MacLachlan. Also, since the split from CMU CL, 386the SBCL DESCRIBE facility was rewritten as a generic function and so 387become entangled with some DESCRIBE code which was distributed as part 388of PCL. 389 390The implementation of the Mersenne Twister RNG used in SBCL is based 391on an implementation written by Douglas T. Crosher and Raymond Toy, 392which was placed in the public domain with permission from M. 393Matsumoto. 394 395Comments in the CMU CL version of FreeBSD-os.c said it came from 396an OSF version by Sean Hallgren, later hacked by Paul Werkowski, 397with generational conservative GC support added by Douglas Crosher. 398 399Comments in the CMU CL version of linux-os.c said it came from the 400FreeBSD-os.c version, morfed to Linux by Peter Van Eynde in July 1996. 401 402Comments in the CMU CL version of backtrace.c said it was "originally 403from Rob's version" (presumably Robert Maclachlan). 404 405Comments in the CMU CL version of purify.c said it had stack direction 406changes, x86/CGC stack scavenging, and static blue bag stuff (all for 407x86 port?) by Paul Werkowski, 1995, 1996; and bug fixes, x86 code 408movement support, and x86/gencgc stack scavenging by Douglas Crosher, 4091996, 1997, 1998. 410 411According to comments in the source files, much of the CMU CL version 412of 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 440was originally written by William Lott, then debugged by Paul 441Werkowski, and in some cases later enhanced and further debugged by 442Douglas T. Crosher; and the x86 runtime support code, 443 x86-assem.S 444was written by Paul F. Werkowski and Douglas T. Crosher. 445 446The CMU CL user manual (doc/cmu-user/cmu-user.tex) says that the X86 447FreeBSD port was originally contributed by Paul Werkowski, and Peter 448VanEynde took the FreeBSD port and created a Linux version. 449 450According to comments in src/code/bsd-os.lisp, work on the generic BSD 451port was done by Skef Wholey, Rob MacLachlan, Scott Fahlman, Dan 452Aronson, and Steve Handerson. 453 454Douglas Crosher wrote code to support Gray streams, added X86 support 455for the debugger and relocatable code, wrote a conservative 456generational GC for the X86 port. He also added X86-specific 457extensions to support stack groups and multiprocessing, but these are 458not present in SBCL 459 460The CMU CL user manual credits Robert MacLachlan as editor. A chapter 461on the CMU CL interprocess communication extensions (not supported in 462SBCL) was contributed by William Lott and Bill Chiles. 463 464Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches 465to CMU CL, to provide additional safety, especially through runtime 466checking on various tricky cases of standard functions (e.g. MAP with 467complicated result types, and interactions of various variants of 468STREAM). 469 470Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various 471other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE 472entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went 473away completely as the code became an unconditional part of the 474system.) 475 476CMU CL's long float support was written by Douglas T. Crosher. 477 478Paul Werkowski turned the Mach OS support code into Linux OS support code. 479 480Versions of the RUN-PROGRAM extension were written first by David 481McDonald, then by Jim Healy and Bill Chiles, then by William Lott. 482 483 484MORE DETAILS ON THE TRANSITION FROM CMU CL 485 486Bill Newman did the original conversion from CMU CL 18b to a form 487which could bootstrap itself cleanly, on Linux/x86 only. Although they 488may not have realized it at the time, Rob Maclachlan and Peter Van 489Eynde were very helpful, RAM by posting a clear explanation of what 490GENESIS is supposed to be doing and PVE by maintaining a version of 491CMU CL which worked on Debian, so that I had something to refer to 492whenever I got stuck. 493 494 495CREDITS SINCE THE RELEASE OF SBCL 496 497(Note: (1) This is probably incomplete, since there's no systematic 498procedure for updating it. (2) Some more details are available in the 499NEWS file, in the project's CVS change logs, and in the archives of 500the sbcl-devel mailing list. (3) In this, as in other parts of SBCL, 501patches are welcome. Don't be shy.) 502 503Martin 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 510Daniel 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 522Zach Beane: 523 He provided a number of additions to SB-POSIX, implemented the 524 original timer facility on which SBCL's timers are based. and also 525 contributed the :SAVE-RUNTIME-OPTIONS support for SAVE-LISP-AND-DIE. 526 527James Bielman: 528 He assisted in work on the port to the Windows operating system, and 529 was instrumental in :EXECUTABLE support for SAVE-LISP-AND-DIE. 530 531Alastair Bridgewater: 532 He contributed a port of the system to the Windows operating system. 533 534Robert E. Brown: 535 He has reported various bugs and submitted several patches, 536 especially improving removing gratuitous efficiencies in the 537 standard library. 538 539Cadabra, Inc. (later merged into GoTo.com): 540 They hired Bill Newman to do some consulting for them, 541 including the implementation of EQUALP hash tables for CMU CL; 542 then agreed to release the EQUALP code into the public domain, 543 giving SBCL (and CMU CL) its EQUALP hash tables. 544 545Douglas Crosher: 546 He continued to improve CMU CL after SBCL forked from it, creating 547 many patches which were directly applicable to SBCL. Notable examples 548 include fixes for various compiler bugs, the implementation of 549 CL:DEFINE-SYMBOL-MACRO, and a generalization of the type system's 550 handling of the CONS type to allow ANSI-style (CONS FOO BAR) types. 551 552Larry D'Anna: 553 He provided several parts of SB-CLTL2 environment access, and has 554 also worked on bugs in the IR2 conversion stage of the compiler. 555 556Alexey Dejneka: 557 He fixed many, many bugs on various themes, and has done a 558 tremendous amount of work on the compiler in particular, fixing 559 bugs and refactoring. 560 561Paul Dietz: 562 He is in the process of writing a comprehensive test suite 563 for the requirements of the ANSI Common Lisp standard. Already, at 564 the halfway stage, it has caught hundreds of bugs in SBCL, and 565 provided simple test cases for them. His random crash tester has 566 caught an old deep problem in the implementation of the stack 567 analysis phase in the compiler. 568 569Brian Downing: 570 He fixed the linker problems for building SBCL on Mac OS X. He 571 found and fixed the cause of backtraces failing for undefined 572 functions and assembly routines. He wrote the core of SBCL's 573 alternative interpreter-based EVAL. 574 575Miles Egan: 576 He creates binary packages of SBCL releases for Red Hat and other 577 (which?) platforms. 578 579Helmut Eller: 580 A lot of the code in the SB-INTROSPECT and SB-COVER contrib modules 581 was originally written by him for Slime/Swank. 582 583Lutz Euler: 584 He made a large number of improvements to the x86-64 disassembler. 585 586Andreas Fuchs: 587 He provides infrastructure for monitoring build and performance 588 regressions of SBCL. He assisted with the integration of the 589 Unicode work. 590 591Stephan Frank: 592 He contributed the SB-GMP contrib to exploit libgmp in bignum and 593 ratio arithmetic. 594 595Nathan Froyd: 596 He has fixed various bugs, and also done a lot of internal 597 cleanup, not visible at the user level but important for 598 maintenance. (E.g. converting the PCL code to use LOOP instead 599 of the old weird pre-ANSI ITERATE macro so that the code can be 600 read without being an expert in ancient languages and so that we 601 can delete a thousand lines of implement-ITERATE macrology from 602 the codebase.) 603 604Bruno Haible: 605 He devised an accurate continued-fraction-based implementation of 606 RATIONALIZE, replacing a less-accurate version inherited from 607 primordial CMUCL. 608 609Cyrus Harmon: 610 He fixed many PPC FFI and callback bugs. He ported Raymond Toy's 611 work on the generational garbage collector for PPC to Linux, finding 612 and fixing other SBCL bugs in the process. 613 614Matthias Hoelzl: 615 He reported and fixed COMPILE's misbehavior on macros. 616 617Daisuke Homma: 618 He added support for SunOS on x86 processors. 619 620ITA Software: 621 They hired Juho Snellman as a consultant to work on improvements to 622 SBCL, to be released into the public domain. The work they've funded 623 includes faster compilation, various improvements to the statistical 624 profiler, the SB-COVER code coverage tool, the interpreter-based 625 evaluator and the IR2-based single-stepper. 626 627Espen S Johnsen: 628 He provided an ANSI-compliant version of CHANGE-CLASS for PCL. 629 630Teemu Kalvas: 631 He worked on Unicode support for SBCL, including parsing the Unicode 632 character database, restoring the FAST-READ-CHAR optimization and 633 developing external format support. 634 635Dmitry Kalyanov: 636 His work was crucial in bringing the Windows backend forward; he 637 implemented pthreads and ported SB-THREAD to this platform. 638 639Yaroslav Kavenchuk: 640 He implemented several missing features and fixed many bugs in 641 the win32 port. He also worked on external-format support for 642 SB-ALIEN. 643 644Anton Kovalenko: 645 He introduced a safepoint-based stop-the-world protocol and greatly 646 contributed to features and bugfixes related to the Windows port. 647 648Richard M Kreyter: 649 He added documentation support for CLOS slot readers and writers, 650 provided several SB-POSIX and NetBSD patches, and cleaned up 651 several of the filesystem/pathname interfaces. 652 653Frederik Kuivinen: 654 He showed how to implement the DEBUG-RETURN functionality. 655 656Arthur Lemmens: 657 He found and fixed a number of SBCL bugs while partially porting 658 SBCL to bootstrap under Lispworks for Windows. 659 660David Lichteblau: 661 He repeatedly failed to update his entry in this file. 662 663Robert MacLachlan: 664 He has continued to answer questions about, and contribute fixes to, 665 the CMU CL project. Some of these fixes, especially for compiler 666 problems, has been invaluable to the CMU CL project and, by 667 porting, invaluable to the SBCL project as well. 668 669Pierre Mai: 670 He has continued to work on CMU CL since the SBCL fork, and also 671 patched code to SBCL to enable dynamic loading of object files 672 under OpenBSD. He contributed to the port of SBCL to MacOS X, 673 implementing the Lisp side of the PowerOpen ABI. 674 675Eric Marsden: 676 Some of his fixes to CMU CL since the SBCL fork have been ported 677 to SBCL. He also maintains the cl-benchmark package, which gives 678 us some idea of how our performance changes compared to earlier 679 releases and to other implementations. He assisted in development 680 of Unicode support for SBCL. 681 682Antonio Martinez-Shotton: 683 He has contributed a number of bug fixes and bug reports to SBCL. 684 685Brian Mastenbrook: 686 He contributed to and extensively maintained the port of SBCL to 687 MacOS X. His contributions include overcoming binary compatibility 688 issues between different versions of dlcompat on Darwin, other 689 linker fixes, and signal handler bugfixes. 690 691Dave McDonald: 692 He made a lot of progress toward getting SBCL to be bootstrappable 693 under CLISP. 694 695Gabor Melis: 696 He mainly worked on robustness related to signal handling, threads, 697 timers with small excursions to constraint propagation, weak hash 698 tables (based on CMUCL code) and optimizing x86/x86-64 calling 699 convention. 700 701Perry E. Metzger: 702 He ported SBCL to NetBSD with newer signals, building on the 703 work of Valtteri Vuorikoski. He also provided various cleanups to 704 the C runtime. 705 706Gerd Moellman: 707 He has made many cleanups and improvements, small and large, in 708 CMU CL (mostly in PCL), which we have gratefully ported to SBCL. Of 709 particular note is his ctor MAKE-INSTANCE optimization, which is both 710 faster in the typical case than the old optimizations in PCL and 711 less buggy. 712 713Timothy Moore: 714 He designed and implemented the original CMUCL linkage-table, on 715 which the SBCL implementation thereof is based. 716 717William ("Bill") Newman: 718 He continued to maintain SBCL after the fork, increasing ANSI 719 compliance, fixing bugs, regularizing the internals of the 720 system, deleting unused extensions, improving performance in 721 some areas (especially sequence functions and non-simple vectors), 722 updating documentation, and even, for better or worse, getting 723 rid of various functionality (e.g. the byte interpreter). 724 725NIIMI Satoshi: 726 He contributed a number of fixes to the FreeBSD port, implemented 727 some external-formats and JOIN-THREAD, and also worked on 728 the :EXECUTABLE support. 729 730Patrik Nordebo: 731 He contributed to the port of SBCL to MacOS X, finding solutions for 732 ABI and assembly syntax differences between Darwin and Linux. 733 734Luís Oliveira: 735 He contributed to the port of SBCL to the Windows operating system, 736 particuarly in the area of FFI. 737 738Scott Parish: 739 He ported SBCL to OpenBSD-with-ELF. 740 741Timothy Ritchey: 742 He implemented SB-BSD-SOCKETS support for the win32 port. 743 744Tobias Rittweiler 745 He has made several contributions relating to source locations, 746 pretty printing, SB-INTROSPECT, and the reader. 747 748Kevin M. Rosenberg: 749 He provided the ACL-style toplevel (sb-aclrepl contrib module), and 750 a number of MOP-related bug reports. He also creates the official 751 Debian packages of SBCL. 752 753Joshua Ross: 754 He fixed some bugs relating to foreign calls and callbacks on the 755 Linux PowerPC platform. 756 757Christophe Rhodes: 758 He ported SBCL to SPARC (based on the CMUCL backend), made various 759 port-related and SPARC-related changes (like *BACKEND-SUBFEATURES*), 760 made many fixes and improvements in the compiler's type system, has 761 essentially completed the work to enable bootstrapping SBCL under 762 unrelated (non-SBCL, non-CMU-CL) Common Lisps. He participated in 763 the modernization of SBCL's CLOS implementation, implemented the 764 treatment of compiler notes as restartable conditions, provided 765 optimizations to compiler output, and contributed in other ways as 766 well. 767 768Stig Erik Sandø: 769 He showed how to convince the GNU toolchain to build SBCL in a way 770 which supports callbacks from C code into SBCL. 771 772Rudi Schlatte: 773 He ported Paul Foley's simple-streams implementation from cmucl, 774 converted the sbcl manual to Texinfo and wrote a documentation 775 string extractor that keeps function documentation in the manual 776 current. 777 778Thiemo Seufer: 779 He modernized the MIPS backend, fixing many bugs, and assisted in 780 cleaning up the C runtime code. 781 782Julian Squires: 783 He worked on Unicode support for the PowerPC platform. 784 785Nikodemus Siivola: 786 He provided build fixes, in particular to tame the SunOS toolchain, 787 implemented package locks, ported the linkage-table code from CMUCL, 788 reimplemented STEP, implemented the compare-and-swap interface, and 789 has fixed many bugs besides. 790 791Juho Snellman: 792 He provided a number of bug fixes and performance enhancements to 793 the compiler, the standard library functions, and to the garbage 794 collector. He ported and enhanced the statistical profiler written 795 by Gerd Moellmann for CMU CL. He completed the work on the x86-64 796 port of SBCL. 797 798Brian Spilsbury: 799 He wrote Unicode-capable versions of SBCL's character, string, and 800 stream types and operations on them. (These versions did not end up 801 in the system, but did to a large extent influence the support which 802 finally did get merged.) 803 804Robert Swindells: 805 He ported SBCL to NetBSD/Sparc. 806 807Raymond Toy: 808 He continued to work on CMU CL after the SBCL fork, especially on 809 floating point stuff. Various patches and fixes of his have been 810 ported to SBCL, including his Sparc port of linkage-table. 811 812Larry Valkama: 813 He resurrected the HPUX port, and worked on the HPPA backend in 814 general. 815 816Peter Van Eynde: 817 He wrestled the CLISP test suite into a mostly portable test suite 818 (clocc ansi-test) which can be used on SBCL, provided a slew of 819 of bug reports resulting from that, and submitted many other bug 820 reports as well. 821 822Valtteri Vuorikoski: 823 He ported SBCL to NetBSD, and also fixed a long-standing bug in 824 DEFSTRUCT with respect to colliding accessor names. 825 826Colin Walters: 827 His O(N) implementation of the general case of MAP, posted on the 828 cmucl-imp@cons.org mailing list, was the inspiration for similar MAP 829 code added in sbcl-0.6.8. 830 831Cheuksan Edward Wang: 832 He assisted in debugging the SBCL x86-64 backend. 833 834Raymond Wiker: 835 He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral 836 CMU CL support for FreeBSD and updating it for the changes made 837 from FreeBSD version 3 to FreeBSD version 4. He also ported the 838 CMU CL extension RUN-PROGRAM, and related code, to SBCL. 839 840 841INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.) 842 843AB Alastair Bridgewater 844AK Anton Kovalenko 845AL Arthur Lemmens 846APD Alexey Dejneka 847CLH Cyrus Harmon 848CSR Christophe Rhodes 849DB Daniel Barlow (also "dan") 850DFL David Lichteblau 851DTC Douglas Crosher 852JES Juho Snellman 853JRXR Joshua Ross 854LAV Larry Valkama 855LEU Lutz Euler 856MG Gabor Melis 857MNA Martin Atzmueller 858NJF Nathan Froyd 859NS Nikodemus Siivola 860PFD Paul F. Dietz 861PRM Pierre Mai 862PVE Peter Van Eynde 863PK/PVK Paul-Virak Khuong 864PW Paul Werkowski 865RAM Robert MacLachlan 866RLT Raymond Toy 867TCR Tobias Rittweiler 868THS Thiemo Seufer 869VJA Vincent Arkesteijn 870WHN William ("Bill") Newman 871