0.9.3.15: debugger streams
[sbcl/tcr.git] / CREDITS
blobd796c1c50839626d163e2f1f77b31a3b785b50b2
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"
14 BROAD OUTLINE
16 SBCL is derived from the 18b version of CMU CL.
18 Most of CMU CL was originally written as part of the CMU Common Lisp
19 project at Carnegie Mellon University. According to the documentation
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.
32 CMU CL's CLOS implementation is derived from the PCL reference
33 implementation written at Xerox PARC.
35 CMU CL's implementation of the LOOP macro was derived from code
36 from Symbolics, which was derived from code from MIT.
38 CMU CL had many individual author credits in the source files. In the
39 sometimes-extensive rearrangements which were required to make SBCL
40 bootstrap itself cleanly, it was tedious to try keep such credits
41 attached to individual source files, so they have been moved here
42 instead.
44 Bill Newman <william.newman@airmail.net> did this transformation, and
45 so any errors made are probably his. Corrections would be appreciated.
48 MORE DETAILS ON SBCL'S CLOS CODE
50 The original headers of the PCL files contained the following text:
52 ;;; Any person obtaining a copy of this software is requested to send their
53 ;;; name and post office or electronic mail address to:
54 ;;;   CommonLoops Coordinator
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.
62 This was intended for the original incarnation of the PCL code as a
63 portable reference implementation. Since our version of the code has
64 had its portability hacked out of it, it's no longer particularly
65 relevant to any coordinated PCL effort (which probably doesn't exist
66 any more anyway). Therefore, this contact information has been deleted
67 from the PCL file headers.
69 A few files in the original CMU CL 18b src/pcl/ directory did not
70 carry such Xerox copyright notices:
71   * Some code was originally written by Douglas T. Crosher for CMU CL:
72     ** the Gray streams implementation
73     ** the implementation of DOCUMENTATION as methods of a generic
74        function
75   * generic-functions.lisp seems to have been machine-generated.
77 The comments in the CMU CL 18b version of the PCL code walker,
78 src/pcl/walk.lisp, said in part
79 ;;;   a simple code walker, based IN PART on: (roll the credits)
80 ;;;      Larry Masinter's Masterscope
81 ;;;      Moon's Common Lisp code walker
82 ;;;      Gary Drescher's code walker
83 ;;;      Larry Masinter's simple code walker
84 ;;;      .
85 ;;;      .
86 ;;;      boy, thats fair (I hope).
89 MORE DETAILS ON SBCL'S LOOP CODE
91 The src/code/loop.lisp file from CMU CL 18b had the following
92 credits-related information in it:
94 ;;;   The LOOP iteration macro is one of a number of pieces of code
95 ;;;   originally developed at MIT for which free distribution has been
96 ;;;   permitted, as long as the code is not sold for profit, and as long
97 ;;;   as notification of MIT's interest in the code is preserved.
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).
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.
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.
117 ;;;   The revision for the ANSI standard is based on the code of my April
118 ;;;   1986 version, with almost everything redesigned and/or rewritten.
120 The date of the M.I.T. copyright statement falls around the time
121 described in these comments. The dates on the Symbolics copyright
122 statement are all later -- the earliest is 1989.
125 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
127 CMU CL's symbol (but not package) code (code/symbol.lisp) was
128 originally written by Scott Fahlman and updated and maintained
129 by Skef Wholey.
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).
136 CMU CL's package code was rewritten by Rob MacLachlan based on an
137 earlier version by Lee Schumacher. It also includes DEFPACKAGE by Dan
138 Zigmond, and WITH-PACKAGE-ITERATOR written by Blaine Burks. William
139 Lott also rewrote the DEFPACKAGE and DO-FOO-SYMBOLS stuff.
141 CMU CL's string code (code/string.lisp) was originally written by
142 David Dill, then rewritten by Skef Wholey, Bill Chiles, and Rob
143 MacLachlan.
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.
156 The modules system (code/module.lisp, containing REQUIRE, PROVIDE,
157 and friends, now deprecated by ANSI) was written by Jim Muller and
158 rewritten by Bill Chiles.
160 The CMU CL garbage collector was credited to "Christopher Hoover,
161 Rob MacLachlan, Dave McDonald, et al." in the CMU CL code/gc.lisp file,
162 with some extra code for the MIPS port credited to Christopher Hoover
163 alone. The credits on the original "gc.c", "Stop and Copy GC based
164 on Cheney's algorithm", said "written by Christopher Hoover".
166 Guy Steele wrote the original character functions
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.
172 Lee Schumacher made the Spice Lisp version of backquote. The comment
173 in the CMU CL sources suggests he based it on someone else's code for
174 some other Lisp system, but doesn't say which. A note in the CMU CL
175 code to pretty-print backquote expressions says that unparsing support
176 was provided by Miles Bader.
178 The CMU implementations of the Common Lisp query functions Y-OR-N-P
179 and YES-OR-NO-P were originally written by Walter van Roggen, and
180 updated and modified by Rob MacLachlan and Bill Chiles.
182 The CMU CL sort functions (code/sort.lisp) were written by Jim Large,
183 hacked on and maintained by Skef Wholey, and rewritten by Bill Chiles.
185 Most of the internals of the Python compiler seem to have been
186 originally written by Robert MacLachlan:
187         the type system and associated "cold load hack magic"
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
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.
245 Sean Hallgren is credited with most of the Alpha backend.  Julian
246 Dolby created the CMU CL Alpha/Linux port. Douglas Crosher added
247 complex-float support.
249 The 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
253 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
254 was written by Miles Bader.
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
267 Bill Chiles also modified code/macros.lisp. Much of the implementation
268 of PURIFY was rewritten in C by William Lott.
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."
274 CMU CL's weak pointer support (code/weak.lisp) was written by
275 Christopher Hoover.
277 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
278 Lott and Skef Wholey jointly.
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.
285 The CMU CL condition system (code/error.lisp) was based on
286 some prototyping code written by Kent Pitman at Symbolics.
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.
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.
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.
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.
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.
322 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
323 MacLachlan.
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
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.
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."
362 Jim Muller was credited with fixing seq.lisp.
364 CMU CL's time printing logic, in code/format-time.lisp, was written
365 by Jim Healy.
367 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
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.
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
379 The INSPECT function was originally written by Blaine Burks.
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.
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.
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.
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.
401 Comments in the CMU CL version of backtrace.c said it was "originally
402 from Rob's version" (presumably Robert Maclachlan).
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.
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.
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.
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.
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.  He also added X86-specific
456 extensions to support stack groups and multiprocessing, but these are
457 not present in SBCL
459 The CMU CL user manual credits Robert MacLachlan as editor. A chapter
460 on the CMU CL interprocess communication extensions (not supported in
461 SBCL) was contributed by William Lott and Bill Chiles.
463 Peter VanEynde also contributed a variety of #+HIGH-SECURITY patches
464 to CMU CL, to provide additional safety, especially through runtime
465 checking on various tricky cases of standard functions (e.g. MAP with
466 complicated result types, and interactions of various variants of
467 STREAM).
469 Raymond Toy wrote CMU CL's PROPAGATE-FLOAT-TYPE extension and various
470 other floating point optimizations. (In SBCL, the PROPAGATE-FLOAT-TYPE
471 entry in *FEATURES* first became SB-PROPAGATE-FLOAT-TYPE, then went
472 away completely as the code became an unconditional part of the
473 system.)
475 CMU CL's long float support was written by Douglas T. Crosher.
477 Paul Werkowski turned the Mach OS support code into Linux OS support code.
479 Versions of the RUN-PROGRAM extension were written first by David
480 McDonald, then by Jim Healy and Bill Chiles, then by William Lott.
483 MORE DETAILS ON THE TRANSITION FROM CMU CL
485 Bill Newman did the original conversion from CMU CL 18b to a form
486 which could bootstrap itself cleanly, on Linux/x86 only. Although they
487 may not have realized it at the time, Rob Maclachlan and Peter Van
488 Eynde were very helpful, RAM by posting a clear explanation of what
489 GENESIS is supposed to be doing and PVE by maintaining a version of
490 CMU CL which worked on Debian, so that I had something to refer to
491 whenever I got stuck.
494 CREDITS SINCE THE RELEASE OF SBCL
496 (Note: (1) This is probably incomplete, since there's no systematic
497 procedure for updating it. (2) Some more details are available in the
498 NEWS file, in the project's CVS change logs, and in the archives of
499 the sbcl-devel mailing list. (3) In this, as in other parts of SBCL,
500 patches are welcome. Don't be shy.)
502 Martin Atzmueller:
503   He reported many bugs, fixed many bugs, ported various fixes
504   from CMU CL, and helped clean up various stale bug data. (He has
505   been unusually energetic at this. As of sbcl-0.6.9.10, the
506   total number of bugs involved likely exceeded 100. Since then,
507   I've lost count. See the CVS logs.)
509 Daniel Barlow:
510   His contributions have included support for shared object loading
511   (from CMUCL), the Cheney GC for non-x86 ports (from CMUCL), Alpha
512   and PPC ports (from CMUCL), control stack exhaustion checking (new),
513   native threads support for x86 Linux (new), and the initial x86-64
514   backend (new).  He also refactored the garbage collectors for
515   understandability, wrote code (e.g. grovel-headers.c and
516   stat_wrapper stuff) to find machine-dependent and OS-dependent
517   constants automatically, and was original author of the asdf,
518   asdf-install, sb-bsd-sockets, sb-executable, sb-grovel and sb-posix
519   contrib packages.
521 Robert E. Brown:
522   He has reported various bugs and submitted several patches,
523   especially improving removing gratuitous efficiencies in the
524   standard library.
526 Cadabra, Inc. (later merged into GoTo.com):
527   They hired Bill Newman to do some consulting for them,
528   including the implementation of EQUALP hash tables for CMU CL;
529   then agreed to release the EQUALP code into the public domain,
530   giving SBCL (and CMU CL) its EQUALP hash tables.
532 Douglas Crosher:
533   He continued to improve CMU CL after SBCL forked from it, creating
534   many patches which were directly applicable to SBCL. Notable examples
535   include fixes for various compiler bugs, the implementation of
536   CL:DEFINE-SYMBOL-MACRO, and a generalization of the type system's
537   handling of the CONS type to allow ANSI-style (CONS FOO BAR) types.
539 Alexey Dejneka:
540   He fixed many, many bugs on various themes, and has done a
541   tremendous amount of work on the compiler in particular, fixing
542   bugs and refactoring.
544 Paul Dietz:
545   He is in the process of writing a comprehensive test suite
546   for the requirements of the ANSI Common Lisp standard. Already, at
547   the halfway stage, it has caught hundreds of bugs in SBCL, and
548   provided simple test cases for them. His random crash tester has
549   caught an old deep problem in the implementation of the stack
550   analysis phase in the compiler.
552 Brian Downing:
553   He fixed the linker problems for building SBCL on Mac OS X.  He
554   found and fixed the cause of backtraces failing for undefined
555   functions and assembly routines.
557 Miles Egan:
558   He creates binary packages of SBCL releases for Red Hat and other
559   (which?) platforms.
561 Lutz Euler:
562   He made a large number of improvements to the x86-64 disassembler.
564 Andreas Fuchs:
565   He provides infrastructure for monitoring build and performance
566   regressions of SBCL.  He assisted with the integration of the
567   Unicode work.
569 Nathan Froyd:
570   He has fixed various bugs, and also done a lot of internal
571   cleanup, not visible at the user level but important for
572   maintenance. (E.g. converting the PCL code to use LOOP instead
573   of the old weird pre-ANSI ITERATE macro so that the code can be
574   read without being an expert in ancient languages and so that we
575   can delete a thousand lines of implement-ITERATE macrology from
576   the codebase.)
578 Bruno Haible:
579   He devised an accurate continued-fraction-based implementation of
580   RATIONALIZE, replacing a less-accurate version inherited from
581   primordial CMUCL.
583 Matthias Hoelzl:
584   He reported and fixed COMPILE's misbehavior on macros.
586 Espen S Johnsen:
587   He provided an ANSI-compliant version of CHANGE-CLASS for PCL.
589 Teemu Kalvas:
590   He worked on Unicode support for SBCL, including parsing the Unicode
591   character database, restoring the FAST-READ-CHAR optimization and
592   developing external format support.
594 Frederik Kuivinen:
595   He showed how to implement the DEBUG-RETURN functionality.
597 Arthur Lemmens:
598   He found and fixed a number of SBCL bugs while partially porting
599   SBCL to bootstrap under Lispworks for Windows.
601 David Lichteblau:
602   He came up with a more memory-efficient representation for
603   structures with raw slots.
605 Robert MacLachlan:
606   He has continued to answer questions about, and contribute fixes to,
607   the CMU CL project. Some of these fixes, especially for compiler
608   problems, has been invaluable to the CMU CL project and, by
609   porting, invaluable to the SBCL project as well.
611 Pierre Mai:
612   He has continued to work on CMU CL since the SBCL fork, and also
613   patched code to SBCL to enable dynamic loading of object files
614   under OpenBSD.  He contributed to the port of SBCL to MacOS X,
615   implementing the Lisp side of the PowerOpen ABI.
617 Eric Marsden:
618   Some of his fixes to CMU CL since the SBCL fork have been ported
619   to SBCL.  He also maintains the cl-benchmark package, which gives
620   us some idea of how our performance changes compared to earlier
621   releases and to other implementations.  He assisted in development
622   of Unicode support for SBCL.
624 Antonio Martinez-Shotton:
625   He has contributed a number of bug fixes and bug reports to SBCL.
627 Brian Mastenbrook:
628   He contributed to and extensively maintained the port of SBCL to
629   MacOS X. His contributions include overcoming binary compatibility
630   issues between different versions of dlcompat on Darwin, other
631   linker fixes, and signal handler bugfixes.
633 Dave McDonald:
634   He made a lot of progress toward getting SBCL to be bootstrappable
635   under CLISP.
637 Perry E. Metzger:
638   He ported SBCL to NetBSD with newer signals, building on the
639   work of Valtteri Vuorikoski.  He also provided various cleanups to
640   the C runtime.
642 Gerd Moellman:
643   He has made many cleanups and improvements, small and large, in
644   CMU CL (mostly in PCL), which we have gratefully ported to SBCL.  Of
645   particular note is his ctor MAKE-INSTANCE optimization, which is both
646   faster in the typical case than the old optimizations in PCL and
647   less buggy.
649 Timothy Moore:
650   He designed and implemented the original CMUCL linkage-table, on
651   which the SBCL implementation thereof is based.
653 William ("Bill") Newman:
654   He continued to maintain SBCL after the fork, increasing ANSI
655   compliance, fixing bugs, regularizing the internals of the
656   system, deleting unused extensions, improving performance in
657   some areas (especially sequence functions and non-simple vectors),
658   updating documentation, and even, for better or worse, getting
659   rid of various functionality (e.g. the byte interpreter).
661 Patrik Nordebo:
662   He contributed to the port of SBCL to MacOS X, finding solutions for
663   ABI and assembly syntax differences between Darwin and Linux.
665 Scott Parish:
666   He ported SBCL to OpenBSD-with-ELF.
668 Kevin M. Rosenberg:
669   He provided the ACL-style toplevel (sb-aclrepl contrib module), and
670   a number of MOP-related bug reports.  He also creates the official
671   Debian packages of SBCL.
673 Christophe Rhodes:
674   He ported SBCL to SPARC (based on the CMUCL backend), made various
675   port-related and SPARC-related changes (like *BACKEND-SUBFEATURES*),
676   made many fixes and improvements in the compiler's type system, has
677   essentially completed the work to enable bootstrapping SBCL under
678   unrelated (non-SBCL, non-CMU-CL) Common Lisps.  He participated in
679   the modernization of SBCL's CLOS implementation, implemented the
680   treatment of compiler notes as restartable conditions, provided
681   optimizations to compiler output, and contributed in other ways as
682   well.
684 Stig Erik Sandoe:
685   He showed how to convince the GNU toolchain to build SBCL in a way
686   which supports callbacks from C code into SBCL.
688 Rudi Schlatte:
689   He ported Paul Foley's simple-streams implementation from cmucl,
690   converted the sbcl manual to Texinfo and wrote a documentation
691   string extractor that keeps function documentation in the manual
692   current.
694 Thiemo Seufer:
695   He modernized the MIPS backend, fixing many bugs, and assisted in
696   cleaning up the C runtime code.
698 Julian Squires:
699   He worked on Unicode support for the PowerPC platform.
701 Nikodemus Siivola:
702   He provided build fixes, in particular to tame the SunOS toolchain,
703   implemented package locks, ported the linkage-table code from CMUCL,
704   reimplemented STEP, and has fixed many (stream-related and other) bugs
705   besides.
707 Juho Snellman:
708   He provided several performance enhancements, including a better hash
709   function on strings, removal of unneccessary bounds checks, and
710   multiple improvements to performance of common operations on
711   bignums.  He ported and enhanced the statistical profiler written by
712   Gerd Moellmann for CMU CL.  He completed the work on the x86-64 port
713   of SBCL.
715 Brian Spilsbury:
716   He wrote Unicode-capable versions of SBCL's character, string, and
717   stream types and operations on them.  (These versions did not end up
718   in the system, but did to a large extent influence the support which
719   finally did get merged.)
721 Raymond Toy:
722   He continued to work on CMU CL after the SBCL fork, especially on
723   floating point stuff. Various patches and fixes of his have been
724   ported to SBCL, including his Sparc port of linkage-table.
726 Peter Van Eynde:
727   He wrestled the CLISP test suite into a mostly portable test suite
728   (clocc ansi-test) which can be used on SBCL, provided a slew of
729   of bug reports resulting from that, and submitted many other bug
730   reports as well.
732 Valtteri Vuorikoski:
733   He ported SBCL to NetBSD, and also fixed a long-standing bug in
734   DEFSTRUCT with respect to colliding accessor names.
736 Colin Walters:
737   His O(N) implementation of the general case of MAP, posted on the
738   cmucl-imp@cons.org mailing list, was the inspiration for similar MAP
739   code added in sbcl-0.6.8.
741 Cheuksan Edward Wang:
742   He assisted in debugging the SBCL x86-64 backend.
744 Raymond Wiker:
745   He ported sbcl-0.6.3 back to FreeBSD, restoring the ancestral
746   CMU CL support for FreeBSD and updating it for the changes made
747   from FreeBSD version 3 to FreeBSD version 4. He also ported the
748   CMU CL extension RUN-PROGRAM, and related code, to SBCL.
751 INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.)
753 VJA  Vincent Arkesteijn
754 MNA  Martin Atzmueller
755 DB   Daniel Barlow (also "dan")
756 DTC  Douglas Crosher
757 APD  Alexey Dejneka
758 PFD  Paul F. Dietz
759 NJF  Nathan Froyd
760 AL   Arthur Lemmens
761 DFL  David Lichteblau
762 RAM  Robert MacLachlan
763 PRM  Pierre Mai
764 WHN  William ("Bill") Newman
765 CSR  Christophe Rhodes
766 THS  Thiemo Seufer
767 NS   Nikodemus Siivola
768 PVE  Peter Van Eynde
769 PW   Paul Werkowski
770 MG   Gabor Melis