My first exposure to Lisp [1] was in the summer of '86 in an introductory

* * * * *

(l (i (s (p () (i (s () (f (u (n)))))))))

My first exposure to Lisp [1] was in the summer of '86 in an introductory
class on artificial intelligence [2]. My impression of the language was that
it was mildly interesting but littered with CARs, CDR [3]s and parentheses.
Lots of parentheses. [4]

It also doesn't bode well when a typical fragment of Lisp looks like:

-----[ Lisp ]-----
(DEFUN VALID-RANGE (LIST)
(IF (NUMBERP (CAR LIST))
(LET ((MIN (CAR LIST)) ;gets SETQed below
(MAX (CAR LIST))) ;gets SETQed below
(DO ((ELS (CDR LIST) (CDR ELS)))
((NULL ELS)
(LIST MIN MAX))
(LET ((CAND (CAR ELS)))
(COND ((NOT (NUMBERP CAND))
(RETURN 'INVALID))
;; at most one of the next
;; two cases can occur.
((< CAND MIN) (SETQ MIN CAND)) ((> CAND MAX)
(SETQ MAX CAND))))))
'INVALID))
-----[ END OF LINE ]-----

Someone well versed in Lisp would be able to see what that does (much like
someone well versed in Perl would be able to tell what $data =~
m/^211\s+\d+\s+(\d+)\s+(\d+)\s/; does—maybe).

But after reading Paul Graham's [5] article about using Lisp for web-based
applications [6] and hearing the remark that XML (eXtensible Markup-Language)
is nothing more than Lisp in drag, I figured it may be time to give Lisp
another look.

Obligatory Sidebar Links

P a u l G r a h a m [7]
An Introduction and Tutorial for Common Lisp [8]
The Association of Lisp Users [9]
Successful Lisp [10]
Schemers.org [11]
cons.org [12]

The two major dialects of Lisp today are Scheme [13] and Common Lisp [14].
Since Scheme is conceptually simpler and cleaner than Common Lisp, I decided
to give it a try. The MIT version (Massachusetts Institute of Technology)
[15] requires one to already have the MIT version (Massachusetts Institute of
Technology) [16] installed before you can install the MIT version
(Massachusetts Institute of Technology) [17] (and that's another lovely
feature about Lisp—recursion [18] to an infinite degree (or until you run out
of memory)).

Off to try Common Lisp.

Oddly enough, the CMUCommon Lisp (Carnegie Mellon University) [19] also
requires an installation of CMUCommon Lisp (Carnegie Mellon University) [20]
before you can install CMUCommon Lisp (Carnegie Mellon University) [21].

Lovely.

Fortunately, Gnu (Gnu's Not Unix) [22] (which itself is a recursive ancronym)
has both a version of Scheme [23] and Common Lisp [24] that don't require a
pre-existing installation to install.

Another thing I've come to realize is that Lisp, much like C++ [25], accreted
features over it's current 54 year history so quite a bit of arcana [26] is
needed to successfully write programs in it. Then again, the principles
underlying Lisp are so simple that, like Forth, one can implement a Lisp
system (functioning, if limited) in a few days of work so maybe that's the
way I should proceed.

[1] http://www.lisp.org/table/lisp.htm
[2] http://www.robotwisdom.com/ai/
[3] http://www.tuxedo.org/~esr/jargon/html/entry/cdr.html
[4] http://www.tuxedo.org/~esr/jargon/html/entry/LISP.html
[5] http://www.paulgraham.com/paulgraham/bio.html
[6] http://www.paulgraham.com/lib/paulgraham/bbnexcerpts.txt
[7] http://www.paulgraham.com/
[8] http://www.apl.jhu.edu/~hall/lisp.html
[9] http://www.lisp.org/table/contents.htm
[10] http://www.psg.com/~dlamkins/sl/cover.html
[11] http://www.schemers.org/
[12] http://www.cons.org/
[13] http://www.scheme.org/
[14] http://www.cons.org/cmucl/
[15] http://www.swiss.ai.mit.edu/projects/scheme/mit/
[16] http://www.swiss.ai.mit.edu/projects/scheme/mit/
[17] http://www.swiss.ai.mit.edu/projects/scheme/mit/
[18] http://www.tuxedo.org/~esr/jargon/html/entry/recursion.html
[19] http://www.cons.org/cmucl/download.html
[20] http://www.cons.org/cmucl/download.html
[21] http://www.cons.org/cmucl/download.html
[22] http://www.gnu.org/
[23] http://www.gnu.org/software/guile/
[24] http://www.gnu.org/software/gcl/
[25] http://www.mozilla.org/hacking/portable-cpp.html
[26] http://www.elwood.com/alu/table/style.htm

Email author at [email protected]