back
14 comments
Would it be funny if Lisp turns out to be something everyone really does love, but the problem was actually the crappy and fractured implementations and the libraries that existed with all the old versions of Common Lisp?

Or would it be like, tragic, or maybe something else.

I thought all high-level languages were complete garbage, until I had to write serious concurrent code in C/CUDA. After a year doing that kind of crap, first-class functions and easy to write transactions were like heaven on Earth.

And clojure-dev makes it pretty straightforward to use all those parens, but I wish it was more emacs-y in its tabbing.

Just to show how impressed I am, I used vim exclusively for two years, then went out of my way to learn emacs to use clojure. Combine some of the most helpful emacs features with the clojure-dev plugin for Eclipse and this thing will take off, IMHO.

No need to learn a new editor. There is a great plugin to use Vim with Clojure. I've always been a Vim user and think its great, although I've never used SLIME so I can't directly compare.

http://kotka.de/projects/clojure/vimclojure.html

Crappy Common Lisp implementations?... Did you try a few different implementations and found out they're crappy or you're just assuming things?

I never had a problem with SBCL (I didn't try others).

And about the supposed "fracturation" of implementations, first it's not a problem if you use only standardized features, second a lot of features (threads, sockets, etc) that aren't standardized are still well-supported in implementations and there are libraries that hide the minor incompatibilities between implementations.

Want threads? cl-thread. Want sockets? bordeaux-threads. Want access to the Meta-Object Protocol? cl-mop. Want generalized streams? gray-streams.

I believe the perceived problems are really blown out of proportion. Maybe CL implementations were crappy in 1995 but things change and sometimes you have to revise your assumptions.

Okay, so you're saying that Common Lisp doesn't have any problems with fractured implementations as long as you spackle over them? Common man. I'm not trying to dis Lisp. I like Lisp... well to a certain extent; it's not my favorite.

I'm just saying that if people are having a love fest on Clojure, maybe the reason Lisp never got adopted had more to do with the implementations available than the language itself.

I'm afraid the parens will always turn off most people.

It's sad they go away without even realizing that using a real editor like Emacs makes the paren problem non-existent.

The whole parens thing is pretty silly. It only turns people off because they think somehow that they it's OK to be turned off by them.

Could you imagine if someone went into a C++ forum and complained about all the semicolons and brackets? They'd get laughed right out of their Usenet client. Instead, people try to make it OK that people don't like parens, by constantly bringing up the parens in hushed voices like they are some sort of evil force out to steal our first-born children.

It's bizarre, especially in light of the fact that people don't seem to have any problems with any other sigils.

"But it’s worth learning a language when you pick up fundamental new ideas that might be helpful (or just interesting)."

I couldn't agree with this more. I've spent the last 6 months or so learning Clojure just for the sake of it. I definitely think I'm a better programmer because of it, regardless of whether the language itself is actually "real world" useful.

I definitely think I'm a better programmer because of it

I'm also curious to know if that's because of Clojure itself, or because it is the first Lisp you learned.

I'm familiar with Java, so I've found it easy to hook up with libraries I already understand and just crank out code. When I've tried Common Lisp before I've always struggled (probably because the barrier to understanding was higher) to find libraries to do things like Graphics and GUI work.

I've been working my way through PAIP (using Clojure instead of Lisp) and that's given me a good sense of Lisp style (I hope). I've found that just the act of typing in the code and converting it over to Clojure has helped me grok some of the functional programming concepts I was struggling with (slightly reminiscent of typing in classic arcade games on my ZX Spectrum!).

Clojure has been my catalyst to understanding Lisp-like concepts, and if I had to give one reason for that it would be just having access to all the Java libraries.

Curious if you have used lisp before, or if you have used java, or both. I hear some pretty good real-world stories about Clojure.
I have used Common Lisp and Clojure, both at a novice level (so take this with a grain of salt).

I really appreciate Clojure's concurrency / STM mechanisms. I think they're very well thought out and pretty straightforward to use. Additionally, the ability to use libraries from the Java ecosystem is really, really, really nice.

Common Lisp has some really nice things as well (for the purposes of this post, I'm referring to SBCL). I have a very deep appreciation for the flexibility of CL - being multi-paradigm is one of its charms, and it feels like the most flexible language I've ever used. When I first started messing around with CLOS, I immediately hated every other object system. Cells is pretty awesome too, although I hear it's being ported to Clojure right now.

I also really like that all the libraries are also written in Common Lisp; although it may just be my preference for "turtles all the way down".

Clojure wins from a deployment perspective; CL wins from a tooling perspective.

I would say there is a definite trade-off between the two, but as it stands today, they are both very solid choices.

I see a lot of articles gushing praise for the parallelism and concurrency benefits of the new breed of functional languages (Scalohaskojuremlang), but too few of them include code. Can anyone share links that include simple tutorials on how to actually use these vaunted abilities to "be ready for the multicore era?"
While this is not exactly a tutorial, the http://shootout.alioth.debian.org/u32q/benchmark.php?test=sp... shows threaded multicore programs in a good number of languages.