Which Lisp should I learn?

Question

What Lisp (dialect) should I learn and why?

Fragmentation between CL and Scheme slows down absorption (at least for me!).

So give me the "correct answer", please!

I tried to read function comparisons, and they seemed to be bogged down in esotericism (which I don't quite understand), for example, whether the dialect is completely tail recursive and the like. I hope you all (collectively) can make the opaque differences clear.

Things I like

Good library support, good environment and Unicode support.

Things I don't like

Flamewars. Features that are useful at the beginning, but interfere with long-term learning.

---

Update

• I mainly use MzScheme, which I really like when I get readline support. I don't run the GUI on Unix, so for me it was a great option.

• I am also very pleased that Clojure has an easy to install .deb package on debian, which makes it much easier to play with. This is a big win. Despite the hostility of some rather easy to anger below, the low barrier to entry is victory. I like to be a spoon.

• After reading the much larger SICP, I better understand the problems around tail recursion.

Answer 1

Clojure is an actively developed, modern dialect of Lisp. It is based on the JVM, so all Java libraries are immediately available and therefore also support Unicode.

This is one of the alternatives, not one true answer.

Answer 2

If you want to avoid flamewars, and you like libraries, go with Clojure. He is small, he is fast, and the community is helpful and not dogmatic. This is Lisp minus the absurd dash of the 1980s. He has a BDFL, and if you have a good idea, there is a damn good chance that he will be embedded in the language.

I played with Common Lisp, this is a great thing. I finished the first 3 chapters and the Metacircular Evaluator in SICP in DrScheme, which is great too. Of course, it will be useful for you to find out about this.

But over time, I came to hold on to the little tongues that are dear to my heart. I won’t lie, I love Javascript, and I love C (and hell if every language doesn’t have a core C in it) because they are small.

Clojure is small. It is elegant. This is a language for our time.

Answer 3

Contra Chuck, the advantage of Common Lisp is that it has a standard to which implementations apply and what they strive for, so you can pretty much develop with SBCL (which has excellent type checking and type inference) and then, say deploy as an executable associated with C libraries (with ECL or others) or as .jar using Java libraries (with ABCL) or with a Mac or Windows native GUI (Clozure, both). Generic Lisp is surprisingly portable across architectures and implementations over time, and Common Lispers does its best to support such things with language support. As an illustration, one silly divergence of non-standard behavior is the question: "Is this a special variable?" So I answered all the options that I use:

#-abcl (defun special-variable-p (symbol) #+ecl(si:specialp symbol) #+ccl(proclaimed-special-p symbol) #+sbcl(equal '(:special t) (multiple-value-list-int:info :variable :kind symbol))) 

which, while reading, decreases by ABCL (it already exists), to (defun special-variable-p (symbol) (si:specialp symbol)) by ECL, etc. Therefore, I can put this in my .rc files and use the generic function in the REPL. But this is not very important: it is not threading or variously supported networks or a library of communication sequential processes . This last example has only one #+sbcl/#-sbcl , even if it works on five implementations. Because it relies on code that has been carefully ported.

But what allows this (and other) advantages also poses a challenge for the student: Common Lisp is a very large language. This is not something that you can erupt in a week or two, as I did Clojure (but my Clojure is already fading with the excellent changes set for deployment), this language, although heavy in its merits, I reminded, unlike that I like Common Lisp.) So you should read this page a lot and save the HyperSpec keystroke (for me, Mx hyperspec RET do-symbols RET is close enough to the Bible.), and consider buying a few books. I'm Practical Generic Lisp , just got Let Over Lambda , and will buy PAIP soon now.

But even if Common Lisp is the True Answer , you won’t waste your time “just picking” some deceptively screaming alternative (“deceiving” because the regular CL don’t “show you everything that macros can do, and has more kinds of macros than anyone. The usual comparison is between bad CL and optimized syntax alternative X). You will still learn the basics, you can still use a lot of what you can read in SICP, Lisp, The Little Schemer etc .. Lisp, even the wrong Lisp, is still better e than non-w139>. (But you will spend some time doing parts of the right Lisp, bad, in the wrong Lisp. Meta-Greenspun.)

Answer 4

Clojure is an excellent LISP dialect that promotes functional programming. It runs on the JVM, so you have access to any Java libraries that you could use. The site has excellent documentation and screencasts to help you learn. Another advantage is that it is very easy to install, unlike many other dialects.

If you're just trying to understand the concepts of Emacs (especially EmacsLISP), this is another alternative. It comes with incredible documentation, tutorials, and lots of code examples. Screencasts are pretty easy to find. One of the great advantages of Emacs is that the editor is written in LISP, so the editor naturally has very good support for launching, editing, and debugging LISP. In addition, you can expand the editor to facilitate daily text editing by learning LISP.

Answer 5

Just pick one and study it. When you find out the differences, you can choose again if you chose poorly for the first time.

Answer 6

Lisp The biggest problem is that there is no standard standard that everyone adheres to. You just don't have to choose between Common Lisp and Scheme; you need to choose between several incompatible implementations of Common Lisp and several incompatible implementations of Schema, as well as other little things like Arc and Clojure.

I would recommend starting with MzScheme . It is popular, it is actively developing, it has many libraries offering the functions of a modern programming environment, and the circuit is somewhat simpler (not to say better, just simpler) than Common Lisp.

Answer 7

Go with Clojure. This is an awesome language with full access to any Java library. It has been under development for a little over 2 years and already has 3 IDE plugins in development and a book published in April about this. It is very fast, very elegant and beautiful. You cannot go wrong with Clojure.

Answer 8

For me, the fundamental theory of the Scheme is much more convincing. PLTScheme is by far the most actively developed LISP that I have found. Unfortunately, it has multiple typing that hides the beauty of Lisp.

I would like to see something like an arc, but this is unlikely.

Answer 9

Take a look at IronScheme .

Answer 10

Explore elisp to extend Emacs.

Answer 11

Hypothesis: when you study your first lisp, do not study it, you will end using it for final development.

Lemma: learn Arc. It's all “hard to pull up” things in lisp - closures, macros, continuations, without any of Clojure's complexity of Java interaction, CL namespace confusion, or schema name fragmentation. If you are committed, you can learn all these things on the weekend. If you are sharp and loyal, at night.

And that will make learning all other lisps easier.

Answer 12

I don't know Lisp, but thats why I think PLT Scheme is a good choice:

• Really nice docs
  http://download.plt-scheme.org/doc/html/

• Drcheche
  DrScheme is an amazing programming environment that comes with a compiler, step mechanism, syntax checkers, REPL, many support languages, and is extensible. It makes the whole experience fun. See screenshots

• Good community support.
  The community is very enthusiastic about their language and very supportive. If you have any questions, mailing lists, groups and forums are available. Even the authors are very accessible.

• Continued research
  PLT is very active and continues to make its tool better and better. You can expect a lot of innovation in the labs. eg. I really liked this: http://blog.plt-scheme.org/2009/05/typed-scheme-20.html

• Free books and interesting tutorials to get you started.
  http://www.htdp.org/
  http://world.cs.brown.edu/

• Good modules and extensive libraries.
  http://www.cs.utah.edu/plt/develop/
  http://planet.plt-scheme.org/ also see docs

If you are learning the Scheme, try DrScheme .

Answer 13

You know ... When I was interested in Lisp, I also thought that I would have to choose. Then, after reading and asking a lot, I decided to choose Common Lisp. Not because it is "better" than the scheme absolutely, but because I had functions that I knew, I would probably use in the next 2-3 years in my projects:

• Very efficient compiler for numerical computation (SBCL),
• System of conditions and ...
• I must admit that SLIME also played an important role in this decision. :-)

So, if I were you, I would start to study the tiny bit of each language and find out what are the relative strengths and weaknesses of each (I mean those that are related to what you need or want to do most often), so that I could choose one. You can just find out that later you will learn more (it happened to me - I had to learn more about the Scheme after one year of studying Common Lisp)

As for Arc, Clojure and Lush, and they don’t know this. I believe that the same arguments can be applied to them ... The reasons why I did not want to invest too much in them were: Arc, it seems, is not interesting for numerical calculations, and P. Graham, it seems, is not understands the size of the code (it makes sense to make its code unreadable); Clojure seems nice, but I don't like the JVM. And Lush ... Well, in addition to using the dynamic area, the compiled and interpreted versions of the language are very different - and you cannot compile recursive functions. So for me it was either Scheme or Common Lisp.

Answer 14

I think you either want Common Lisp or a PLT scheme.

The former has a lot of freedom and power (which may startle you at first), and the latter comes with a bunch of libraries, related tutorials, and a well-integrated IDE.

Answer 15

I'm a Scheme fan, but it's been over 10 years since I did something with Scheme.

as others have said, just pick one and go.

Answer 16

There are very few real options: SBCL, Clojure or PLTScheme.

Answer 17

Choose something other than Clojure, go with it and you can better appreciate it later.

You have formulated this question, which Lisp is the best tool for learning Lisp, and for me it should include Lisp, which is created from low-level primitives, while the bulk of Clojure is written in Java.

If you have formulated this question as the best Lisp to launch a new project, then Clojure may be the best choice.