+@node Extensions
+@comment node-name, next, previous, up
+@section Extensions
+
+SBCL comes with numerous extensions, some in core and some in modules
+loadable with @code{require}. Unfortunately, not all of these
+extensions have proper documentation yet.
+
+@c FIXME: Once bits and pieces referred to here get real documentation
+@c add xrefs there.
+
+@table @strong
+
+@item System Definition Tool
+@code{asdf} is a flexible and popular protocol-oriented system
+definition tool by Daniel Barlow. @inforef{Top,the asdf manual,asdf}, for
+more information.
+
+@item Third-party Extension Installation Tool
+@code{asdf-install} is a tool that can be used to download and install
+third-party libraries and applications, automatically handling
+dependencies, etc.
+
+@item Foreign Function Interface
+@code{sb-alien} package allows interfacing with C-code, loading shared
+object files, etc. @xref{Foreign Function Interface}.
+
+@code{sb-grovel} can be used to partially automate generation of
+foreign function interface definitions. @xref{sb-grovel}.
+
+@item Recursive Event Loop
+SBCL provides a recursive event loop (@code{serve-event}) for doing
+non-blocking IO on multiple streams without using threads.
+
+@item Metaobject Protocol
+@code{sb-mop} package provides a metaobject protocol for the Common
+Lisp Object System as described in @cite{Art of Metaobject Protocol}.
+
+@item Native Threads
+SBCL has native threads on x86/Linux, capable of taking advantage
+of SMP on multiprocessor machines. @xref{Threading}.
+
+@item Network Interface
+@code{sb-bsd-sockets} is a low-level networking interface, providing
+both TCP and UDP sockets. x@ref{Networking}.
+
+@item Introspective Facilities
+@code{sb-introspect} module offers numerous introspective extensions,
+including access to function lambda-lists.
+
+@item Operating System Interface
+@code{sb-ext} contains a number of functions for running external
+processes, accessing environment variables, etc.
+
+@code{sb-posix} module provides a lispy interface to standard POSIX
+facilities.
+
+@item Extensible Streams
+@code{sb-gray} is an implentation of @emph{Gray Streams}. @xref{Gray
+Streams}.
+
+@code{sb-simple-streams} is an implementation of the @emph{simple
+streams} API proposed by Franz Inc. @xref{Simple Streams}.
+
+@item Profiling
+@code{sb-profile} is a exact per-function profiler. @xref{Accurate
+Profiler}.
+
+@code{sb-sprof} is a statistical profiler, capable of call-graph
+generation and instruction level profiling. @xref{Statistical
+Profiler}.
+
+@item Customization Hooks
+SBCL contains a number of extra-standard customization hooks that
+can be used to tweak the behaviour of the system. @xref{Customization
+Hooks for Users}.
+
+@code{sb-aclrepl} provides an Allegro CL -style toplevel for SBCL,
+as an alternative to the classic CMUCL-style one. @xref{sb-aclrepl}.
+
+@item CLTL2 Compatility Layer
+@code{sb-cltl2} module provides @code{compiler-let} and environment
+access functionality described in @cite{Common Lisp The Language, 2nd
+Edition} which were removed from the language during the ANSI
+standardization process.
+
+@item Executable Fasl Packaging
+@code{sb-executable} can be used to concatenate multiple fasls into a
+single executable (though the presense of an SBCL runtime and core image
+is still required to run it).
+
+The @code{:executable} argument to @ref{Function
+sb-ext:save-lisp-and-die} can produce a `standalone' executable
+containing both an image of the current Lisp session and an SBCL
+runtime.
+
+@item Bitwise Rotation
+@code{sb-rotate-byte} provides an efficient primitive for bitwise
+rotation of integers, an operation required by eg. numerous
+cryptographic algorightms, but not available as a primitive in ANSI
+Common Lisp. @xref{sb-rotate-byte}.
+
+@item Test Harness
+@code{sb-rt} module is a simple yet attractive regression and
+unit-test framework.
+
+@item MD5 Sums
+@code{sb-md5} is an implementation of the MD5 message digest algorithm
+for Common Lisp, using the modular arithmetic optimizations provided
+by SBCL. @xref{sb-md5}.
+
+@end table
+
+
+
+
+@node Idiosyncrasies
+@comment node-name, next, previous, up
+@section Idiosyncrasies
+
+The information in this section describes some of the ways that SBCL
+deals with choices that the ANSI standard leaves to the
+implementation.
+
+@menu
+* Declarations::
+* Compiler-only Implementation::
+* Defining Constants::
+* Style Warnings::
+@end menu
+
+@node Declarations
+@comment node-name, next, previous, up
+@subsection Declarations
+
+Declarations are generally treated as assertions. This general
+principle, and its implications, and the bugs which still keep the
+compiler from quite satisfying this principle, are discussed in
+@ref{Declarations as Assertions}.
+
+@node Compiler-only Implementation
+@comment node-name, next, previous, up
+@subsection Compiler-only Implementation
+
+SBCL is essentially a compiler-only implementation of Common Lisp.
+That is, for all but a few special cases, @code{eval} creates a lambda
+expression, calls @code{compile} on the lambda expression to create a
+compiled function, and then calls @code{funcall} on the resulting
+function object. This is explicitly allowed by the ANSI standard, but
+leads to some oddities, e.g. collapsing @code{functionp} and
+@code{compiled-function-p} into the same predicate.
+
+@node Defining Constants
+@comment node-name, next, previous, up
+@subsection Defining Constants
+@findex defconstant
+
+SBCL is quite strict about ANSI's definition of @code{defconstant}.
+ANSI says that doing @code{defconstant} of the same symbol more than
+once is undefined unless the new value is @code{eql} to the old value.
+Conforming to this specification is a nuisance when the ``constant''
+value is only constant under some weaker test like @code{string=} or
+@code{equal}.
+
+It's especially annoying because, in SBCL, @code{defconstant} takes
+effect not only at load time but also at compile time, so that just
+compiling and loading reasonable code like
+@lisp
+(defconstant +foobyte+ '(1 4))
+@end lisp
+runs into this undefined behavior. Many implementations of Common Lisp
+try to help the programmer around this annoyance by silently accepting
+the undefined code and trying to do what the programmer probably
+meant.
+
+SBCL instead treats the undefined behavior as an error. Often such
+code can be rewritten in portable ANSI Common Lisp which has the
+desired behavior. E.g., the code above can be given an exactly defined
+meaning by replacing @code{defconstant} either with
+@code{defparameter} or with a customized macro which does the right
+thing, eg.
+@lisp
+(defmacro define-constant (name value &optional doc)
+ `(defconstant ,name (if (boundp ',name) (symbol-value ',name) ,value)
+ ,@@(when doc (list doc))))
+@end lisp
+or possibly along the lines of the @code{defconstant-eqx} macro used
+internally in the implementation of SBCL itself. In circumstances
+where this is not appropriate, the programmer can handle the condition
+type @code{sb-ext:defconstant-uneql}, and choose either the
+@command{continue} or @command{abort} restart as appropriate.
+
+@node Style Warnings
+@comment node-name, next, previous, up
+@subsection Style Warnings
+
+SBCL gives style warnings about various kinds of perfectly legal code,
+e.g.
+
+@itemize
+