Re: A question on Lisp, Scheme, Guile, eLisp etc. (slightly offtopic)

["Mark C. Chu-Carroll" <mcc watson ibm com>]

On Sun, 14 May 2000, Archit Baweja wrote:
> Hey
> 
> I have a slightly offtopic question. Also I'm not subscribed to the guile
> mailing list (if there is any) so bear with me.
> 
> I have a very basic question. What is the relationship between all these
> languages, namely
> [1] Lisp
> [2] eLisp
> [3] Scheme
> [4] Guile
> [5] Script-fu (I'm totally in the dark about this one).
> [6] Common Lisp
> In particular I would like to know which one of these was first (that would
> definitely not be Guile or eLisp, I know). I mean which came first, and which
> derived from the other.

Lisp is one of the earliest programming languages to be designed. It
was originated in, I believe, the late 1960s at MIT by McCarthy. There
were a collection of variants fairly rapidly. So "Lisp", in itself, is sort
of a generic term for referring to a wide family of closely related languages.
The distinguishing features are that they're loosely derived from (McCarthy's
misunderstanding) of Lambda calculus. The syntax generally features
a lot of parens. 

For a while, Lisps were quite popular in certain circles, but there were
a lot of distinct variants, and interoperability between the variants 
became a huge problem. The major lisp vendors got together, and
formed a standard dialect, which is Common Lisp. Common lisp
is a wonderful, but incredibly complex language. 

Right around the time of the Common Lisp standardization, Guile Steele,
who was involved in the CL process, decided to create a minimal
variant in contrast to Common Lisp. He stripped out the accumulated
garbage of years, and came up with an incredibly elegant, incredibly
small lisp variant, called Scheme.

Guile is the official GNU implementation of Scheme. If I remember correctly,
it's based on an earlier Scheme interpreter, called Scheme48(?).

OK. That's the basic lineage of what I consider the "primary" variants.

Back in the relatively early lisp day, a hacker by the name of Richard
Stallman was doing cool things with one of the early lisps, a variant
called MacLisp. At the time, he was using an editor called "Teco", which
many of us older guys remember fondly. Teco was incredibly powerful,
but incredibly difficult to use. Stallman wrote a collection of macros to
turn Teco into a more easy to use, screen based editor. He called it
"emacs", for "editor macros". After a while, he reimplemented Emacs,
using a simple lisp interpreter as the core, rather than Teco. That lisp
variant at the core of emacs is Elisp. 

Script-fu I don't know much about. I know it's a part of GIMP, but I've
never really taken a look at the language, so I don't know how it fits into
the lineage.

> Here is all that I know about them
> [1] These add extensibility to your programs.
> [2] eLisp is the lisp variant (am I right in calling it a variant?) for emacs.
> [3] Guile is favourite with the GNOME hackers and is GNU's default <something>
> 
> I would be glad if someone could enlighten me on this.

OK. Your first point is a misunderstanding. Lisp variants are quite popular
as scripting engines for a variety of applications, but Lisp is used for quite
a lot more than that. CommonLisp has been used for a variety of huge
applications. With the use of pragmas, numeric code in better CommonLisp
compilers has been known to out-perform Fortran. There's a pretty
great free CommonLisp compiler called CMU CommonLisp. Scheme
is, quite possibly, the most elegant programming language ever designed;
unfortunately, there's never been a decent small compiler for it which was
available for free. I've implemented some huge free-standing systems 
in Scheme.

Guile was specifically intended for scripting. A few years ago, Guile
was proposed by Stallman as a replacement for TCL as a ubiquitous
scripting language. A lot of GNOME people are quite fond of it. Personally,
I think it's not a very good implementation. There are a lot of Scheme
implementations out there; you can do better than Guile.

Elisp is very much a part of emacs. I wouldn't particularly recommend
trying to separate it and use it for another purpose.

One thing you ommitted was REP, which is an Elisp like Lisp interpreter
used by the Sawfish (formerly Sawmill) window manager, and by an
emacs-clone called Jade. If you want to use a lisp for GNOME scripting,
personally, I'd recommend using REP. I haven't done a lot with it yet,
but my initial impression is that it's a very solid little interpreter, and
while its lisp variant isn't quite as pretty as Scheme, it's pretty darn good.

	-Mark

-- 
Mark Craig Chu-Carroll          || "I'm not dumb, 
IBM T.J. Watson Research Center || I just have a command of thoroughly useless
Email: mcc@watson.ibm.com       || information." --- Calvin