From: Mark Kantrowitz
Subject: FAQ: Frequently Asked Questions about Lisp 1/2 [Monthly posting]
Date:
Message-ID: <lisp-faq-1.text_697768216@cs.cmu.edu>
Archive-name: lisp-faq/part1
Last-Modified: Mon Feb 10 17:40:59 1992 by Mark Kantrowitz
Version: 1.1
The news.answers newsgroup has been temporarily removed from this
posting until the news.answers moderator gets around to reading his email.
;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Lisp ***************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; lisp-faq-1.text -- 49756 bytes
This post contains Part 1 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 us at ········@think.com.
Topics Covered (Part 1):
[1] What is the purpose of this newsgroup?
[2] What documentation is available on Lisp? How can I learn Lisp?
[3] What documentation is available about object-oriented
programming in Lisp?
[4] How can I improve my Lisp programming style and coding efficiency?
[5] Where can I learn about implementing Lisp interpreters and compilers?
[6] Where can I get/buy Lisp for the ... architecture?
[7] Where can I get an implementation of Prolog in Lisp?
[8] What Lisp-related discussion groups and mailing lists exist?
Topics Covered (Part 2):
[9] What FTP resources are available?
[10] Is there a GNU-Emacs interface to Lisp?
[11] How can I use the X Window System from Lisp?
[12] What does CLOS, PCL, X3J13, CAR, CDR, ... mean?
What is CLOS (PCL) and where can I get it?
How do you pronounce CLOS?
What is CLOS (PCL) and where can I get it?
[14] Why does (READ-FROM-STRING "foobar" :START 3) return FOOBAR
instead of BAR?
[15] Why can't it deduce from (READ-FROM-STRING "foobar" :START 3)
that the intent is to specify the START keyword parameter
rather than the EOF-ERROR-P and EOF-VALUE optional parameters?
[16] How I write a function that can access defstruct slots by
name? I would like to write something like
(STRUCTURE-SLOT <object> '<slot-name>).
[17] Why can't I apply #'AND and #'OR?
[18] When is it right to use EVAL?
[19] I used a destructive function (e.g. DELETE, SORT), but it
didn't seem to work. Why?
[20] After I NREVERSE a list, it's only one element long. After I
SORT a list, it's missing things. What happened?
[21] What is the equivalent of EXPLODE and IMPLODE in Common Lisp?
[22] Is Lisp inherently slower than more conventional languages such as C?
[23] Why does my program's behavior change each time I use it?
[24] Why does Common Lisp have "#'"?
[25] How can I list all the CLOS instances in a class?
[26] How do I call non-Lisp functions from Lisp?
[27] Can I call Lisp functions from other languages?
[28] Why does (READ-LINE) return "" immediately instead of waiting
for me to type a line?
[29] I typed a form to the read-eval-print loop, but nothing happened. Why?
[30] I want to call a function in a package that might not exist at
compile time. How do I do this?
[31] What is CDR-coding?
[32] What is garbage collection?
[33] How do I save an executable image of my loaded Lisp system?
[34] I'm porting some code from a Symbolics Lisp machine to some
other platform, and there are strange characters in the code.
What do they mean?
[35] History: Where did Lisp come from?
Search for [#] to get to question number # quickly.
Introduction:
Certain questions and topics come up frequently in the various network
discussion groups devoted to and related to Lisp. This file/article is
an attempt to gather these questions and their answers into a convenient
reference for Lisp programmers. It (or a reference to it) is posted
periodically. The hope is that this will cut down on the user time and
network bandwidth used to post, read and respond to the same questions
over and over, as well as providing education by answering questions
some readers may not even have thought to ask.
This is not a Lisp tutorial, nor is it an exhaustive list of all Lisp
intricacies. Lisp is a very powerful and expressive language, but with
that power come many complexities. This list attempts to address the
ones that average Lisp programmers are likely to encounter. If you are
new to Lisp, see the answer to the question "How can I learn Lisp?".
The latest version of this file should always be available via anonymous
FTP from any CMU CS machine (e.g., a.gp.cs.cmu.edu), in the directory
/afs/cs.cmu.edu/user/mkant/Public/Lisp-Utilities/ as the files
lisp-faq-1.text and lisp-faq-2.text.
[Note: You must cd to this directory in one command, as intermediate
directories are protected from an anonymous ftp.]
Unless otherwise specified, the Lisp dialect referred to is Common Lisp,
as defined by "Common Lisp: the Language" (aka "CLtL") as well as
corrections (but not enhancements) from "Common Lisp: the Language, 2nd
Edition" (aka "CLtL2"), both by Guy L. Steele, Jr. and published by
Digital Press.
----------------------------------------------------------------
[1] What is the purpose of this newsgroup?
This newsgroup (comp.lang.lisp) exists for general discussion of
topics related to the programming language Lisp. For example, possible
topics can include (but are not necessarily limited to):
announcements of Lisp books and products
discussion of programs and utilities written in Lisp
discussion of portability issues
questions about possible bugs in Lisp implementations
problems porting an implementation to some architecture
Postings should be of general interest to the Lisp community.
Questions about object oriented programming in Lisp should be directed
to the newsgroup comp.lang.clos. Similarly, questions about the
programming language Scheme should be directed to the newsgroup
comp.lang.scheme. Discussion of AI programs implemented in Lisp should
sometimes be cross-posted to the newsgroup comp.ai.
----------------------------------------------------------------
[2] What documentation is available on Lisp?
How can I learn Lisp?
There are several good Lisp introductions and tutorials:
1. David S. Touretzky
"Common Lisp: A Gentle Introduction to Symbolic Computation"
Benjamin/Cummings Publishers, 1990. 384 pages.
Perhaps the best tutorial introduction to the language. It has
clear and correct explanations, and covers some fairly advanced
topics. The book is an updated Common Lisp version of the 1984
edition published by Harper and Row Publishers.
2. Robert Wilensky
"Common LISPcraft"
W. W. Norton, 1986. 385 pages.
3. Wade L. Hennessey
"Common Lisp"
McGraw-Hill, 1989. 395 pages.
Fairly good, but jumps back and forth from the simple to the
complex rather quickly, with no clear progression in difficulty.
4. Laurent Siklossy
"Let's Talk LISP"
Prentice-Hall, NJ, 1976. 237 pages.
Other introductions to Lisp include:
1. A. A. Berk.
"LISP, The Language of Artificial Intelligence"
Van Nostrand Reinhold, 1985. 160 pages.
2. Paul Y. Gloess.
"An Alfred handy guide to Understanding LISP"
Alfred Publishers (Sherman Oaks, CA), 1982. 64 pages.
3. Ward D. Maurer.
"The Programmer's Introduction to LISP"
American Elsevier, 1972. 112 pages.
4. Hank Bromley and Richard Lamson.
"LISP Lore: A Guide to Programming the LISP Machine"
Kluwer Academic (Boston), 1987. 337 pages.
5. Sharam Hekmatpour.
"Introduction to LISP and Symbol Manipulation"
Prentice Hall (New York), 1988. 303 pages.
6. Deborah G. Tatar
"A programmer's guide to Common Lisp"
Digital Press, 1987. 327 pages. ISBN 0-932376-87-8.
Good introduction on Common Lisp.
More advanced introductions to Lisp and its use in Artificial
Intelligence include:
1. Peter Norvig.
"Paradigms of AI Programming: Case Studies in Common Lisp"
Morgan Kaufmann, 1992. 946 pages. ISBN 1-55860-191-0.
2. Eugene Charniak, Christopher K. Riebeck, Drew V. McDermott
and James R. Meehan.
"Artificial Intelligence Programming", 2nd edition.
Lawrence Erlbaum Associates (Hillsdale, NJ), 1987. 533 pages.
Provides many nice code fragments, all of which are written
in Common Lisp. The first half of the book covers topics
like macros, the reader, data structures, control structures,
and defstructs. The second half of the book describes
programming techniques specific to AI, such as
discrimination nets, production systems, deductive database
retrieval, logic programming, and truth maintenance.
3. Patrick H. Winston and Berthold K. P. Horn.
"LISP", 3rd edition.
Addison-Wesley (Reading, MA), 1989. 611 pages.
Covers the basic concepts of the language, but also gives a lot
of detail about programming AI topics such as rule-based expert
systems, forward chaining, interpreting transition trees,
compiling transition trees and finding patterns in images. Not
a tutorial. Has many good examples.
4. Rodney A. Brooks.
"Programming in Common Lisp"
Wiley, 1985. 303 pages.
5. John R. Anderson, Albert T. Corbett, and Brian J. Reiser.
"Essential LISP"
Addison-Wesley (Reading, MA), 1987. 352 pages.
Concentrates on how to use Lisp with iteration and recursion.
6. Robert D. Cameron and Anthony H. Dixon
"Symbolic Computing with Lisp"
Prentice-Hall, 1992, 326 pages. ISBN 0-13-877846-9.
The book is intended primarily as a third-year computer science
text. In terms of programming techniques, it emphasizes recursion
and induction, data abstraction, grammar-based definition of Lisp
data structures and functional programming style. It uses
two Lisp languages:
(1) a purely functional subset of Lisp called Small Lisp and
(2) Common Lisp.
An MS-DOS interpreter for Small Lisp (including source) is
provided with the book. It considers applications of Lisp
to formal symbolic data domains: algebraic expressions,
logical formulas, grammars and programming languages.
7. Hasemer and Domingue.
"Common Lisp Programming for Artificial Intelligence"
Addison-Wesley, 1989.
General Lisp reference books include:
1. Guy L. Steele
"Common Lisp: The Language" [CLtL1]
Digital Press, 1984. 465 pages. ISBN 0-932376-41-X.
2. Guy L. Steele
"Common Lisp: The Language, 2nd Edition" [CLtL2]
Digital Press, 1990. 1029 pages. ISBN 1-55558-041-6.
3. Franz Inc.
"Common Lisp: The Reference"
Addison-Wesley, Reading, MA 1988. ISBN 0-201-11458-5
Entries on lisp functions in alphabetical order.
4. K. Dybvig.
"The Scheme programming language"
Prentice Hall, 1987.
Good reference for Scheme.
Lisp periodicals include:
1. LISP Pointers.
Published by ACM SIGPLAN six times a year. Volume 1, Number 1
was April-May 1987.
2. LISP and Functional Programming (···@lucid.com is the editor).
3. Proceedings of the biannual ACM Lisp and Functional Programming
Conference. (First one was in 1980.)
4. Proceedings of the annual Lisp Users and Vendors Conference.
Introductions to Scheme (Many books on Scheme are worth reading
even if you use Common Lisp, because many of the issues are similar):
1. Harold Abelson and Gerald Jay Sussman, with Julie Sussman.
"Structure and Interpretation of Computer Programs"
MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985.
542 pages.
Starts off introductory, but rapidly gets into powerful
Lisp-particular constructs, such as using closures and
engines, building interpreters, compilers and
object-oriented systems.
2. Daniel P. Friedman and M. Felleisen.
"The Little LISPer"
Science Research Associates (Chicago), 1974. 58 pages.
MIT Press (Cambridge, MA), 1987. ISBN 0-262-56038-0.
Good for a quick introduction. Uses Scheme instead of
Common Lisp.
3. George Springer and Daniel P. Friedman
"Scheme and the Art of Programming"
MIT Press and McGraw Hill, 1989.
Introduces basic concepts of programming in Scheme. Also deals
with object oriented programming, co-routining, continuations.
4. Wolfgang Kreutzer and Bruce McKenzie
"Programming for Artificial Intelligence:
Methods, Tools and Applications"
Addison-Wesley (Reading, MA), 1990. 682 pages.
ISBN 0-201-41621-2.
Discusses Scheme, Prolog, and Smalltalk, gives an overview of
the history and philosophy of AI, surveys three major
programming paradigms (procedural, declarative, and
object-oriented), and metaphors to AI programming.
5. Smith
"Introduction to Scheme"
1988.
Focuses on PC Scheme.
6. Michael Eisenberg
"Programming in Scheme"
Scientific Press (Redwood City, CA), 1988. 304 pages.
----------------------------------------------------------------
[3] What documentation is available about object-oriented programming in Lisp?
Books about object-oriented programming in Lisp include:
1. See CLtL2 for a description of the CLOS standard.
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
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.
----------------------------------------------------------------
[4] How can I improve my Lisp programming style and coding efficiency?
There are several books about Lisp programming style, including:
1. Molly M. Miller and Eric Benson
"Lisp Style and Design"
Digital Press, 1990. 214 pages. ISBN 1-55558-044-0.
How to write large Lisp programs and improve Lisp programming
style. Uses the development of Lucid CL as an example.
2. Robin Jones, Clive Maynard, and Ian Stewart.
"The Art of Lisp Programming"
Springer-Verlag, 1989. 169 pages.
3. W. Richard Stark.
"LISP, Lore, and Logic: an algebraic view of LISP
programming, foundations, and applications"
Springer-Verlag, 1990. 278 pages.
Self-modifying code, self-reproducing programs, etc.
4. CMU CL User's Manual, Chapter 7, (talks about writing
efficient code). It is available by anonymous ftp from any CMU CS
machine (e.g., lisp-rt1.slisp.cs.cmu.edu) as the file
/afs/cs.cmu.edu/project/clisp/docs/cmu-user/cmu-user.ps
[when getting this file by anonymous ftp, one must cd to
the directory with one command, as intermediate directories
a protected during an anonymous ftp].
5. See also Norvig's book, SICP (Abelson & Sussman), SAP
(Springer and Friedman).
Here are some general suggestions/notes about improving Lisp
programming style:
Functions often abused or misunderstood by novices:
- EVAL
- PROGV. Avoid unnecessary use of special variables; PROGV
is especially dangerous because of the risk that variables
will get dynamically rebound.
- CATCH and THROW. Often a named BLOCK and RETURN-FROM are
more appropriate.
- Many programmers religiously avoid using BLOCK, PROG, TAGBODY.
- Destructive operations, such as NCONC, SORT, DELETE,
RPLACA, and RPLACD, should be used carefully and sparingly.
In general, trust the garbage collector: allocate new
data structures when you need them.
Think twice before using any of these functions.
To improve the readability of your code,
- Don't use any C{A,D}R functions with more than two
letters between the C and the R. When nested, they become
hard to read. If you have complex data structures, you
are often better off describing them with a DEFSTRUCT,
even if the type is LIST. If you must use C{A,D}R, try to
use destructuring-bind instead.
- Use COND instead of IF and PROGN. In general, don't use PROGN if
there is a way to write the code within an explicit
progn. For example,
(if (foo x)
(progn (print "hi there") 23)
34)
should be written using COND instead.
Don't use rplaca and rplacd. If you must, use (setf (car ..) ..)
and (setf (cdr ..) ..).
Don't use quoted constants where you might later destructively
modify them. For example, instead of writing '(c d) in
(defun foo ()
(let ((var '(c d)))
..))
write (list 'c 'd) instead. Using a quote here can lead to
unexpected results later. If you later destructively modify the
value of var, this is self-modifying code! Some Lisp compilers
will complain about this, since they like to make constants
read-only. Modifying constants has undefined results in ANSI CL.
Don't proclaim unsafe optimizations, such as
(proclaim '(optimize (safety 0) (speed 3) (space 1)))
since this yields a global effect. Instead, add the
optimizations as local declarations to small pieces of
well-tested, performance-critical code:
(defun well-tested-function ()
(declare (optimize (safety 0) (speed 3) (space 1)))
..)
Such optimizations can remove run-time type-checking, which
is necessary unless you've very carefully checked your code
and added all the appropriate type declarations.
Don't add declarations to code until it is fully debugged.
Incorrect declarations can be an annoying source of errors.
Use CHECK-TYPE liberally while developing code, if you later
intend to add declarations.
To produce efficient code,
- choose the right algorithm. For example, append is an
O(n^2) operation, so replacing it with a more efficient
algorithm (e.g., keeping a pointer to the last cons of
the list and nconcing onto the end of that) can speed up
the code.
- use type declarations liberally, if you are a seasoned
Lisp programmer. This helps the compiler
generate more specific and optimized code. It also lets
the reader know what assumptions were made. For example,
if you only use fixnum arithmetic, adding declarations
can lead to a significant speedup. If you are a novice
Lisp programmer, you should use type declarations
sparingly, as there is no checking to see if the
declarations are correct.
- check the code produced by the compiler by using the
disassemble function
----------------------------------------------------------------
[5] Where can I learn about implementing Lisp interpreters and compilers?
Books about Lisp implementation include:
1. John Allen
"Anatomy of Lisp"
McGraw-Hill, 1978. 446 pages. ISBN 0-07-001115-X
2. Kamin
"Programming Languages, An Interpreter-Based Approach"
Includes sources to several interpreters for Lisp-like
languages, and a pointer to sources via anonymous ftp.
3. Sharam Hekmatpour
"Lisp: A Portable Implementation"
Prentice Hall, 1985. ISBN 0-13-537490-X.
Describes a portable implementation of a small dynamic
Lisp interpreter (including C source code).
4. Peter Henderson
"Functional Programming: Application and Implementation"
Prentice-Hall (Englewood Cliffs, NJ), 1980. 355 pages.
5. Peter M. Kogge
"The Architecture of Symbolic Computers"
McGraw-Hill, 1991. ISBN 0-07-035596-7.
Includes sections on memory management, the SECD and
Warran Abstract Machines, and overviews of the various
Lisp Machine architectures.
6. Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes
"Essentials of Programming Languages"
MIT Press, 1992, 536 pages. ISBN 0-262-06145-7.
Teaches fundamental concepts of programming language
design by using small interpreters as examples. Covers
most of the features of Scheme. Includes a discussion
of parameter passing techniques, object oriented languages,
and techniques for transforming interpreters to allow
their implementation in terms of any low-level language.
Also discusses scanners, parsers, and the derivation of
a compiler and virtual machine from an interpreter.
7. Also see the proceedings of the biannual ACM Lisp and
Functional Programming conferences, and the implementation
notes for CMU Common Lisp.
----------------------------------------------------------------
[6] Where can I get/buy Lisp for the ... architecture?
There are about eight free implementations of Lisp and Scheme
interpreters and compilers and a dozen or so commercially available
Lisp and Scheme implementations.
Free Lisp implementations:
Kyoto Common Lisp (KCL) is free, but requires a license. Austin Kyoto
Common Lisp (AKCL) is Bill Schelter's improvements to KCL. Both are
available by anonymous ftp from rascal.ics.utexas.edu [128.83.138.20]
in the directory /pub. KCL is in the file kcl.tar, and AKCL is in the
file akcl-xxx.tar.Z (take the highest value of xxx). Runs on Sparc,
IBM RT, RS/6000. Mailing List: ···@rascal.ics.utexas.edu
XLISP is free, and runs on the IBM PC (MSDOS), Amiga (Atari ST),
Macintosh, and Unix. It should run on anything with a C compiler. It
was written by David Michael Betz, 127 Taylor Road, Peterborough, NH
03458. 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.1 is the same as XLISP 2.0, but modified to bring it closer
to Common Lisp and with several bugs fixed. It can be obtained by
anonymous ftp from
glia.biostr.washington.edu 128.95.10.115
bikini.cis.ufl.edu 128.227.224.1
in the file xlisp21c.zip (soon xlisp21d.zip) and comes with IBM/PC
executables. For obtaining a copy through US mail, send email to Tom
Almy, ····@sail.labs.tek.com.
CMU Common Lisp is free, and runs on Sparcs (Mach and SunOs),
DecStation 3100 (Mach), 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 any CMU CS machine, such as
lisp-rt1.slisp.cs.cmu.edu and lisp-rt2.slisp.cs.cmu.edu, in the
directory /afs/cs.cmu.edu/project/clisp/release. Login with username
"anonymous" and ·······@host" (your email address) as password. Due to
security restrictions on anonymous ftps, 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
15b-sun4-source.tar.Z, which contains all the ".lisp" source files
used to build version 15b for Sparc machines, and
10-16-91-cmucl-master.tar.Z which contains the project/clisp/master
subtree, with RCS source (,v) files for all of CMU CL. Bug reports
should be sent to ··········@cs.cmu.edu.
PC LISP is a Lisp interpreter for IBM PCs (MSDOS) available from any
site that archives the group comp.binaries.ibm.pc, such as
ix1.cc.utexas.edu:/microlib/pc/languages/pc-lisp/ps-lisp.arc
wuarchive.wustl.edu:/mirrors/msdos/lisp/pclisp30.zip
Free Scheme implementations:
Many free Scheme implementations are available from altdorf.ai.mit.edu
[18.43.0.246]. See also the Scheme Repository described below in the
section about repositories of Lisp/Scheme code.
C-Scheme, free by anonymous ftp from altdorf.ai.mit.edu.
PC-Scheme, free by anonymous ftp from altdorf.ai.mit.edu in the
directory /archive/pc-scheme/. Written by Texas Instruments. Runs on
IBM PCs and compatibles. Includes an optimizing compiler and an
emacs-like editor. Conforms to the Revised^4 Report on Scheme. Also
supports the dialect used in SICP. The official implementation costs
$95 and includes a reference manual and user's guide. Write to: Texas
Instruments, 12501 Research Boulevard, MS 2151, Austin, TX 78759 and
order TI Part number #2537900-0001, or call 1-800-TI-PARTS and order
it using your Visa or Mastercard.
MIT Scheme, free by anonymous ftp from altdorf.ai.mit.edu in the
directory scheme-7.1. The compiler is currently ported to four
architectures: MC68020/30/40, HP Precision Architecture, MIPS, and
VAX. The interpreter will soon be available for any Unix-based
machine. Includes a reference manual and user's manual, as well as a
copy of the Revised^4 Report on Scheme. Send bug reports to
···········@zurich.ai.mit.edu. The mailing list
············@altdorf.ai.mit.edu is gatewayed to the comp.lang.scheme.c
mailing list.
SCM, free by anonymous ftp from altdorf.ai.mit.edu:archive/scm or
nexus.yorku.ca:pub/oz/scheme/new. Current version 3c. Runs on Amiga,
IBM PC, VMS, Macintosh, Unix, and similar systems. Scm conforms to
the Revised^4 Report on the Algorithmic Language Scheme and the IEEE
P1178 specification. Scm is written in C. ASCII and EBCDIC are
supported.
Gambit is an optimizing Scheme compiler/system. It supports the IEEE
Scheme standard and `future' construct. It is available by anonymous
ftp from acorn.cs.brandeis.edu:/dist [129.64.3.8] and runs on M680x0
based unix machines, such as Sun3, HP300, BBN GP1000, etc. Contact
Marc Feeley at ······@chaos.cs.brandeis.edu.
T3.1 is a Scheme-like language developed at Yale. Available by
anonymous ftp from altdorf.ai.mit.edu in the directory /archive/t3.1/.
Runs on DecStations 3100 (PMAX), Sun4 (SPARC), Sun3, Vax/Unix, Encore,
HP workstations, Apollo and Macintosh (AUX). Includes a copy of the
online version of the T manual and release notes for T3.0 and T3.1.
The vaxen/sun implementations include a foreign function (C)
interface. To be informed of fixes, new releases, etc., send your
email address to ·········@cs.yale.edu. Bug reports should go to
·······@cs.yale.edu. A multiprocessing version of T is available from
masala.lcs.mit.edu:/pub/mult
Oaklisp is an seamless integration of Scheme with an object-oriented
substrate. Available by anonymous ftp from f.gp.cs.cmu.edu
[128.2.250.164] in the directory /usr/bap/oak/ftpable, and includes
reference and implementation manuals.
Elk (Extension Language Kit) is a Scheme interpreter designed to be
used as a general extension language. Available by anonymous ftp from
the Scheme Repository in nexus.yorku.ca:/pub/scheme/imp/. Runs on
Unix, SunOs, and Ultrix based platforms, including VAX, Sun3, Sun4
(Sparc), 680x0, 80386, MIPS, and IBM RT. The Elk interpreter is mostly
R3RS compatible. Elk has interfaces to Xlib and the various widget
sets. Implemented by Oliver Laumann.
EuLisp is available from gmdzi.gmd.de [129.26.8.90] in the
/lang/lisp/eulisp directory.
Scheme->C compiles R3RS Scheme to C that is then compiled by the
native C compiler for the target machine. Runs on Vaxen and DecStation
3100s running Ultrix, as well as Sun3, Sun4, and Apollo. It is
available for anonymous ftp from gatekeeper.dec.com [16.1.0.2] in
/pub/DEC/Scheme-to-C. Information on obtaining documentation may be
obtained by sending mail to ···············@decwrl.dec.com with
subject line "help".
SIOD (Scheme in One Defun), free by anonymous ftp from
bu.edu:users/gjc/siod-v2.4-shar [128.197.2.6]. Runs on VAX/VMS, VAX
UNIX, Sun3, Sun4, Amiga, Macintosh, MIPS, Cray. Small scheme
implementation in C arranged as a set of subroutines that can be
called from any main program for the purpose of introducing an
interpreted extension language. Compiles to ~20K bytes of executable.
Lisp calls C and C calls Lisp transparently.
XScheme is available free by anonymous ftp from uunet.uu.net in the
directories MSDOS/languages/X-scheme and amiga-sources/xscheme.20.zoo.
Implemented by David Betz. XScheme is discussed in the newsgroup
comp.lang.scheme.x. It may also be found in the Scheme Repository.
Fools' Lisp is a small Scheme interpreter that is R4RS conformant, and
is available by anonymous ftp from scam.berkeley.edu [128.32.138.1] in
the directory src/local/fools.tar.Z. Runs on Sun3 and Sun4 (SunOs),
DecStation 3100s, Vax (Ultrix), Sequent, and Apollo. Implemented by
Jonathan Lee <········@scam.berkeley.edu>.
Scheme84 is in the public domain, and available by mail from Indiana
University. It runs on the VAX 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 ···@indiana.edu for more information.
UMB Scheme is a R4RS Scheme available by anonymous ftp from
ucbarpa.berkeley.edu in pub/UMB_scheme.tar.Z and also in the Scheme
Repository. It includes a simple editor, debugger, Written by William
Campbell, University of Massachusetts at Boston, ····@cs.umb.edu.
Free Scheme Implementations 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
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,
or call Toll free tel: (800) 745-7323; FAX: (415) 578-0672
PseudoScheme is available free by anonymous ftp from
altdorf.ai.mit.edu:/archive/pseudo/pseudo-2-8.tar.Z. 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 (···@altdorf.ai.mit.edu,
···@cs.cornell.edu). Send mail to ·····················@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.
Scheme88 is available by anonymous ftp from rice.edu:public/scheme88.sh
and also from the Scheme Repository.
Commercial Lisp implementations:
Macintosh Common Lisp (MCL) runs on the Apple Macintosh (Mac+ or
higher with 2.5mb RAM [4mb recommended] and system software 6.0.4 or
later) and is available from APDA for $495. It includes a native
CLOS, Macintosh Toolbox/interface toolkit, generational garbage
collection, incremental compiler, window-based debugger, source-code
stepper, object inspector, emacs-style editor, and a foreign function
(C) interface. Write to: APDA, Apple Computer Inc., 20525 Mariani
Avenue, MS 33-G, Cupertino, CA 95014-6299 or call toll free
1-800-282-2732 (US), 1-800-637-0029 (Canada), 1-408-562-3910. Their
fax number is 1-408-562-3971 and their telex is 171-576. Email may
also be sent to ····@applelink.apple.com. There is a mailing list for
users <········@cambridge.apple.com> which is gatewayed to the
newsgroup comp.lang.lisp.mcl and vice versa. If you don't get news,
you can be added to the list by sending mail to
················@cambridge.apple.com.
Procyon Common Lisp runs on either the Apple Macintosh or IBM PC
(MSDOS), costing approximately $2700. It requires 8mb RAM on the
Macintosh and 5mb RAM on PCs, and includes a native CLOS with
meta-object protocol, incremental compilation, foreign function
interface, object inspector, text editor, debugger, and trace. Write
to: ExperTelligence, Inc., 5638 Hollister Ave, Suite 302, Goleta, CA
93117 or call 1-800-828-0113, (805) 967-1797. Their fax is (805)
964-8448 and email is ·····@applelink.apple.com. An alternate address
for British customers is: Procyon Research Ltd., Block B, Westbrook
Centre, Milton Road, Cambridge CB4 1YQ, UK, with phones 011
44-223-421221, 011 44-223-65011, FAX 011 44-223-460290, and email
······@applelink.apple.com.
Franz Lisp 2.0 runs on the Apple Macintosh, requiring 1mb RAM for the
interpreter ($99) and 2.5mb RAM for the compiler ($199). Write to:
Fort Pont Research, 15 Fort Pond Road, Acton, MA 01720 or call
1-508-263-9692.
Allegro Common Lisp 4.1 runs on a variety of platforms, including
Sparcs and DecStations ($3750), as well as the NeXT ($1875). 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), Common LISP Interface Manager (CLIM is a
Symbolic's Dynamic WIndows clone) and Allegro CLIP (a parallel version
of Lisp for the Sequent). Write to: Franz Inc., 1995 University
Avenue, Berkeley, CA 94704 or call (510) 548-3600 (area code was 415),
fax (510) 548-8253, telex 340179 WUPUBTLXSFO. Bug reports can be
mailed to ····@franz.com. Questions about Franz Inc. products (e.g.,
current and special pricing) can be sent to ····@franz.com.
Ibuki Common Lisp is a commercialized and improved version of Kyoto
Common Lisp. It runs on over 30 platforms, including Sparc, Dec
(Ultrix), Apollo, HP 9000, IBM RS/6000, Silicon Graphics and IBM PCs.
It includes an incremental compiler, interpreter, foreign function
interface. It generates C code from the Lisp and compiles it using the
local C compiler. Cost is $2800 (workstations), $3500 (servers), $700
(IBM PCs). 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.
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, and costs $2500 (IBM PCs), $4400 (other
platforms). Lucid includes native CLOS, foreign function interface,
and generational garbage collection. Write to: Lucid Inc., 707 Laurel
Street, Menlo Park, CA 94025, or call toll free in CA 800-225-1386
(outside CA 800-843-4204), 415-329-8400, fax 415-329-8480, or
email ················@lucid.com.
Medley is a Common Lisp development environment that includes a native
CLOS, window toolkit, window-based debugger, incremental compiler,
structure editor, inspectors, stepper, code analysis tools, and
browsers. It runs on a variety of platforms, including Suns,
DecStations, 386s, IBM RS/6000, MIPS, HP, and Xerox 1186. Requires
Unix and 8mb RAM. Write to: Venue, 1549 Industrial Rd, San Carlos, CA
94070, or call 1-800-228-5325, fax 415-508-9770, or email
············@envos.xerox.com.
Golden Common Lisp (GCLisp) runs on IBM PCs under DOS and Windows,
costing $2,000 ($250 extra for Gold Hill Windows), and includes an
incremental compiler, foreign function interface, interactive
debugger, and emacs-like editor. It supports DDE and other Windows
stuff, and is CLtL1 compatible. It requires 4mb RAM. 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, or
call (617) 621-3300.
Star Saphire Common LISP provides a subset of Common Lisp and includes
an emacs-like editor. It runs on IBM PCs (MSDOS), requires 640kb RAM,
and costs $100. Write to: Sapiens Software Corporation, PO Box 3365,
Santa Cruz, CA 95063-3365, call (408) 458-1990, or fax (408) 425-0905.
Software Engineer is a Lisp for Windows that creates small stand-alone
executables. It is a subset of Common Lisp, but includes CLOS. It
requires 2mb RAM, but can use up to 16mb of memory, generating 286
specific code. It costs $250. Write to: Raindrop Software, 833
Arapaho Road, Suite 104, Richardson, TX 75081, call (214) 234-2611, or
fax (214) 234-2674.
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, 8 New England Executive Park,
Burlington, MA 01803, call 1-800-533-SMBX, or fax (617) 221-1099.
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.
Harlequin Lispworks runs on a variety of Unix platforms, including
Sun3, Sparc, RS/6000, DEC (MIPS), MIPS, Intergraph, HP 400, HP 700,
and IBM PCs. It is a full graphical Common Lisp environment and costs
$2500. Harlequin is coming out with a delivery 386 Lisp in June.
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 ··@uk.co.harlqn (or
··@harlqn.co.uk for US people).
Lisp-to-C Translator translates Common Lisp into C. It costs $12,000.
Write to: Chestnut Software, Inc., 636 Beacon Street, Boston, MA 02215,
call (617) 262-0914, or fax (617) 536-6469.
Poplog Common Lisp is an integrated Lisp/Prolog environment with an
incremental compiler. It runs on a variety of platforms, including
Unix ($749), Sparc ($4500), Macintosh A/UX ($749), and VAX/VMS
($4500). Write to: Computable Functions, Inc., 35 South Orchard Drive,
Amherst, MA 01002, call (413) 253-7637, or fax (413) 545-1249.
Other Lisps for PCs include:
o UO-LISP from Calcode Systems, ····················@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 muLISP-87. Not Common Lisp.
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 ···@franz.com.
Lisps which run on special-purpose hardware (Lisp Machines) include
o Symbolics
o TI Explorers
o Xerox Interlisp.
Commercial Scheme implementations:
Chez Scheme is fully compatible with the IEEE and R4RS standards for the
Scheme programming language and includes an incremental compiler, object
inspector, multitasking with engines, and a foreign function interface. It
runs on Sparc and Sun3 (SunOs), Vax and DecStation (Ultrix), Apollo, and
NeXT, costs approximately $2000 and requires 4-8mb RAM. Implemented by
Kent Dybvig, Robert Hieb, and Carl Bruggeman. Write to: Cadence Research
Systems, 620 Park Ridge Road, Bloomington, IN 47408, call (812) 333-9269,
or fax (812) 332-4688. email: ···@iuvax.cs.indiana.edu
MacScheme is a Scheme interpreter and compiler for the Apple Macintosh, and
includes an editor, debugger and object system. MacScheme costs $125
(includes compiler) and Scheme Express costs $70 (interpreter only). It
requires 1mb RAM. A development environment (MacScheme+Toolsmith) costs
$395. Conforms to the Revised^4 Report on the Algorithmic Language Scheme.
MacScheme+Toolsmith includes support for menus, windows, and interfaces to
the Macintosh Toolbox, and can create small standalone Macintosh
executables. Implemented by Will Clinger, John Ulrich, Liz Heller and Eric
Ost. Write to: Lightship Software, PO Box 1636, Beaverton, OR 97075, or
call (503) 292-8765. They're moving to California. The temporary phone
number is 415-940-4008 (Liz Heller). The new phone number will be
415-694-7799.
EdScheme runs on Macintosh, DOS and Atari Amiga and costs $50. It includes
an incremental compiler, and editor, and is a close match to the IEEE
standard. Implemented by Iain Ferguson, Edward Martin, and Burt Kaufman.
The book (The Schemer's Guide) costs $30. Write to: Schemers Inc., 4250
Galt Ocean Mile, Suite 7U, Fort Lauderdale, FL 33308, call (305) 776-7376,
or fax (305) 749-3541. You can also send email to ··········@compuserve.com
----------------------------------------------------------------
[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
The Prolog package from the University of Calgary is written in Scheme and
has support for delayed goals and interval arithmetic. It relies on
continuations, and so is not easily ported to Common Lisp. Available by
anonymous ftp from cpsc.ucalgary.ca:pub/prolog1.1/prolog11.tar.Z
A prolog interpreter for Chez Scheme is available by anonymous ftp from
titan.rice.edu:public/slog.sh
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:archives/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
----------------------------------------------------------------
[8] 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.
First of all, there are several lisp-related newsgroups:
comp.lang.lisp General Lisp-related discussions.
Not currently archived by any known site.
comp.lang.clos Discussion related to CLOS, PCL, and
object-oriented programming in Lisp.
comp.lang.lisp.mcl Discussions related to Macintosh
Common Lisp. This newsgroup is gatewayed
to the ········@cambridge.apple.com
mailing list.
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.
comp.lang.scheme General Scheme-related discussion.
This newsgroup is gatewayed to the
······@mc.lcs.mit.edu mailing list.
comp.lang.scheme.c Discussion of C-Scheme, a scheme dialect.
This newsgroup is gatewayed to the
············@zurich.ai.mit.edu mailing list.
comp.ai and subgroups General AI-related dicusssion.
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.
General Lisp Mailing Lists:
···········@mcc.com Technical discussion of Common Lisp.
············@cs.cmu.edu Low volume mailing list associated with
the Lisp Utilities repository at CMU.
Do *NOT* post directly to this list.
Send mail to
····················@cs.cmu.edu
instead and the moderator will either
answer your question or post
the message for you.
········@think.com A mailing list concerning the contents
of this FAQ posting.
······@mc.lcs.mit.edu Discussion of Scheme. Gatewayed to
the comp.lang.scheme newsgroup.
Particular Flavors of Lisp:
········@cambridge.apple.com Macintosh Common Lisp. Gatewayed
to the comp.lang.lisp.mcl newsgroup.
····@ai.sri.com Symbolics Lisp Users Group
··········@ucbvax.berkeley.edu Franz Allegro Common Lisp
··········@franz.com Franz Allegro Common Lisp
···@rascal.ics.utexas.edu Kyoto Common Lisp
··········@cs.cmu.edu CMU Common Lisp bug reports
················@sumex-aim.stanford.edu TI Explorer Lisp Machine
············@zurich.ai.mit.edu C-Scheme. Gatewayed to the
comp.lang.scheme.c newsgroup.
·········@cs.yale.edu T, a dialect of Scheme.
·············@mc.lcs.mit.edu PseudoScheme
Lisp Windowing Systems:
··········@mcc.com Common Lisp Window System Discussions.
·······@expo.lcs.mit.edu CLX (Common Lisp X Windows)
····@bbn.com Common Lisp Interface Manager
···········@dsg.csc.ti.com Common Lisp User-Interface Environment
···············@cs.cmu.edu Express Windows
············@cs.cmu.edu Garnet
··········@gmdzi.gmd.de GINA and CLM
·········@harlequin.co.uk LispWorks
·······@hplnpm.hpl.hp.com WinterP
·····@csrl.aoyama.ac.jp YYonX
Lisp Object-Oriented Programming:
···········@Xerox.com PCL (Xerox PARC's portable
implementation of CLOS).
Miscellaneous:
······················@umnstat.stat.umn.edu
Use of Lisp and Lisp-based systems in statistics.
························@ucbarpa.berkeley.edu
Franz Inc's GNU-Emacs/Lisp interface.
----------------------------------------------------------------
Questions 9-35 are continued in Part 2 of this Lisp FAQ.
;;; ********************************
;;; Change Log *********************
;;; ********************************
;;; Date Who Ver Reason
;;; ------------------------------------------------------------
;;; 7-FEB-92 mk 1.0 Initial release.
;;; 10-FEB-92 mk 1.1 Pre-release corrections and additions.
;;; ------------------------------------------------------------
;;; *EOF*