1 <chapter id="intro"><title>Introduction</>
3 <para>&SBCL; is a mostly-conforming implementation of the &ANSI;
4 &CommonLisp; standard. This manual focuses on behavior which is
5 specific to &SBCL;, not on behavior which is common to all
6 implementations of &ANSI; &CommonLisp;.</para>
8 <sect1><title>More Information on &CommonLisp; in General</>
10 <para>If you are an experienced programmer in general but need
11 information on using &CommonLisp; in particular, <emphasis>ANSI Common
12 Lisp</>, by Paul Graham, is a good place to start. <emphasis>Paradigms
13 Of Artificial Intelligence Programming</>, by Peter Norvig, also has
14 some good information on general &CommonLisp; programming, and many
15 nontrivial examples. For CLOS in particular, <emphasis>Object-Oriented
16 Programming In Common Lisp</> by Sonya Keene is useful.</para>
18 <para>Two very useful resources for working with any implementation of
20 <ulink url="http://ilisp.cons.org"><application>ILISP</></ulink>
21 package for <application>Emacs</> and
22 <ulink url="http://www.harlequin.com/books/HyperSpec">the &CommonLisp;
27 <sect1><title>More Information on SBCL</title>
29 <para>Besides this manual, some other &SBCL;-specific information is
32 <listitem><para>There is a Unix <quote>man page</> file
33 <filename>sbcl.1</> in the &SBCL; distribution,
34 describing command options and other usage information
35 for the Unix <function>sbcl</> command which invokes
36 the &SBCL; system.</para></listitem>
37 <listitem><para>Documentation for non-&ANSI; extensions for
38 various commands is available online from the &SBCL; executable
39 itself. The extensions for functions which have their own
40 command prompts (e.g. the debugger, and <function>inspect</>)
41 are documented in text available by typing <userinput>help</>
42 at their command prompts. The extensions for functions which
43 don't have their own command prompt (e.g. <function>trace</>)
44 are described in their documentation strings,
45 unless your &SBCL was compiled with an option not
46 to include documentation strings, in which case the doc strings
47 are only readable in the source code.</para></listitem>
48 <listitem><para>The <ulink url="http://sbcl.sourceforge.net/">
49 &SBCL; home page</ulink> has some general
50 information, plus links to mailing lists devoted to &SBCL;,
51 and to archives of these mailing lists.</para></listitem>
52 <listitem><para>Some low-level information describing the
53 programming details of the conversion from &CMUCL; to &SBCL;
54 is available in the <filename>doc/FOR-CMUCL-DEVELOPERS</>
55 file in the &SBCL; distribution.</para></listitem>
61 <sect1 id="implementation"><title>System Implementation and History</>
63 <para>You can work productively with SBCL without understanding
64 anything about how it was and is implemented, but a little knowledge
65 can be helpful in order to better understand error messages,
66 troubleshoot problems, to understand why some parts of the system are
67 better debugged than others, and to anticipate which known bugs, known
68 performance problems, and missing extensions are likely to be fixed,
69 tuned, or added.</para>
71 <para>&SBCL; is descended from &CMUCL;, which is itself descended from
72 Spice Lisp. Early implementations for the Mach operating system on the
73 IBM RT, back in the 1980s. Design decisions from that time are still
74 reflected in the current implementation:
76 <listitem><para>The system expects to be loaded into a
77 fixed-at-compile-time location in virtual memory, and also expects
78 the location of all of its heap storage to be specified
79 at compile time.</para></listitem>
80 <listitem><para>The system overcommits memory, allocating large
81 amounts of address space from the system (often more than
82 the amount of virtual memory available) and then failing
83 if ends up using too much of the allocated storage.</para></listitem>
84 <listitem><para>A word is a 32-bit quantity. The system has been
85 ported to many processor architectures without altering this
86 basic principle. Some hacks allow the system to run on the Alpha
87 chip (a 64-bit architecture) but the assumption that a word is
88 32 bits wide is implicit in hundreds of places in the
89 system.</para></listitem>
90 <listitem><para>The system is implemented as a C program which is
91 responsible for supplying low-level services and loading a
92 Lisp <quote>.core</quote> file.
97 <para>&SBCL; also inherited some newer architectural features from
98 &CMUCL;. The most important is that it has a generational garbage
99 collector (<quote>GC</>), which has various implications (mostly good)
100 for performance. These are discussed in <link linkend="efficiency">
101 another chapter</link>.</para>
103 <para>The direct ancestor of &SBCL; is the X86 port of &CMUCL;.
104 This port is in some ways the least mature of any in the &CMUCL;
105 system, and some things (like profiling and backtracing)
106 do not work particularly well there. &SBCL; should be able
107 to improve in these areas, but it may take a while.</para>
109 <para>The &SBCL; GC, like the GC on the X86 port of &CMUCL;, is
110 <emphasis>conservative</>. This means that it doesn't maintain a
111 strict separation between tagged and untagged data, instead treating
112 some untagged data (e.g. raw floating point numbers) as
113 possibly-tagged data and so not collecting any Lisp objects that they
114 point to. This has some negative consequences for average time
115 efficiency (though possibly no worse than the negative consequences of
116 trying to implement an exact GC on a processor architecture as
117 register-poor as the X86) and also has potentially unlimited
118 consequences for worst-case memory efficiency. In practice,
119 conservative garbage collectors work reasonably well, not getting
120 anywhere near the worst case. But they can occasionally cause
121 odd patterns of memory usage.</para>
123 <para>The fork from &CMUCL; was based on a major rewrite of the system
124 bootstrap process. &CMUCL; has for many years tolerated a very unusual
125 <quote>build</> procedure which doesn't actually build the complete
126 system from scratch, but instead progressively overwrites parts of a
127 running system with new versions. This quasi-build procedure can cause
128 various bizarre bootstrapping hangups, especially when a major change
129 is made to the system. It also makes the connection between the
130 current source code and the current executable more tenuous than in
131 any other software system I'm aware of -- it's easy to accidentally
132 <quote>build</> a &CMUCL; system containing characteristics not
133 reflected in the current version of the source code.</para>
135 <para>Other major changes since the fork from &CMUCL; include
137 <listitem><para>&SBCL; has dropped support for many &CMUCL; extensions,
138 (e.g. remote procedure call, Unix system interface, and X11
139 interface).</para></listitem>
140 <listitem><para>&SBCL; has deleted or deprecated
141 some nonstandard features and code complexity which helped
142 efficiency at the price of maintainability. For example, the
143 &SBCL; compiler no longer implements memory pooling internally
144 (and so is simpler and more maintainable, but generates more
145 garbage and runs more slowly), and various block-compilation
146 efficiency-increasing extensions to the language have been
147 deleted or are no longer used in the implementation of &SBCL;
148 itself.</para></listitem>