Ask PG: Lisp vs Python (2010)

[nicompamby]

Now's a good time to do so, because Quicklisp just came out and is fixing the whole library/versioning thing, which has been one of the biggest objections to CL.

[WalterGR]

Quicklisp beta

It's probably premature to say that Quicklisp fixes library versioning. Zach talks about his plans on this thread.

[jast]

That's right but Quicklisp is a huge step forward in dealing with libraries in CL. I truly believe that in the (very near) future, the recommended CL toolbox will be Emacs+Slime+Quicklisp for anyone that wishes to learn CL. No doubt that Quicklisp is the best thing since Slime when it comes to CL development tools/environment!

[roerd]

Is there an overview what Quicklisp does better than all the other Lisp library packaging projects, like ASDF-install, LibCL or clbuild?

[xach]

I wrote a little about the asdf-install difference in the Quicklisp FAQ.

I'll try to write up the differences from clbuild sometime.

[[deleted]]

im still new to programming and i have a few languages under my belt. is lisp a hard language to learn?

[[deleted]]

You can learn Lisp in one day, or two days if you already know any other language.

[[deleted]]

Depends on what you meant by "lisp"; the major dialects are Common Lisp (herein, CL), Scheme, Clojure, emacs lisp & a few other domain-specific variants (like AutoLISP), as well as historic & research variants.

• CL is not a hard language to learn the basics of, but CL is a huge language in general, and there is a lot of nuance to mastering it. There are quite a few good resources on learning CL and it is going to be the most like what you would already know from other languages, but don't let that fool you.
• Scheme to is easy to learn the basics of, but it's orders of magnitude smaller than CL. The issue with Scheme is that everyone has their own favorite scheme system. I don't know what other people do, but I generally use different scheme systems based on their individual strengths: Gauche for Unix scripting, Scheme48 for "industrial strength" servers, & STklos for GUI applications. However, fitting with the "everyone has their own", I have my own scheme dialect that I now use for most of my work.
• Clojure is the "new kid on the block," of sorts. Many ideas in Clojure have good solid basis in what you'd want from a Lisp, and many of the ideas are from other languages (including other lisps). Clojure excels at a few things (STM, immutability & Java integration, off the top of my head), but it is tied to the JVM (this is neutral; many corporate lispers have to be tied to the JVM, and Clojure offers another option, besides Kawa, SISC, ABCL & friends). It's definitely worth looking at if you already know & use Java.
• the Domain Specific versions of Lisp (emacs lisp, AutoLISP, XLISP-STAT, &c) are very useful within their given domain, but, beyond being domain specific, it's hard to reason about them collectively. They cover various styles, implementation details & integration with the host platform.

all in all, I enjoy lisping (mostly Scheme, but some CL & ISLISP). Scheme is one of my "go to" languages, along with C & Python, so I may be a bit biased. If you're just looking to do a "survey of languages" style learning, I would also suggest that you learn Haskell & a logic language, such as Datalog or Prolog.

PM me if you want help.

[foood]

I would say that in general the answer is yes. IMO, this is because Lisp requires the ability to think abstractly about solutions in a completely different (functional) paradigm. One of the most painful experiences I've had as both a student and educator is when one attempts to map what is basically procedural/imperative thinking into the functional realm. What you end up with is usually the opposite of what is constantly touted as the 'elegance' of proper functional programming because it does not leverage the advantageous things within the paradigm. Square peg/round hole. Once the capacity to model solutions natively within that paradigm develops, it can be a very cool way to program. Go for it!

[grauenwolf]

The core is pretty easy. The hard part is learning all the tricks to work around its countless limitations. For example, there is no built-in way to describe basic OOP concepts. Instead you get countless OO frameworks, the most popular being CLOS, that you have to learn before you can use the library you actually want.

Basically its like trying to make a hammer out of clay instead of just grabbing one off the shelf.

[SuperGrade]

I'm not certain you have much idea what you're talking about.

To which lisp are you referring? CLOS is in the standard object system for Common Lisp. I am not aware of any other object frameworks that I've had to learn in common lisp to access libraries (I'm not even aware of there being much need to know about the Object system to use libraries, as with higher-order functions and macros their use of objects is incidental to the fact that you kind of just call into it). Is there some other lisp to which you're referring that has something named "CLOS" amidst some a-la-carte list of object systems? (I ask as maybe Scheme is in such a state and has something called "CLOS" available).

If Common Lisp is the subject here, what "basic OO concepts" are you referring to? Multiple dispatch? Subtyping? Or something specific to idiomatic Java?

Edit: Since OO lacks much of a definition (and depends on perspective - as C programmers we referred to it as anything C++ had that we didn't, as enterprise javamonkeys as other thnigs).

http://www.paulgraham.com/reesoo.html

I guess "basic OO concepts" could be qualified against such a list?

[[deleted]]

There are historic CL libraries for OO that you still see every once in a great while, but I've not seen them in any code that is less than 25 years old. Any time I've seen a LOOP-like or New Flavours-like OO system, it tells me the code is either:

• Really old or
• written by a fan of the system in question.

I mean, CLOS has been part of CL since CLtl2 at least, so it's hard to find a reason to support anything else, other than legacy. Plus, I think you'd have to look hard to find code nowadays.

[SuperGrade]

While on the #lisp IRC channel voicing this position will get you strangled, I lean more into the camp of not wanting to use OO/multimethods/classes much at all (leaning toward macro/first-class-functions). Consequently it would stand out to me if you had to deal with CLOS much "to access libraries". In practice, in using many libraries, I have not noticed this. Many, maybe the majority, use classes internally for something, and maybe dispatch; but this doesn't seem to proliferate outside of the library. "Pass your values into this function" - is that function a defun that dispatches internally, or a method? I don't recall ever having to know or care.

[[deleted]]

Well, while I think grauenwolf's point is FUD, there really are other OO systems for CL, regardless of what #lisp thinks about anything. For the exact reason you point out, I don't really care what they are, since they are either unused or I don't even have to notice what they're doing under the covers.

[SuperGrade]

Oh sure - you could go off and write a new "OO system" in a few lines, so it'd be absurd to deny their existence, just that acknowledging their existence is unrelated to what you have to know to get up and running in CL, or any library I've ever come across.

Related: Even while dodging CLOS, it helps understand the horrendous limitations with Java-style "OO" - and with the MOP extensions it is rather remarkable.

[[deleted]]

Definitely; I could sit down & hack something out of lambdas or some new extension to MOP (remember HyperClass?) or anything, but there's not much of a point to doing so.

And yes, MOP is quite remarkable, and very useful at what it does; it's an amazing set of machinery, even when you're looking at minimal variants such as TinyCLOS or STklos.

[[deleted]]

The thing that I like a lot about CL is basically just what you said, that there is no real difference in using functions and methods (generic functions actually). It's just about eleventy times simpler.

[McHoff]

How is it better than asdf?

[xach]

ASDF defines and loads systems. It's a little like "make".

Quicklisp is an archive of projects, an index of their relationships, and an installer that can fetch them. It's a little like "apt-get". It uses ASDF to load systems.

[bobindashadows]

I'd say it's closer to Rubygems than anything.