You contend that Lisp is regular, without defining regular. I contend
that as soon as you have ' it is not regular, and no one writes Lisp
without '.

You keep using the term 'syntax' for Clojure's non-list data
structures. If list literals are not syntax, neither are vector or map
literals.

You consistently presume the differences in Clojure are gratuitous.
That presumption isn't going to help you, as it is wrong.

I understand, you have a world with which you are familiar, and enter
a new world where things are different, and it's frustrating. But you
are complaining about how it ought to be more similar to what you
know, without spending any time to understand why it is the way it is.
Part of that may come from expectations driven by the claim that
Clojure is a Lisp. It is a Lisp, but in a much more expansive notion
of Lisp than a mere syntactic one. I've presented Clojure to many of
the people who wrote CL and Scheme, and no one can deny it is a Lisp.
But it is not Common Lisp, nor Scheme, nor a derivative thereof. I am
not 'changing things'. I've written a new Lisp.

In some ways, you sound a lot like the people drifting into
comp.lang.lisp over the years, who within the first few hours/days
with CL know what's wrong with it and how it should be changed in
order to be better. Those people normally get responses of this sort:
once you understand it, these differences will seem less gratuitous
and you'll see how it all fits together. Same here, with fewer
flames :)

I contend that Clojure is as regular as Common Lisp, i.e. both are
mostly regular, except for reader macros. That the point of Lisp is
not 'everything is a list', but that 'code is data', which is true for
Clojure. Clojure is not like Dylan, or Arc.

Nothing about the differences is gratuitous. There is a holistic
nature to Clojure that it may take a while to see. Not every decision
is ideal, but all were considered.

I think you'll have a much better experience if you:

Keep an open mind.

Ask questions rather than presume. If you must presume, presume the
better rather than the worse.

Leverage the documentation and support channels - there are 82 people
logged in to the #clojure IRC right now. Someone there could get you
unstuck in an instant rather than an hour.

Accept up front that it is going to be different.

Yes, cond has fewer parens, and do and assoc mean something different
etc. These things, while initially frustrating, are superficial. Many
Lispers have become productive with Clojure. Yes, there could be more
of a roadmap for Lispers, but there's a Wiki and I encourage users to
help each other out by contributing any advice or tips they feel will
be helpful.

I think, if you stick with it, you'll find that Clojure is indeed a
Lisp, at a deep level, and its core non-list data structures are
considerably lispier than their counterparts in other Lisps. That
Clojure programs are shorter and clearer than corresponding CL
programs. That the sequence abstraction is a powerful expansion of the
list concept. That adding first-class maps/sets/vectors to lists is
empowering. That functional programming and concurrency are well
supported. And much more.

Rich

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To post to this group, send email to clojure@googlegroups.com
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