Monday, April 19, 2010

Why I ignore Clojure

Because Clojure ignores Lisp.

Put that gun down, and let me explain.

Lisp is a process. Progress is measured in decades.

Lisp gets lexical scope right, for example, simply because we have a head start of decades over the competition others.

I'm quite certain that the unwashed masses will discover macros around 2020 and hygiene around 2040.

It's simply a matter of time.

Lisp moves slooooooooooooooowly.

And because of this slowness, individual contributions simply don't matter. They're just a blip on the radar. You can measure a programmer's inexperience by the amount of saliva generated by new, unproven language features.

Yeah, great, Clojure does some newfangled stuff with persistent data structures. Well, if it works, Lisp will adopt it in a couple of decades. In the meantime, we'll just keep on using the same tools we've been using for decades, well.

Yeah, great, Clojure has some semi-solution for hygienic macros. Again, we'll see how that plays out in a couple of decades.

If you have some great new idea for PLs, you can be quite certain that Lispers heading an Ivy League university's CS dept have already tried it out, decades ago. And if it isn't in today's Lisps, it's because it didn't work.

So what do I mean when I say that Clojure ignores Lisp? Well, it ignores the fact that individual inventions in Lisp are mostly meaningless, because Lisp is a community process.

For the larger Lisp family to adopt a feature, it has to be tried out and implemented in a dozen different dialects and implementations, over the stretch of decades. Until that happens, it didn't happen.

And there have been and are so many smart people in this community, that if you think you've got the great new idea to push Lisp farther, you're wrong.

(I'm surely not one of these dweebs that say CL is the be-all/end-all of Lisps, and we should all be using it. Hell no. Everyone should be writing new Lisps! It's one of the greatest learning experiences there is.)

Now, go ahead and have fun using Clojure if it floats your boat, but stop whining about how it's a more modern or better Lisp. That doesn't make the slightest bit of sense.
Why do you glorify doing something new and stupid, when doing good things well is what people really should be admiring. — Linus Torvalds
[Update: this is a rant. I'm not writing articles. The good people at HN have pointed out the many flaws of this rant.]


Anonymous said...

Your Linus quote nails it: Clojure helps a lot to do good things well. Common Lisp has some roadblocks on that path :( at least for me.

I know Common Lisp after I learned Clojure, and I think both have their value. Just Clojure is the practical oriented programming language I always dreamed of, and Common Lisp is the standardization of a theoretical effort with a lot of new stuff coming in slowly these days, but lacking the coherence and practical tools necessary for quick and good development.

For me, Common Lisp is just too big with too many things missing... Clojure cuts down the bullshit and concentrates on the stuff you need at work.

Joshua Scholar said...

If the Lisp community embraces all really useful ideas, then explain to me why Common Lisp doesn't have continuations.

Backtracking, for instance, is a very useful method, but if I want a language that supports it I need Scheme or Prolog (from 1971 even!) or something from that family.

I'm currently working in scheme, and while I find the language as a whole good. I don't think I've ever been so productive, I must say that I'm very disappointed with the state of macros in Scheme. The pattern matching system is weak, the pattern variables are not real variables, they're opaque. And if you need to break hygiene you have to use a horrible horrible API, when a well designed system could have just explicitly notated what sort of variable use you needed and could have used normal variables and objects to do it.

You say Lisp moves slowly, but there's such a thing as too slow.

Unknown said...

It's wrong on so many levels I don't even know if I should start. Probably I shouldn't. Just try to critic it yourself for at least 5 minutes, by timer..

patrickdlogan said...

This response i probably 4 years too late for the person who claimed they could not do backtracking in Common Lisp. As with many Lisp features, backtracking is not "native". Instead you can choose when and how you wish to do backtracking.

In fact Common Lisp backtracking goes to 11...

z0ltan said...

What an utter retard! It's an old post I know but you, sir, are a complete and utter retard. Please stay away from programming languages.

aoeu256 said...

Lisp invented destructuring-bind and pattern matching, yet, everyone goes on using car/cdr... which unfortunately can not be made parallel... Also John Mcarthy himself said that he wanted the let syntax to be like Clojure's.