> Oh but that's not what I said.

Actually, it is. Basically when someone says, "____ is smug," what they're really doing is making a soft, attitude based argument for dismissing the more substantive arguments. Same as calling someone a hater.

> You can like and evangelize Clojure without making such rabid claims, especially when they are unsupported by data or strong arguments.

I can support the arguments quite well. And I can make the same argument for Go, Scala, Erlang, and Dart. We simply haven't had the space or opportunity to really expound on it here, since the context is a post that attacks "lisp" with spurious complaints.

> Strong claims require strong supporting evidence.

This is true, but what you're doing is ignoring the context of the conversation after the fact to try and weaken my position. I can make a case for these claims, and in fact in many of my blog posts I have made a case for these claims. Saying I never have in this thread is a little disingenuous.

> I even know (horror!) people who know all three and don't always choose Clojure.

You then have the horror of knowing me, the person you have mischaracterized as a Clojure evangelist instead of a modern software tools evangelist.

> at least not without some very convincing arguments

Allow me to just list out Clojure's strong points with respect to Ruby, since that's close at hand. Because you keep acting like I an a Clojure fanatic, dedicated with laser-like precision to the cause of promoting Hickey's work, let me re-iterate: _I COULD DO THE SAME WITH A HALF-DOZEN OTHER TOOLKITS._

1. Ruby and Clojure are both dynamic langages with a variety of beyond-the-Java features but...
a. Clojure's answer to the "expression problem" is safer, faster, and cleaner [1].
b. Clojure has explicitly modeled multi-methods, something that observations of the industry suggest would be useful for clarifying a lot of existing code [2].
c. Clojure can support functional programing and OO programming directly. It often ends up having "cleaner" (less punctuation and repetition) expressions of OO call stacks than its host language, Java. [3]

2. Clojure and Ruby both have rich collection libraries, but...
a. Clojure's core data structure libraries are somewhat richer (e.g., better set support, some better numerics), and safer in multi-threaded use because of their persistent design.
b. Clojure's libraries implement the same "pass in a block" pattern as Ruby, but with more universal names in most cases, and with more consistency (which is important due to the thrush combinators).
c. When the standard persistent data structures cannot meet your performance needs, high performance mutable structures are available from the Java toolkit. Ruby usually has to appeal to C to get faster results, the binding process of which is fraught with peril even with 1.9 (and is excruciatingly difficult in 1.8 due to fundamental design mistakes).

3. Both languages support concurrency primitives but....
a. Ruby's concurrency primitives never allow for parallel processing except in a tiny minority of implementations, whereas in all but a tiny minority of implementations Clojure's primitives do.
b. Ruby's concurrency primitives are basic, whereas Clojure not only offers the Java primitives (themselves ranging from basic atomic references to the contents of java.util.concurrent) but also offers a Software Transactional Memory implementation which emphasizes reasonable performance and ease of use.

4. Both communities value brevity and meta-programming, but...
a. Clojure's half-hygenic macros with quasi-quoting provide an approachable way to make arbitrary syntax extensions to the language; in this Lisp is only challenged by other Lisps and perhaps the Haskell and ML world.
b. Many similar abstractions like Sinatra vs. Compojure exist in the "Ruby and Clojure"-verse, but because of macros the Clojure side can always go further. In the context of the above points, Clojure almost always has a significant performance advantage, too.

5. Both languages have excellent deployment strategies...
a. Ruby has a suite of integrated in-language tools and a lot of service vendors that directly support it for distributed software projects.
b. Clojure is deployable almost anywhere Java is deployable, which is "almost almost" everywhere.
c. Clojure has a mixed blessing in that it has access to ".war" and "uberjar" type deployments. These can be more confusing, but often eminently more easy for an operations (or devops) team.

I'll stop for now, but I want to re-iterate I could make cases against many popular languages for a variety of other languages when the situation warrants. For example, when correctness and ease of distributed processing is your goal, Erlang is unmatched.

[1] http://kirindave.tumblr.com/post/658770511/monkey-patching-g... for more on this.

[2] http://homepages.ecs.vuw.ac.nz/~alex/files/MuscheviciPotanin...

[3] http://java.ociweb.com/mark/clojure/article.html and grep for "noisy" for a casual treatment.