Release notes for CMU Common Lisp 16d, 30 May 92
16d is our first version 16 general release, and incorporates many changes not
present in the 15 series. It is currently fairly close to our current
internal development (alpha) systems, and is thus less stable. The major
changes are:
New Aliens
New pathnames
New pretty printer
New format
R5.0 CLX.
5/1/90 May Day PCL (REV 4b)
Revised manual
CLX and Hemlock are now optional. When CMU CL is installed, the maintainer can
elect not to load CLX and Hemlock -- this saves 7 megabytes of disk and
improves memory usage somewhat. See the installation section of the README
file for details.
The ``CMU Common Lisp User's Manual'' has been updated to be more helpful for
non-CMU users. The new manual also documents the new Alien facility for
foreign function calls and data structure access. The manual is now formatted
with Mike Clarkson's LaTeXinfo package, so a consistent version of the
documentation is available online in Gnu info format. See `doc/cmu-user.ps'
and `doc/cmu-user.info'.
Distribution:
CMU Common Lisp is only available via anonymous FTP. We don't have the
manpower to make tapes. These are our distribution machines:
lisp-rt1.slisp.cs.cmu.edu (128.2.217.9)
lisp-rt2.slisp.cs.cmu.edu (128.2.217.10)
Log in with the user "anonymous" and ·········@host" as password (i.e. your
EMAIL address.) When you log in, the current directory should be set to the
CMU CL release area. If you have any trouble with FTP access, please send mail
to ·····@cs.cmu.edu.
The release area holds compressed tar files with names of the form:
<version>-<machine>_<os>.tar.Z
<version>-extra-<machine>_<os>.tar.Z
FTP compressed tar archives in binary mode. To extract, "cd" to the
directory that is to be the root of the tree, then type:
uncompress <file.tar.Z | tar xf - .
As of 5/27/92, the latest SunOS Sparc release is:
16d-sun4c_41.tar.Z (6.5 meg)
16d-extra-sun4c_41.tar.Z (3.5 meg)
The first file holds binaries and documentation for the basic Lisp system,
while the second `-extra' file contains the Hemlock editor, the graphical
inspector and the CLX interface to X11. The basic configuration takes 16
megabytes of disk space; adding the extras takes another 8 megabytes. For
installation directions, see the section "site initialization" in README file
at the root of the tree.
If poor network connections make it difficult to transfer a 10 meg file, the
release is also available split into 2 megabyte chunks, suffixed `.0', `.1',
etc. To extract from multiple files, use:
cat file.tar.Z.* | uncompress | tar xf - .
The release area also contains source distributions and other binary
distributions. A listing of the current contents of the release area is in
FILES. Major release announcements will be made to comp.lang.lisp until there
is enough volume to warrant a comp.lang.lisp.cmu.
Source availability:
Lisp and documentation sources are available via anonymous FTP ftp to any CMU
CS machine. [See the "Distribution" section for FTP instructions.] All CMU
written code is public domain, but CMU CL also makes use of two imported
packages: PCL and CLX. Although these packages are copyrighted, they may be
freely distributed without any licensing agreement or fee.
The release area contains a source distribution, which is an image of all the
".lisp" source files used to build version 16d:
16d-source.tar.Z (3.6 meg)
Detailed release notes are in doc/release-notes.txt
________________________________________________________________
Sun Release 4.1 1
CMUCL(1) USER COMMANDS CMUCL(1)
NAME
CMU Common Lisp
DESCRIPTION
CMU Common Lisp is public domain "industrial strength" Com-
mon Lisp programming environment. Many of the X3j13 changes
have been incorporated into CMU CL. Wherever possible, this
has been done so as to transparently allow use of either
CLtL1 or proposed ANSI CL. Probably the new features most
interesting to users are SETF functions, LOOP and the WITH-
COMPILATION-UNIT macro.
HARDWARE REQUIREMENTS
CMU CL is currently available for Sparcstations and DECsta-
tions (pmaxes) running Mach (or OSF/1). We are beta-testing
a SunOS SPARC version and an IBM RT Mach version. At least
16 megabytes of memory and 25 megabytes of disk space are
recommended. As usual, more is better.
OVERVIEW
When compared other Common Lisp implementations, CMU CL has
two broad advantages:
-- The new CMU CL compiler (Python) is more sophisticated
than other Common Lisp compilers. It both produces
better code and is easier to use.
-- The programming environment based on the Hemlock editor
is better integrated than gnu-emacs based environments.
(Though you can still use GNU if you want.)
CMU CL also has significant non-technical advantages:
-- It has good local support for CMU users, and is well
integrated with the CMU CS environment.
-- It is public domain, and is freely available to non-CMU
sites that aren't able to afford a site-license for a
commercial Lisp.
COMPILER FEATURES
The `Advanced Compiler' chapter of the User's manual exten-
sively discusses Python's optimization capabilities (See
DOCUMENTATION below.) Here are a few high points:
-- Good efficiency and type-checking at the same time. Com-
piling code safe gives a 2x speed reduction at worst.
-- In safe code, type declarations are verified, allowing
declarations to be debugged in safe code. When you go to
compile unsafe, you know the declarations are right.
-- Full source level debugging of compiled code, including
display of the exact call that got an error.
-- Good efficiency notes that tell you why an operation
can't be open coded or where you are number-consing, and
that provide unprecedented source context
-- Block compilation, partial evaluation, lightweight func-
tions and proper tail-recursion allow low-cost use of
function call abstraction.
TYPE SUPPORT
The most visible way in which Python differs from previous
Common Lisp compilers is that it has a greater knowledge
about types and a different approach to type checking. In
particular, Python implements type checking which is `eager'
and `precise':
-- Eager in the sense that type checking is done immediately
whenever there is a declaration, rather than being
delayed until the the value is actually used. For exam-
ple:
(let ((x ...))
(declare (fixnum x))
...)
Here, the type of the initial value of X must be a FIXNUM
or an error will be signalled.
-- Precise in the sense that the exact type specified is
checked. For example, if a variable is declared to be of
type (integer 3 7), then the value must always be an
integer between 3 and 7.
OPTIMIZATION
Python does many optimizations that are absent or less gen-
eral in other Common Lisp compilers: Proper tail recursion,
lightweight function call, block compilation, inter-
procedural type inference, global flow analysis, dynamic
type inference, global register allocation, stack number
allocation, control optimization, integer range analysis,
enhanced inline expansion, multiple value optimization and
source-to-source transforms.
Optimization and type-checking are controlled by the OPTIM-
IZE declaration. The default compilation policy is type-
safe.
NUMERIC SUPPORT
Python is particular good at number crunching:
-- Good inline coding of float and 32 bit integer opera-
tions, with no number consing. This includes all the
hardware primitives ROUND, TRUNCATE, COERCE, as well as
important library routines such as SCALE-FLOAT and
DECODE-FLOAT. Results that don't fit in registers go on
a special number stack.
-- Full support for IEEE single and double (denorms, +-0,
etc.)
-- In block compiled code, numbers are passed as function
arguments and return values in registers (and without
number consing.)
-- Calls to library functions (SIN, ...) are optimized to a
direct call to the C library routine (with no number
consing.) On hardware with direct support for such func-
tions, these operations can easily be open-coded.
-- Substantially better bignum performance than commercial
implementations (2x-4x). Bignums implemented in lisp
using word integers, so you can roll your own.
Python's compiler warnings and efficiency notes are espe-
cially valuable in numeric code. 50+ pages in the user
manual describe Python's capabilities in more detail.
THE DEBUGGER
In addition to a basic command-line interface, the debugger
also has several powerful new features:
-- The "source" and "vsource" commands print the *precise*
original source form responsible for the error or pending
function call. It is no longer necessary to guess which
call to CAR caused some "not a list" error.
-- Variables in compiled code can be accessed by name, so
the debugger always evaluates forms in the lexical
environment of the current frame. This variable access
is robust in the presence of compiler optimization ---
although higher levels of optimization may make variable
values unavailable at some locations in the variable's
scope, the debugger always errs on the side of discre-
tion, refusing to display possibly incorrect values.
-- Integration with the Hemlock editor. In a slave, the
"edit" command causes the editor edit the source for the
current code location. The editor can also send non-
line-mode input to the debugger using C-M-H bindings.
Try apropos "debug" in Hemlock.
See the debugger chapter in the user manual for more
details. We are working on integrating the debugger with
Hemlock and X windows.
SUPPORT
Bug reports should be sent to ··········@cs.cmu.edu. Please
consult your local CMU CL maintainer or Common Lisp expert
to verify that the problem really is a bug before sending to
this list.
We have insufficient staffing to provide extensive support
to people outside of CMU. We are looking for university and
industrial affiliates to help us with porting and mainte-
nance for hardware and software that is not widely used at
CMU.
By the way, does anyone know if the ILISP gnu emacs package has been
engineered to work more happily with CMU common lisp? The last time I
tried, arglist and edit-definition didn't work properly (though CMU
CL's describe seemed to have available the information necessary to
support those features).
R