| blob | b2061fbcae6652c213930a53ef86ccaa28dac8fc |
1 -*- coding: utf-8; mode: text; -*-
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"
15 BROAD OUTLINE
17 SBCL is derived from the 18b version of CMU CL.
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.
33 CMU CL's CLOS implementation is derived from the PCL reference
34 implementation written at Xerox PARC.
36 CMU CL's implementation of the LOOP macro was derived from code
37 from Symbolics, which was derived from code from MIT.
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.
45 Bill Newman <william.newman@airmail.net> did this transformation, and
46 so any errors made are probably his. Corrections would be appreciated.
49 MORE DETAILS ON SBCL'S CLOS CODE
51 The original headers of the PCL files contained the following text:
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.
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.
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.
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).
90 MORE DETAILS ON SBCL'S LOOP CODE
92 The src/code/loop.lisp file from CMU CL 18b had the following
93 credits-related information in it:
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.
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.
126 MORE DETAILS ON OTHER SBCL CODE FROM CMU CL
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.
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).
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.
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.
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.
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.
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".
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.
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.
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.
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.
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
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.
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.
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
254 The CMU CL machine-independent disassembler (compiler/disassem.lisp)
255 was written by Miles Bader.
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
268 Bill Chiles also modified code/macros.lisp. Much of the implementation
269 of PURIFY was rewritten in C by William Lott.
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."
275 CMU CL's weak pointer support (code/weak.lisp) was written by
276 Christopher Hoover.
278 The CMU CL DEFSTRUCT system was credited to Rob MacLachlan, William
279 Lott and Skef Wholey jointly.
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.
286 The CMU CL condition system (code/error.lisp) was based on
287 some prototyping code written by Kent Pitman at Symbolics.
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.
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.
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.
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.
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.
323 The CMU CL IR1 interpreter was written by Bill Chiles and Robert
324 MacLachlan.
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
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.
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."
363 Jim Muller was credited with fixing seq.lisp.
365 CMU CL's time printing logic, in code/format-time.lisp, was written
366 by Jim Healy.
368 Bill Chiles was credited with fixing/updating seq.lisp after Jim Muller.
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.
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
380 The INSPECT function was originally written by Blaine Burks.
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.
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.
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.
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.
402 Comments in the CMU CL version of backtrace.c said it was "originally
403 from Rob's version" (presumably Robert Maclachlan).
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.
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.
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.
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.
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
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.
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).
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.)
476 CMU CL's long float support was written by Douglas T. Crosher.
478 Paul Werkowski turned the Mach OS support code into Linux OS support code.
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.
484 MORE DETAILS ON THE TRANSITION FROM CMU CL
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.
495 CREDITS SINCE THE RELEASE OF SBCL
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.)
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.)
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.
522 Zach 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.
527 James 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.
531 Alastair Bridgewater:
532 He contributed a port of the system to the Windows operating system.
534 Robert E. Brown:
535 He has reported various bugs and submitted several patches,
536 especially improving removing gratuitous efficiencies in the
537 standard library.
539 Cadabra, 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.
545 Douglas 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.
552 Larry 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.
556 Alexey 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.
561 Paul 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.
569 Brian 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.
575 Miles Egan:
576 He creates binary packages of SBCL releases for Red Hat and other
577 (which?) platforms.
579 Helmut 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.
583 Lutz Euler:
584 He made a large number of improvements to the x86-64 disassembler.
586 Andreas Fuchs:
587 He provides infrastructure for monitoring build and performance
588 regressions of SBCL. He assisted with the integration of the
589 Unicode work.
591 Stephan Frank:
592 He contributed the SB-GMP contrib to exploit libgmp in bignum and
593 ratio arithmetic.
595 Nathan 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.)
604 Bruno Haible:
605 He devised an accurate continued-fraction-based implementation of
606 RATIONALIZE, replacing a less-accurate version inherited from
607 primordial CMUCL.
609 Cyrus 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.
614 Matthias Hoelzl:
615 He reported and fixed COMPILE's misbehavior on macros.
617 Daisuke Homma:
618 He added support for SunOS on x86 processors.
620 ITA 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.
627 Espen S Johnsen:
628 He provided an ANSI-compliant version of CHANGE-CLASS for PCL.
630 Teemu 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.
635 Dmitry Kalyanov:
636 His work was crucial in bringing the Windows backend forward; he
637 implemented pthreads and ported SB-THREAD to this platform.
639 Yaroslav 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.
644 Anton Kovalenko:
645 He introduced a safepoint-based stop-the-world protocol and greatly
646 contributed to features and bugfixes related to the Windows port.
648 Richard 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.
653 Frederik Kuivinen:
654 He showed how to implement the DEBUG-RETURN functionality.
656 Arthur Lemmens:
657 He found and fixed a number of SBCL bugs while partially porting
658 SBCL to bootstrap under Lispworks for Windows.
660 David Lichteblau:
661 He repeatedly failed to update his entry in this file.
663 Robert 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.
669 Pierre 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.
675 Eric 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.
682 Antonio Martinez-Shotton:
683 He has contributed a number of bug fixes and bug reports to SBCL.
685 Brian 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.
691 Dave McDonald:
692 He made a lot of progress toward getting SBCL to be bootstrappable
693 under CLISP.
695 Gabor 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.
701 Perry 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.
706 Gerd 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.
713 Timothy Moore:
714 He designed and implemented the original CMUCL linkage-table, on
715 which the SBCL implementation thereof is based.
717 William ("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).
725 NIIMI 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.
730 Patrik 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.
734 Luís Oliveira:
735 He contributed to the port of SBCL to the Windows operating system,
736 particuarly in the area of FFI.
738 Scott Parish:
739 He ported SBCL to OpenBSD-with-ELF.
741 Timothy Ritchey:
742 He implemented SB-BSD-SOCKETS support for the win32 port.
744 Tobias Rittweiler
745 He has made several contributions relating to source locations,
746 pretty printing, SB-INTROSPECT, and the reader.
748 Kevin 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.
753 Joshua Ross:
754 He fixed some bugs relating to foreign calls and callbacks on the
755 Linux PowerPC platform.
757 Christophe 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.
768 Stig 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.
772 Rudi 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.
778 Thiemo Seufer:
779 He modernized the MIPS backend, fixing many bugs, and assisted in
780 cleaning up the C runtime code.
782 Julian Squires:
783 He worked on Unicode support for the PowerPC platform.
785 Nikodemus 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.
791 Juho 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.
798 Brian 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.)
804 Robert Swindells:
805 He ported SBCL to NetBSD/Sparc.
807 Raymond 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.
812 Larry Valkama:
813 He resurrected the HPUX port, and worked on the HPPA backend in
814 general.
816 Peter 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.
822 Valtteri Vuorikoski:
823 He ported SBCL to NetBSD, and also fixed a long-standing bug in
824 DEFSTRUCT with respect to colliding accessor names.
826 Colin 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.
831 Cheuksan Edward Wang:
832 He assisted in debugging the SBCL x86-64 backend.
834 Raymond 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.
841 INITIALS GLOSSARY (helpful when reading comments, CVS commit logs, etc.)
843 AB Alastair Bridgewater
844 AK Anton Kovalenko
845 AL Arthur Lemmens
846 APD Alexey Dejneka
847 CLH Cyrus Harmon
848 CSR Christophe Rhodes
849 DB Daniel Barlow (also "dan")
850 DFL David Lichteblau
851 DTC Douglas Crosher
852 JES Juho Snellman
853 JRXR Joshua Ross
854 LAV Larry Valkama
855 LEU Lutz Euler
856 MG Gabor Melis
857 MNA Martin Atzmueller
858 NJF Nathan Froyd
859 NS Nikodemus Siivola
860 PFD Paul F. Dietz
861 PRM Pierre Mai
862 PVE Peter Van Eynde
863 PK/PVK Paul-Virak Khuong
864 PW Paul Werkowski
865 RAM Robert MacLachlan
866 RLT Raymond Toy
867 TCR Tobias Rittweiler
868 THS Thiemo Seufer
869 VJA Vincent Arkesteijn
870 WHN William ("Bill") Newman