mat (04/19/83)
Why LISP ? Well, remember that it has indefiniately extensible data structures. If you have designed a module to pass/handle a particular structure, it can pass ANY structure, since all memory cells look the same. And if you use the provided functions, and are careful to write utility parts in general form (easy, since the languages recursive data structures are matched by the availability of easy recursion) full extensibility is maintained. Mark Terribile Duke of deNet
tim (04/20/83)
The following are the major advantages of Lisp that I know of.
(1) Symbolic computation. In Lisp, you acn manipulate expressions in
various languages (e.g., algebraic equations) in a human-readable
form. There is no need to set up elaborate systems of symbolic
constants and such.
(2) Run-time management of data structures. You don't need to worry about
allocating space for dynamic data structures, writing a garbage
collector, etc. All this is inherent in the system. This feature
allows you to forget all those troublesome implementation details
of dynamic data structures and stay closer to the design level.
(3) Interpretation and compilation. Most Lisps run interpreted, making
interactive debugging easy, but also provide for compilation, so
that debugged code will run fast.
(4) Inertia. The language has been around for a very long time, people
know it very well, and there is a very large body of literature on
how to do various things in Lisp. Being able to avail yourself of such
a body of literature is a great advantage.
(5) Extensibility. Because of the simplicity of Lisp syntax, it is easy
to add things to it. If you wanted to add a new control construct to C
(or any compiled language), you'd have to modify the compiler, which
is usually impossible. In Lisp, you can simply define it as an nlambda.
(6) All Lisp programs are Lisp objects. The advantage here is not in self-
modifying code; why would you want that, since you'll need an invariant
kernel anyway? However, Lisp functions can create functional and
symbolic objects, as well as manipulate objects in Lisp expressions.
This is the main reason for (5) above, by the way.
No doubt others could add to this. I think Lisp is a wonderful language.
Tim Maroneygumby (04/20/83)
the run-time datastructures are the best. A number of languages (including that monstrosity of static typing, CLU), have run-time garbage collection, but few, if any have the complete openness of typing provided by LISP. It allows you to define any sort of abstraction you want, so you may attack a problem in the cleanest` way. As for claims that maintaining large systems is difficult, I beg to differ. The lisp machine comprises at LEAST three megabytes of code; an entire operating system, in fact. You can even lambda-bind the paging switches! And it's efficient. MACSYMA, the symbolic math package, (another multi-megabyte program) is entirely written in PDP-10 MACLISP, and produces math code as efficient as the PDP-10 Fortran compiler. In fact, I write TOPS-20 system code in maclisp. david
jah (04/22/83)
Dan Wilson asks "have I missed something?" in his wquestion about LISP. The answer is "yes." He's essentially missed the entire reason for Lisp. Lisp is a symbolic language with the ability to pur information on symbols (i.e. the property list stuff). This is not trivially available in most other languages, and when needed must be implemented. Lisp is a recursively based language. Other languages provided recursion, Lisp encourages it. For those doing tasks with a recursive flavor this is quite helpful. But in actuality, the main reason many people use Lisp has nothing, a priori, to do with Lisp qua Lisp. It has to do with the computing environment provided by a decent Lisp. Included one finds debugging tools, trace packages, and break facilities that are, in general, far superior to those found in other languages. (NOTE: I realize that this is a changing trend. Many languages are now starting to provide similar packages. However, I would still argue that Lisp is ahead of the game. Compare the (debug) facility in Franz with sdb or other c debuggers). Partly because of the interpretive nature of many Lisps, partly due to the history of the problems being solved, and partly due to the man-power that has been spent on Lisp, this language provides about the best environment I've yet found for doing any serious form of symboolic processing. Dan further points out that many languages now contain the sorts of facilities that Lisp provides. I ask, "what took them so long?" Jim Hendler Brown University