(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:

(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))

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/