I've been converting some projects to Clojure for the past few months,
and I thought it was about time to say something about how much fun it
is. I've nearly posted a couple of times about issues that cropped up,
but thinking about them enough to express the issue clearly has so far
always resulting in my solving them easily. To me, that's a sign of a
good piece of design.

I've been a Common  Lisp programmer for many years. My first  serious
project with Common Lisp started at Apple Computer in 1989. I used
Coral Common Lisp and got to know the people who produced it. I ended
up working with them again several times. They're my main customer
now; their business is called Clozure Associates, and they maintain
Clozure Common Lisp, which, once upon a time, was Coral Common Lisp.
It was a message from one of the Clozure partners that first made me
aware of Clojure. She noticed that they weren't the only Lisp-based
venture using a misspelling of "closure" as a name.

One of the things the Coral/Clozure folks did while I was at Apple was
the design and implementation of Dylan. The early version of Dylan,
before the invention of the infix notation, was probably my favorite
programming language. I worked on a version of the Newton OS that was
implemented in that version of Dylan, and preferred it over any other
programming language before or since.

I think I've used Clojure enough now to say that I like it as much as
that old version of Dylan. It's possible I'll end up liking it more.

In some areas, I'm not sure yet whether I like Clojure as much. Is it
as easy to extend the sequence abstraction to user-defined datatypes
as it was in Dylan? Dunno. I do know that I like the unified sequence
abstraction in Clojure. Is the Clojure design for multimethods as
natural and convenient as the CLOS-based one in Dylan? Dunno. It feels
awkward so far, but I do like the separation of protocol from
representation; Clojure may be the first language I've used that does
what I've always wanted there. It's taking a while to get used to
derive. I very much like the freedom to create arbitrary ad hoc
classification relationships with it, but relying on symbol tags feels
a little forced sometimes. It doesn't seem to be impeding me, though,
so maybe it's just a matter of getting used to something new. Are
Clojure namespaces as pleasant as Dylan modules? Hm. Not really. And
the implicit mapping to a hierarchical filesystem feels a little
creepy, as it does in other languages that do it (e.g. Java and
Python). But Clojure's design fits the JVM, which is a virtue that
might trump other considerations, at least for now.

I've moved pretty much all my spare-time projects over to clojure and
it's been a pleasure so far. It's a nice piece of work. It seemed
appropriate to say thanks for it. So thanks!

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to