Iwanna Learn Lisp

The LispLanguage seems powerful and intriguing. How would the good WikiZens suggest one would go about starting with it? (Maybe this page should have been named IwannaBeaSmugLispWeenie.)

To get an idea of how to read Lisp code in the below materials, see LispIndentation.

Major Proprietary CommonLisp implementations with free trials; work on Windows

AllegroCommonLisp (http://www.franz.com/) personal edition with IDE
LispWorks (http://www.lispworks.com/) personal edition with IDE

Major OpenSource CommonLisp implementations for Unix-- more at lisp.org

Lisp in a Box (http://common-lisp.net/project/lispbox/), also for Windows and Mac.
GnuClisp? (http://clisp.cons.org/)
CMUCL CarnegieMellonUniversityCommonLisp? (http://www.cons.org/cmucl/)
SBCL SteelBankCommonLisp? (http://sbcl.sourceforge.net/) -- branch of CMUCL

CommonLisp Learning resources

PracticalCommonLisp by PeterSeibel -- recent work, now finished. (http://www.gigamonkeys.com/book/)
CommonLispaGentleIntroductionToSymbolicComputation by DavidTouretsky? -- newbie intro, on Web
CastingSpelsInLisp -- a comic-book tutorial on the web
AnsiCommonLisp by PaulGraham -- not a standards book; the standard intro
CommonLispHyperSpec -- standard reference, included or freely downloadable
OnLisp By PaulGraham -- not for beginners, excellent intro to macros, on Web
ParadigmsOfArtificialIntelligenceProgramming by PeterNorvig -- classic AI intro
PascalCostanzasHighlyOpinionatedGuideToLisp
http://www.lisp.org (the server of the Association of Lisp Users)
http://alu.cliki.net/ (the wiki of the Association of Lisp Users
http://www.lisp.org/table/learn.html
http://www.cliki.net (a wiki for 'free' Lisp programming on Unix platforms)
http://cl-cookbook.sourceforge.net

Other Lisp Learning resources

Lush (http://lush.sourceforge.net/) is a Lisp which has an older syntax, but great integration with C and a range of external libraries for signal processing, numerical work and AI. Used for development of DejaVu alternative to PDF. You can get started playing with video and SDL in no time - but maybe it lacks some of the language features you were looking for. Not CommonLisp.

Aside from the libraries, how different are the languages themselves?

Different enough to be incompatible. ;-)

For those of us considering playing around with either CLisp, CMUCL or SBCL, which would be recommended for a beginner?

If you just want to play around, I suggest getting Lisp in a Box, as it includes everything you need (IDE, etc.) in a single, easy-to-install package.

All of the above are fine for learning Lisp. My preference would be CMUCL or SBCL. But you can also can download AllegroCommonLisp from Franz and the LispWorks personal edition for several platforms. Especially LispWorks has an IDE written in Lisp. Such an IDE might be helpful for learning Lisp development (debugger, inspector, editor, stepper, etc. as GUI-based tools).

If you decide to go the open-source way, you'll still need an IDE. The canonical way to do that, recently, has been to use Emacs+Slime+SBCL. For more information, see http://www.cliki.net/Slime

I suggest that the discussion about the differences between SchemeLanguage and CommonLisp be better discussed on another page (maybe there is already one). Learning about the differences is surely interesting (for example for choosing which Lisp dialect to learn), but does not really help much in learning to program in Lisp. ;-)

Much discussion moved to LispSchemeDifferences.

Any comments on EmacsLisp? I always wanted a super-charged editor that I can customize all kinds of features into. It might be a good road to start Lisp.

Programming in Emacs Lisp is IMHO slightly harder than Scheme or CommonLisp but there's very good documentation and tutorials available with the emacs distribution, and you can do useful stuff fast. I recommend it as way to get started on lisp, although Lisp in a Box may be better. - anon

One way to speed up learning Lisp/Scheme is to put it on your HandHeld. LispMe for Palm, PocketScheme for PocketPc. Then while waiting on the bus or other idle time you can experiment.

Too many parenthesis and you blow the stack, zapping your neighbour's pace maker :-)

Recognizing Function Calls

One thing I seem to have a problem with as a Lisp beginner is knowing whether something is a list or a function call when visually scanning code. Often one cannot tell the difference without knowing the context. For example, a LET statement (in EmacsLisp) may have a set of variables to assign values to. One cannot tell which is a variable assignment and which is a function call without first finding the LET. This is not something I ever had to do with "normal" programming languages [1], so I am at odds on how to overcome it. Or, is it just an inherent shortcoming of Lisp that is compensated for in other ways?

[1] The one exception was arrays versus functions in MS Basic dialects. Some call it "polymorphism" to justify it. I guess I half agree since I had to switch implementation from arrays to function calls a few times and it came in handy.

With practice this becomes easier. You'll learn to quickly recognize macros like LET by their indentation style. With a good editor you should also have the source and documentation for everything at your fingertips when you want to look something up, and even have some information (like function/macro argument lists) automatically displayed. That helps tremendously while you familiarize yourself with new functions and macros.

In EmacsLisp, try 'M-x eldoc-mode' to automatically see documentation for the function/macro at point, and 'M-x find-function' to jump to the sources to the function called at point. And don't miss Emacs's comprehensive built-in online help system, described at http://www.gnu.org/software/emacs/manual/html_chapter/emacs_10.html#SEC42

Special Characters

Different dialects seem to have different symbols as operators or markers of some sort, such as dots, colons, etc. Is there a pattern or brief catalog of what these mean and which dialects support them?

Yes, somewhere on http://www.cliki.net/

I was wondering if there is not a simplified "Lisp lite" language out there that is nothing but lists. No single quoting, colons, etc. One would use Eval on strings instead of symbols (single quote). I realize it may run slower, but that is the tradeoff for being "lite".

I am a Lisp newbie and just kicking around ideas, so forgive me if it is a naive question. I have a habit of learning by asking weird questions.

The things that you mention are already much closer to standard Lisp than you would think. For instance, single quote has always just been an abbreviation for the special form (quote ...), and the only thing that differs between strings and symbols is how they are eval'ed.

So although it may seem you are suggesting a "Lisp lite" dialect, actually that's still just Lisp.

There are, of course, ultra-tiny implementations of Lisp, such as the classic eval-written-in-Lisp that tends to be presented as part of every intro to Lisp course and book.

You may also want to check out SchemeLanguage, which is designed to be simple and minimalistic. It has no keyword args, no GenericFunctions, no GeneralizedReferences, and a different macro system. Still has quoting (which, as mentioned above, merely expands to the form (QUOTE ...)), but that's necessary in any language where CodeIsData. The naming conventions are also more logical than in CommonLisp.

There's also GooLanguage, which is Scheme + object orientation (in the form of generic functions). This is a research project from MIT, and is also supposed to be a simple language suitable for teaching. Unfortunately, the function names in it can be a bit cryptic.

Depending on what you mean by "simple", PaulGraham has been working on ArcLanguage, a "simplified" version of CommonLisp. While more complex than SchemeLanguage, ArcLanguage seeks to remove a lot of the "cruft" from CommonLisp.

I cry foul, there is no public Arc definition yet, let alone available implementation, and may not be for years.

Depending on what you're doing with it, you may find that TclLanguage is this "simple" Lisp which you desire. That said, it is a much less powerful language in many ways.

Lisp blog: http://lemonodor.com/

I wonder how many other languages have a blog? -- DavidCary

I'm a PerlLanguage, PythonLanguage, and EmacsLisp hacker with some experience in SchemeLanguage, so neither basic lisp, lexical scoping, nor closures are really foreign to me. I've written some really powerful EmacsLisp, but what I want to learn is how I can start using a lisp environment like SBCL to replace a lot of my one-offs in perl and python. Let me give you a few of the one-offs I'm talking about:

Web page update checker: Recursively crawl a bunch of web pages. Store the URL and content in some persistent fashion -- the filesytem's not great, since I have to attach more metadata later. Flag pages that match certain regular expressions (must be able to match line boundaries but also cross lines, ala perl's /sm modifiers). If the page content differs, display where they differ. I previously used wget and cobbled together some scripts with diff, but have been moving it to use WWW::Mechanize, DBD::SQLite, and Algorithm::Diff (well, now it's mothballed...).
Spam DNSBL checker: Given a large list (thousands) of domains, look up all IP's associated with them, including A, NS, and MX, and check these IPs against spam blacklist DNS zones. Do this as simultaneously as possible. Previously used Net::DNS and POE (puke), converted to use stackless python and nonblocking DNS lookups instead. Of course, storing the results in a database is de rigeur (I used Postgresql for that).
SOAP client: I have to query a few web services and craft some queries by hand. So I need to more or less be able to hand-craft SOAP queries and parse the answers, including dealing with error codes, preferably without touching raw XML.
Various input munging filters: Perl is still great as a sort of super-duper sed and awk fusion. I look for lisp tutorials, and I can't even get a good answer on how to read a stream in less code than it would take Java, much less match and transform them. There must be some good syntax sugar libraries that let me do sed-like things, no?

You can use cl-awk. It's at http://www.geocities.com/mparker762/clawk.html

All of these should be easy to plug into CGI client backends. FastCGI would be nice, but not required. Lisp-only webserver interfaces I'm not too interested in, because I need to be able to swap implementation languages in and out if I really want to (not everyone here is keen on lisp).

You might say some of these examples are "stacked" against lisp, requiring libraries or coroutine facilities that aren't present. Of course that's why I've tended to gravitate toward perl in the first place... If a scheme implementation is a better answer for these, terrific. Basically, what I'm looking for is LispForPerlHackers? ...