Hacker News Reader

Comment by csdrane | Hacker News Reader

Not too long ago I was researching what Lisp to learn. I contemplated Common Lisp, but ultimately chose to learn Clojure. The latter won because the development community seems to have more life to it. Additionally, the fact that one can import existing Java libraries is a huge plus. Very much enjoying everything so far.

View on HN

I've dabbled in Scheme (SICP), Clojure, Elisp (Emacs) and now Common Lisp. My opinion is that there is value in at least looking at more than one. That way you will see what compromises have been made, and how it affects your program.

While Clojure is definitely more a in-thing right now, it's nice to see "the originals", where it all came from. There are several things Clojure does really well, at the cost of other aspects. It's a very opinionated language, and for some, it may be too opinionated. I find idiomatic Clojure-code to be a bit on the too terse side, affecting the clarity of the code.

Let's also mention the JVM. While this is often used as argument for Clojure, it can also be an argument against it. Now your application needs a JVM to run. That excludes my Raspberry from ever running it, unless you find 30 seconds+ startup time to be acceptable. I don't.

Looking into Scheme, you will definitely appreciate the simplicity of the language. Unlike Clojure, there's no magic behind the curtains. What you see is what you get, and yet it's still so capable. That's quite eye-opening and magic in its own right.

Scheme however isn't a standardized language, like Common Lisp. In that regard you cannot guarantee that what works in one Scheme-implementation works in another. With Common Lisp you can do that. And from that point of view, it makes sense to have a good story on modules/packages. And Common Lisp has that. In plenty.

In Clojure, with Leiningen, you can easily declare what dependencies you have and have those fetched build-time without any extra work what so ever. Sounds good, eh? In Common Lisp you can do that in ordinary code, runtime, even in the REPL. Your code just declares what it needs, and it's there. Just stop a second and think what that does to extensibility, when software written in CL lets you plug your own code in.

All in all, once you know a LISP looking into others is much less work. And as such, you should definitely check out others. Maybe there are other LISPs which suites your needs even better? Unless you look around, you will never know.

> Scheme however isn't a standardized language, like Common Lisp.

Scheme is a standardized language. The first standards defined a relatively small language, also useful for teaching purposes. Then it was tried to define a more modern Scheme with a core language and a library. The R6RS standard was kind of controversial and now there is work for quite some time on R7RS. Additionally the Scheme community has a process to define extensions. Generally the landscape of Scheme is quite a bit more fragmented than the CL landscape. The implementations can differ widely in their implemented language. But if you look at individual systems, Scheme systems have to offer quite a lot. Also, historically there are a several really excellent Scheme books for learning programming and/or computer science.

This site, news.ycombinator.com , actually is written in a Lisp dialect (Arc) running on top of a 'Scheme'.

In practice I tend to think of Scheme as quasi-standardized, in the sense that there is a standard core, but it's difficult to stay within it. Whereas with standards like C99, Fortran 90, or ANSI CL, it's quite common for people to write nontrivial standards-conforming programs that you can expect to run unmodified across implementations. Culturally the Common Lisp community also seems more interested in maintaining portability even when leaving the confines of the official standard, through the heavy use of compatibility layers like Bordeaux-Threads. The Scheme approach seems to be to just target a specific implementation, and share functionality across them on a case-by-case basis by porting libraries (which is sometimes trivial, and sometimes more involved). Hence CL has Quicklisp, while Scheme has a package repository per system.

> Additionally, the fact that one can import existing Java libraries is a huge plus [to Clojure].

Armed Bear Common Lisp http://abcl.org/ is a JVM Common Lisp with this feature.

Reply on news.ycombinator.com