I already know Scheme (read SICP, took the class, got an A, wrote a logo interpreter in Scheme, wrote a Scheme interpreter in Python, etc.) but I haven't touched it much in two years. It seems to be great for computation, and I can certainly see where it would be a perfect fit for artificial intelligence, but I can't imagine using it for applications or even simple scripts.
So tell me /prog/, what Lisp dialect should I learn or at least what are the pros and cons of each?
Name:
Anonymous2011-10-30 20:30
>>1
Scheme or Clojure (if you want to deal with Java).
>>2
Well, I'm not sure about it dying any time soon, but when inevitably some guy cites Quiklisp as evidence of its revival... it's just a fucking package manager written by some random dude. It may be portable package manager, but that at least some libraries to manage are about the least of what's needed to be called a usable language nowadays.
Name:
Anonymous2011-10-30 22:18
>>2
Thanks. I was actually going to mention that I was interested in Clojure's Java integration, mainly because I heard of people developing for App Engine by leveraging the Java API with Clojure and I wondered if the same thing was possible for Android. Dealing with Java is big demotivator for me when it comes to Android development and Jython isn't available for that platform. Since I'm not part of the Lisp community, I'm not sure if Clojure is just a fad/toy-language or if Common Lisp is more established. I noticed that Peter Norvig wrote a 1000-page book about AI with Common Lisp which seems interesting. Scheme seems very good for the type of computation associated with AI (basically, lots of linear algebra with large vectors and matrices), but what you do with that data seems better suited for something else, so maybe that something is Common Lisp.
Well thanks for your input. Keep it coming /prog/.
Name:
Anonymous2011-10-30 23:07
>>4
CL carries whole bloat of hairy features that are +50 years old and don't have modern ones out-of-the-box, like continuations or persistent data structures. But CL has great compilers. It's libraries also rely heavily on OOP, which was shown to be inconsistent dead end paradigm.
>>5
Clojure attempts to be convenient, as to provide lots of syntactic sugar and some heavy-weight features to provide some traditionally simpler ones (like mutability). Its reliance on STM is an interesting experiment on an Lisp language, but other decisions such a s giving :keywords such preponderance, the seq abstraction which yields sometimes surprising results (don't mix vector and list functions, but don't ask me how do you tell which ones are which), and many ways to define a record-like thing are somewhat off-putting.
On the other hand, I'd be surprised if 1000-pages-spec Common Lisp didn't share many of those same weaknesses. And good luck finding any libraries for the JVM Schemes.
The stack traces do suck, though, and that's a damn shame.
>>7
Expanding on my own ranting against the keyword type: they aren't that special, as they merely implement the IFn interface which is employed by applicable objects. It just so happens that it's so rarely implemented that they do seem magic in the end.
1st and 2nd Rules of Identifying Lisps You May Encounter on the Internet:
1. If its name is ____LISP (for most ____) and invented after 1990 it's probably not a real LISP.
2. If it has a name that is violently Résumé unfriendly it's probably a real LISP.
>>2
CL isn't going to die. There are many implementations and many libraries, all being updated all the the time. There are also many de-facto standards for all your "modern" needs.
>>6 [...] features that are +50 years old [...] don't have modern ones [...] like continuations or persistent data structures.
Do you even read what you write? CPS and continuations are at least as old as ALGOL 60, the first compiler compiled to CPS code, encoding GOTOs with continuations[1]. Continuations are 50 years old.
Persistent data structures exist since the invention of linked lists, and ML had them immutable since ever (correct me if I'm wrong). ML is 40 years old, and lists are 55 years old.
>>21
First off because being practical was its main design goal, as opposed to other Lisps.
The goal of Common Lisp lays in its name: to reduce all Lisps available at that time to a "common denominator", standardize it. This process by its nature is hostile to practicality and requires a lot of compromises. For example one member of the committee later said making CL a lisp-2 was a mistake, this decision was made only under a pressure from Symbolics, as it could preserve backward compatibility and save old code from being broken because of numerous name collisions. There is lots and lots of stuff like that in Common Lisp.
The goal of Scheme is to be minimalistic. Minimalism is good by itself, but when you obsessively make it your main goal at the expense of everything else it ruins practicality. It's not news for the Scheme people. You can read about the drama around R6RS, standard that was planned to address this issue; or the next (still going) attempt in which they split the language in two parts: "minimal one" and "practical one". All that shows that the problem is definitely there.
So turns out, Clojure is the only Lisp that from the start at last tries to be practical and, in my opinion, succeeds at it.
Some of the Scheme's are huge library-wise, quite ``practical'', and more importantly have active communities (Racket and Chicken comes to mind). CLers have been using the ``Scheme is small, also, a toy'' meme for decades, perhaps from a former truth that most Schemes were strictly one-off research things. I assume the larger Schemes got rid of the Scheme name because of this lingering perception. R6RS underlines a schism of varied purposes that morphed the report into an attempt akin to ANSI Common Lisp-1. Things like Clojure, newLISP and whatever else get attention more easily because they are perceived to reside at the ``top node'' of the Lisp hierarchy, where the hierarchy being CL, Scheme, and everything else.
>>26
You forgot to mention that there exist ENTERPRISE-READY Scheme implementations, such as Bigloo and Gambit.
I recommend Racket and/or Chicken for usual (pratical) Scheming.
Name:
Anonymous2011-10-31 9:14
The goal of Common Lisp lays in its name: to reduce all Lisps available at that time to a "common denominator", standardize it.
Bullshit. Common Lisp was designed to create a modernized successor to Maclisp, unifying the other attempts to do so (ZetaLisp, NIL, ...).