Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

FAQ: Lisp Implementations and Mailing Lists 4/7 [Monthly posting]

0 views

Skip to first unread message

Mark Kantrowitz

unread,

Aug 13, 1997, 3:00:00 AM8/13/97

Archive-name: lisp-faq/part4
Last-Modified: Fri Mar 14 11:41:35 1997 by Mark Kantrowitz
Version: 1.61
Maintainer: Mark Kantrowitz and Barry Margolin <ai+li...@cs.cmu.edu>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html
Size: 68923 bytes, 1314 lines

;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Lisp ***************
;;; ****************************************************************
;;; lisp_4.faq

This post contains Part 4 of the Lisp FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

Lisp/Scheme Implementations and Mailing Lists (Part 4):

[4-0] Free Common Lisp implementations.
[4-1] Commercial Common Lisp implementations.
[4-1a] Lisp to C translators
[4-2] Scheme Implementations
[4-4] Free Implementations of Other Lisp Dialects
[4-5] Commercial Implementations of Other Lisp Dialects
[4-6] What is Dylan?
[4-7] What is Pearl Common Lisp?
[4-9] What Lisp-related discussion groups and mailing lists exist?
[4-10] ANSI Common Lisp -- Where can I get a copy of the draft standard?

Search for \[#\] to get to question number # quickly.

----------------------------------------------------------------
Subject: [4-0] Free Common Lisp implementations.

Repositories of Lisp source code are described in the answer to
question [6-1].

Remember, when ftping compressed or compacted files (.Z, .arc, .fit,
etc.) to use binary mode for retrieving the files.

The Allegro CL 3.0 Web Version for Windows is a full functional free
version of our Dynamic Object Oriented Programming Development System
for ANSI standard CLOS, with some limitations*. This version includes
an in-core native 32-bit compiler, a drag & drop Interface Builder,
full debugging and development tools and an editor. We sell a supported
version of this software, Allegro CL for Windows, without these
limitations. For more information, call 1-800-3-CLOS-NOW or
1-510-548-3600, fax 1-510-548-8253, or send email to in...@franz.com.
Franz's web page is located at the URL
http://www.franz.com/
Suggestions and bug reports should be sent to w...@franz.com. Since
this software is unsupported, they may not get back to you, but the
input is still welcome.
* The limitations are: limited heap size, no foreign function support,
missing compile-file, missing disassembler and missing save-image.
The documentation fully explains these capabilities.

CLiCC (Common Lisp to C Compiler) generates C-executables from Common
Lisp application programs. CLiCC is not a Common Lisp system, and
hence does not include any program development or debugging support.
CLiCC is intended to be used as an add-on to existing Common Lisp
systems for generating portable applications. (CLiCC has been tested
in Allegro CL, Lucid CL, CMU CL, CLISP, and AKCL. It should run in any
CLtL1 lisp with CLOS.) CLiCC supports CL_0, a subset of Common Lisp +
CLOS, which excludes EVAL and related functions. At present CL_0 is
based on CLtL1, but is headed towards CLtL2 and ANSI-CL. The generated
C code (ANSI-C or K&R-C compatible) may be compiled using a
conventional C compiler on the target machine, and must be linked with
the CLiCC runtime library in order to generate executables. CLiCC has
a foreign function interface. CLiCC is available by anonymous ftp from
ftp.informatik.uni-kiel.de:/pub/kiel/apply/clicc-0.6.4.tar.gz
[134.245.15.114].
CLiCC was developed by Wolfgang Goerigk <w...@informatik.uni-kiel.de>,
Ulrich Hoffman <u...@informatik.uni-kiel.de>, and Heinz Knutzen
<h...@informatik.uni-kiel.de> of Christian-Albrechts-Universitaet zu
Kiel, Institut fuer Informatik und Praktische Mathematik,
Preusserstr. 1-9, D-24105 Kiel, Germany. The authors welcome
suggestions and improvements and would appreciate receiving email
even if you just used CLiCC successfully. For more information,
send mail to cl...@informatik.uni-kiel.de.

CLISP is a Common Lisp (CLtL1 + parts of CLtL2) implementation by
Bruno Haible of Karlsruhe University and Michael Stoll of Munich
University, both in Germany. It runs on microcomputers (DOS, OS/2,
Atari ST, Amiga 500-4000) as well as on Unix workstations (Linux, Sun4,
Sun386, HP9000/800, SGI, Sun3 and others) and needs only 1.5 MB of RAM.
It is free software and may be distributed under the terms of GNU GPL.
German and English versions are available, French coming soon. CLISP
includes an interpreter, a compiler, a subset of CLOS (e.g., no MOP)
and, for some machines, a screen editor. Packages running in CLISP
include PCL and, on Unix machines, CLX and Garnet. Available by anonymous
ftp from
ma2s2.mathematik.uni-karlsruhe.de:/pub/lisp/clisp/ [129.13.115.2]
For more information, contact hai...@ma2s2.mathematik.uni-karlsruhe.de.
There is a mailing list for users of CLISP. It is the proper forum for
questions about CLISP, installation problems, bug reports, application
packages etc. For information about the list and how to subscribe,
send mail to list...@ma2s2.mathematik.uni-karlsruhe.de, with the two lines
help
information clisp-list
in the message body.
A Sybase SQL interface interface for CLIPS is available
by anonymous ftp from wuarchive.wustl.edu:packages/clips2sybase/. For
more information, write to Sherry Steib <she...@informatics.wustl.edu>.

CMU Common Lisp (CMU CL) is free, and runs on HPs, Sparcs (Mach,
SunOs, and Solaris), DecStation 3100 (Mach), SGI MIPS (Iris), DEC
Alpha/OSF1, IBM RT (Mach) and requires 16mb RAM, 25mb disk. It
includes an incremental compiler, Hemlock emacs-style editor,
source-code level debugger, code profiler and is mostly X3J13
compatible, including the new loop macro. It is available by
anonymous ftp from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/project/clisp/release [128.2.206.173]
Login with username "anonymous" and "userid@host" (your email
address) as password. Due to security restrictions on anonymous ftps
(some of the superior directories on the path are protected against
outside access), it is important to "cd" to the source directory with
a single command. Don't forget to put the ftp into binary mode before
using "get" to obtain the compressed/tarred files. The binary releases
are contained in files of the form
<version>-<machine>_<os>.tar.Z
Other files in this directory of possible interest are
17f-source.tar.gz, which contains all the ".lisp" source files
used to build version 17f. A listing of the current contents of the
release area is in the file FILES. You may also use "dir" or "ls" to
see what is available. Bug reports should be sent to cmucl...@cs.cmu.edu.

ECoLisp is a Common Lisp implementation which compiles Lisp functions
into C functions that use the C stack and standard procedure call
conventions. This lets Lisp and C code be easily mixed. It can be used
as a C library from any C application. It is available by anonymous
ftp from
ftp.di.unipi.it:/pub/lang/lisp/ [131.114.4.36]
ftp.icsi.berkeley.edu:/pub/ai/ecl/ [128.32.201.7]
as the file ecl-??.tar.gz where ?? is the version number. This is an alpha
release. So far it has been tested on Sun workstations (SunOS 4.x),
SGI (IRIX 4.x), and IBM PC (DOS/go32). For more information, please contact
Giuseppe Attardi <att...@di.unipi.it> or <att...@icsi.berkeley.edu>.

GNU Common Lisp (GCL) is a free implementation of Common Lisp (CLtL1)
based originally on Austin Kyoto Common Lisp (AKCL). Versions 1.0
and above of GCL (aka versions 1-625 and above of AKCL) are
available under the GNU General Public Library License v2.0, and no
longer require the kcl.tar file to build the system. For
information on previous versions of AKCL, see the KCL entry. GCL
generates C code which it compiles with the local optimizing C
compiler (e.g., GCC). It is intended to eventually support the
ANSI standard for Common Lisp. GCL runs on Sparc, IBM RT, RS/6000,
DecStation 3100, hp300, hp800, Macintosh (under A/UX), mp386,
IBM PS2, IBM RT_AIX, Silicon Graphics 4d, Sun3, Sun4, Sequent
Symmetry, IBM 370, NeXT, Vax, and IBM PC 386/486 (linux, bsd).
GCL version 1.0 and above are available by anonymous ftp from
ftp.cli.com:/pub/gcl/ [192.31.85.129]
math.utexas.edu:/pub/gcl/ [128.83.133.215]
as the file gcl-X.X.tgz (e.g., gcl-2.1.tgz), where X.X should be
replaced with the version number; you'll generally want the largest
version number. The bandwidth to math.utexas.edu is higher than cli.
The file pcl-gcl-1.0.tgz contains a port of PCL (CLOS) to GCL.
The file xgcl-2.tgz contains an interface to X Windows for GCL,
including a low-level interface to Xlib, and in addition to being
available from the above sites, is also available from
ftp.cs.utexas.edu:/pub/novak/xgcl/
http://www.cs.utexas.edu/users/novak/
For more information, write to William Schelter <w...@math.utexas.edu>
(or <w...@cli.com>, <w...@rascal.ics.utexas.edu>). GCL is under
continuing development, and folks interested in helping should send
him email. Andy Wang <aw...@plains.nodak.edu> has compiled GCL 1.0
for Linux 1.1.50 (using gcc 2.5.8 and libc 4.5.26) and made the
resulting binaries available by anonymous ftp from
sunsite.unc.edu:/pub/Linux/Incoming/gcl-1.0.bin.tgz

Kyoto Common Lisp (KCL) is free, but requires a license. Conforms to CLtL1.
KCL was written by T. Yuasa <yu...@tutics.tut.ac.jp> and M. Hagiya
<hag...@is.s.u-tokyo.ac.jp> at Kyoto University in 1984. Austin
Kyoto Common Lisp (AKCL) is a collection of ports, bug fixes and
improvements to KCL by Bill Schelter (<w...@cli.com> or
<w...@rascal.ics.utexas.edu>). Since 1994, AKCL versions 1-625 and
higher are covered by the GNU GPL, so generally one will generally
not need KCL (see GCL above for details). {A}KCL generates C code
which it compiles with the local C compiler. Both are available by
anonymous ftp from
rascal.ics.utexas.edu:/pub/ [128.83.138.20]
ftp.cli.com:/pub/ [192.31.85.1]
utsun.s.u-tokyo.ac.JP:/pub/ [133.11.11.11]
KCL is in the file kcl.tar, and AKCL is in the file akcl-xxx.tar.Z
(take the highest value of xxx). To obtain KCL, one must first sign
and mail a copy of the license agreement to: Special Interest Group in
LISP, c/o Taiichi Yuasa, Department of Computer Science, Toyohashi
University of Technology, Toyohashi 441, JAPAN. Runs on Sparc, IBM RT,
RS/6000, DecStation 3100, hp300, hp800, Macintosh (under A/UX),
mp386, IBM PS2, Silicon Graphics 4d, Sun3, Sun4, Sequent Symmetry, IBM
370, NeXT and Vax. For the beta test version of the DOS port, see
the files akclexe.zip and go32sexe.zip in
math.utexas.edu:/pub/msdos/akcl-beta/
Commercial versions of {A}KCL are available from Austin Code Works,
11100 Leafwood Lane, Austin, TX 78750-3409, Tel. 512-258-0785, Fax
512-258-1342, E-mail gut...@acw.com, including a CLOS for AKCL.
See also Ibuki, below.

PowerLisp is a Common Lisp development environment for the Macintosh.
It consists of a Common Lisp interpreter, native-code 680x0 compiler,
680x0 macro assembler, disassembler, incremental linker and
multi-window text editor. It requires a Macintosh with at least a
68020 processor (any Mac except a Plus, SE or Classic) and system 7.0
or later. About 2 megabytes of RAM are required to run it, and to do
much with it you need more like 5 or 6 megabytes. Like any Common Lisp
system, the more memory the better. PowerLisp has the ability to run
in the background. While executing a Common Lisp program, the user may
switch to another application as it continues to run. You can also
edit programs while a Common Lisp program is running. PowerLisp is
targeted to be compatible with CTLTL2 without CLOS (for now) but some
Common Lisp functions are not yet implemented. Upcoming versions
should include the remaining language features. The current released
version is 1.10. PowerLisp is available from America Online and Genie as a
shareware program ($50). It is also available from the Lisp
Repository, as
ftp.cs.cmu.edu:/user/ai/lang/lisp/impl/powerlsp/v1_10/powerlsp.hqx
Written by Roger Corman. For more information, send mail to
Powe...@aol.com, ro...@island.com or roge...@aol.com (RogerC34
on America Online).

RefLisp is a small Lisp interpreter. Versions exist for MS Windows,
MS-DOS and UNIX (AIX). The MS-DOS version supports CGA/EGA/VGA
graphics and the Microsoft Mouse. The interpreter is a shallow-binding
(i.e., everything has dynamic scope), reference counting design making
it suitable for experimenting with real-time and graphic user
interface programming. Common Lisp compatibility macros are provided,
and most of the examples in "Lisp" by Winston & Horn have been run on
RefLisp. RefLisp makes no distinction between symbol-values and
function-values, so a symbol can be either but not both. RefLisp
comes with an ASCII manual and many demonstration programs, including
an analogue clock which never stops for garbage collection. It is
written in ANSI C and is in the public domain. Source and binaries are
available from the author's Web site at
http://www.ozemail.com.au/~birchb/reflisp.html
and from the Lisp Utilities repository by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/lang/lisp/impl/reflisp/
For further information, send email to the author Bill Birch
<bir...@ozemail.com.au>.

WCL is an implementation of Common Lisp for Sparc based workstations.
It is available free by anonymous ftp from
cdr.stanford.edu:/pub/wcl/ [36.93.0.31]
as the files wcl2.2-solaris-src.tar.gz, wcl2.2-solaris-bins.tar.gz,
wcl2.2-sunos4-src.tar.gz, wcl2.2-sunos4-bins.tar.gz, and
wgdb4.2-sunos4.tar.gz. It includes a native solaris version (but with
no dynamic .o loading or wgdb yet...), can use any version of GCC 2.X
(GCC 2.1 is no longer required), and includes separate binary and
source distribution so that recompilation is no longer needed to
install WCL and WGDB. The wcl2.2-*.tar.gz files contain the WCL
distribution, including CLX and PCL; wgdb4.2-sunos4.tar.gz contains a
version of the GDB debugger which has been modified to grok WCL's
Lisp. WCL provides a large subset of Common Lisp as a Unix shared
library that can be linked with Lisp and C code to produce efficient
and small applications. For example, the executable for a Lisp version
of the canonical ``Hello World!'' program requires only 40k bytes
under SunOS 4.1 for SPARC. WCL provides CLX R5 as a shared library,
and comes with PCL and a few other utilities. For further information
on WCL, see the paper published in the proceedings of the 1992 Lisp
and Functional Programming Conference, a copy of which appears in the
wcl directory as lfp-paper.ps, or look in the documentation directory
of the WCL distribution. Written by Wade Hennessey
<wa...@sunrise.stanford.edu>. Please direct any questions to
w...@sunrise.stanford.edu. If you would like to be added to a mailing
list for information about new releases, send email to
wcl-r...@sunrise.stanford.edu.

XLISP is free, and runs on the IBM PC (MSDOS), Windows 95, Apple
Macintosh, and Unix. It should run on anything with an Ansi C
compiler. It was written by David Michael Betz, 18 Garrison Drive,
Bedford, NH 03110, 603-472-2389 (H&W), Davi...@aol.com or
db...@xlisper.mv.com. The reference manual was written by
Tim Mikkelsen. Version 2.0 is available by anonymous ftp from
cs.orst.edu:/pub/xlisp/ [128.193.32.1] or
sumex-aim.stanford.edu:/info-mac/lang/
Version 2.1g* is the same as XLISP 2.0, but modified by Tom Almy
<to...@sail.labs.tek.com> to bring it closer to Common Lisp, in
addition to fixing several bugs. The latest version of XLISP can be
obtained by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/lang/lisp/impl/xlisp/ [128.2.206.173]
It may also be available (in possible older versions) from
ftp.biostr.washington.edu:/pub/xlisp [128.95.10.115]
wasp.eng.ufl.edu:/pub [128.227.116.1]
A Macintosh port of version 2.1e (and the C source code to its
interface) is also available, from Macintosh ftp sites such as
sumex.stanford.edu:/info-mac/dev/xlisp-21e2.hqx
mac.archive.umich.edu:/mac/development/languages/xlisp2.1e2.sit.hqx
The Macintosh version was written by Brian Kendig, <bske...@netcom.com>.
To obtain a copy through US mail, send email to Tom Almy,
to...@sail.labs.tek.com. A Windows version of the statistical
version of xlisp is available by anonymous ftp from
ftp.cica.indiana.edu:/util/wxlslib.zip
A version of XLISP-PLUS 2.1g that includes an experimental byte code
compiler is available by anonymous ftp from
umnstat.stat.umn.edu:/pub/xlispstat/xlisponly/ [128.101.51.1]
as the file xlisp21gbc.tar.gz. Write to Luke Tierney <lu...@stat.umn.edu>
for more information.

----------------------------------------------------------------
Subject: [4-1] Commercial Common Lisp implementations.

Allegro Common Lisp:

Allegro Common Lisp 4.2 runs on a variety of platforms, including
Sparcs, RS6000, HP700, Silicon Graphics, DecStation (prices start at
$4,500) and NeXT ($2,000). It requires 12mb RAM for the 680x0 and 16mb
for RISC. It includes native CLOS, X-windows support, Unix interface,
incremental compilation, generational garbage collection, and a
foreign function interface. Options include Allegro Composer
(development environment, including debugger, inspector, object
browser, time/space code profiler, and a graphical user interface,
$1,500), Common LISP Interface Manager (CLIM 2.0 is a portable
high-level user interface management system. CLIM 2.0 for Allegro CL
supports both Motif and Openlook and Windows, ($1,000). Franz also
markets Allegro CL 3.0 for Windows 3.1, Windows NT and Windows95 for
$595 (discount prices of $449 are sometimes advertised in various AI
magazines). A Professional version with royalty free runtime
distribution and source code is available for $2495.
Allegro CL for Windows provides 32-bit compilation, complete CLOS, an
integrated development environment, visual drag & drop Interface Builder,
interface to the Windows API, DLL support, and free runtime delivery.
Write to: Franz Inc., 1995 University Avenue, Berkeley, CA 94704 or
call 1-800-333-7260, 510-548-3600, fax 510-548-8253, telex 340179
WUPUBTLXSFO. Bug reports can be mailed to bu...@franz.com. Questions
about Franz Inc. products (e.g., current and special pricing) can be
sent to in...@franz.com. To receive Franz Flash, Franz's electronic
newsletter, send mail to fl...@franz.com.
Files related to the products (e.g., patches, Franz's GNU-Emacs/Lisp
interface, the Allegro FAQ)
are available by anonymous ftp from
ftp.franz.com:/pub/ [192.48.96.9]
http://www.franz.com/

CLOE:

CLOE (Common Lisp Operating Environment) is a cross-development
environment for IBM PCs (MSDOS) and Symbolics Genera. It includes
CLOS, condition error system, generational garbage collection,
incremental compilation, code time/space profiling, and a stack-frame
debugger. It costs from $625 to $4000 and requires 4-8mn RAM and a 386
processor. Write to: Symbolics, 6 New England Tech Center,
521 Virginia Road, Concord, MA 01742, call 1-800-394-5522 or
508-287-1000 or fax 508-287-1099.

Golden Common Lisp:

Golden Common Lisp (GCLisp 4.4) runs on IBM PCs under DOS, Windows,
OS/2, and Windows NT, costing $2,000 ($250 extra for Gold Hill
Windows), and includes an incremental compiler, foreign function
interface, interactive debugger, SQL interface, and emacs-like editor.
It supports DDE and other Windows stuff, and is CLtL1 compatible.
Supports PCL/CLOS. It requires 4mb RAM, and 12mb disk. See a review in
PC-WEEK 4/1/91 comparing GCLisp with an older version of MCL. Write
to: Gold Hill Computers, 26 Landsdowne Street, Cambridge, MA 02139,
call 617-621-3300, or fax 617-621-0656.

Harlequin LispWorks:

LispWorks (R) from Harlequin runs on a variety of Unix platforms,
including Sun Sparc and clones (SunOS and Solaris), IBM RS/6000 (AIX),
DEC MIPS (Ultrix), DEC Alpha (OSF/1), HP PA (HP-UX), and SGI (IRIX).
LispWorks uses menus and graphics to provide convenient, user friendly
access to its wide array of powerful tools. A C/C++ interface, an SQL
interface, and a fully integrated Prolog compiler are a standard part
of LispWorks. CLIM 2.0 is also available.

+ COMMON LISP: CLtL2 compatible, native CLOS/MOP, generational GC,
C/C++ interface.

+ ENVIRONMENT: Prolog, Emacs-like editor/listener/shell, defadvice,
defsystem, cross-referencing, lightweight processes,
debugger, mail reader, extensible hypertext online doc, LALR
parser generator.

+ BROWSERS/GRAPHERS: files, objects, classes, generic functions,
source code systems, specials, compilation warnings.

+ GRAPHICS: CLX, CLUE, Toolkit, CAPI, Open Look, Motif,
interface builder.

+ INTEGRATED PRODUCTS: CLIM 2.0, KnowledgeWorks (RETE engine).

For further information, contact by e-mail worldwide:
lispwork...@harlequin.com (OR @harlequin.co.uk)
or in the US:
FAX: 617-252-6505
Voice: 800-WORKS-4-YOU (800-967-5749) or 617-374-2400 or 617-252-0052
Mail: Harlequin Inc., One Cambridge Center, Cambridge, MA 02142
or in Europe:
FAX: 0223-872-519 (OR 44-1223-872-519 from outside UK)
Voice: 0223-873-800 OR -872-522 (OR 44-1223-873-800 from outside UK)
Telex: 818440 harlqn g
Mail: Harlequin Ltd., Barrington Hall, Barrington, Cambridge, CB2 5RG

For more information, see their web page at the URL
http://www.harlequin.com/

Harlequin FreeLisp:

Harlequin Inc. is shipping FreeLisp (TM), which has been developed
specifically to meet the Lisp teaching requirements of the academic
community in terms of both functionality and price. FreeLisp
is a reduced implementation of Harlequin's premier Common Lisp
development environment, LispWorks (R). FreeLisp runs under on PC's
under Windows, and has many of the environmental features as
LispWorks but does not include a compiler. For prices and information
about FreeLisp, contact by e-mail worldwide
lispwork...@harlequin.com (OR @harlequin.co.uk)
or in the US:
fax: 617-252-6505
voice: 800-WORKS-4-YOU (800-967-5749) or 617-374-2400 or 617-252-0052
mail: Harlequin Inc., One Cambridge Center, Cambridge, MA 02142
or in Europe:
fax: 0223-872-519 (OR 44-1223-872-519 from outside UK)
voice: 0223-873-800 OR -872-522 (OR 44-1223-873-800 from outside UK)
Telex: 818440 harlqn g
mail: Harlequin Ltd., Barrington Hall, Barrington, Cambridge, CB2 5RG
Freelisp is available at the URL
http://www.harlequin.com/freelisp/

Ibuki Common Lisp:

Ibuki Common Lisp (IBCL) v02/01 is a commercialized and improved
version of Kyoto Common Lisp. It runs on over 30 platforms, including
Sun3, Sparc, Dec (Ultrix), Apollo, HP 9000, IBM RS/6000, Silicon
Graphics and IBM PCs (under AIX). It includes an incremental compiler,
interpreter, and C/Fortran foreign function interface. It generates C
code from the Lisp and compiles it using the local C compiler. Image
size is about 3mb. Cost is $2800 (workstations), $3500 (servers), $700
(IBM PCs). Supports CLOS and CLX ($200 extra). Source code is
available at twice the cost. Ibuki now also has a product called CONS
which compiles Lisp functions into linkable Unix libraries. Write to:
Ibuki Inc., PO Box 1627, Los Altos, CA 94022, or call 415-961-4996,
fax 415-961-8016, or send email to Richard Weyhrauch, r...@ibuki.com or
sup...@ibuki.com.

LinkLisp:

LinkLisp is a Lisp implementation for Windows that supports a large
subset of Common Lisp. It is DLL and VBX callable from C/C++ and
Visual Basic. It costs $249. For more information, write to Conscious
Computing, 3100 Connecticut Avenue NW, Suite 202, Washington, DC
20008, call 202-483-6350, or fax 202-462-9110.

Lucid Common Lisp:

Lucid Common Lisp runs on a variety of platforms, including PCs (AIX),
Apollo, HP, Sun-3, Sparc, IBM RT, IBM RS/6000, Decstation 3100,
Silicon Graphics, and Vax. Lucid includes native CLOS, a foreign
function interface, and generational garbage collection. CLIM is
available for Lucid as a separate product. See also the comments in
question [1-2] on the wizards.doc file that comes with the release.

[Note: Lucid encountered financial difficulties because of forays
into C-related products; the Lisp end of the company remained strong.
Harlequin announced on 23-NOV-94 that they have acquired the
rights to the Lisp-related technology of Lucid, Inc., that they
will market and support Lucid Common Lisp alongside their
LispWorks products, and that they have hired several former Lucid
employees for this purpose.]

Macintosh Common Lisp:

Macintosh Common Lisp (MCL) is an object-oriented dynamic language
(OODL) from Digitool, Inc. MCL 4.0 will work on any Power Macintosh
with at least 16 MB of RAM, 28 MB of disk storage, and Macintosh System
Software 7.5 or later. MCL 3.1 will work on any 68K-based Macintosh
with at least 8 MB of RAM, 15 MB of disk storage, and Macintosh System
6.x or 7.x. Both versions are included on CD-ROM together with extensive
documentation, runtime sources, development utilities, and sample code.
A CD-ROM drive is required for installation.

MCL implements the industry standard Common Lisp programming language
and CLOS (as defined in Common Lisp: The Language, second edition),
and is fully integrated with the Macintosh family of personal computers.

MCL is a completely integrated development environment, including a
fast incremental compiler which produces efficient native PPC code or
680x0 code, a window-based debugger, a source code stepper, a dynamic
object inspector, a stack backtrace inspector, a programmable
Macintosh-style emacs-like editor, online documentation, and an
interactive interface toolkit. MCL supports multiple processes and
provides both high-level object-oriented user interface class library
and complete low-level access to the Macintosh Toolbox.

Using MCL, you can create a standalone double-clickable Macintosh
application. A license is required to distribute an application
created with MCL. Licenses are available to include the MCL compiler
in a distributed application.

MCL may be purchased individually or as a subscription; site licenses
are also available. For more information, mailto:in...@digitool.com;
for orders, mailto:ord...@digitool.com, call (617) 441-5000 or fax
(617) 576-7680. See http://www.digitool.com/MCL-price-list.html for
current pricing.

Medley:

Medley 2.0 is a Common Lisp development environment that includes a
native CLOS w/MOP, window toolkit, window-based debugger, incremental
compiler, structure editor, inspectors, stepper, cross-referencer
(Masterscope), code analysis tools, and browsers. It is the successor
to InterLisp-D. It runs on a variety of platforms, including Suns,
DecStations, 386/486s, IBM RS/6000, MIPS, HP, DEC Alpha, and Xerox
1186. The price for Unix machines is $3,195 for the developer version
and $1,250 for the runtime version. Medley also runs under DOS 4.0 or
higher ($795 developer version, $300 runtime version, and $250 student
version). Instructional licenses are also available at $250/copy for DOS
(to a max of $1,250) and $1,000/copy for Unix (to a max of $5,000).
For more information, write to Venue, 1624 Franklin Street, Suite 1212,
Oakland, CA 94612, call 800-228-5325 or 510-835-8856, fax
510-835-8251, or send email to aisupp...@envos.xerox.com.

muLISP-90:

muLISP-90 v7.1 is a small Lisp which runs on IBM PCs (or the HP 95LX
palmtop), MS-DOS version 2.1 or later. It isn't Common Lisp, although
there is a Common Lisp compatibility package which augments muLISP-90
with over 450 Common Lisp special forms, macros, functions and control
variables. Includes a screen-oriented editor and debugger, a window
manager, an interpreter and a compiler. Among the example programs is
DOCTOR, an Eliza-like program. The runtime system allows one to create
small EXE or COM executables. Uses a compact internal representation
of code to minimize space requirements and speed up execution. The
kernel takes up only 50k of space. Costs $150. muLISP-XM is a version
of muLISP-90 that can take advantage of up to 4 gigabytes of extended
memory and costs $300. Write to Soft Warehouse, Inc., 3660 Waialae
Avenue, Suite 304, Honolulu, HI 96816-3236, call 808-734-5801, or fax
808-735-1105.

NanoLISP:

NanoLISP 2.0 is a Lisp interpreter for DOS systems that supports a
large subset of the Common Lisp (CLtL2) standard, including lexical and
dynamic scoping, four lambda-list keywords, closures, local functions,
macros, output formatting, generic sequence functions, transcendental
functions, 2-d arrays, bit-arrays, sequences, streams, characters
double-floats, hash-tables and structures. Runs in DOS 2.1 or higher,
requiring only 384k of RAM. Cost is $100. Write to: Microcomputer Systems
Consultants, PO Box 6646, Santa Barbara, CA 93160 or call 805-967-2270.

Poplog Common Lisp:

Poplog Common Lisp is an incremental compiler and X-based development
environment for Common Lisp. Poplog Common Lisp provides a compact and
memory-efficient implementation which has recently been upgraded to
include support for CLtL2, including a native CLOS implementation.

The Poplog environment also includes efficient incremental compilers
for Prolog, Standard ML and Pop-11, a language-sensitive editor and
supports easy dynamic linking to C, Fortran etc. Poplog has over 400
customers in 36 countries.

Poplog runs on a variety of platforms including Sun SPARC (SunOS 4.1,
Solaris 2.x), HP-RISC (HP-UX), Silicon Graphics (IRIX), PC UNIX (SCO,
Linux), DECstation (Ultrix) and under VMS on both VAX and Alpha.

For more information, contact:
Integral Solutions Ltd, 3 Campbell Court,
Bramley, Basingstoke, Hants. RG26 5EG, UK.
Call +44 (0)1256 882028, fax +44 (0)1256 882182
Email i...@isl.co.uk

In North America, contact:
Computable Functions, Inc., 35 South Orchard Drive,
Amherst, MA 01002.
Call 413-253-7637, fax 413-545-1249.

Procyon Common Lisp:

Procyon Common Lisp runs on either the Apple Macintosh or IBM PC (386/486
or OS/2 native mode), costing 450 pounds sterling ($675) educational,
1500 pounds ($2250) commercial. It requires 2.5mb RAM on the Macintosh
and 4mb RAM on PCs (4mb and more than 4mb recommended respectively). It
is a full graphical environment, and includes a native CLOS with
meta-object protocol, incremental compilation, foreign function
interface, object inspector, text and structure editors, and debugger.
Write to: Scientia Ltd., St. John's Innovation Centre, Cowley Road,
Cambridge, CB4 4WS, UK, with phone +44-223-421221, fax +44-223-421218.
E-mail: 10014...@compuserve.com.
[NOTE: The rights to the MS Windows version of Procyon were sold to
Franz who are marketing and developing it as Allegro CL\PC. See
Allegro's entry for more information. The MS Windows version of
Procyon is no longer available from Scientia. Expertelligence no
longer distributes any version of Procyon.]

Software Engineer:

Software Engineer 2.1 is a Lisp for Windows that creates small
stand-alone executables (no royalties or run-time libraries required).
It is a subset of Common Lisp, but includes CLOS. Supports DDE and
Windows API calls. It requires 2mb RAM, but can use up to 16mb of
memory, generating 286/386 specific code. It costs $350. Write to:
Raindrop Software, 833 Arapaho Road, Suite 104, Richardson, TX 75081,
call 214-234-2611, fax 214-234-2674, or send email to
70632...@compuserve.com.

Star Sapphire Common LISP:

Star Sapphire Common LISP 3.4 provides a subset of Common Lisp and
includes an emacs-like editor, compiler, debugger, DOS graphics and
CLOS. It runs on IBM PCs (MSDOS or Windows), requires 640k RAM, a hard
disk, and costs $100. Write to: Sapiens Software Corporation,
PO Box 3365, Santa Cruz, CA 95063-3365, call 408-458-1990,
fax 408-425-0905/9220. Copies may also be ordered from the Programmers'
Shop at 800-421-8006. Sapiens Software also has a Lisp-to-C
translator in beta-test.

Top Level Common Lisp:

Top Level Common Lisp includes futures, a debugger, tracer, stepper,
foreign function interface and object inspector. It runs on Unix
platforms, requiring 8mb RAM, and costs $687. Write to: Top Level,
100 University Drive, Amherst, MA 01002, call (413) 549-4455, or fax
(413) 549-4910.

Lisps which run on special-purpose hardware (Lisp Machines) include

o Symbolics 1-800-394-5522 (508-287-1000) fax 508-287-1092
6 Concord Farms, 555 Virginia Road, Concord, MA 01742.
In Germany: Symbolics Systemhaus GmbH, Mergenthalerallee 77,
65760 Eschborn, (49) 6196-47220, fax (49) 6196-481116.
Symbolics Open Genera runs on DEC 3000 Workstations (models 600
and 800 APX with the OSF/1 operating system), at a price of $18,500.

o TI Explorers
Texas Instruments Incorporated, Data Systems Group,
P.O. Box 181153 DSG-230, Austin, Texas 78718

o Xerox Interlisp. See Medley above.

----------------------------------------------------------------
Subject: [4-1a] Lisp to C translators

Lisp-to-C Translator translates Common Lisp into human-readable ANSI
C. Release 3.2 supports such features as CLOS, the condition system,
Lisp type declaration heeding, and Mac, Windows, and Alpha
compatibility. (Release 3.0, introduced in 1992, eliminated the old
requirement that the garbage collector had to be called explicitly).
Works with Lucid, Symbolics, Allegro, Harlequin and MCL. It costs
$11,995. Write to: Chestnut Software, Inc., 2 Park Plaza, Suite 205,
Boston, MA, 02116, call 617-542-9222, fax 617-542-9220, or e-mail Mr.
Kenneth J. Koocher <k...@chestnut.com>.

Some Lisp compilers (AKCL, Ibuki) and Scheme compilers (Bigloo,
Hobbit/SCM, Scheme->C) compile into C.

----------------------------------------------------------------
Subject: [4-2] Scheme Implementations

Scheme implementations are listed in the Scheme FAQ posting,

Free Scheme implementations include PC-Scheme, PCS/Geneva, MIT Scheme (aka
C-Scheme), SCM, Hobbit, Gambit, T, Oaklisp, Elk, Scheme->C, SIOD
(Scheme in One Defun), XScheme, Fools' Lisp, Scheme48, UMB Scheme,
VSCM, Pixie Scheme, HELP (a lazy Scheme), Similix, FDU Scheme,
PseudoScheme, Scheme84 and Scheme88.

Commercial Scheme implementations include Chez Scheme, MacScheme, and EdScheme.

Of the free Scheme implementations, the following are implemented in Lisp:

Peter Norvig's book "Paradigms of AI Programming" has a chapters about
Scheme interpreters and compilers, both written in Common Lisp. The
software from the book is available by anonymous ftp from
mkp.com:/Norvig/ and on disk in Macintosh or DOS format from
the publisher, Morgan Kaufmann. For more information, contact: Morgan
Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260, San Mateo CA 94403,
or call Toll free tel: (800) 745-7323; FAX: (415) 578-0672

PseudoScheme is available free by anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/pseudo/pseudo-2-8.tar.Z [18.43.0.152]
It is Scheme implemented on top of Common Lisp, and runs in Lucid,
Symbolics CL, VAX Lisp under VMS, and Explorer CL. It should be easy
to port to other Lisps. It was written by Jonathan Rees
(j...@altdorf.ai.mit.edu, j...@cs.cornell.edu). Send mail to
info-clsch...@mc.lcs.mit.edu to be put on a mailing list for
announcements. Conforms to R3RS except for lacking a correct
implementation of call/cc. It works by running the Scheme code through
a preprocessor, which generates Common Lisp code.

Scheme84 is in the public domain, and available by mail from Indiana
University. It runs on the VAX in Franz Lisp under either VMS or BSD Unix.
To receive a copy, send a tape and return postage to: Scheme84
Distribution, Nancy Garrett, c/o Dan Friedman, Department of Computer
Science, Indiana University, Bloomington, Indiana. Call 1-812-335-9770
or send mail to n...@indiana.edu for more information. It will also
run in Jeff Dalton's port of Franz Lisp to Net/Free/386BSD on 386-like
machines. (See the Lisp FAQ for information on Franz Lisp.)

Scheme88 is a re-implementation of Scheme84 to run in Common Lisp. It
available by anonymous ftp from
rice.edu:/public/scheme88.sh
and also from the Scheme Repository.

----------------------------------------------------------------
Subject: [4-4] Free Implementations of Other Lisp Dialects

Franz Lisp:

[Franz Lisp is a dialect of Lisp that predates Common Lisp. It is
very similar to MacLisp. It lacks full lexical scoping.]

The official archive site for Franz List Opus 38.92 and 38.93b (the
last public domain releases) is
ftp.cs.cmu.edu:/user/ai/lang/others/franzlsp/
It includes the official version from the ucbvax ftp site before
its demise, Barry Schein's port of 38.92, the UC Davis port of 38.92,
and Jeff Dalton's port of 38.92 (see below). For more information,
contact ai+fr...@cs.cmu.edu.

An implementation of (Berkeley) Franz Lisp Opus 38.92 for 386/486
machines running NetBSD 0.9 (and possibly also 386BSD and FreeBSD)
is available by anonymous ftp from
macbeth.cogsci.ed.ac.uk:/pub/franz-for-NetBSD/
The implementation generates C code and hence is quite portable. It
has been tested on 68K Suns, VAX 750s, and ICL Perqs running PNX.
A reference manual is included in the distribution. For more
information, write to Jeff Dalton <J.Da...@ed.ac.uk>, or see the URL
http://www.aiai.ed.ac.uk/~jeff/franz-for-386.html

PC LISP is a Lisp interpreter for IBM PCs (MSDOS) available from any
site that archives the group comp.binaries.ibm.pc, such as
wuarchive.wustl.edu:/mirrors/msdos/lisp/pclisp30.zip
PC-LISP is a Franz LISP dialect and is by no means Common LISP
compatible. It is also available directly from the author by sending
2 blank UNFORMATTED 360K 48TPI IBM PC diskettes, a mailer and
postage to: Peter Ashwood-Smith, 8 Du Muguet, Hull, Quebec, CANADA,
J9A-2L8; phone 819-595-9032 (home). Source code is available from the
author for $15.

EuLisp:

Feel (Free and Eventually Eulisp) is an initial implementation of the
EuLisp language. It can be retrieved by anonymous FTP from
ftp.bath.ac.uk:/pub/eulisp/
as the file feel-0.75.tar.Z. feel-0.75.sun4.Z is the Sparc executable.
The EuLisp language definition is in the same directory. Feel is also
available from
ftp.gmd.de:/languages/lisp/eulisp/ [129.26.8.84]
It includes an integrated object system, a module system, condition
system, and support for parallelism (threads). EuLisp (European
Lisp) is sort of like an extended Scheme. The program is a C-based
interpreter, and a bytecode interpreter/compiler will be available
sometime soon. The distribution includes an interface to the PVM
library, support for TCP/IP sockets, and libraries for futures, Linda,
and CSP. Feel is known to run on Sun3, Sun4, Stardent Titan, Alliant
Concentrix 2800, Orion clippers, DEC VAX, DECstation 3000, Gould
UTX/32, and Inmos T800 transputer (using CS-Tools). (All bar the last
four have a threads mechanism.) It can run in multi-process mode on
the first three machines, and hopefully any other SysV-like machine
with shared memory primitives. Porting Feel to new machines is
reasonably straightforward. It now also runs on MS-DOS machines.
Written by Pete Broadbery <p...@maths.bath.ac.uk>.

Apply/Eu2C is an EuLisp->C compiler available from ISST. Eu2C runs on
top of Franz Allegro CL 4.1 and compiles EuLisp-Modules into C source
code which then must be compiled by an ANSI C-compiler (currently only
GCC is supported). The Eu2C implementation provides EuLisp 0.99
level-0, with the exception of concurrency. Future versions of Eu2C
will include a C interface and straight module compilation. The
development of Apply/Eu2C was supported by the German Federal Ministry
for Research and Technology (BMFT) within the joint project APPLY. The
partners of this project are the Christian Albrechts University Kiel,
the Fraunhofer Institute for Software Engineering and Systems
Engineering (ISST), the German National Research Center for Computer
Science(GMD), and VW-Gedas. The main goal of APPLY project is to
develop a Lisp system which consistently supports the efficient
execution of applications and simplifies their integration into
current software environments. Towards that end, ISST is
investigating strategies for the compilation of EuLisp-Modules into
efficient stand-alone C-Programs. The Eu2C compiler is the first step
along this path. Eu2C is available by anonymous ftp from
ftp.isst.fhg.de:/APPLY/Distribution/. Please send bug reports and
comments to ulrich....@isst.fhg.de or ingo...@isst.fhg.de. If
you're using Eu2C, please send them a message with "Apply/Eu2C" in the
subject line to be added to the mailing list of users.

More information about EuLisp may be found in
Lisp and Symbolic Computation 6(1-2), August 1993
which was devoted to EuLisp.

JLISP:
jlisp is a lisp interpreter designed to be used as an embedded
interpreter and is easily interfaced with C/C++. jlisp is easily
extended. It is available by anonymous ftp from
ftp.ee.rochester.edu:/pub/weisberg/jlisp-1.03.tar.gz
For more information, write to Jeff Weisberg <weis...@ee.rochester.edu>

----------------------------------------------------------------
Subject: [4-5] Commercial Implementations of Other Lisp Dialects

Franz Lisp 2.0 runs on the Apple Macintosh, requiring 1mb RAM for the
interpreter ($99) and 2.5mb RAM for the compiler ($199). Student prices
are $60 for the interpreter and $110 for the interpreter and compiler.
Includes editor and language reference manual. Complete sources are
available for $649. The ALJABR symbolic mathematics system costs $249.
Write to: Fort Pond Research, 15 Fort Pond Road, Acton, MA 01720,
call 1-508-263-9692, or send mail to or...@fpr.com.

Le-Lisp includes a compiler, color and graphic output, a debugger, a
pretty printer, performance analysis tools, tracing, and incremental
execution. Le-Lisp currently runs on Unix, VMS, and Windows 3.1. Note
that Le-Lisp is neither Common Lisp nor Scheme. Le-Lisp was
originally developed in 1980 at Inria, the French national computer
science laboratory, by a team led by Jerome Chailloux for work on VLSI
design. It was based on several earlier Lisps in the MacLisp family,
but was not directly derived from MacLisp. Le-Lisp enjoyed a large
success in the French academic world because it was small, fast, and
portable, being based on a abstract machine language called LLM3. In
1983, for example, Le-Lisp ran on Z-80 machines running CP/M. In 1987,
Ilog was formed as an offshoot of Inria to commercialize and improve
Le-Lisp and several products which had been developed with it,
including a portable graphic interface system and an expert system
shell. Since then, Ilog has continued to grow and expand the use of
Le-Lisp into industrial markets around the world. Ilog is the largest
European Lisp vendor, and continues to develop new products and
markets for Lisp. In 1992, Ilog released the next major version of
Le-Lisp, Le-Lisp version 16. This version modernizes Le-Lisp for use
in the industrial world, adding lexical closures and
special-form-based semantics for static analysis, a new object system
based on the EuLisp object system (TELOS), an enhanced module system
for application production, a conservative GC for integration with C
and C++, and compilation to C for portability and efficiency on a wide
range of processors. For pricing and other information, write to
ILOG, 2 Avenue Gallieni, BP 85, 94253 Gentilly Cedex, France, call
33-1-46-63-66-66, fax 33-1-46-63-15-82, or send email to Jerome
Chailloux (chai...@ilog.fr).

CLISP v6.89 is a library of functions which extends the C programming
language to include some of the functionality of Lisp. Requires
ANSI C. Costs $349 with no run-time fee.
Write to Drasch Computer Software, 187 Slade Road, Ashford, CT 06278,
or call or fax 203-429-3817.

Two references in Dr. Dobb's journal on Lisp-style libraries for C
are: Douglas Chubb, "An Improved Lisp-Style Library for C", Dr. Dobb's
Jounral #192, September 1992, and Daniel Ozick, "A Lisp-Style Library
for C", Dr. Dobb's Journal #179:36-48, August 1991. Source is available by
ftp from various archives, including wuarchive.wustl.edu (MSDOSDDJMAG),
or ftp.mv.com:/pub/ddj, or the DDJ Forum on Compuserve.

Lily (LIsp LibrarY) is a C++ class library that lets C++ programmers
write LISP-style code. Includes some example programs from Winston's
Lisp book recoded in Lily. Most or all of chapters 17 (Symbolic
Pattern Matching), 18 (Expert Problem Solving), and 23 (Lisp in Lisp)
are implemented in the examples. Lily works with GNU G++ (2.4.5) and
Turbo C++ for Windows. Lily is available by anonymous ftp from
sunsite.unc.edu:/pub/packages/development/libraries/ [152.2.22.81]
as lily-0.1.tar.gz. This site is fairly slow; a copy is available from
the Lisp Utilities collection. For more information, contact
Roger Sheldon <she...@kong.gsfc.nasa.gov>.

Other Lisps for PCs include:

o UO-LISP from Calcode Systems, e-mail:calcode!ma...@rand.org
It comes complete with compiler and interpreter, and is optimised for
large programs. It is Standard LISP, not Common LISP. They are based
in Amoroso Place in Venice, CA.

o LISP/88 v1.0. Gotten from Norell Data Systems, 3400 Wilshire Blvd,
Los Angeles, CA 90010, in 1983. They may or may not still exist.

o IQLisp. Not a Common Lisp but still very good for PCs - you can
actually get a lot done in 640K. The lisp itself runs in less than
128K and every cons cell takes only 6 bytes. Unfortunately that
makes the 640K (maybe a little more, but certainly no more than 1M)
limit really hard. It has a byte code compiler which costs extra.
This has support for all sorts of PC specific things.
It costs $175 w/o compiler, $275 with.
Write to: Integral Quality, Box 31970, Seattle, WA 98103,
call Bob Rorschach, (206) 527-2918 or email r...@franz.com.

----------------------------------------------------------------
Subject: [4-6] What is Dylan?

Dylan is a new Object-Oriented Dynamic Language (OODL), based on
Scheme, CLOS, and Smalltalk. The purpose of the language is to retain
the benefits of OODLs and also allow efficient application delivery.
The design stressed keeping Dylan small and consistent, while allowing
a high degree of expressiveness. Dylan is consistently object-oriented;
it is not a procedural language with an object-oriented extension. A
manual/specification for the language is available from Apple Computer.
Send email to dylan-manu...@cambridge.apple.com or write to
Apple Computer, 1 Main Street, Cambridge, MA 02142. Include your
complete address and also a phone number (the phone number is
especially important for anyone outside the US). Comments on Dylan can
be sent to the internet mail address dylan-c...@cambridge.apple.com.

The mailing list info-...@cambridge.apple.com is for any and all
discussions of Dylan, including language design issues, implementation
issues, marketing issues, syntax issues, etc. The mailing list
announc...@cambridge.apple.com is for major announcements about
Dylan, such as the availability of new implementations, new versions
of the manual, etc. This mailing list should be *much* lower volume
than info-dylan. Everything sent to this list is also sent to
info-dylan. The newsgroup comp.lang.dylan is gatewayed to the
info-dylan mailing list.

Send mail to the -request version of the list to be added to it.
You can also send an email message to majo...@cambridge.apple.com
with "subscribe info-dylan" or "unsubscribe info-dylan" in the body,
and likewise for the other lists, mutatis mutandis.

Apple hasn't announced plans to release Dylan as a product.

The directory cambridge.apple.com:pub/dylan contains some documents
pertaining to Dylan, including a FAQ list.

======== THOMAS ========

Thomas is a compiler for a language that is compatible with the
language described in the book "Dylan(TM) an object-oriented dynamic
language" by Apple Computer Eastern Research and Technology, April
1992. Thomas was written at Digital Equipment Corporation's Cambridge
Research Laboratory. Thomas is NOT Dylan(TM) and was built with no
direct input, aid, assistance or discussion with Apple.

Thomas is available to the public by anonymous ftp at
crl.dec.com:/pub/DEC/Thomas
gatekeeper.pa.dec.com:/pub/DEC/Thomas
swiss-ftp.ai.mit.edu:/archive/Thomas

The Thomas system is written in Scheme and runs under MIT's CScheme,
DEC's Scheme->C, and Marc Feeley's Gambit. It can run on a wide range
of machines including the Macintosh, PC compatibles, Vax, MIPS, Alpha,
and 680x0. Thomas generates IEEE compatible Scheme code.

A ready-made version of Thomas 1.1 interpreter built upon MacGambit
2.0 as a double-clickable Macintosh application is available by
anonymous ftp from cambridge.apple.com:/pub/dylan/gambit/ as
the file thomas-1.1-interp.hqx.

For discussion of Thomas, send a note to
info-thom...@crl.dec.com
to be added to the mailing list.

DEC CRL's goals in building Thomas were to learn about Dylan by
building an implementation, and to build a system they could use to
write small Dylan programs. As such, Thomas has no optimizations of
any kind and does not perform well.

The original development team consisted of:
Matt Birkholz (Birk...@crl.dec.com)
Jim Miller (JMi...@crl.dec.com)
Ron Weiss (RWe...@crl.dec.com)
In addition, Joel Bartlett (Bart...@wrl.dec.com), Marc Feeley
(Fee...@iro.umontreal.ca), Guillermo Rozas (Ji...@zurich.ai.mit.edu)
and Ralph Swick (Sw...@crl.dec.com) contributed time and energy to the
initial release.

======== Marlais ========

Marlais is a simple interpreter for a language strongly resembling
Dylan. It is available by anonymous ftp from
ftp.cis.ufl.edu:/pub/Marlais
cambridge.apple.com:/pub/dylan/Marlais
travis.csd.harris.com:/pub/
Currently runs on i386 and i486 (OS/2 or Linux), IBM PC/RT, IBM
RS/6000, HP9000/300, HP9000/700, DECstations (Ultrix), SGI (IRIX),
Sony News, Apple Macintosh (A/UX), Sun3, Sun4, Vax (4.3bsd and
ultrix), m88k (Harris Nighthawk running CX/UX), MIPS M/120, Sequent
Symmetry, Encore Multimax. Contact Joe Wilson <j...@cis.ufl.edu> or
Brent Benson <br...@ssd.csd.harris.com> for more information.

================

The Gwydion Project at CMU is developing an innovative new software
development environment based on the Dylan language (and, in the
process, will make available a very high-quality implementation of
Dylan). This project includes many of the same people responsible for
CMU Common Lisp. (In Welsh mythology, Gwydion is the uncle of Dylan
and nephew of Math.) A Mosaic page describing the project goals, how
they fit in with the Dylan language, and copies of the Dylan language
manual and latest approved design notes is available as
http://legend.gwydion.cs.cmu.edu/gwydion/
For more information, write to gwydio...@cs.cmu.edu.

Mindy (Mindy Is Not Dylan Yet) is a Dylan-like language from the
Gwydion Project. Mindy is intended for use as a development tool while
work on the "real" high-performance Dylan implementation progresses.
Mindy is available by anonymouse ftp from legend.gwydion.cs.cmu.edu as
the file /afs/cs.cmu.edu/project/gwydion/release/mindy.tar.gz.
Send bug reports to gwydio...@cs.cmu.edu; support will be minimal.

----------------------------------------------------------------
Subject: [4-7] What is Pearl Common Lisp?

When Apple Computer acquired Coral Software in January 1989, they
re-released Coral's Allegro Common Lisp and its optional modules as
Macintosh Allegro Common Lisp (now just Macintosh Common Lisp).
Coral's other product, Pearl Lisp, was discontinued at that time.
Pearl Lisp provides a subset of the functionality of MACL 1.3 and is
not even fully CLtL1-compatible (e.g., the implementation of defstruct is
different).

Despite rumors to the contrary, Pearl Lisp is not and never was public
domain. Nevertheless, Pearl Lisp and its documentation were placed in
the "Moof:Goodies:Pearl Lisp" folder on the first pressing of "Phil
and Dave's Excellent CD", the precursor to the current Apple
Developer's CD-ROM series. Apple removed Pearl from later versions of
the developer CD-ROM distribution because of complaints from other
Lisp vendors. If you own a copy of Pearl Lisp or a copy of this
CD-ROM, you can make it runnable under System 7 with some slight
modifications using ResEdit. To repeat, Pearl Lisp is NOT public
domain, so you must own a copy to use it.

To make it runnable, one needs to use ResEdit to make changes to the
BNDL and FREF resources so that it will connect to its icons properly.
This will make it respond to double-clicks in the normal manner and
make it be properly linked to its files. Detailed instructions for
modifying Pearl Lisp using ResEdit may be obtained from the Lisp
Utilities Repository by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/lang/lisp/impl/pearl/
as the file pearl.txt.

After you've made the changes, it will run under System 7 on 68000s
and 68030s if you turn off 32-bit addressing. It seems to bomb on a
Quadra.

If you need a more powerful Lisp or one that is compatible with the
standard for Common Lisp, consider purchasing Macintosh Common Lisp.

----------------------------------------------------------------
Subject: [4-9] What Lisp-related discussion groups and mailing lists exist?

Before posting to any discussion group, please read the rest
of this FAQ, to make sure your question isn't already answered.

Scheme-related mailing lists and newsgroups are listed in the Scheme
FAQ, and AI-related mailing lists and newsgroups are listed in the AI FAQ.

First of all, there are several Lisp-related newsgroups:
comp.lang.lisp General Lisp-related discussions.
See below for archive information.

comp.lang.clos Discussion related to CLOS, PCL, and
object-oriented programming in Lisp.
Gatewayed to commo...@cis.ohio-state.edu.
(or equivalently, comp.la...@cis.ohio-state.edu)
See below for info on the newsgroup's archives.

comp.org.lisp-users Discussions related to Association of Lisp Users.
Gatewayed to the ALU mailing list. This is an
organizational mailing list/newsgroup, not a
technical forum.

comp.std.lisp For discussion of emerging standards for
the Lisp language, including "de facto" standards.
Moderated by Brad Miller <mil...@cs.rochester.edu>.
Submissions should be sent to
lisp-st...@cs.rochester.edu
Archived on
ftp.cs.rochester.edu:/pub/archives/lisp-standards/
Gatewayed to a mailing list (send mail to
lisp-standa...@cs.rochester.edu to join).

comp.lang.lisp.mcl Discussions related to Macintosh
Common Lisp. This newsgroup is gatewayed
to the info...@digitool.com
mailing list and archived on digitool.com.

comp.lang.lisp.franz Discussion of Franz Lisp, a dialect of Lisp.
(Note: *not* Franz Inc's Allegro.)

comp.lang.lisp.x Discussion of XLISP, a dialect of Lisp, and XScheme.

comp.sys.xerox Discussions related to using Medley (name exists
for historical reasons, and is likely to change
soon). Gatewayed to the info-1100 mailing list.

comp.sys.ti.explorer TI Explorers Lisp machines.

comp.windows.garnet Garnet, a Lisp-based GUI.

comp.ai and subgroups General AI-related dicusssion.

The newsgroup comp.lang.lisp is archived on
ftp.gmd.de:/usenet/comp.lang.lisp/ [129.26.8.84]
by month, from 1989 onward. Individual files are in rnews
format. (They contain articles prefixed by a header line "#! rnews
<nchars> archive" where <nchars> is the number of characters in the
article following the header. That format is convenient for various
news processing programs (e.g. relaynews) and is rather easy to
process from a lisp program too.) A copy of the GMD archives for
comp.lang.lisp is available on cambridge.apple.com:/pub/comp.lang.lisp/.

We list several mailing lists below. In general, to be added to
a mailing list, send mail to the "-request" version of the address.
This avoids flooding the mailing list with annoying and trivial
administrative requests. [To subscribe to info-dylan, or
other mailing lists based at cambridge.apple.com, send a message to
majo...@cambridge.apple.com with "subscribe <list_name>" in the
message body. Likewise use "unsubscribe <list_name>" to cancel your
subscription and "help" to get help.]

General Lisp Mailing Lists:

commo...@ai.sri.com Technical discussion of Common Lisp.
lisp-ut...@cs.cmu.edu Low volume moderated mailing list
associated with the Lisp Utilities
Repository at CMU. (Also known as
cl-uti...@cs.cmu.edu)
lisp...@think.com A mailing list concerning the contents
of this FAQ posting only.

a...@freud.arc.nasa.gov Forum for use by members (current
and prospective) of the Association
of Lisp Users. It is bidirectionally
gatewayed into the newsgroup
comp.org.lisp-users. This is an
organizational mailing list,
not a technical forum.

Particular Flavors of Lisp:

info...@digitool.com Macintosh Common Lisp. Gatewayed
to the comp.lang.lisp.mcl newsgroup.
info-mc...@digitool.com Automatically generated digest format
version of the info-mcl mailing list.

cmucl...@cs.cmu.edu CMU Common Lisp bug reports

sl...@ai.sri.com Symbolics Lisp Users Group
Archived on warbucks.ai.sri.com and
ftp.ai.sri.com:/pub/slug.

alleg...@cs.berkeley.edu Franz Allegro Common Lisp

amiga...@contessa.phone.net Lisp on the Amiga

k...@cli.com Kyoto Common Lisp
Archived in ftp.cli.com:/pub/kcl/kcl-mail-archive
k...@rascal.ics.utexas.edu Forwards to k...@cli.com.

lisp...@harlequin.com LispWorks

clisp...@ma2s2.mathematik.uni-karlsruhe.de CLISP
To subscribe, send mail to list...@ma2s2.mathematik.uni-karlsruhe.de
with "subscribe clisp-list <your full name>" in the message body.
Use "help" to get a help message back and "unsubscribe clisp-list"
to remove yourself from the list.

info-ti-...@sumex-aim.stanford.edu TI Explorer Lisp Machine
bug-ti-...@sumex-aim.stanford.edu TI Explorer Lisp Machine

info...@cis.ohio-state.edu Xerox/Envos Lisp machine environment,
InterLisp-D, and Medley. Gatewayed to
the newsgroup comp.sys.xerox. Will be
moving to info...@anzus.com.

franz-...@cs.berkeley.edu The Franz Lisp Language.
franz-c...@cs.berkeley.edu Maintainers of Franz Lisp.

Lisp Windowing Systems:

cl-wi...@ai.sri.com Common Lisp Window System Discussions.
bug...@expo.lcs.mit.edu CLX (Common Lisp X Windows)
cl...@bbn.com Common Lisp Interface Manager
clue-...@dsg.csc.ti.com Common Lisp User-Interface Environment
express...@cs.cmu.edu Express Windows
garnet...@cs.cmu.edu Garnet (send mail to gar...@cs.cmu.edu
or garnet-...@cs.cmu.edu to be added)
gina-...@gmd.de GINA and CLM
lisp...@harlequin.co.uk LispWorks
win...@netcom.com WINTERP (OSF/Motif Widget INTERPreter)
yy...@csrl.aoyama.ac.jp YYonX

Lisp Object-Oriented Programming:

Commo...@cis.ohio-state.edu (same as comp.la...@cis.ohio-state.edu)
Discussion related to CLOS, PCL, and object-oriented programming
in Lisp. The name is in honor of the first freely-available
implementation of CLOS, Xerox PARC's Portable Common Loops, and
was originally the mailing list for discussing that
implementation. Now gatewayed to the comp.lang.clos newsgroup.
The mailing list is archived on nervous.cis.ohio-state.edu in
the directory pub/lispusers/commonloops.
The CLOS code repository is in pub/lispusers/clos.

Miscellaneous:

stat-lisp-n...@umnstat.stat.umn.edu
Use of Lisp and Lisp-based systems in statistics.
Lisp...@cis.ohio-state.edu
Job offers requiring a knowledge of Lisp. See [1-7].

Electronic Journals:

Electronic Journal of Functional and Logic Programming (EJFLP)

EJFLP is a refereed journal that will be distributed for free via e-mail.
The aim of EJFLP is to create a new medium for research investigating the
integration of the functional, logic and constraint programming paradigms.

For instructions on submitting a paper, send an empty mail message with
Subject: Help
to
submi...@ls5.informatik.uni-dortmund.de.
You will receive an acknowledgment of your submission within a few hours.

To subscribe to the journal, send an empty mail message to
subscr...@ls5.informatik.uni-dortmund.de
You will receive an acknowledgment of your subscription within
a few days.

If there are any problems with the mail-server, send mail to
ejfl...@ls5.informatik.uni-dortmund.de.

The editorial board is: Rita Loogen (RWTH Aachen), Herbert Kuchen (RWTH
Aachen), Michael Hanus (MPI-Saarbruecken), Manuel MT Chakravarty (TU
Berlin), Martin Koehler (Imperial College London), Yike Guo (Imperial
College London), Mario Rodriguez-Artalejo (Univ. Madrid), Andy Krall
(TU Wien), Andy Mueck (LMU Muenchen), Tetsuo Ida (Univ. Tsukuba,
Japan), Hendrik C.R. Lock (IBM Heidelberg), Andreas Hallmann (Univ.
Dortmund), Peter Padawitz (Univ. Dortmund), Christoph Brzoska (Univ.
Karlsruhe).

----------------------------------------------------------------
Subject: [4-10] Where can I get a copy of the ANSI Common Lisp standard?
What is ISO Lisp?

As of December 8, 1994, Common Lisp is now an official ANSI Standard:
ANSI X3.226:1994 American National Standard for Programming Language
Common LISP (X3J13).

Copies of the ANSI/X3.226 standard may be purchased from the
American National Standards Institute
11 West 42nd Street
New York, NY 10036
For more information, visit the ANSI home page at http://www.ansi.org/

A web version of the ANSI Common Lisp standard is not available. The
official ANSI standard is available only in hardcopy form.

However, Kent Pitman (k...@harlequin.com) of Harlequin, Inc. has, with
permission from ANSI and X3, written an HTML document that is based on
ANSI standard for Common Lisp. This version is not a definitive
reference, but is much more practical for most casual browsing. It is
also cross-referenced against some design documents. The document is
available for online browsing at
http://www.harlequin.com/books/HyperSpec/FrontMatter/index.html
Subject to some legal restrictions, you can download a copy for your
own use and get much better performance. Visit
http://www.harlequin.com/books/HyperSpec/
for information on downloading your own copy. The .tar.gz file is
just a little over 2MB, and unpacks into a set of files that is just
a little over 15MB.

Copies of the TeX sources and Unix-compressed DVI files for the *draft*
version of the standard may be obtained by anonymous FTP from
parcftp.xerox.com:/pub/cl/ [13.1.64.94]
The files corresponding to the second Public Review of Common Lisp are
in the directory /pub/cl/dpANS2/*. These files correspond to draft
14.10, also known as document X3J13/93-102, which was forwarded by
X3J13 to X3 in October, 1993. (The files from the first draft are in
the directory /pub/cl/dpANS1/*.) The draft is about 1500 pages long.
The file Reviewer-Notes.text should be read before ftping the other files.

For more information, write to X3 Secretariat, Attn: Lynn Barra, 1250
Eye Street NW, Suite 200, Washington, DC 20005-3922, call
202-626-5738, fax 202-638-4922, or send email to x3...@itic.nw.dc.us.

The international working group on Lisp is ISO/IEC JTC1/SC22/WG16.
Pierre Parquier (parq...@ilog.fr) is the WG16 Convenor. Kent Pitman
(k...@harlequin.com) is the International Representative of X3J13 to
WG16 and is also Project Editor for WG16. WG16 is working on the
design of a dialect of Lisp called ISLISP (which is neither a subset
nor a superset of Common Lisp). A Committee Draft (CD) of the ISLISP
specification has been registered by WG16 as ``CD13816: Information
Technology - Programming languages, their environments and system
software interfaces - Programming language ISLISP.'' The CD, which
WG16 internally refers to as version 15.6, is available by anonymous
FTP from
ma2s2.mathematik.uni-karlsruhe.de:/pub/lisp/islisp/ [129.13.115.2]
in the directory islisp-15.6/.
The draft has passed its first CD letter ballot. A second WG16 letter
ballot will be held to determine whether this Committee Draft will
become a Draft International Standard (DIS); this is expected to
happen by April 1996.

----------------------------------------------------------------

;;; *EOF*

Mark Kantrowitz

unread,

Aug 13, 1997, 3:00:00 AM8/13/97

Archive-name: lisp-faq/part5
Last-Modified: Thu Feb 13 09:10:34 1997 by Mark Kantrowitz
Version: 1.56

Maintainer: Mark Kantrowitz and Barry Margolin <ai+li...@cs.cmu.edu>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html

Size: 28488 bytes, 597 lines

;;; Written by Mark Kantrowitz and Barry Margolin
;;; lisp_5.faq

This post contains Part 5 of the Lisp FAQ. It is cross-posted to the
newsgroup comp.lang.clos because it contains material of interest to
people concerned with CLOS, PCL and object-oriented programming in
Lisp. The other parts of the Lisp FAQ are posted only to the
newsgroups comp.lang.lisp and news.answers.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

CLOS/PCL Questions (Part 5):

[5-0] What is CLOS (PCL) and where can I get it?
How do you pronounce CLOS? What is the Meta-Object Protocol (MOP)?
[5-1] What documentation is available about object-oriented
programming in Lisp?
[5-2] How do I write a function that can access defstruct slots by
name? I would like to write something like
(STRUCTURE-SLOT <object> '<slot-name>).
[5-3] How can I list all the CLOS instances in a class?
[5-4] How can I store data and CLOS instances (with possibly circular
references) on disk so that they may be retrieved at some later
time? (Persistent Object Storage)
[5-5] Given the name of a class, how can I get the names of its slots?
[5-6] Free CLOS software.
[5-7] Common CLOS Blunders

Search for \[#\] to get to question number # quickly.

In general, questions about object oriented programming in Lisp,
especially questions about using CLOS or compiling PCL, should be
directed to the newsgroup comp.lang.clos.

The comp.lang.clos newsgroup is archived in
ftp.cs.cmu.edu:/user/ai/pubs/news/comp.lang.clos/
on a weekly basis.

----------------------------------------------------------------
Subject: [5-0] What is CLOS (PCL) and where can I get it?
How do you pronounce CLOS?

CLOS (Common Lisp Object System) is the object-oriented programming
standard for Common Lisp. It is the successor to Symbolics FLAVORS and
Xerox LOOPS (Lisp Object Oriented Programming System). The acronym
CLOS is pronouned either as "See-Loss" or "Closs" ("Claws"), depending
on taste. PCL (Portable Common Loops) is a portable CLOS
implementation, and is available by anonymous ftp from
parcftp.xerox.com:/pub/pcl/ [13.1.64.94]
Also in the same directory are sources for CLX R5 and an inspecter.

Most Common Lisp implementations now include their own CLOS
implementations. Common Lisp implementations with native CLOS include:
MCL, {A}KCL, Allegro CL (including Allegro CL\PC), Ibuki, Lucid,
Medley, Symbolics Genera, CLOE, and Harlequin LispWorks. CMU CL uses a
customized version of PCL as their CLOS. However, not all native CLOS
implementations have as detailed a meta-object protocol as PCL. For
example, MCL 2.0 users sometimes use the july-1d version of PCL
instead of the native CLOS for precisely this reason.

The book ``The Art of the Metaobject Protocol'' (see below) includes
the CLOS Metaobject Protocol specification as chapters 5 and 6. The
sources for the MOP spec itself are available from
parcftp.xerox.com:/pub/pcl/mop/ [13.1.64.94]
as the file spec.tar.Z, but this is no substitute for buying the
book, since the book contains a lot of useful explanatory material
beyond the spec. The Closette files related to the book are also
available from parcftp as the file closette.lisp.

The CLOS code repository is available by anonymous ftp to
nervous.cis.ohio-state.edu:/pub/lispusers/clos/ [128.146.61.200]
If you've got code you'd like to add to the repository, send mail to
Arun Welch, commonloo...@cis.ohio-state.edu.

----------------------------------------------------------------
Subject: [5-1] What documentation is available about object-oriented
programming in Lisp?

Books about object-oriented programming in Lisp include:

1. dpANS CL describes the entire Common Lisp language, which includes the
CLOS standard. Informally, CLtL2 can also be used to learn about CLOS,
but please remember that CLtL2 is not an official X3J13 committee
document. (The presentation of CLtL2 differs from that of the draft
proposed standard, and some matters of fact have changed in the proposed
standard since the publication of CLtL2.)

2. Sonya E. Keene
"Object-Oriented Programming in Common Lisp:
A Programmer's Guide to CLOS"
Addison-Wesley (Reading, MA), 1989. 266 pages. ISBN 0-201-17589-4.
Tutorial introduction to CLOS with many examples and
a lot of good advice for designing large programs using CLOS.

3. Jo A. Lawless and Molly M. Miller.
"Understanding CLOS: the Common Lisp Object System"
Digital Press, 1991. 192 pages.

4. Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow.
"The Art of the Metaobject Protocol"
MIT Press, 1991. 335 pages. ISBN 0-262-61074-4, $34.95.
The first part of the book presents a model CLOS implementation,
introduces the basic principles of metaobject protocols, and
works through the key elements of the CLOS Metaobject Protocol.
The second half is the detailed specification of the CLOS
Metaobject Protocol. A simple working interpreter suitable
for experimentation is contained in an appendix.

5. Robert R. Kessler and Amy R. Petajan.
"LISP, Objects, and Symbolic Programming"
Scott, Foresman and Company (Glenview, IL), 1988. 644 pages.
Includes a small Lisp compiler.

6. A short introduction to CLOS written by Jeff Dalton of the
University of Edinburgh <J.Da...@ed.ac.uk> is available by
anonymous ftp from
ftp.aiai.ed.ac.uk:/pub/packages/lisp/random/
as the file clos-guide.

7. Andreas Paepcke, editor.
"Object-Oriented Programming: The CLOS Perspective"
MIT Press, 1993. 400 pages, ISBN 0-262-16136-2 ($40).
This book is a collection of essays on the following topics:
- Description of CLOS and its design philosophy.
- The Metaobject Protocol and its use.
- Comparison of CLOS with Smalltalk, Eiffel, Sather, and C++.
- CLOS Uses and Methodology. Descriptions of two large CLOS
applications (Sun's LispView and a hybrid knowledge
representation tool) and an approach to documenting
object-oriented protocols (similar to that of AMOP).
- Implementation details. Descriptions of TI CLOS for the
Explorer and PCL's method dispatch mechanism.

----------------------------------------------------------------
Subject: [5-2] How can I write a function that can access defstruct slots
by name? I would like to write something like
(STRUCTURE-SLOT <object> '<slot-name>).

There is currently no portable, built-in way to access structure slots
given only the name. If your Common Lisp includes an implementation
of CLOS that supports the meta-object protocol specified in the
original X3J13 draft spec (document X3J13/88-003), then it probably will
allow (SLOT-VALUE <object> '<slot-name>); however, not all
implementations of CLOS currently provide this. Lacking this, some
implementations may provide implementation-dependent functions that
allow access to structure slots by name; note that this may cause
saved images to be larger, as some implementations normally open-code
structure accessors and discard slot name information.

While it is not possible to write a fully general STRUCTURE-SLOT function,
it is not very difficult to write version that handles specific structure
types. For instance, after defining:

(defstruct spaceship name captain position velocity)

one may then define:

(defun spaceship-slot (spaceship slot-name)
(ecase slot-name
(name (spaceship-name spaceship))
(captain (spaceship-captain spaceship))
(position (spaceship-position spaceship))
(velocity (spaceship-velocity spaceship))))

or using CLOS (generic functions):

(defgeneric spaceship-slot (spaceship slot-name)
(:method ((x spaceship) (slot (eql :name)))
(spaceship-name x))
(:method ((x spaceship) (slot (eql :captain)))
(spaceship-captain x))
(:method ((x spaceship) (slot (eql :position)))
(spaceship-position x))
(:method ((x spaceship) (slot (eql :velocity)))
(spaceship-velocity x)))

Another popular way to define this is:

(defun spaceship-slot (spaceship slot-name)
(funcall (symbol-function
(find-symbol (format nil "SPACESHIP-~A" slot-name)
#.(package-name *package*)))
spaceship))

I personally recommend the first version. It is likely to be much faster
and more memory efficient than the second version. It's also easy to get
the second one wrong; many people forget to specify the package argument to
FIND-SYMBOL, which can cause incorrect results when the package at run time
is different from the one at compile time. Even my version assumes that
SPACESHIP-SLOT is being defined in a file that is in the same package as
the one containing the structure definition; if this isn't the case,
#.(PACKAGE-NAME *PACKAGE*) should be replaced by a string naming the
correct package.

Another workaround is to define a MY-DEFSTRUCT macro that parses the
defstruct arguments and expands into a call to DEFSTRUCT along with a
definition of the runtime slot-accessor function.

Some non-portable techniques include the use of SYSTEM:STRUCTURE-REF
in Lucid (LCL:STRUCTURE-REF in earlier versions of Lucid) and
EXCL:STRUCTURE-REF in Allegro.
----------------------------------------------------------------
Subject: [5-3] How can I list all the CLOS instances in a class?

There is no built-in way to enumerate the instances of a class. If you are
only interested in listing the instances of classes that you have defined,
it is not very difficult to implement it as part of your class definition.
Add a shared slot, e.g. ALL-INSTANCES, with an initial value of NIL, to the
class definition. Then write an after-method on INITIALIZE-INSTANCE for
this class, which pushes the instance being initialized onto ALL-INSTANCES.
Note that this must be done separately for each class that wants to maintain
such a list; it can't be encapsulated in a mixin class, because all its
dependent classes would share the same ALL-INSTANCES slot. A compromise
would be to use a mixin to define the INITIALIZE-INSTANCE after-method (and
any other general-purpose methods that use the slot), but not the shared
slot; it would be up to the descendant classes to define the slot at the
level of the class hierarchy that is appropriate. You could also try
defining the classes that need instance-recording as instances of a
metaclass that holds the instance registry on the class object. The
recording behavior could then be built-in to an after method on
initialize-instance for the root class of the metaclass, or even
allocate-instance. To allow for garbage collection of old instances,
you will also need to define a generic function to remove the recorded
instances from the list of instances.
----------------------------------------------------------------
Subject: [5-4] How can I store data and CLOS instances (with possibly
circular references) on disk so that they may be
retrieved at some later time? (Persistent Object Storage)

There are two approaches to CLOS object persistence. The first uses
regular CLOS facilities in concert with a standard file system. The
second uses a more sophisticated storage facility, such as a database.
The first solution provides just the persistence, and usually cannot
retrieve only some of the objects from disc. The second goes beyond this
by providing some or all of the facilities typically associated with
databases: transaction management, concurrency control, queries,
selective object materialization, etc. Below, the two solutions are
addressed in turn.

There are two main techniques for the file system solution. The first
involves using #. to compile the data into a file. The second
produces an ASCII representation which, when evaluated, will reproduce
an equivalent set of data.

If the data you wish to save is stored in the variable *hash-table*,
create a file containing just the lines
(in-package "YOUR-PACKAGE")
(setq *hash-table* '#.*hash-table*)
and compile it. The #. macro performs read-time evaluation of the
expression following the dot, and so this compiles the data into the
file. You may then load the file to restore the data. However, the
resulting binary file is not portable between Lisp implementations,
and sometimes not even for the same Lisp on different platforms. Also,
some Lisps will treat the data as constant, and place it on pages in
memory that are marked read-only (after it is loaded). If one tries to
later modify the data, these Lisps will signal an error. Lucid CL only
puts such constants in a read-only area when they appear inside
functions, so this should be safe. Allegro CL doesn't seem to complain
about modification if the data is a cons. DEC's VAXLisp, however, has
problems with #. circular structures in .fas files. MCL seems to work
well with using #. to save data (and even functions) to a file.

The other technique is to produce an ASCII representation of the Lisp
objects which may then be saved to a file. To reproduce the data, one
can load (or compile and load) the file. This technique is portable
between different Lisps and platforms. Unfortunately, the resulting
data is not necessarily EQ to the original. Kerry Koitzsch's
save-object.lisp package is included in the Lisp Utilities Repository,
ftp.cs.cmu.edu:/user/ai/lang/lisp/code/ext/save_obj/
The Lisp Utilities Repository is described in detail in the answer to
question [6-1].

See also the discussion of MAKE-LOAD-FORM and MAKE-LOAD-FORM-SAVING-SLOTS
in CLtL2.

Here are some solutions to object persistence that use databases instead
of file systems.

Free Persistent Object Storage systems include:

WOOD (William's Object Oriented Database) is a simple persistent
object store for MCL 2.0.x & MCL 3.0, written by Bill St. Clair
<bi...@cambridge.apple.com>. Its goal is to provide a way to
save/restore Lisp objects to/from disk. It is available by anonymous
ftp from from ftp://ftp.digitool.com:/pub/mcl2/contrib/wood/.
Send bug reports to bug-...@cambridge.apple.com. To be added to the
mailing list, send mail to info-woo...@cambridge.apple.com.

PCLOS is a persistent object store for CLOS that was implemented using
CLOS's metaobject protocol. It allowed multiple different storage
facilities to be used. The benefit of this approach is it lets you use
different storage facilities depending on your needs, ranging from a
full-blown database with concurrency control and recovery to a very
fast store that trades speed for functionality. For example, an
in-memory store that saves its state to disk periodically can be much
faster than traditional databases, but risks loss of data due to
crashes. Unfortunately, PCLOS was built on a very old version of CLOS,
so it is unusable in its current form, and there are no plans to
update it. The introductory MOP chapter in the book "Object-Oriented
Programming: The CLOS Perspective" (see [5-1] above) explains how to
do the rewrite in principle and shows how the CLOS MOP was used for
object persistence in PCLOS. See also
1. Andreas Paepcke, "PCLOS: A Flexible Implementation of CLOS
Persistence", in Proceedings of ECOOP-88, S. Gjessing and K.
Nygaard, editors, Lecture Notes in Computer Science, Springer
Verlag, pages 374-389, 1988. [Explains the PCLOS architecture.]
2. Andreas Paepcke, "PCLOS: A Critical Review", in OOPSLA-89, 1989.
[Uses PCLOS as a roadmap through the issues of object persistence.]
3. Andreas Paepcke, "PCLOS Reference Manual", Hewlett-Packard
Laboratories, December, 1991.
For more information about PCLOS, write to Andreas Paepcke
<pae...@parc.xerox.com>.

GBB (see [6-3]) is a blackboard architecture with persistence of a
sort. Every object in GBB is held in RAM, and there are dump and
restore functions. It handles distributed object delivery and
function-call triggering of receiving processes.

Commercial Persistent Object Storage systems include:

AllegroStore is a high-performance object-oriented database management
system from Franz. It offers Allegro CL users persistent object
storage with very fast retrieval and update of object data. It
provides query processing and transaction-based operation. Built on a
multi-client, multi-server architecture, it permits concurrent access
over a network to objects by multiple independent processes. It uses
the ObjectStore ODBMS from Object Design Inc, and thus has both Lisp
and C interfaces and is also very fast. The CLOS interface is based
on MOP, with dynamic class/schema modification and redefinition.
AllegroStore can handle large-scale applications with minimal impact
on performance. It uses page-faulting and page-locking mechanisms
instead of object locking, providing high throughput and low overhead
for concurrent access by multiple users. Standard database features
include deadlock detection, referential integrity, and inverse
functions. Exception handling is integrated into the Lisp condition
system. AllegroStore runs on Sparc, SGI, HP, RS/6000, and
MS-Windows/NT systems. For more information, send email to
in...@franz.com, write to Franz Inc., 1995 University Avenue, Berkeley,
CA 94704, call 1-800-333-7260, 510-548-3600, fax 510-548-8253, or
telex 340179 WUPUBTLXSFO.

ITASCA ODBMS V2.2 is a distributed active object database management
system. ITASCA allows clients to transparently access data that is
distributed among multiple servers. ITASCA supports full dynamic
schema modification that can be performed during any phase of the
software lifecycle. Applications written in dissimilar and
incompatible languages, such as C/C++ and CLOS, can share objects through
ITASCA. ITASCA stores methods inside the database, promoting
reusability and maintainability. ITASCA is based on work at MCC's
Object-Oriented and Distributed Systems Lab on the ORION system. For
more information, write to Itasca Systems, Inc., 7850 Metro Parkway,
Minneapolis, MN 55425, sa...@itasca.com, 612-832-0409, fax 612-851-3157.
[Clint Hyde has written a MOP CLOS interface to Itasca, which has some
features not present in their interface. For a free copy of his source
code, send him mail to ch...@bbn.com.]

LispWorks (from Harlequin), in addition to providing a traditional
SQL-based interface to relational databases, also provides a CLOS/SQL
interface, which is an object-oriented access layer that enables SQL
data to be manipulated as objects within Lisp, even though those objects
are not manifest in the database. This can be especially useful when
importing data from and exporting data to a database provided by another
(usually non-Lisp-based) application that already uses a relational
database to achieve data persistence.

Statice is a commercial product from Symbolics, that provides a
powerful persistent ODBMS. It runs on Symbolics Lisp Machines.

----------------------------------------------------------------
Subject: [5-5] Given the name of a class, how can I get the names
of its slots?

(defun class-slot-names (class-name)
"Given a CLASS-NAME, returns a list of the slots in the class."
(mapcar #'clos:slot-definition-name
(clos:class-slots (find-class class-name))))

(defmethod class-slot-names ((instance standard-object))
"Given an INSTANCE, returns a list of the slots in the instance's class."
(mapcar #'clos:slot-definition-name
(clos:class-slots (class-of instance))))

You can use CLASS-DIRECT-SLOTS instead of CLASS-SLOTS if you don't
want inherited slots. Note that these functions are from the
meta-object protocol specified in the original X3J13 draft spec
(document X3J13/88-003), and may not be supported by all Lisps.

----------------------------------------------------------------
Subject: [5-6] Free CLOS software.

Software Repositories:

The CLOS code repository is available by anonymous ftp to
nervous.cis.ohio-state.edu:/pub/lispusers/clos/ [128.146.61.200]
If you've got code you'd like to add to the repository, send
mail to Arun Welch, commonloo...@cis.ohio-state.edu.
The CLOS code repository includes dag.lisp.Z and 3DGeometry.lisp.

----------------------------------------------------------------
Subject: [5-7] Common CLOS Blunders

This question is based on a document written by Marty Hall
<ha...@aplcenmp.apl.jhu.edu>. The full text of Marty's
"Introduction to CLOS" handout is available by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/lang/lisp/doc/intro/closintr.tgz

This question lists a variety of common errors that occur when writing
CLOS code. It is extremely useful to glance through this list when
debugging CLOS code.

[A] Omitting a set of parentheses around the arglist in DEFMETHOD.

For example, writing
(defmethod Area (Sq Square) ...)
instead of
(defmethod Area ((Sq Square)) ...)

Lisp will accept the former, and think that you have two
unspecialized arguments instead of one argument specialized as a
Square.

[B] Missing parentheses around the slot definition list in DEFCLASS.

For example, writing
(defclass Rectangle (Polygon)
(Width ...)
(Height ...))
instead of
(defclass Rectangle (Polygon)
((Width ...)
(Height ...)))

Lisp will not accept the former, but the error message doesn't
always clearly identify the problem.

[C] Forgetting to include an empty slot definition list if you don't
define local slots in DEFCLASS.

For example, writing
(defclass Square (Rectangle))
instead of
(defclass Square (Rectangle) ())
Lisp will not accept the former.

[D] Referring to the class name instead of the instance variable in
DEFMETHOD.

For example, writing
(defmethod Area ((Sq Square))
(* (Width Square) (Width Square)))
instead of
(defmethod Area ((Sq Square))
(* (Width Sq) (Width Sq)))

Lisp may give you a warning about an unknown free variable, but
probably won't even do that if you type the defmethod directly into
the Lisp Listener (Lucid doesn't). So you might not encounter a
problem until run-time.

[E] Forgetting that accessors are functions and thus could conflict
with built-in function names.

For example, writing
(defclass Graphical-Object ()
((Position :accessor Position)))
will signal an error, since you cannot redefine the built-in
POSITION function.

[F] Putting the new value last instead of first in the definition of a
SETF method.

For example, writing
(defmethod (setf Area) ((Sq Square) (New-Area number))
(setf (Width Sq) (sqrt New-Area)))
instead of
(defmethod (setf Area) ((New-Area number) (Sq Square))
(setf (Width Sq) (sqrt New-Area)))

Lisp will accept the former, causing users to be later puzzled as
to why (setf (Area Square-1) 10) doesn't work.

[G] Putting the new value last instead of first in a call to a :writer
method.

For example, given
(defclass Circle ()
((Radius :reader Radius :writer Set-Radius :initform 5)))
(setq Circle-1 (make-instance 'Circle))
and writing
(Set-Radius Circle-1 10)
instead of
(Set-Radius 10 Circle-1)

[H] Confusion about documentation strings in DEFMETHOD.

People often write code like
(defmethod Area ((Rect Rectangle))
"WIDTH times HEIGHT of the rectangle"
(* (Width Rect) (Height Rect)))
without clearly thinking about what this might mean. Some people
think it will make a documentation string on the generic function that
can be retrieved by calling (DOCUMENTATION 'Area 'function) or the
equivalent emacs keystrokes. Others vaguely expect it to make a doc
string on each separate method, and that the call to DOCUMENTATION
will somehow be able to automagically figure out which method it
applies to.

In fact, Lisp won't complain about this code, with the result that the
documentation is added to the method *object*, which beginners
probably know nothing about.

Use the :documentation entry in defgeneric to add a documentation
string to the generic function.

[I] Invalid :initargs are accepted by MAKE-INSTANCE.

Many Lisp implementations will accept unknown keyword initargs without
complaint, even at the highest safety settings.

So the following code, which includes a typo of :SLOT1 instead of
:SLOT-1 in the call to make-instance
(defclass Foo ()
((Slot-1 :accessor Slot-1 :initarg :Slot-1 :initform 5)))

(setq Test (make-instance 'Foo :Slot1 10))
will not produce an error message, with the result that
(Slot-1 Test) returns 5, not 10.

This is a bug in the implementation; all implementations are
supposed to flag this as an error.

[J] Forgetting the class must exist before any method can specialize upon it.

Lisp programmers are used to being able to define functions in any
order, where even if FOO calls BAR, FOO can be defined first. But doing
(defmethod Area ((Rect Rectangle)) ...)
(defclass Rectangle (Polygon) ...)
is illegal. You have to define the class first.

If while trying to debug the problem, you define the class by
evaluating the definition without reordering the code to put the
class first, you'll only run into problems later the next time you
try to recompile the code from scratch.

Many experienced programmers put each class definition in its own
file at the top of the file, with methods for that class after it
in the file. Others opt to put all the class definitions for a
program in a single file that is loaded first, with methods in files
that are loaded later.

[K] Changing a method to apply to a more general class does not
supersede previous method.

For example, suppose a user writes
(defmethod Half-Area ((Rect Filled-Rectangle))
(/ (Area Rect) 2))
and then notices that this functionality could apply to all
Rectangles, not just Filled-Rectangles. They might then change the
class referenced in this method, under the specious intuition that by
changing the old defintion, they are replacing it. In fact, they are
actually adding a new, less-specific method.

Now suppose that later on, they change this new method (in this
example, by adding a call to FLOAT to avoid returning a ratio),
(defmethod Half-Area ((Rect Rectangle))
(float (/ (Area Rect) 2)))
If they test it on an instance of Filled-Rectangle, they will be
puzzled as to why their new definition appears to have not taken
effect. But because the old definition specialized to Filled-Rectangle
still exists, they're actually getting the old, more-specific definition.

Moreover, the next time they restart a fresh Lisp and recompile
the code, the problem will magicly disappear, since the old
definition is no longer in the code.

----------------------------------------------------------------
;;; *EOF*

Mark Kantrowitz

unread,

Aug 13, 1997, 3:00:00 AM8/13/97

Archive-name: lisp-faq/part6
Last-Modified: Wed Feb 19 16:45:11 1997 by Mark Kantrowitz
Version: 1.55

Maintainer: Mark Kantrowitz and Barry Margolin <ai+li...@cs.cmu.edu>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html

Size: 74922 bytes, 1431 lines

;;; ****************************************************************
;;; FTP Archives and Other Resources *******************************

;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin

;;; lisp_6.faq

This post contains Part 6 of the Lisp FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

Topics Covered (Part 6):
[6-0] General information about FTP Resources for Lisp
[6-1] Repositories of Lisp Software
[6-3] Publicly Redistributable Lisp Software
[6-6] Formatting code in LaTeX (WEB and other literate programming tools)
[6-7] Where can I get an implementation of Prolog in Lisp?
[6-8] World-Wide Web (WWW) Resources

Search for \[#\] to get to question number # quickly.

----------------------------------------------------------------
Subject: [6-0] General information about FTP Resources for Lisp

Remember, when ftping compressed or compacted files (.Z, .z, .arc, .fit,

etc.) to use binary mode for retrieving the files.

Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
prep.ai.mit.edu:/pub/gnu/
as the files gzip-1.2.3.shar, gzip-1.2.3.tar,or gzip-1.2.3.msdos.exe.

FTP sites for Lisp and Scheme interpreters and compilers are discussed
in the answer to questions [4-0] and [4-2] and in the Scheme FAQ. See
the entry on Macintosh Common Lisp in question [4-1] for information
on the CD-ROM of Lisp code that Apple distributes with MCL 2.0.

----------------------------------------------------------------
Subject: [6-1] Repositories of Lisp Software

There are several repositories of publicly redistributable and
public domain Lisp code.

Common Lisp Repository:

The Common Lisp Repository is accessible by anonymous ftp to
ftp.cs.cmu.edu:/user/ai/lang/lisp/ [128.2.206.173]
through the AFS directory
/afs/cs.cmu.edu/project/ai-repository/ai/lang/lisp/
or by WWW from the URL
http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html
and includes more than 250 megabytes of sources, including all
freely distributable implementations and many programs. This
repository supersedes the Lisp Utilities collection, and is now
part of the CMU Artificial Intelligence Repository.

Programs in the repository include XREF (portable cross referencing
tool for Lisp, similar to the Symbolics Who-Calls and the Xerox
MasterScope programs), Brad Miller's initializations package for
Allegro CL 4.0, DEFSYSTEM (portable system definition facility, a
"Make" for Lisp), a portable implementation of the X3J13 June 1989
specification for logical pathnames, METERING (a portable code
time/space profiling tool), SOURCE-COMPARE (a portable "diff" utility
for Lisp), USER-MANUAL (a program which helps with documenting Lisp
code), PSGRAPH (Joe Bates' PostScript DAG grapher), several matchers
for Lisp, NREGEX (a regular expressions matcher), a date formatter, an
infix reader macro for Lisp, SAVE-OBJECT (Kerry Koitzsch's package to
save ASCII representations of Lisp objects to a file), Stephen
Nicoud's semi-portable CLtL2 version of defpackage, LALR (Mark
Johnson's lisp YACC parser generator), various implementations of the
Loop Macro, William Schelter's sloop macro, Frank Ritter and Jim
Panagos' implementation of the Yale yloop macro (described in
McDermont, Charniak and Riesbeck's AI programming book), all free Lisp
GUIs, including Express Windows, the iterate macro, Waters' Series
Macro package, Waters' XP Lisp Pretty Printer, Bruno Haible's
implementation of the Simplex algorithm, MAPFORMS (Moon's code
walker), Brad Miller's resources package, and much much more.

The repository has standardized on using 'tar' for producing
archives of files and 'gzip' for compression.

To search the keyword index by mail, send a message to:
ai+q...@cs.cmu.edu
with one or more lines containing calls to the keys command, such as:
keys lisp iteration
in the message body. Keywords may be regular expressions and are
compared with the index in a case-insensitive conjunctive fashion.
You'll get a response by return mail. Do not include anything else
in the Subject line of the message or in the message body. For help on
the query mail server, include:
help
instead.

A Mosaic interface to the keyword searching program is in the
works. We also plan to make the source code (including indexes) to
this program available, as soon as it is stable.

Most of the Common Lisp Repository appears on Prime Time Freeware
for AI, Issue 1-1, a mixed-media book/CD-ROM publication. It
includes two ISO-9660 CD-ROMs bound into a 224 page book and sells
(list) for US$60 plus applicable sales tax and shipping and handling
charges. Payable through Visa, Mastercard, postal money orders in US
funds, and checks in US funds drawn on a US bank. For more
information write to Prime Time Freeware, 370 Altair Way, Suite 150,
Sunnyvale, CA 94086 USA, call 408-433-9662, 408-433-0727 (fax),
or send email to p...@cfcl.com.

Contributions of software and other materials are always welcome but
must be accompanied by an unambiguous copyright statement that grants
permission for free use, copying, and distribution -- either a
declaration by the author that the materials are in the public domain,
that the materials are subject to the GNU General Public License (cite
version), or that the materials are subject to copyright, but the
copyright holder grants permission for free use, copying, and
distribution. (We will tell you if the copying permissions are too
restrictive for us to include the materials in the repository.)
Inclusion of materials in the repository does not modify their
copyright status in any way. Materials may be placed in:
ftp.cs.cmu.edu:/user/ai/new/
When you put anything in this directory, please send mail to
ai+co...@cs.cmu.edu
giving us permission to distribute the files, and state whether
this permission is just for the AI Repository, or also includes
publication on the CD-ROM version (Prime Time Freeware for AI).
We would also appreciate if you would include a 0.doc file for your
package; see /user/ai/new/package.doc for a template. (If you don't
have the time to write your own, we can write it for you based on
the information in your package.)

The Common Lisp Repository is maintained by Mark Kantrowitz,
lisp-utilit...@cs.cmu.edu.

Known mirrors:
ftp.sunet.se:/pub/lang/lisp/

CLOS:

repository includes dag.lisp.Z and 3DGeometry.lisp. [The AI
Repository's Lisp Section includes a directory of CLOS code as well,
in ftp.cs.cmu.edu:/user/ai/lang/lisp/oop/clos-code/.]

MCL:
The Macintosh Common Lisp repository contains Lisp code for
MCL contributed by MCL users. It is available by anonymous ftp from
ftp.digitool.com/pub/mcl/contrib/ [198.112.73.129]
http://www.digitool.com
and also contains the Info-MCL mailing list archives. The
repository contains, among other things, AV_Parser.hqx and Zebu
(general parser toolkits), babylon-2.2.sit.hqx (expert system shell
from GMD in Germany), btree.sit.hqx (binary trees), LGL.lisp (Lisp
Graphics Library for MCL), quicktime code, mmlisp.sit.hqx
(midi-manager interface), tips on optimizing MCL code, PARKA.sit.hqx
(a knowledge representation system), starsim.sit.hqx (*Lisp for MCL),
IP/TCP examples, and support for hypercard XCMDs and XFCNs. See the
file README for a quick overview of the contents of the MCL
repository.

CLIM:
The CLIM Library (a library of user contributed code for the CLIM
environment) is available by anonymous ftp on
cambridge.apple.com:/pub/clim [134.149.2.3]
For information on CLIM, see the entry in [6-5] below. For more
information on the CLIM Library, contact Vincent Keunen, keu...@nrb.be.

MIT AI Lab:
ftp.ai.mit.edu:/pub/
loop-macro.tar [LOOP from CLtL1]
series/ [SERIES from CLtL2; older version]
Iterate/ [Alternative to series and loop.]
clmath.tar [Numeric math 1984]
ontic/ [ONTIC Knowledge Rep. for Mathematics]
clmath is a Lisp library of mathematical functions that calculate
hyperbolic and inverse hyperbolic functions, Bessel functions,
elliptic integrals, the gamma and beta functions, and the incomplete
gamma and beta functions. There are probability density functions,
cumulative distributions, and random number generators for the normal,
Poisson, chi-square, Student's T, and Snedecor's F functions. Discrete
Fourier Transforms. Multiple linear regression, Fletcher-Powell
unconstrained minimization, numerical integration, root finding,
and convergence. Code to factor numbers and to do the
Solovay-Strassen probabilistic prime test is included.
A technical report describing CLMath is available as MIT AI Lab
Memo 774, Gerald Roylance, "Some Scientific Subroutines in LISP",
September 1984. Iterate is Jonathan Amsterdam's alternative to
series and the Loop macro. For more information, contact j...@ai.mit.edu.

LispUsers Archives:
The LispUsers Archives, a collection of programs for Medley, can be
found on
nervous.cis.ohio-state.edu:/pub/lispusers/medley/
The files include a plotting module, addressbook, chat program, clock,
call-grapher, grep implementation, Tower of Hanoi, Life, lisp dialect
translator, and fonts. Also on nervous.cis.ohio-state.edu is GTT, an
implementation of Chandrasekaran's Generic Tasks Toolset, in directory
pub/lispusers/toolset.

Amiga LISP implementations:
There's a repository of Amiga LISP implementations (and other Lisp-like
language implementations) on gatekeeper.pa.dec.com:/pub/micro/amiga/lisp/.

Inside Computer Understanding:
Common Lisp versions of the mini programs from "Inside Computer
Understanding" by Schank and Riesbeck, 1981, are available by
anonymous ftp from
cs.umd.edu:/pub/schank/icu/
This includes the SAM and ELI miniatures. It will eventually include copies
of the miniature versions of PAM, POLITICS, and Tale-Spin. The FOR
macro is also available in this directory, as are a set of functions
for manipulating and matching lisp representations of Conceptual
Dependency formulas. Contact Bill Andersen <waa...@cs.umd.edu> for
more information.

Norvig:

The software from Peter Norvig's book "Paradigms of AI Programming" is
available by anonymous ftp from unix.sri.com:/pub/norvig/ and on disk in

Macintosh or DOS format from the publisher, Morgan Kaufmann.

Software includes Common Lisp implementations of:
Eliza and pattern matchers, Emycin, Othello, Parsers,
Scheme interpreters and compilers, Unification and a prolog
interpreter and compiler, Waltz line-labelling,
implementation of GPS, macsyma, and random number generators.

For more information, contact:
Morgan Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260

San Mateo CA 94403, (800) 745-7323; FAX: (415) 578-0672
Mac ISBN 1-55860-227-5
DOS 3.5" ISBN 1-55860-228-3
DOS 5.25" ISBN 1-55860-229-1

NL Software Registry:
A catalog of free and commercial natural language software is
available from the Natural Language Software Registry, by anonymous
ftp from
ftp.dfki.uni-sb.de:/registry/
or by email to regi...@dfki.uni-sb.de.

TI Explorer Lisp Code:

sumex-aim.stanford.edu:/pub/exp/

The Knowledge Systems Lab's set of Explorer patches and tools. It
includes in the jwz subdirectory a set of tools written and collected
by Jamie Zawinski. Send questions to ac...@sumex-aim.stanford.edu.

Waters' Programs:

Dick Waters' XP Lisp Pretty Printer is available by anonymous ftp
from
merl.com:/pub/xp/
as the files xp-code.lisp, xp-doc.txt, and xp-test.lisp.

The Series Macro is available from
merl.com:/pub/series/
as the files s-code.lisp, s-test.lisp, and s-doc.txt. The
Series macro package is described fully in Waters, R.C., "Automatic
Transformation of Series Expressions into Loops", ACM Transactions on
Programming Languages and Systems, 13(1):52--98, January 1991,
MIT/AIM-1082 and MIT/AIM-1083.

Both programs are also available from the Common Lisp Repository
described above.

For further information, contact Dick Waters, <di...@merl.com> or
<di...@ai.mit.edu>. An improved version of Series is in the works.

----------------------------------------------------------------
Subject: [6-3] Publicly Redistributable Lisp Software

AI Algorithms and Tools:

PAIL (Portable AI Lab) is a computing environment containing a
collection of state-of-the-art AI tools, examples, and documentation.
It is aimed at those involved in teaching AI courses at university
level or equivalent. The system has enough built-in functionality to
enable its users to get practical experience with a broad range of AI
problems without having to build all the supporting tools from
scratch. It is implemented in Common Lisp and uses CLOS and Allegro
Common Windows (i.e., in Allegro CL 4.1). It is available by anonymous
ftp from
pobox.cscs.ch:/pub/ai/ [148.187.10.13]
Written by Mike Rosner and Dean Allemang {dean,mike}@idsia.ch.

AI_ATTIC is an anonymous ftp collection of classic AI programs and
other information maintained by the University of Texas at Austin. It
includes Parry, Adventure, Shrdlu, Doctor, Eliza, Animals, Trek, Zork,
Babbler, Jive, and some AI-related programming languages. This
archive is available by anonymous ftp from
ftp.cc.utexas.edu:/pub/AI_ATTIC/ [128.83.186.13]
(AKA bongo.cc.utexas.edu). For more information, contact
attic...@bongo.cc.utexas.edu.

Analogical Reasoning:

SME is the Structure-Mapping Engine, as described in Falkenhainer,
Forbus, and Gentner's 1987 AIJ article. Available from
multivac.ils.nwu.edu:/pub/SME For further information, contact Brian
Falkenhainer <falken...@parc.xerox.com> or Ken Forbus
<for...@ils.nwu.edu>.

Benchmarks:

Gabriel Lisp Benchmarks are available by anonymous ftp as
ai.toronto.edu:/pub/gabriel-lisp-benchmarks.tar.Z.
The benchmarks are described in the book "Performance Evaluation of
Lisp Systems", by Richard Gabriel.

Lucid CL contains a set of benchmarks in its goodies/ directory,
including Bob Boyer's logic programming benchmark, a benchmark to
create and browse through an AI-like database of units, a CLOS speed
test, a compilation speed test, TAKR (the 100 function version of TAK
that tries to defeat cache memory effects), CTAK (A version of the
TAKeuchi function that uses the CATCH/THROW facility), STAK (A version
of the TAKeuchi function with special variables instead of parameter
passing), DERIV and DDERIV (Symbolic derivative benchmarks written by
Vaughn Pratt), DESTRU (a destructive operation benchmark), DIV2 (a
benchmark which divides by 2 using lists of n ()'s), the FFT benchmark
written by Harry Barrow, FPRINT (a benchmark to print to a file),
FRPOLY (a Franz Lisp benchmark by Fateman based on polynomial
arithmentic), Forest Baskett's PUZZLE benchmark (originally written in
Pascal), the TPRINT benchmark to read and print to the terminal, a
benchmark that creates and traverses a tree structure, and TRIANG
(board game benchmark). Some of the benchmarks may work only in Lucid.

Blackboard Architectures:

The UMass GBB system (V1.2) is available by anonymous ftp from
ftp.cs.umass.edu:/gbb. The commercial GBB product is not.
Work on the UMass GBB project (and funding) ended over 2 years ago.
Many researchers using it have opted for the commercial
release. The UMass research system remains available, but the
two should not be confused as the commercial system is
substantially improved and extended. The commercial system is
available from Blackboard Technology Group, 401 Main Street, Amherst,
Massachusetts 01002, telephone 800-KSS-8990 or 413-256-8990, fax
413-256-3179.

For a tutorial on how to build a blackboard system, see the paper
P. R. Kersten and Avi C. Kak, "A Tutorial on LISP Object-Oriented
Programming for Blackboard Computation (Solving the Radar Tracking
Problem)", International Journal of Intelligent Systems 8:617-669, 1993
Although samples of the code are given in the paper, the full source
code is available in a separate technical report from the School of
Electrical Engineering at Purdue University. If you are interested in
getting a copy of the technical report, send mail to Avi Kak
<k...@ecn.purdue.edu>. (The circumstances under which the software was
developed prevent them from making the source code available by
anonymous FTP. However, the full source code is printed in the
technical report.)

Case-based Reasoning:

CL-Protos is a Common Lisp implementation of the case-based
reasoning system developed by E. Ray Bareiss and Bruce W.
Porter of the University of Texas/Austin AI Lab. It runs
on Sun3, TI Explorer, HP 9000, and Symbolics, and gobbles a
huge amount of memory. Common Lisp implementation by
Rita Duran, Dan Dvorak, Jim Kroger, Hilel Swerdlin, and Ben Tso.
For more information, bug reports, or comments, contact
either Dan Dvorak <dvo...@cs.utexas.edu> or Ray Bareiss
<bar...@ils.nwu.edu> or Erik Eilerts <eil...@cs.utexas.edu>
Available by anonymous ftp from cs.utexas.edu:/pub/porter

The complete code for "Inside Case-Based Reasoning" by Riesbeck and
Schank, 1989, is available by anonymous ftp from
cs.umd.edu:/pub/schank/icbr/
This includes code for an instructional version of CHEF by Kristian
Hammond and MICRO-xxx. Contact Bill Andersen <waa...@cs.umd.edu>
for more information.

CLOS Software:
See question [5-6].

Constraint Programming and Non-determinism:

SCREAMER:

Screamer is an extension of Common Lisp that adds support for
nondeterministic programming. Screamer consists of two levels. The
basic nondeterministic level adds support for backtracking and
undoable side effects. On top of this nondeterministic substrate,
Screamer provides a comprehensive constraint programming language in
which one can formulate and solve mixed systems of numeric and
symbolic constraints. Together, these two levels augment Common Lisp
with practically all of the functionality of both Prolog and
constraint logic programming languages such as CHiP and CLP(R).
Furthermore, Screamer is fully integrated with Common Lisp. Screamer
programs can coexist and interoperate with other extensions to Common
Lisp such as CLOS, CLIM and Iterate.

In several ways Screamer is more efficient than other implementations
of backtracking languages. First, Screamer code is transformed into
Common Lisp which can be compiled by the underlying Common Lisp
system. Many competing implementations of nondeterministic Lisp are
interpreters and thus are far less efficient than Screamer. Second,
the backtracking primitives require fairly low overhead in Screamer.
Finally, this overhead to support backtracking is only paid for those
portions of the program which use the backtracking primitives.
Deterministic portions of user programs pass through the Screamer to
Common Lisp transformation unchanged. Since in practise, only small
portions of typical programs utilize the backtracking primitives,
Screamer can produce more efficient code than compilers for languages
in which backtracking is more pervasive.

Screamer is fairly portable across most Common Lisp implementations.
It currently runs under Genera 8.1.1 and 8.3 on both Symbolics 36xx
and Ivory machines, under Lucid 4.0.2 and 4.1 on Sun SPARC machines,
under MCL 2.0 and 2.0p2 on Apple Macintosh machines, and under Poplog
Common Lisp on Sun SPARC machines. It should run under any
implementation of Common Lisp which is compliant with CLtL2 and with
minor revision could be made to run under implementations compliant
with CLtL1 or dpANS.

Screamer is available by anonymous FTP from
ftp.ai.mit.edu:/pub/screamer.tar.Z
Contact Jeffrey Mark Siskind <qo...@ai.mit.edu> for further
information. Screamer is also available from the Common Lisp Repository.

The Screamer Tool Repository, a collection of user-contributed
Screamer code, is available by anonymous ftp from
ftp.cis.upenn.edu:/pub/screamer-tools/
or by WWW from
http://www.cis.upenn.edu/~screamer-tools/home.html
Please direct all inquires about the repository to
screamer-...@cis.upenn.edu.

Defeasible Reasoning:

An implementation of J. Paris and A. Vencovska's model of belief is

available by anonymous ftp from

ftp.cs.cmu.edu:/user/ai/areas/reasonng/defeasbl/belief/
Paris and Vencovska's paper (Artificial Intelligence, 64(2), December
1993) provides a mathematical model of an agent's belief in an event
by identifying it with his ability to imagine the event within the
context of his previous experience. This approach leads to beliefs
having properties different from those normally ascribed to it. The
implementation was written by Ian Pratt <ipr...@cs.man.ac.uk> and Jens
Doerpmund <dorp...@cs.man.ac.uk> and runs in Common Lisp.

Eliza and Similar Programs:

See Peter Norvig's book and AI_ATTIC (question [6-1] above).

The doctor.el is an implementation of Eliza for
GNU-Emacs emacs-lisp. Invoke it with "Meta-X doctor"

muLISP-87 (a MSDOS Lisp sold by Soft Warehouse) includes
a Lisp implementation of Eliza.

Implementations of ELIZA for other languages are mentioned in the AI FAQ.

The original Parry (in MLISP for a PDP-10) is available in
labrea.stanford.edu:/pub/parry.tar.Z.

Other programs, such as RACTER, are listed in part 4 of the AI FAQ.

Expert Systems:

FOCL is an expert system shell and machine learning program written in
Common Lisp. The machine learning program extends Quinlan's FOIL
program by containing a compatible explanation-based learning
component. FOCL learns Horn Clause programs from examples and
(optionally) background knowledge. The expert system includes a
backward-chaining rule interpreter and a graphical interface to the
rule and fact base. For details on FOCL, see: Pazzani, M. and Kibler,
D., "The role of prior knowledge in inductive learning", Machine
Learning 9:54-97, 1992. It is available by anonymous ftp from
ics.uci.edu:/pub/machine-learning-programs/
as the files README.FOCL-1-2-3, FOCL-1-2-3.cpt.hqx (a binhexed,
compacted Macintosh application), FOCL-1-2-3.tar.Z (Common Lisp
source code), and FOCL-1-2-3-manual.hqx (binhexed manual). If you
use a copy of FOCL, or have any comments or questions, send mail to
paz...@ics.uci.edu.

BABYLON is a development environment for expert systems. It
includes frames, constraints, a prolog-like logic formalism, and a
description language for diagnostic applications. It is implemented in
Common Lisp and has been ported to a wide range of hardware platforms.

Available by anonymous ftp from

ftp.gmd.de:/gmd/ai-research/Software/Babylon/ [129.26.8.84]
as a BinHexed stuffit archive, on the Web via the URL
http://www.gmd.de/
on the Apple CD-ROM, or with the book "The AI Workbench BABYLON",
which contains *full source code* of BABYLON and the stand-alone
version for the Mac. The book describes the use of BABYLON in detail.

OPS5 is a public domain Common Lisp implementation of the OPS5
production system interpreter written by Charles Forgy. It is
available from the CMU AI Repository in
ftp.cs.cmu.edu:/user/ai/areas/expert/ops5/
and includes the original port by George Wood and Jim Kowalski
(ops5orig.tar.gz), and a later port by Mark Kantrowitz (ops5.tar.gz).
The latter has been tested under Allegro, Lucid, CMU CL, Ibuki CL and
MCL.

Frame Languages:

FrameWork is a portable generic frame system available from the CMU
AI Repository, in
ftp.cs.cmu.edu:/user/ai/areas/kr/systems/frames/framewrk/

THEO (learning frame system) is available free from CMU, after
signing a license agreement. Send mail to Tom.Mi...@cs.cmu.edu.

FrameKit is available free from CMU, after signing a
license agreement. Send mail to Eric....@cs.cmu.edu

KR. Send mail to Brad....@cs.cmu.edu for more info.

PARKA. Frames for the CM. Contact spe...@cs.umd.edu.

PARMENIDES (Frulekit) is available free, after signing
a license agreement. Send mail to peter...@cs.cmu.edu

FROBS is available free by anonymous ftp from
cs.utah.edu:/pub/frobs.tar.Z
Contact Robert Kessler <kes...@cs.utah.edu> for more info.

PFC is a simple frame system written by Tim Finin
available free by anonymous ftp from linc.cis.upenn.edu.

YAK is a hybrid knowledge-representation system of the
KL-ONE family. Includes an optional graphical interface
depending on the Lisp. Available free after signing a license
agreement. Contact Enrico Franconi <fran...@irst.it>.

Genetic Algorithms:

GECO (Genetic Evolution through Combination of Objects) is a
genetic algorithm shell written by George Williams,
<geo...@hsvaic.boeing.com>. It is available by anonymous ftp
from cambridge.apple.com:/pub/mcl2/contrib/ as the following
files:
GECO-v1.0.cpt.hqx binhex'd Compact Pro archive
GECO-v1.0.tar.Z compressed tar file for Unix machines (no MCL
fonts)
GECO.abstract a brief description
It runs in MCL 2.0, but should be portable among CLtL2 compliant
Common Lisps.

GAL is a genetic algorithm suite written by Bill Spears of NRL. The
MCL2.0 port was done by Howard Oakley <how...@quercus.demon.co.uk> and
is available from cambridge.apple.com:/pub/MCL2/contrib as
GAL.sea.hqx. Improvements and adaptations should be sent to Bill
Spears, but questions on the MCL port should be directed to Howard Oakley.

Other genetic algorithms code is available
ftp.aic.nrl.navy.mil:/pub/galist
including Genesis (source-code/ga-source/genesis.tar.Z) and the archives
of the GA-List mailing list. A survey of free and commercial
genetic algorithms implementations is available in
information/ga-software-survey.txt.

Knowledge Representation:

KNOWBEL is an implementation of Telos (a sorted/temporal logic
system) by Bryan M. Kramer, <kra...@ai.toronto.edu>. It is
available by anonymous ftp from ai.toronto.edu:/pub/kr/ as the
files knowbel.tar.Z and manual.txt.tar.Z
Runs in Allegro CL on Sparcstations and Silicon Graphics 4d
and in MCL on Apple Macintoshes.

SNePS (Semantic Network Processing System) is the implementation of a
fully intensional theory of propositional knowledge representation and
reasoning. SNePS includes a module for creating and accessing
propositional semantic networks, path-based inference, node-based
inference based on SWM (a relevance logic with quantification) that
uses natural deduction and can deal with recursive rules, forward,
backward and bi-directional inference, nonstandard logical connectives
and quantifiers, an assumption based TMS for belief revision, a
morphological analyzer and a generalized ATN (GATN) parser for parsing
and generating natural language, SNePSLOG, a predicate-logic-style
interface to SNePS, XGinseng, an X-based graphics interface for
displaying, creating and editing SNePS networks, SNACTor, a
preliminary version of the SNePS Acting component, and SNIP 2.2, a new
implementation of the SNePS Inference Package that uses rule shadowing
and knowledge migration to speed up inference. SNeRE (the SNePS
Rational Engine), which is part of Deepak Kumar's dissertation about
the integration of inference and acting, will replace the current
implementation of SNACTor. SNePS is written in Common Lisp, and has
been tested in Allegro CL 4.1, Lucid CL 4.0, TI Common Lisp, CLISP
May-93, and CMU CL 17b. It should also run in Symbolics CL, AKCL 1.600
and higher, VAX Common Lisp, and MCL. The XGinseng interface is built
on top of Garnet. SNePS 2.1 is free according to the GNU General
Public License version 2. The SNePS distribution is available by
anonymous ftp from
ftp.cs.buffalo.edu:/pub/sneps/ [128.205.32.9]
as the file rel-x-yyy.tar.Z, where 'x-yyy' is the version. The other
files in the directory are included in the distribution; they are
duplicated to let you get them without unpacking the full distribution
if you just want the bibliography or manual. If you use SNePS, please
send a short message to sha...@cs.buffalo.edu and
sn...@cs.buffalo.edu. Please also let them know whether you'd like to
be added to the SNUG (SNePS Users Group) mailing list.

COLAB (COmpilation LABoratory) is a hybrid knowledge representation
system emphasizing the horizontal and vertical compilation of
knowledge bases. It is comprised of cooperating subsystems -- CONTAX,
FORWARD, RELFUN and TAXON -- which deal with different knowledge
representation and reasoning formalisms. Each subsystem can also be
used as stand-alone system. CONTAX deals with constraint nets and
constraint-propagation techniques. Relational knowledge in the form of
Horn rules is processed by forward (FORWARD) and backward (RELFUN)
chaining. Taxonomic knowledge is represented by intensional concept
definitions which are automatically arranged in a subsumption
hierarchy (TAXON). The COLAB software was developed at DFKI and the
University of Kaiserslautern and runs in Common Lisp. (The subsystems
have been tested in AKCL and Lucid CL, and possibly also Allegro CL
and Symbolics CL.) All the subsystems are available free of charge for
research purposes.
o RELFUN is a logic-programming language with call-by-value (eager),
non-deterministic, non-ground functions, and higher-order operations.
It accepts freely interchangeable LISP-style and PROLOG-style syntaxes.
For sources to RELFUN and copies of relevant papers, contact
Dr. Harold Boley, DFKI, Postfach 2080, W-6750 Kaiserslautern, Germany,
call +49-631-205-3459, fax +49-631-205-3210, or send email to
bo...@informatik.uni-kl.de.
o TAXON is a terminological knowledge representation system extended by
concrete domains. For sources to TAXON and copies of relevant papers,
contact Philipp Hanschke, DFKI, Postfach 2080, W-6750 Kaiserslautern,
Germany, call +49-631-205-3460, fax +49-631-205-3210, or send email to
hans...@dfki.uni-kl.de.
o CONTAX is a constraint system for weighted constraints over
hierarchically structured finite domains. CONTAX uses CLOS in addition
to Common Lisp. For sources to CONTAX and copies of relevant papers,
contact Manfred Meyer, DFKI, Postfach 2080, W-6750 Kaiserslautern,
Germany, call +49-631-205-3468, fax +49-631-205-3210, or send email to
me...@dfki.uni-kl.de.
o FORWARD is a logic programming language with bottom-up and top-down
evaluation of Horn clauses. For sources to FORWARD and copies of
relevant papers, contact Knut Hinkelmann, DFKI, Postfach 2080, W-6750
Kaiserslautern, Germany, call +49-631-205-3467, fax +49-631-205-3210,
or send email to hink...@dfki.uni-kl.de.

URANUS is a logic-based knowledge representation language. Uranus is
an extension of Prolog written in Common Lisp and using the syntax of
Lisp. Uranus extends Prolog with a multiple world mechanism for
knowledge representation and term descriptions to provide
functional programming within the framework of logic programming.

It is available free by anonymous ftp from

etlport.etl.go.jp:/pub/uranus/ftp/ [192.31.197.99]
for research purposes only. For more information contact the author,
Hideyuki Nakashima <naka...@etl.go.jp>.

Languages and Alternate Syntaxes:

Generalized Lisp (or Glisp for short) is a coordinated set of high
level syntaxes for Common Lisp. Initially GLisp consists of three
dialects: Mlisp, Plisp and ordinary Lisp, together with an extensible
framework for adding others. Mlisp (Meta-Lisp) is an Algol-like
syntax for people who don't like writing parentheses. For example,
one can write print("abc", stream) instead of (print "abc" stream).
Plisp (Pattern Lisp) is a pattern matching rewrite-rule language.
Plisp is a compiler-compiler; its rules are optimized for writing
language translators. All dialects may be freely intermixed in a
file. The translators for all dialects are written in Plisp, as is
the Glisp translator framework itself. Support routines for the
translators are written in Mlisp and/or Lisp. All dialects are
translated to Common Lisp and execute in the standard Common Lisp
environment. Glisp is available by anonymous ftp from apple.com or
ftp.apple.com:/dts/mac/lisp/glisp.tar.Z
GLISP runs in MCL and has to be modified for other Common Lisp
implementations.

CGOL is algol-like language that is translated into Lisp before
execution. It was developed originally by Vaughn Pratt. A Common Lisp
implementation of CGOL is available by anonymous ftp from
peoplesparc.berkeley.edu:/pub/cgol.1.tar.Z [128.32.131.14]
(The number "1" may increase if newer versions are posted.) It was
written by a UC Berkeley graduate student, Tom Phelps, as a term
project, so there may still be some rough edges. There is a lot of
documentation in the distribution, including the "original" CGOL memo
(pratt.memo). For more information, contact Richard Fateman
<fat...@peoplesparc.berkeley.edu>.

StarLisp Simulator. The StarLisp Simulator simulates *Lisp, one of
the programming langauges used to program the Connection Machine.
StarLisp runs under Symbolics, Lucid, Allegro, and Franz, and is

available by anonymous ftp from

think.com:/cm/starlisp/starsim-f19-sharfile
The "CM5 *Lisp Tutorial" is available by anonymous ftp from
arp.anu.edu.au:/ARP/papers/starlisp/ [150.203.20.2]
in Andrew "ez" and postscript formats. Write to Zdzislaw Meglicki
<Zdzislaw...@cisr.anu.edu.au> for more information about the tutorial.

InterLisp->Common-Lisp Translator -- ftp.ai.sri.com:/pub/pkarp/lisp/ilisp/
Other InterLisp to Common Lisp translators may be found in the LispUsers
archive listed above.

The Yale Haskell system runs in CMU Common Lisp, Lucid CL, and AKCL.

It is available by anonymous ftp from

Chalmers animal.cs.chalmers.se:/pub/haskell/yale/ [129.16.225.66]
Glasgow ftp.dcs.glasgow.ac.uk:/pub/haskell/yale/ [130.209.240.50]
Yale nebula.cs.yale.edu:/pub/haskell/yale/ [128.36.13.1]
as the files
haskell-beta-2-source.tar.Z -- full sources
haskell-beta-2-sparc.tar.Z -- sparc executable

Lisp Tools:

See the Common Lisp Repository in [6-2].

The Automatic Memoization Facility adds a practical memoization
facility to Common Lisp. Automatic memoization is a technique by which
an existing function can be transformed into one that "remembers"
previous arguments and their associated results, yielding large
performance gains for certain types of applications. This facility
extends the ideas from Norvig's book into what is needed for a
practical tool for us in large programs. It adds facilities for
bookkeeping and timing, and lets you evaluate of the timing advantages
of memoization, and save hash tables to disk for automatic reuse in
later sessions. The code is available by anonymous ftp from
archive.cs.umbc.edu:/pub/Memoization [130.85.100.53]. Contact Marty Hall
<ha...@aplcenmp.apl.jhu.edu> for more information. The code includes an
overview of memoization and its applications.

PLisp - A Common Lisp front end to Postscript. This translates many
Common Lisp functions to postscript as well as manage the environment
and many lispisms (&optional and &rest arguments, multiple values,
macros, ...). Available via anonymous ftp
nebula.cs.yale.edu:/pub/plisp/plisp.tar.Z [128.36.13.1]
Written by John Peterson <peters...@cs.yale.edu>.

RegExp is an extension to Allegro Common Lisp which adds
regular expression string matching, using the foreign
function interface. Available by anonymous ftp from
ftp.ai.sri.com:/pub/pkarp/regexp/. Contact pk...@ai.sri.com
for more information.

ifi.informatik.uni-stuttgart.de:/pub/xit/cl-utilities/ contains
three small utilities:
completion.lisp A simple filename completion program.
cl-utilities.lisp Some macros for dealing with points,
regions, and some miscellaneous macros.
copy-objects.lisp Code for copying instances.

think.com:/think/lisp contains some useful lisp code (most of it
Symbolics dependent) including:
lisp-lint.lisp A set of compiler style checkers that
warn when a function call does not
conform to Common Lisp.

MEASURES is a system to handle engineering numbers and measures in
Common Lisp. It runs in Allegro CL, LispWorks, MCL, and Symbolics CL.
Written by Roman Cunis. Some documentation can be found in the file
measures.doc and examples in measures-example.lisp. It is available
from the Common Lisp Repository
ftp.cs.cmu.edu:/user/ai/lang/lisp/lisp/syntax/
in the file measures-2.0.tar.gz. For further information, contact Ralf
Moeller, University of Hamburg, Bodenstedtstr 16, 2000 Hamburg 50,
Germany, call 40-4123-6134, fax 40-4123-6530, or send email to
moe...@informatik.uni-hamburg.de.

DEFTABLE provides a macro that unifies the interface to Common
Lisp's table-like data structures (e.g., association lists, property
lists, and hash tables). Written by Peter Norvig
<nor...@harlequin.com>. It is available by anonymous ftp from
ftp.ai.mit.edu:/pub/lptrs/deftable.lisp [128.52.32.6] and also the
Lisp Utilities Repository. An article describing deftable was
published in ACM Lisp Pointers 5(4):32-38, December 1992.

SEQUEL (SEQUEnt processing Language) is designed both as a general
purpose AI language for generating type-secure and efficient Lisp
programs and as a very high level specification language for
implementing logics on the computer. Designed at the University of
Leeds, SEQUEL compiles sequent-calculus specifications of arbitrary
logics to working proof assistants. The sequent calculus
specifications are compiled into Horn clauses and from Horn clauses
into virtual machine instructions of an abstract machine SLAM (SequeL
Abstract Machine) which then translates these instructions into
efficient Lisp code using WAM-style compilation techniques. Although
a functional programming language, SEQUEL includes facilities for
backtracking usually associated with logic programming, and supports a
pattern-matching method of building functions based on Prolog
notation. The Lisp code generated from SEQUEL functions is completely
portable and runs in most Common Lisp implementations. It is
comparable in efficiency with hand-written code. SEQUEL also supports
optional static type-checking in the manner of SML and similar
languages. With type-checking enabled, all inputs and loaded files
are type-checked and the resulting Lisp programs are type-secure. The
SEQUEL compiler uses the information gleaned from type-checking to add
compiler directives within the generated Lisp functions to produce
optimized Lisp programs. SEQUEL includes a UNIX-style top level with
its own trace package and type-checking debugger. SEQUEL is also of
interest to automated reasoning researchers. It provides a very
powerful means of generating proof assistants and theorem provers that
have a very fast performance using WAM-derived compilation techniques.
The theorem provers are automatically verified. It includes a facility
for Datalog and an efficient occurs-check Horn-clause-to-Lisp
compiler, a mouse driven graphical interface for all proof assistants
and theorem provers built under SEQUEL (currently available only under
Lucid). Several demonstration theorem provers for different logics,
including FOL, Clarke's logic of space, partial evaluation, set
theory, and constructive type theory are available. SEQUEL runs under
Kyoto CL, Lucid CL, and CMU Common Lisp. SEQUEL is available free for
non-commercial purposes by anonymous ftp from
agora.leeds.ac.uk:/scs/logic/ [129.11.144.130]
and includes LaTeX documentation in the distribution. For more
information, contact Mark Tarver <ma...@scs.leeds.ac.uk> or
<csc...@gps.leeds.ac.uk>.

ILU (Xerox PARC Inter-Language Unification) is a system for promoting
language interoperability via interfaces between units of program
structure called "modules". ILU currently supports Common Lisp, ANSI
C, C++, and Modula-3. The Common Lisp support provides CLOS `network
objects' that communicate via RPC between Lisp processes, as well
between Lisp and other languages. ILU is available by anonymous ftp
from
parcftp.parc.xerox.com:/pub/ilu/1.6.4/ilu-1.6.4.tar.gz
Write to Bill Janssen <jan...@parc.xerox.com> for more information.

Machine Learning:

ID3: A Lisp implementation of ID3 and other machine learning
algorithms are available by anonymous ftp from the machine learning
group at the University of Texas as cs.utexas.edu:/pub/mooney

COBWEB/3 is a concept formation system available free after
signing a license agreement. Contact cob...@ptolemy.arc.nasa.gov
for more information.

RWM (Refinement With Macros) is a Common Lisp program for learning
problem solving strategies. RWM takes a high level description of a
problem as input and successively refines it into a sequence of
"easier" subproblems, which collectively constitute a strategy for
solving the given problem. RWM also learns macro moves which are
useful for efficiently solving the problem. A short documentation and
some example problems/strategies are included. To get a copy of this
description, send mail to the Bilkent University Archieve Server
bil...@trbilun.bitnet with "send RWM.tar.Z" in the body of the
message. For further information, contact H. Altay Guvenir
<guv...@trbilun.bitnet>.

Mathematics:

MockMma -- peoplesparc.berkeley.edu:/pub/mma.tar.Z [128.32.131.14]
A Mathematica-style parser written in Common Lisp. Written by Richard
Fateman; fat...@renoir.Berkeley.EDU. Runs in any valid Common Lisp.
Tested in Allegro, KCL and Lucid.

rascal.ics.utexas.edu:/pub/ 128.83.138.20
Maxima for Common Lisp (License required from National
Energy Software Center at Argonne.) Ported by Bill Schelter.

QUAIL (Quantitative Analysis in Lisp) extends Common Lisp to better
support quantitative analysis. It includes an object-oriented
quantitative analysis programming environment based on CLOS. Quail
was developed by the Statistical Computing Laboratory of the
Department of Statistics and Actuarial Science of the University of
Waterloo. It includes a variety of mathematical and statistical
capabilities, such as symbolic and numerical differentiation,
numerical integration, probability calculations (e.g., pseudo-random
number generation), and statistical response models. The
object-oriented graphics display facilities include building blocks
for arbitrary graphics, a collection of stock statistical graphics,
function plotting, 3d-rotating function and surface plots, and
graphical browsers. Quail currently runs in MCL, but a Franz and CLX
based version is forthcoming. It is available by anonymous ftp from
setosa.uwaterloo.ca:/pub/Quail/ [129.97.141.101]
You must read the file README-I-MEAN-IT and return a signed copy of
the license agreement ($10 annual license fee) before using the
software. For further information, contact Dr. R. W. Oldford,
<rwol...@watstat.waterloo.edu> or <rwol...@watstat.uwaterloo.ca>.

Medical Reasoning:

TMYCIN -- sumex-aim.stanford.edu:/tmycin The TMYCIN rule based system.

Music:

Common Music is a music composition language written in Common Lisp
and CLOS that outputs music (directly or through scorefiles) to a
variety of synthesis packages, such as the Music Kit, Common Lisp
Music, MIDI, and CSound. Common Music runs under MCL 2.0, Allegro CL
3.1.2 (NeXT), AKCL 1.615 (NeXT), Allegro CL 4.1 beta (SGI Iris), and
AKCL 6.15 (Sun4). It is available by anonymous ftp from
ccrma-ftp.stanford.edu:/pub/Lisp/cm.tar.Z [36.49.0.93]
ftp.zkm.de:/pub/cm.tar.Z [192.101.28.17]

To be added to the mailing list, send mail to

cmdist-...@ccrma.stanford.edu. For further information, contact
Rick Taube, <h...@zkm.de> or <h...@ccrma.stanford.edu>.
[Note: In the Common Music sources, there is a generic portable Lisp
Listener style interpreter that supports command dispatching in
addition to Lisp evaluation. It is the file ./utils/tl.lisp.]

Common Lisp Music (CLM) is a software synthesis and signal
processing package (CL-MUSIC) and a package that makes it relatively
easy to take advantage of the Motorola DSP 56000 (CL-MUSIC-56). It is

available by anonymous ftp from

ccrma-ftp.stanford.edu:/pub/Lisp/clm.tar.Z [36.49.0.93]
Basic documentation is in clm.wn (or clm.rtf) and
ins.lisp. CLM runs on NeXT under Allegro CL or KCL and on SGI Indigo
under Allegro CL. The non-56000 version should run on any machine with
C and Common Lisp. Send bug reports or suggestions to
Bil Schottstaedt <b...@ccrma.stanford.edu>.

Common Music Notation (CMN) is a western music notation package based on
Common Lisp, CLOS (pcl), PostScript, and the Adobe Sonata font. It is

available by anonymous ftp from

ccrma-ftp.stanford.edu:/pub/Lisp/cmn.tar.Z [36.49.0.93]
To be added to the mailing list (same list as for Common Music),
send mail to cmdist-...@ccrma.stanford.edu. Please send bug
reports and suggestions to Bil Schottstaedt <b...@ccrma.stanford.edu>.

Natural Language Processing:

The Xerox part-of-speech tagger is available by anonymous ftp from
parcftp.xerox.com:/pub/tagger/tagger-1-0.tar.Z. It is implemented in
Common Lisp and has been tested in Allegro CL 4.1, CMU CL 17e, and
Macintosh CL 2.0p2. For more information, contact the authors, Jan Pedersen
<pede...@parc.xerox.com> and Doug Cutting <cut...@apple.com>.

Natural Language Generation:

FUF is a natural language generation system based on Functional
Unification Grammars implemented in Common Lisp. It includes a
unifier, a large grammar of English (surge), a user manual and many
examples. FUF is available by anonymous ftp from
cs.columbia.edu:/pub/fuf/
black.bgu.ac.il:/pub/fuf/
as the files fuf5.2.tar.Z and surge.tar.Z. For further information,
contact the author, Michael Elhadad <elh...@bengus.bgu.ac.il>.
[A WAM-based C compiler for FUF is in the works.]

Neural Networks:

ANSIL -- nervous.cis.ohio-state.edu:/pub/lispusers/ansil/
"Advanced Network Simulator in Lisp"
email: an...@cis.ohio-state.edu

Object-Oriented Programming:

PCL -- parcftp.xerox.com:/pcl/ [13.1.64.94]
Portable Common Loops (PCL) is a portable implementation of
the Common Lisp Object System (CLOS). A miniature CLOS
implementation called Closette is available pcl/mop/closette.lisp.

CLOS-on-KEE -- zaphod.lanl.gov:/pub/
A subset of CLOS that is implemented on top of KEE. Contact
egdorf%zap...@LANL.GOV (Skip Egdorf) for more info.

MCS (Meta Class System) -- ftp.gmd.de:/lang/lisp/mcs/ [129.26.8.84]
Portable object-oriented extension to Common Lisp. Integrates the
functionality of CLOS (the Common Lisp Object System), and TELOS, (the
object system of LeLisp Version 16 and EuLisp). MCS provides a metaobject
protocol which the user can specialize. Runs in any valid Common Lisp.
Contact: Harry Bretthauer and Juergen Kopp, German National Research
Center for Computer Science (GMD), AI Research Division,
P.O. Box 1316, D-5205 Sankt Augustin 1, FRG, email: juerge...@gmd.de

CommonORBIT (also called CORBIT) is an object-oriented extension of
Common Lisp. It uses a prototype (classless) model of OOP, is easy to
use and yet has many sophisticated features found also in KL-ONE type
languages. CommonORBIT is a Common Lisp reimplementation of ORBIT,
which was originally conceived by Luc Steels around 1981-1983.
Because of its delegation-based rather than class-based inheritance,
CommonORBIT offers extreme flexibility to define and change
practically anything at run-time. Because of the generic functions,
it fits well into regular Lisp code. It can co-exist with CLOS but
remains completely separate. The source code of CommonORBIT is in the
public domain and available by anonymous ftp from the Lisp
Utilities Repository,
ftp.cs.cmu.edu:/user/ai/lang/lisp/
in the oop/non-clos/corbit/ subdirectory as the file corbit.tar.gz.
Documentation is available as the files corbit.msword.hqx, corbit.ps
or corbit.text. A stripped-down version of CORBIT, known as BOOPS
(Beginner's Object-Oriented Programming System), is also available
from the repository as boops.tar.Z. For further information,
contact the author, Koenraad de Smedt <des...@ruls40.LeidenUniv.nl>.

Parser Generators:

Mark Johnson <m...@cs.brown.edu> has written a LALR parser generator
for Common Lisp. It is fairly small (about 500 lines of code) and
can be found in the Common Lisp Repository above.

IPG (Incremental Parser Generator) is available by email from
Jan Rekers <rek...@cwi.nl>. It is an appendix to his thesis. It is
written in LeLisp, but should be portable to other Lisp dialects.

Zebu 2.8.5 is a parser generator for Common Lisp by Joachim H. Laubsch
<lau...@hplabs.hpl.hp.com>. It is an extention written in Common
Lisp of the Scheme version. It generates a LALR(1) parsing table. To
parse a string with a grammar, only this table and a driver need to be
loaded. The present version of Zebu contains the ability to define
several grammars and parsers simultaneously, a declarative framework
for specifying the semantics, as well as efficiency related
improvements. The current version compiles a grammar with 300
productions (including dumping of the tables to disk) in approx 2
minutes and 30 seconds on a HP 9000/370. This implimentation has been
tested in Lucid CL, Allegro CL, and MCL 2.0b. The current version
can also produce a generator in addition to a parser. A copy may be
found on cambridge.apple.com:/pub/mcl2/contrib/zebu-2.2.tar.Z.

Probabilistic Reasoning and Statistics:

BELIEF is a Common Lisp implementation of the Dempster and Kong fusion
and propagation algorithm for Graphical Belief Function Models and the
Lauritzen and Spiegelhalter algorithm for Graphical Probabilistic
Models. It includes code for manipulating graphical belief models such
as Bayes Nets and Relevance Diagrams (a subset of Influence Diagrams)
using both belief functions and probabilities as basic representations
of uncertainty. It is available by anonymous ftp from
ftp.stat.washington.edu [128.95.17.34]
and by email from the author, Russell Almond <alm...@stat.washington.edu>.
Contact the author at alm...@statsci.com for information about a
commercial version GRAPHICAL-BELIEF currently in the prototype stages.

XLISP-STAT is an extensible statistics package which runs in XLISP.
It has recently been ported to Common Lisp, and is available as
umnstat.stat.umn.edu:/pub/xlispstat/CL/CLS1.0A1.tar.Z [128.101.51.1]
The CL port does not yet include the lisp-stat dynamic graphics
package, only the numerics. The XLisp version is available from
the above site and several mirror sites, such as mac.archive.umich.edu,
and runs on the Apple Macintosh, Unix systems running X11
(Vax, PMAX, Sun3, Encore Multimax, and Cray XMP), Sun workstations
running SunView, and the Commodore Amiga. An experimental version
for DOS computers running Microsoft Windows 3.0 is also available.
Documentation is available online, in the tutorial introduction
pub/xlispstat/xlispstat.doc.tar.Z and also in the book
Luke Tierney, "Lisp-Stat: An Object Oriented Environment for Statistical
Computing and Dynamic Graphics", Wiley, 1990, 397 pages.
ISBN 0-471-50916-7.
For more information, write to Lisp-Stat Information, School of
Statistics, 270 Vincent Hall, University of Minnesota, Minneapolis, MN
55455, or send e-mail to lispst...@umnstat.stat.umn.edu.

CLASP (Common Lisp Analytical Statistics Package) provides the basic
functionality of a statistics package. It is implemented on top of
CLOS and CLIM on a variety of platforms, and uses BBN's SciGraph
package for plotting. The CLIM interface includes a "notebook" that is
both a "desktop" for icons and a Lisp interactor pane. The Common
Lisp Instrumentation Package (CLIP) is available along with CLASP.
CLIP is designed to allow AI system developers andevaluators a
portable way to define and manage "alligator clips" for instrumenting
their programs. CLIP produces data about program behavior in CLASP
format, as well as other commonly used data formats. It currently has
facilities to support experiment design, such as scenario scripting
and factorial combination of independent variables, and can collect
data in summary form (at the end of each trial) or based upon the
occurrence of specific events (both periodic and non-periodic). CLASP

is available by anonymous ftp from

ftp.cs.umass.edu:/pub/eksl/clasp/
and CLIP is in the directory
ftp.cs.umass.edu:/pub/eksl/clip/
A tutorial on CLASP can be found in
ftp.cs.umass.edu:/pub/eksl/clasp-tutorial/
Bugs should be reported to clasp-...@cs.umass.edu. For more
information, contact Dave Hart <dh...@cs.umass.edu>.

IDEAL is a LISP system developed for building and evaluating influence
diagrams and Bayesian networks. It is accompanied with a graphical
user interface (CLIM-based) for constructing, editing, and solving
belief networks and influence diagrams. For more information, write
to srin...@rpal.rockwell.com.

Planning:

NONLIN -- cs.umd.edu:/pub/nonlin (128.8.128.8)
Common Lisp implementation of the NONLIN planning system originally
designed and implemented by Austin Tate. Bugs can be reported to
nonli...@cs.umd.edu. User's group is nonlin...@cs.umd.edu.
The authors request that anybody ftping the code send a message to
nonlin-use...@cs.umd.edu, letting them know you have a copy
and also letting them know if you wish to subscribe to the users group.
More information can also be obtained from Jim Hendler, hen...@cs.umd.edu.

ABTWEAK is a complete hierarchical, non-linear planner that extends
David Chapman's (MIT 1986) TWEAK planner as described by
Yang (Waterloo) and Tenenberg (Rochester) in 1989. This implementation
includes a complete search strategy suited to abstraction hierarchies
known as LEFT-WEDGE (Woods 1991). This planner and related work
predates that of SNLP. ABTWEAK is available by anonymous ftp from
logos.uwaterloo.ca:/pub/abtweak/Abtweak.tar.Z
For more information, send mail to Qiang Yang <qy...@logos.uwaterloo.ca>.
Also, source, all related papers, and manuals are available via WWW
at the home page of Steve Woods <sgw...@logos.uwaterloo.ca>,
on URL http://logos.uwaterloo.ca/students/sgwoods/sgwoods.html, or via the
Logic Programming and Artificial Intelligence Group (LPAIG) page
on URL http://logos.uwaterloo.ca/.

RHETORICAL is a planning and knowledge tool available by
anonymous ftp from ftp.cs.rochester.edu:/pub/packages/knowledge-tools
in the files rhet-19-40.tar.Z and cl-lib-3-11.tar.Z. The files
tempos-3-6.tar.Z and timelogic-5-0.tar.Z add James Allen's
interval logic to Rhet. It runs on Symbolics Genera and
Allegro Common Lisp. Written by Brad Miller <mil...@cs.rochester.edu>.

PRODIGY is an integrated planning and learning system,
available free after signing a license agreement. Contact
pro...@cs.cmu.edu for more information.

SOAR is an integrated intelligent agent architecture currently
being developed at Carnegie Mellon University, the University of
Michigan, and the Information Sciences Institute of the University of
Southern California. SOAR, and its companion systems, CParaOPS5 and
TAQL, have been placed in the public domain. The system may be
retrieved by anonymous ftp to ftp.cs.cmu.edu (or any other CMU CS
machine) in the directory /afs/cs.cmu.edu/project/soar/5.2/2/public/.
[Note: You must cd to this directory in one atomic operation, as
superior directories may be protected during an anonymous ftp.] For
more information, send email to soar-r...@cs.cmu.edu or write to
The Soar Group, School of Computer Science, Carnegie Mellon
University, Pittsburgh, PA 15213. Finally, though the software is in
the public domain, the manual remains under copyright. To obtain one
(at no charge) send a request (including your physical mail address)
to soar...@cs.cmu.edu or to the physical address above.

A simple route planning agent implemented in Soar6 is available by
anonymous ftp from
earth.med.ohio-state.edu:/pub/IEEE-Soar-code/route-planning.soar6.
This is the complete code for the agent described in the IEEE Expert
article: Smith, J. W. and Johnson, T. R., "A stratified approach to
specifying, designing, and building knowledge systems", IEEE Expert,
8(3):15-25, 1993.

SNLP is a domain independent systematic nonlinear planner,
available by anonymous ftp from cs.washington.edu:/pub/snlp.tar.Z
Contact we...@cs.washington.edu for more information.

IDM is a Common Lisp implementation of both a classical and extended
version of the STRIPS planner. It is available by anonymous ftp from
sauquoit.gsfc.nasa.gov (128.183.101.29). Questions, comments and bug
reports may be sent to idm-...@chelmsford.gsfc.nasa.gov.

Planning Testbeds:

TILEWORLD is a planning testbed/simulator developed at SRI
International by Martha Pollack, Michael Frank and Marc
Ringuette. TILEWORLD originally ran under Lucid CL, but was
later extended and ported to Allegro CL by Badr H. Al-Badr
and Steve Hanks. The new tileworld is available by anonymous
ftp from cs.washington.edu as the file new-tileworld.tar.Z
It includes an X interface. Contact pol...@cs.pitt.edu for more
information.

TRUCKWORLD is a simulated world intended to provide a
testbed for AI planning programs, where the planning agent
is a truck with arms that roams around the simulated world. It is

available by anonymous ftp from

cs.washington.edu:/pub/ai/truckworld.tar.Z
It includes an X interface. Contact Steve Hanks <ha...@cs.washington.edu>
for more information. Send mail to
truckworld-u...@cs.washington.edu
to be added to the mailing list.

ARS MAGNA is a simulated world intended for use as a testbed for
planning and mapping programs. The simulated agent is a robot in an
indoors environment. High-level sensing and action are provided,
realistically modelled on current vision and robotics research. It is
written in Nisp, a macro package running on top of Common Lisp. It is

available by anonymous ftp from

dept.cs.yale.edu:/pub/nisp/
as file ars-magna.tar.Z. It includes an X display. Contact Sean Engelson
<enge...@cs.yale.edu> for more information.

Qualitative Reasoning:

QSIM is a qualitative reasoning system implemented in Common
Lisp. It is available by anonymous ftp from cs.utexas.edu:/pub/qsim
Contact Ben Kuipers <kui...@cs.utexas.edu> for more information.

QPE is the Qualitative Process Engine, an envisioner for QP theory.
QPE is publically available from multivac.ils.nwu.edu:/pub/QPE
Maintained by Ken Forbus <for...@ils.nwu.edu>.

Theorem Proving:

MVL (Multi-Valued Logic) is a theorem proving system written in Common
Lisp. MVL is a bilattice-based reasoning system. By changing the
bilattice, you can use MVL to do truth maintenance, nonmonotonic
reasoning, first-order reasoning, and a variety of other reasoning
strategies. MVL is available by anonymous ftp from
t.uoregon.edu:/mvl/mvl.tar.Z [128.223.56.46]
as mvl.tar.Z. A user's manual may be found in the file manual.tex. For
more information, contact Matthew L. Ginsberg, <gins...@t.stanford.edu>
or <gins...@cs.stanford.edu>. Matthew asks that you send him an email
message if you retrieve the system by anonymous ftp.

Boyer-Moore
ftp.cli.com:/pub/nqthm/nqthm.tar.Z Contact: kau...@cli.com
rascal.ics.utexas.edu:/pub/ 128.83.138.20
nqthm/ Boyer and Moore's theorem prover.
Also available from ftp.cli.com:/pub/nqthm.
proof-checker/ Matt Kaufmann's proof checking
enhancements to nqthm.
The mailing list nqthm-use...@cli.com is for users of the
Boyer-Moore theorem-prover, NQTHM.

DTP is a general first-order theorem prover incorporating intelligent
backtracking and subgoal caching, as well as a trace facility that can
display proof spaces graphically. Implemented in CLtL2 Common Lisp, it runs
in Franz Allegro, Lucid, and Macintosh (MCL) Common Lisp. DTP is available
on the Web at
http://logic.stanford.edu/dtp/
or by anonymous ftp from
meta.stanford.edu:/pub/dtp/ [36.8.0.54]
Contact Don Geddis <Ged...@CS.Stanford.EDU> for more information.

RRL (Rewrite Rule Laboratory) -- herky.cs.uiowa.edu:/public/rrl
[128.255.28.100]

FRAPPS (Framework for Resolution-based Automated Proof Procedures) is
a portable resolution theorem-prover written in Common Lisp. It is
available via anonymous ftp from a.cs.uiuc.edu:/pub/frapps [128.174.252.1].
If you take a copy of FRAPPS, please send a short note to Prof.
Alan M. Frisch <fri...@cs.uiuc.edu>.

Truth Maintenance:

The truth maintenance system and problem solver implementations
described in the book "Building Problem Solvers" by Ken Forbus and
Johan de Kleer are available by anonymous ftp from
parcftp.xerox.com:/pub/bps/. Includes a constraint propagation
system similar to Steele's Constraints system, among other things.
For more information send mail to Johan de Kleer <deK...@parc.xerox.com>.

Virtual Reality:

VEOS (Virtual Environment Operating Shell) is an extendible environment
for prototyping distributed applications for Unix. The programmer's
interface uses XLISP 2.1. Although intended for distributed
Virtual Reality applications at The Human Interface Technology Lab
in Seattle, it should be appropriate for other applications. VEOS
uses heavyweight sequential processes, corresponding roughly to
unix processes. VEOS runs on DEC/5000, Sun4, and Silicon Graphics
VGX and Indigo. VEOS is available by anonymous ftp from
milton.u.washington.edu:/public/veos/ [128.95.136.1]
as veos.tar.Z. If you use the software, the authors ask that you send
them mail to veos-s...@hitl.washington.edu.

Vision:

OBVIUS -- white.stanford.edu:/obvius/ [36.121.0.16]
whitechapel.media.mit.edu:/obvius/ [18.85.0.125]
Object-Based Vision and Image Understanding System (OBVIUS), is a Common
Lisp image processing package. Provides a library of image processing
routines (e.g., convolutions, fourier transforms, statistical
computations, etc.) on gray or binary images and image-sequences (no
color support yet), an X windows display interface, postscript printer
output, etc. It uses a homebrew interface to X11 (i.e., it does not use
clx or clue). However, they eventually hope to port Obvius to a clx/clue
platform. Written by David Heeger <hee...@white.stanford.edu> and Eero
Simoncelli <ee...@central.cis.upenn.edu>. Runs in Lucid-4.0. Includes
LaTeX documentation and User's Guide.

Miscellaneous:

ftp.csrl.aoyama.ac.jp:/YY/ YY window toolkit sources
ftp.csrl.aoyama.ac.jp:/lispsrc/ Common Lisp programs, including MIT's FRL.

----------------------------------------------------------------
Subject: [6-6] Formatting code in LaTeX (WEB and other literate
programming tools)

SLaTeX is a R4RS-compliant Scheme program that allows you to write
program code "as is" in your LaTeX or TeX source. It is particularly
geared to the programming languages Scheme and Common Lisp, and has
been tested in Chez Scheme, Common Lisp, MIT C Scheme, Elk, Scheme->C,
SCM and UMB Scheme on Unix; and MIT C Scheme and SCM on MSDOS. The
formatting of the code includes assigning appropriate fonts to the
various tokens in the code (keywords, variables, constants, data), at
the same time retaining the proper indentation when going to the
non-monospace (non-typewriter) provided by TeX. SLaTeX comes with two
databases that recognize the standard keywords/variables/constants of
Scheme and Common Lisp respectively. These can be modified by the
user using easy TeX commands. In addition, the user can inform SLaTeX
to typeset arbitrary identifiers as specially suited TeX expressions
(i.e., beyond just fonting them). The code-typesetting program SLaTeX

is available by anonymous ftp from

cs.rice.edu:/public/dorai/slatex23.tar.gz
Send bug reports to do...@cs.rice.edu.

SchemeWEB provides simple support for literate programming in Lisp.
SchemeWEB version 2.0 is a Unix filter that allows you to generate
both Lisp and LaTeX code from one source file. The generated LaTeX
code formats Lisp programs in typewriter font obeying the spacing in
the source file. Comments can include arbitrary LaTeX commands.
SchemeWEB was originally developed for the Scheme dialect of Lisp, but
it can easily be used with most other dialects. Version 2.0 is
available in the Scheme Repository as
cs.indiana.edu:/pub/scheme-repository/new/schemeweb.sh
or in the Comprehensive TeX Archive Network (CTAN) in the directory
ftp.shsu.edu:/tex-archive/web/schemeweb

LiSP2TeX is a system that allows easy insertions of Scheme, or Lisp,
code towards TeX files. The originality of LiSP2TeX is that it
extracts Scheme definitions from the files where they appear and wraps
them appropriately within TeX macros for insertion into the
documentation file. LiSP2TeX decorrelates writing documentation from
programming: it is therefore possible to separately develop programs
and documentations and to merge them at the end to produce up to date
final documents. LiSP2TeX also has some pretty-printing capabilities
to produce denotations full of greek letters. It is available by
anonymous ftp from ftp.inria.fr:/INRIA/Projects/icsla/.

See also ftp.cs.cmu.edu:/user/ai/lang/lisp/code/tools/user_man/.

The Literate Programming FAQ lists a number of alternatives, both
language-independent and Lisp-specific. The Literate Programming FAQ
is posted once a quarter to the comp.literate.programming newsgroup
and is available by anonymous ftp from rtfm.mit.edu. A copy may also be
requested by sending an email message to file...@shsu.edu
sendme litprog.faq
in the body of the message.

----------------------------------------------------------------
Subject: [6-7] Where can I get an implementation of Prolog in Lisp?

Implementations of Prolog in Lisp:

The Frolic package from the University of Utah is written in Common Lisp
and available by anonymous ftp from cs.utah.edu:/pub/frolic.tar.Z

LM-PROLOG by Ken Kahn and Mats Carlsson is written in ZetaLisp and not
easily portable to Common Lisp. It is available by anonymous ftp from
sics.se:/archive/lm-prolog.tar.Z.

Peter Norvig's book "Paradigms of AI Programming" includes Common Lisp
implementations of a prolog interpreter and compiler. The software is
available by anonymous ftp from unix.sri.com:/pub/norvig/ and on disk in

Macintosh or DOS format from the publisher, Morgan Kaufmann. For more
information, contact: Morgan Kaufmann, Dept. P1, 2929 Campus Drive, Suite

260, San Mateo CA 94403, (800) 745-7323; FAX: (415) 578-0672

Harlequin's LispWorks comes with Common Prolog -- a fast
Edinburgh-compatible Prolog integrated with Common Lisp. Write to:
Harlequin Limited, Barrington Hall, Barrington, Cambridge, CB2 5RG, call
0223 872522 (or 44223 872522 outside UK), telex 818440 harlqn g, fax 0223
872519, or send email to a...@uk.co.harlqn (or a...@harlqn.co.uk for US people).

eLP (Ergo Lambda Prolog) is an interpreter written by Conal Elliott,
Frank Pfenning and Dale Miller in Common Lisp and implements the core
of lambda Prolog (higher-order hereditary Harrop formulas). It is
embedded in a larger development environment called ESS (the Ergo
Support System). eLP implements all core language feature and offers
a module system, I/O, some facilities for tracing, error handling,
arithmetic, recursive top-levels, on-line documentation and a number
of extended examples, including many programs from Amy Felty's and
John Hannan's thesis. It should run in Allegro Common Lisp, Lucid
Common Lisp, Kyoto Common Lisp, CMU Common Lisp and Ibuki Common Lisp.
The eLP implementation of lambda Prolog is no longer developed or
maintained, but it is still available via anonymous ftp from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/project/ergo/export/ess/. The file
ergolisp.tar.Z contains the Ergo project's extensions to Common Lisp,
including some facilities for attributes and dealing with abstract
syntax trees. The file sb.tar.Z contains the Ergo
Parser/Unparser/Formatter generator and ab.tar.Z contains the Ergo
Attribute Grammar facility. The file elp.tar.Z contains the Ergo
implementation of lambda Prolog. To customize grammars you need the
sb.tar.Z file. When you retrieve the system, please print, fill out,
and send in a copy of the non-restrictive license you will find in the
file LICENSE. To subscribe to the e...@cs.cmu.edu mailing list, send
mail to elp-r...@cs.cmu.edu. Bugs should be sent to
elp-...@cs.cmu.edu.

The book "On Lisp" by Paul Graham includes an implementation of
Prolog in Common Lisp. The code is available by anonymous ftp from
endor.harvard.edu:/pub/onlisp
and also in the CMU AI Repository as
ftp.cs.cmu.edu:/user/ai/lang/lisp/bookcode/graham/

See the Scheme FAQ for information on implementations of Prolog in Scheme.

----------------------------------------------------------------
Subject: [6-8] World-Wide Web (WWW) Resources

The World Wide Web (WWW) is a hypermedia document that spans the
Internet. It uses the http (HyperText Transfer Protocol) for the
light-weight exchange of files over the Internet. NCSA Mosaic is a
World Wide Web browser developed at the National Center for
Supercomputing Applications (NCSA).

Mosaic's popularity derives, in part, from its ability to communicate
using more traditional Internet protocols like FTP, Gopher, WAIS, and
NNTP, in addition to http. Mosaic can display text, hypertext links,
and inlined graphics directly. When Mosaic encounters a file type it
can't handle internally, such as Postscript documents, mpeg movies,
sound files, and JPEG images, it uses an external viewer (or player)
like Ghostscript to handle the file. Mosaic also includes facilities
for exploring the Internet. In other words, Mosaic is an multimedia
interface to the Internet.

The hypertext documents viewed with Mosaic are written in HTML
(HyperText Markup Language), which is a subset of SGML (Standard
Generalized Markup Language). All that is needed is just a few more
improvements, such as the ability to format tables and mathematics,
and a WYSIWYG editor, for HTML to greatly facilitate electronic
journals and other publications.

NCSA Mosaic for the X Window System is available by anonymous ftp from
ftp.ncsa.uiuc.edu:/Mosaic/
as source code and binaries for Sun, SGI, IBM RS/6000, DEC Alpha OSF/1, DEC
Ultrix, and HP-UX. Questions about NCSA Mosaic should be directed to
mosa...@ncsa.uiuc.edu (X-Windows version), mosai...@ncsa.uiuc.edu
(Macintosh), and mosai...@ncsa.uiuc.edu (Microsoft Windows).

A simple HTML version of the Lisp FAQ (this FAQ) is available as
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html

Association of Lisp Users:
http://www.cs.rochester.edu/u/miller/alu.html
[Contains links to a lot of Lisp resources, including a history of
Lisp, bibliographies of Lisp books, the Lisp Repository at CMU, and
even some Lisp humor. Very nicely done.]
Contact: Brad Miller <mil...@cs.rochester.edu>

----------------------------------------------------------------
;;; *EOF*

Mark Kantrowitz

unread,

Aug 13, 1997, 3:00:00 AM8/13/97

Archive-name: lisp-faq/part7
Last-Modified: Fri Mar 22 16:00:46 1996 by Mark Kantrowitz
Version: 1.54

Maintainer: Mark Kantrowitz and Barry Margolin <ai+li...@cs.cmu.edu>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html

Size: 18249 bytes, 320 lines

;;; ****************************************************************
;;; Lisp Window Systems and GUIs ***********************************

;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin

;;; lisp_7.faq

This post contains Part 7 of the Lisp FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

Topics Covered (Part 7):

[7-1] How can I use the X Window System or other GUIs from Lisp?
[7-2] What Graphers/Browsers are available?

Search for \[#\] to get to question number # quickly.

----------------------------------------------------------------
Subject: [7-1] How can I use the X Window System or other GUIs from Lisp?

There are several GUI's and Lisp interfaces to the X Window System. Mailing
lists for these systems are listed in the answer to question [4-7].
Various vendors also offer their own interface-building packages.

CLX provides basic Common Lisp/X functionality. It is a de facto standard
low-level interface to X, providing equivalent functionality to XLib, but
in Lisp. It is also a good source for comparing the foreign function calls
in various Lisps. Does *not* depend on CLOS. Available free as part of the
X release in the contrib directory. Also available by anonymous ftp from
ftp.x.org:/R5contrib/ as the files CLX.Manual.tar.Z and CLX.R5.02.tar.Z.
[Note: The new version of CLX for X11R6 can be found (untarred) in
ftp.x.org:/pub/R6.1/contrib/lib/CLX/
with documentation in
ftp.x.org:/pub/R6.1/contrib/doc/CLX/
and includes some slight modifications for CLtL2 compatability. You
can get it in tarred form from the CMU AI Repository, Lisp section.]
Primary Interface Author: Robert W. Scheifler <r...@zermatt.lcs.mit.edu>
Send bug reports to bug...@expo.lcs.mit.edu.
The 232 page manual is available in /pub/R5untarred/mit/hardcopy/CLX
(PostScript format) and /pub/R5untarred/mit/doc/CLX (Interleaf source).

CLIM (Common Lisp Interface Manager) is a portable, graphical user
interface toolkit originally developed by International Lisp
Associates, Symbolics, and Xerox PARC, and now under joint development
by several Lisp vendors, including Symbolics, Franz, Lucid, Illudium,
and Harlequin. It is intended to be a portable successor of Symbolics
UIMS (Dynamic Windows, Presentations Types). CLIM 2.0 also supports
more traditional toolkit-style programming. It runs on Symbolics Lisp
Machines; Allegro, Lucid, and Harlequin on several Unix platforms;
Symbolics CLOE on 386/486 IBM PCs running Windows; and MCL on Apple
Macintoshes. It is *not* free, and with the exception of
Macintoshes, if it is available it can be purchased from the vendor
of the Lisp system you are using. For the Macintosh version write
to Illudium:
Contact: Dennis Doughty - Dou...@ileaf.com
or contact: Bill York - yo...@parc.xerox.com
Illidium has signed a distribution agreement for MCL CLIM with
Lucid. [Contact Harlequin for information about Lucid.]
CLIM includes a general purpose grapher. The CLIM 2.0 SPECIFICATION
is available by anonymous ftp from ftp.franz.com:/pub/clim/clim.ps.Z.
To be added to the mailing list send mail to clim-r...@bbn.com.

CLUE (Common Lisp User-Interface Environment) is from TI, and extends CLX
to provide a simple, object-oriented toolkit (like Xt) library that uses
CLOS. Provides basic window classes, some stream I/O facilities, and a few
other utilities. Still pretty low level (it's a toolkit, not widget
library). Available free by anonymous ftp from csc.ti.com:/pub/clue.tar.Z
Written by Kerry Kimbrough. Send bug reports to clue...@dsg.csc.ti.com.

CLIO (Common Lisp Interactive Objects) is a GUI from the people who created
CLUE. It provides a set of CLOS classes that represent the standard
components of an object-oriented user interface -- such as text, menus,
buttons, scroller, and dialogs. It is included as part of the CLUE
distribution, along with some packages that use it, both sample and real.

Allegro Common Windows provides a front end to CLX. Uses CLOS.
It is *not* free. Contact in...@franz.com for more information.
[Intellicorp's KEE4.0 comes with Common Windows also. They've
implemented the CW spec to run on Lucid 4.0 on Sparcs, HP300/400s,
HP700/800s, and IBM RS6000s. Contact ta...@intellicorp.com for more
information.]

The LispWorks Toolkit is an extensible CLOS-based widget set that uses
CLX and CLUE. The LispWorks programming environment has been written
using the toolkit and includes: an Emacs-like editor, listener,
debugger, profiler, and operating system shell; browsers/graphers for
classes, generic functions, processes, windows, files, compilation
errors, source code systems, and setting LispWorks parameters; and an
interactive interface builder and complete online hypertext
documentation. Contact: lispwork...@harlqn.co.uk

CLM (Common Lisp Motif) and GINA (Generic Interactive Application) and
IB (Interface Builder). CLM runs Motif widgets in a separate C
process, with minimal work on the Lisp side and communicates between C
and Lisp using TCP sockets. Runs in Allegro CL, Sun CL, CMU CL, Lucid
CL, and Symbolics Genera. GINA uses CLOS. Available free in the X
contrib directory or by anonymous ftp from either
ftp.x.org:/contrib (formerly export.lcs.mit.edu) or
ftp.gmd.de:/gmd/gina [129.26.8.84]
as the files CLM+GINA.README, CLM2.2.tar.Z and GINA2.2.tar.Z. CLM was
written by Andreas Baecker <bae...@gmd.de>, GINA by Mike Spenke
<spe...@gmd.de>, and IB by Thomas Berlage <ber...@gmd.de>.
Contact Mike Spenke for more info. To be added to the mailing list,
send a message to gina-user...@gmd.de.

EW (Express Windows) is intended to mimic Symbolics' Dynamic Windows user
and programmer interfaces. It is available free in the Common Lisp
Repository as
ftp.cs.cmu.edu:/user/ai/lang/lisp/gui/ew/
It is no longer under active development. Runs on Sun/Lucid, Franz
Allegro, and Symbolics. Should port easily to other Lisps with CLX.
Written by Andrew L. Ressler <ares...@oiscola.columbia.ncr.com>.

Garnet is a large and flexible GUI. Lots of high-level features. Does
*not* depend on CLOS, but does depend on CLX. Garnet (version 2.0 and
after) is now in the public domain, and has no licensing restrictions,
so it is available to all foreign sites and for commercial uses.
Detailed instructions for obtaining it by anonymous ftp are available
by anonymous ftp as
a.gp.cs.cmu.edu:/usr/garnet/garnet/README [128.2.242.7]
Garnet includes the Lapidiary interactive design tool, C32 constraint
editor, spreadsheet object, Gilt Interface Builder, automatic display
management, two widget sets (Motif look-and-feel and Garnet
look-and-feel), support for gesture recognition, and automatic
constraint maintenance, application data layout and PostScript
generation. Runs in virtually any Common Lisp environment, including
Allegro, Lucid, CMU, and Harlequin Common Lisps on Sun, DEC, HP,
Apollo, IBM 6000, and many other machines. Garnet helps implement
highly-interactive, graphical, direct manipulation programs for X/11
in Common Lisp. Typical applications include: drawing programs
similar to Macintosh MacDraw, user interfaces for expert systems and
other AI applications, box and arrow diagram editors, graphical
programming languages, game user interfaces, simulation and process
monitoring programs, user interface construction tools, CAD/CAM
programs, etc. Contact Brad Myers (b...@a.gp.cs.cmu.edu) for more
information. Bug reports should be sent to garne...@cs.cmu.edu.
Administrative questions should be sent to gar...@cs.cmu.edu or
garnet-...@cs.cmu.edu. Garnet is discussed on the newsgroup
comp.windows.garnet (which is gatewayed to garnet...@cs.cmu.edu for
those without access to netnews).

LISP2WISH is a very simple demonstration of how to connect and
communicate SYNCHRONOUSLY between a lisp process and a C process
running a Tcl/Tk executable. The demo uses the vanilla 'wish'
executable that is included with the Tcl/Tk distribution. Tcl/Tk is a
very flexible system for building Graphical User Interfaces (GUIs),
with the look-and-feel of Motif. One writes scripts in a high-level,
C-like language, and an interpreter evaluates the commands and passes
execution either to a built-in function (and there are many), or to
your own C routines. Tcl/Tk is becoming increasingly popular because
of its ease of use, and because it is freely distributable (even
commercially, I believe). For more information on Tcl/Tk, look on the
USENET newsgroup comp.lang.tcl, or get the distribution from the
archive (listed below) or ftp.cs.berkeley.edu. The Tcl/Tk archive
also has many user-contributed extensions which make Tcl/Tk even more
desirable. Tcl/Tk was originally written by Dr. John Ousterhout, at
Berkeley. LISP2WISH lets you make a window/menu/drawing interface for
your lisp routines, where you can take advantage of all the stuff
written for Tcl/Tk (and build your own!).
LISP2WISH has only been tested under X-Windows and Lucid Common Lisp
4.0 and 4.1, but should work on other platforms that support Lucid
(or Allegro) and Tcl/Tk. LISP2WISH is available at the Tcl/Tk archive
harbor.ecn.purdue.edu:/pub/tcl/lisp2wish6.tar.gz,
from the author through the WWW at the URL
http://www.cis.upenn.edu/~kaye/home.html
by anonymous ftp from
ftp.cis.upenn.edu:/pub/kaye/lisp2wish6.tar.Z
or in the GUI section of the Lisp Repository as
ftp.cs.cmu.edu:/user/ai/lang/lisp/gui/lsp2wish/lsp2wish.tgz
For more information, contact Jonathan Kaye <ka...@linc.cis.upenn.edu>.

LispView is a GUI written at Sun that does not use CLX. Instead it
converts Xlib.h directly into Lucid foreign function calls. It is intended
to be fast and tight. Uses CLOS. Available for anonymous ftp from
ftp.x.org:/contrib/lispview1.1 (formerly export.lcs.mit.edu) and
xview.ucdavis.edu:/pub/XView/LispView1.1
Includes a general-purpose 2D grapher library.
Written by Hans Muller (hmu...@sun.com). Runs in Sun CL and Lucid CL.
Direct questions about the source provision to lisp...@Eng.Sun.Com.

WINTERP (Widget INTERPreter) is an application development environment
developed at HP. It enables the rapid prototyping of graphical
user-interfaces through direct manipulation of user interface objects
and their attached actions. WINTERP provides an interface to the X11
toolkit (Xt) and the OSF/Motif widget set and a built-in RPC mechanism
for inter-application communication. It includes an object-oriented
2.5D graphics and animation widget based on the Xtango path transition
animation system, the XmGraph graph browser (with graph nodes as
arbitrary WINTERP widgets), and GIF image support. The interpreter is
based on David Betz's XLISP interpreter, which implements a small
subset of Common Lisp and runs on PCs, IBM RS/6000, Decstation 3100s,
HP9000s, Sun3, Sparcs, SGI, and NeXT. XLISP provides a simple
Smalltalk-like object system, with OSF/Motif widgets as real XLISP
objects -- they can be specialized via subclassing, methods added
or altered, etc. WINTERP includes an interface to GNU-Emacs which
allows code to be developed and tested without leaving the editor.
WINTERP is a free-standing Lisp-based tool for setting up window
applications. WINTERP is available free in X contrib directory, or
by anonymous ftp from
ftp.x.org:/contrib/devel_tools/
as winterp-???.tar.gz (formerly export.lcs.mit.edu) where ??? is the
version number. The current version is 2.03 (X11r6 support). If you
do not have Internet access you may request the source code to be
mailed to you by sending a message to winterp...@netcom.com.
The WWW home page for WINTERP is accessible via the URL
http://www.eit.com/software/winterp/winterp.html
or mirrored on
file://ftp.x.org/contrib/devel_tools/winterp.html
Contact Niels Mayer <ma...@netcom.com> for more information. To be
added to the mailing list, send mail to winterp...@netcom.com.

Xgcl provides an interface to X Windows for GCL (GNU Common Lisp),
formerly Austin Kyoto Common Lisp (AKCL). It includes a low-level
interface to the Xlib routines, and an interface that provides
graphics, menus, and mouse interaction via functions that are called
from Lisp. Xgcl is built on top of GCL, and it is somewhat larger
(e.g. 6.7 MB for Xgcl vs. 4.9 MB for GCL) because it incorporates
Xlib. To make Xgcl, you must first obtain and make GCL. The code
was written by Gordon Novak, Hiep Nguyen, and William Schelter. Xgcl

is available by anonymous FTP from

math.utexas.edu:/pub/gcl/
ftp.cli.com:/pub/gcl/
ftp.cs.utexas.edu:/pub/novak/xgcl/
and on the Web from
http://www.cs.utexas.edu/users/novak
as the file xgcl-2.tgz. To use, put the xgcl-2.tgz file in the same
directory as gcl-1.1.tgz and uncompress it with
gzip -dc xgcl-2.tgz | tar xvf -
Then see the README in the directory xgcl-2. For more information,
write to Gordon Shaw Novak, Jr. <no...@cs.utexas.edu>.

YYonX is a port of the YY system to X windows. Runs in Lucid CL, Allegro
CL, and Symbolics Genera. Supports kanjii. Developed at Aoyama Gakuin
University. Available free by anonymous ftp from
ftp.csrl.aoyama.ac.jp:/YY/
Written by Masayuki Ida <i...@cc.aoyama.ac.jp>

Picasso is a CLOS based GUI, and is available from
postgres.berkeley.edu:/pub/Picasso-2.0
toe.cs.berkeley.edu:/pub/picasso/
It runs on DecStation 3100s, Sun3 (SunOs), Sun4 (Sparc), and Sequent
Symmetry in Allegro CL. The file pub/xcl.tar.Z contains X-Common Lisp
interface routines. Send mail to pic...@postgres.berkeley.edu for
more information. [Picasso is no longer an actively supported system.]

XIT (X User Interface Toolkit) is an object-oriented user interface
development environment for the X Window System based on Common Lisp,
CLOS, CLX, and CLUE. It has been developed by the Research Group
DRUID at the Department of Computer Science of the University of
Stuttgart (dr...@informatik.uni-stuttgart.de) as a framework for
Common Lisp/CLOS applications with graphical user interfaces for the X
Window System. XIT contains user interface toolkits, including
general building blocks and mechanisms for building arbitrary user
interface elements and a set of predefined common elements (widgets),
as well as high-level interactive tools for constructing, inspecting,
and modifying user interfaces by means of direct manipulation.
Although the system kernel is quite stable, XIT is still under active
development. XIT can be obtained free by anonymous ftp from
ftp.informatik.uni-stuttgart.de:/pub/xit/ [129.69.211.2]

----------------------------------------------------------------
Subject: [7-2] What Graphers/Browsers are available?

Most of the graphics toolkits listed above include graphers. In
particular, CLIM, LispWorks, Garnet, and Lispview all include
graphers. The ISI grapher used to be in fairly widely used, but the
CLIM grapher seems to be overtaking it in popularity.

A simple grapher like the one described in "Lisp Lore" by Bromeley and
Lamson is available by anonymous ftp from
ftp.csrl.aoyama.ac.jp:/graphers/
as the file graphers.tar.Z.uu. It includes versions for CLX, Express
Windows, NCW, CLUE, CLM/GINA, Common Windows, LispView, Winterp, CLIM
and YY. Several implementations have a mouse sensitivity feature and
others have implementation-specific features. A copy has been made
available from the Lisp Utilities Repository. For further information,
contact Masayuki Ida <i...@csrl.aoyama.ac.jp>.

Grasper-CL is a system for viewing and manipulating graph-structured
information. Grasper-CL includes procedures for graph construction,
modification, and queries as well as a menu-driven, interactive,
layout and drawing package (implemented using CLIM) that allows graphs
to be constructed, modified, and viewed through direct pictorial
manipulation. Grasper-CL nodes include simple geometric figures, such
as circles, rectangles, and diamonds, as well as user-defined icons.
Grasper-CL links include piecewise linear and arbitrarily curved
arrows between nodes. User-definable actions can be associated with
every graphical object. The Grasper-CL system consists of several
different components: a core procedure library for programmatically
manipulating the graph abstract datatype, a graph-display module for
producing drawings of graphs, a graph editor that allows users to
interactively draw and edit arbitrary graphs, and a suite of automatic
graph-layout algorithms. Grasper-CL is available under license from
SRI; contact lowr...@ai.sri.com for licensing information. For
additional technical information see
P. D. Karp, J. D. Lowrance, T. M. Strat, and D. E. Wilkins, "The
Grasper-CL Graph Management System", LISP and Symbolic Computation: An
International Journal, Kluwer Academic Publishers, 7:251-290, 1994.
and the Grasper-CL home page,
http://www.ai.sri.com/~grasper/

----------------------------------------------------------------
;;; *EOF*

0 new messages