I appreciate the answers that everyone has given to my post, and I thought
I'd send a single response before ceasing my bleating; I do realise that
this discussion has the potential to devolve into multiple different
religious wars, and I appreciate everyone's tolerance and forbearance so
far.
I think, that most people who have responded have done so from the
perspective that they feel Clojure currently strikes a good balance between
terseness and comprehensibility. Since there is currently no strong IDE
offering, everyone who is writing Clojure is currently writing in a general
purpose text editor, perhaps with some customisation to make the process
more pleasant. Many of the people on the list have pre-existing preference
for a text editor and the fact that they can work effectively in Clojure is
a real win.

A few thoughts before I vanish back into the crowd:

- The approach that Clojure takes to state management in a multi-threaded
environment is very promising. I don't know if it is 'the right answer' to
the problems of concurrency and parallelism .. but if it is I'd like to see
it succeed. Success in this case would have to be considered in terms of
wide-scale adoption. I believe that Lisp and, later, Smalltalk were "the
right answer" of their time, but both failed to capture the mind-share they
deserved.

- The current users of Clojure probably aren't representative of the
development community as a whole. I'm not suggesting that they/we are better
or worse than average. Just that early adopters are atypical, exemplified by
the fact that they are early adopters. I'm sure that many of the developers
currently contributing to this list could work effectively using any tools,
and with any naming convention you cared to concoct. If Clojure is adopted
widely, the programmers working with it will predominantly be using an IDE,
running on Windows. They won't be using Vi or Emacs or TextMate ( fine
editors all, and I love them all equally ). I believe that optimising for
this group is key to success.

- The languages that have grabbed major developer mind-share have each been
more expressive than the last, but also more verbose in the choice of
identifiers. C gave us printf, Java gave us System.out.println. In an IDE
world verbosity actually helps you be more productive since you can
disambiguate and investigate using code completion - if aget, aset and co
were named array-set, array-get then I could type array-<insert code
completion key> to see a list of all the array related functions. With the
names as they stand typing a<insert code completion key> will give me quite
a long list of mostly irrelevant functions.

Of course this is all predicated upon the creation of IDE tooling that is
still very far away, so it is in many ways an argument based on a future
which may never happen. I can see the value in optimising for now rather
than the future, but I fear being trapped in a local optima.


Rob Lally.

--~--~---------~--~----~------------~-------~--~----~
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