Sunday, December 20, 2009

On Immutable Minds

I've wanted to write about Clojure for a while. It has not happened yet because I just didn't find the time for it. Its still not time for it, but today I thought about a phenomenon I observed since Clojures new popularity more than before. There is a particular kind of people who seemingly have problems to live with multiple options. I've called them the "Immutable Minds" because they are incapable of changing their mind without completely replacing all things who were there before. I called it also that way, because I think immutable is such a nice tagword this times ;-). This isn't anything special with Clojure (there is nothing wrong with it)

The Immutable Mind is single-minded

When Common Lisp was fresh (actually refreshed) the Immutable Minds found it and replaced whatever they had in their minds before. But what they found seemed like a trap: It was the obvious "single option" for them, but Common Lisp itself was full of things "multi": It had multi-methods, multi-inheritance, multiple namespaces. It even had multiple implementations (yes that really got critized!) and even worse: Multiple opinions. They couldn't use it but it had replaced what was there before (which was already declared "dead" and they've lost the reference), so they did the only thing they still could do: Pestering people outside the community about Lisp being "The One And Only (tm)" while annoying the community members by constant requests on how to change lisp to be less multi but more single. Single namespace, single inheritance, single implementation and the most important: Single opinion (theirs). When they didn't get what they wanted they got angry and filled with bitterness. Then came Clojure.

Clojure has a single mind (not really)

They saw Clojure and saw that it was a single platform, single implementation by one guy (Rich Hickey). A dream has come true. So they switched their mind again, obsoleting Common Lisp and replacing it by Clojure. Since Common Lisp is still a Lisp they had a problem. As long as Common Lisp exists they cannot use Clojure as the "One and Only Future Lisp". So they started pestering all the world about Clojure being a replacement for Common Lisp. They didn't see the second trap. Clojure may be driven single-mindedly and there is a single mind which controls much of its drive, but regardless of all that things: It's actually quite multi.

They'll move on

They will not touch a line of Clojure like they didn't with Common Lisp (or OCaml, Haskell and many other living languages too). They will be wearisome and pesky, but don't despair dear Clojurians - they will move on and Clojure will thrive to be a multi-language. Perhaps this kind of people are the same ones, who think there is only one god to believe in – without realizing that the world would be a better one without religion.

Tuesday, December 1, 2009

A Lisp for the JVM



In the current issue of Toolbox my article »Lisp für die JVM« (Lisp for the JVM) was published. It's about ABCL, the not too old JVM-based Common Lisp. Since I wrote the article, a lot of things happened with ABCL. Now, one can read about first successful experiments to get this Lisp on Googles AppEngine. Also, the core of the system - the compiler - was continuously improved. ABCL is developing from an experimental prototype to a full CL alternative for java based environments.Thats incredible news for me; not only as an author, but also as a software developer.

And Clojure?

If one currently speaks about a Lisp for the JVM, everybody seems to think of Clojure. Ich already have Clojure on my screen and will very likely publish an article about it. Its just that ABCL was the bigger news to me. A practical and full implementation of Common Lisp on the JVM is a great achievement!

I dont' share the view, that a modern new dialect of lisp has to use an existing runtime like the JVM. I'm not even certain, if Rich Hickey actually meant this point as a fortune against Common Lisp. For me, his statement makes only sense if applied to languages like Python or Ruby: Many such scripting languages appeared in the last years; most of them came with their own runtimes. For such languages, defined by ad hoc reference implementations, it probably doesn't make much sense any more to write your own runtime.

JVM is not a USP

Common Lisp got specified independent from a concrete platform. The ANSI standard doesn't try to make the platform fix. So why not develop a Common Lisp for the JVM or the CLR? ABCL proved that it is possible and that the standard works for this task. If I'll write an article about Clojure, a fixation on the JVM or CLR will not be important. It would be more likely counted negatively. Clojure is currently in its design phase to emancipate from its VM. Yes - it was practical and useful, but the JVM is not a USP for Clojure. In an article about Clojure I would like to check what there actually is about all the hype and what actually is innovative about it.