Two weeks ago, I opened up this year's Clojure & ClojureScript survey. Now, you get to see what everyone said, and we all get to speculate on what it means.
First, some process details:
One immediately-surprising thing is that fewer people participated than last year; not by a staggering amount, but enough to make me pause. Of course, there's a ton of uninteresting reasons why that might be the case: the time of year the survey was offered, the new collection method being used (PollDaddy vs. a Google Docs form last year), the size of the survey (23 questions vs. 13 last year), and the peer presence of ClojureScript in the survey (which accounts for the increase in question count). Of course, all of this comes with the caveat that I'm far from a professional pollster, so there are tons of factors that I'm surely unaware of that would impact participation (maybe some that I'm responsible / to blame for).
(Late note: people have mentioned that, in contrast to prior surveys, this year's did not get any significant placement on Hacker News et al. That may further explain the drop-off in responses.)
What follows is a super-brief summary of the results, with my own opinions interspersed.
The community is effectively split between those that use only Clojure, and those that use Clojure and ClojureScript. Only 7% of respondents use only ClojureScript.
In a few words, web development, open source, math and data analysis, and building commercial services and products using databases. There aren't a lot of surprises here.
Notable is that ~20% of respondents are using Datomic in some capacity.
The relative distribution of the domains really hasn't changed since I started running the survey. At this point, the only utility of this question is to limit one's view of the rest of the results in terms of what people are working on.
It's no surprise that functional programming, REPLs, immutability, "ease of development" (an ill-defined aspect to include in the list, I now realize), and host interop are hugely impactful; these are core to Clojure's rationale.
On the other end of the spectrum, metadata and newer features like reducers and tagged reader literals are comparatively not getting a lot of love. This is actually a bit unfair, especially with regard to metadata, but the stack-ranking nature of the question means that some useful bits were guaranteed to be lingering at the bottom.
This question changed from prior years (people could choose only one development environment this time around), so comparisons with prior years would be inappropriate.
Very few people are using these alternative implementations, though up to 20% of respondents are evaluating at least one; the "winner" there is clojurec, which makes sense given some of the most popular complaints around Clojure, i.e. its general unsuitability for command-line utility development and the difficulty of using native libraries from within the JVM.
More than half of respondents are using Clojure at work, which is a big jump compared to the last two years, when only a third of respondents were so lucky. This is nothing but good.
We are generally early adopters, and that carries over to JDK selection: 75% of respondents are using 1.7, 5% are on some pre-release of JDK 1.8. JDK 5 is dead now, and JDK 6 is on its way.
This is another question where I changed the survey to force people to make one selection, so comparisons across years don't make sense. Leiningen dominates the Clojure project management / build space.
This was a free-form question, and I'm not going to attempt to summarize the responses. I'd encourage everyone to click through to the full survey results and look at some of these yourselves (maybe filtered to focus on the "types" of Clojure programmers / usage you are interested in).
Update: Alex Miller has summarized this question's responses into a ranked set of categories of features. This is a great way to get an overall impression of what's top-of-mind among participants without weeding through the raw responses yourself. Thanks, Alex!
This question attempted to gauge general sentiment with regard to library quality on a couple of different criteria. In short, Clojure libraries are easy to find, their maintainers are receptive to feedback and patches, they are technically of high quality, but they're not always very well-documented. None of that is surprising or particularly different from last year.
Clojure is not generally suitable for building command-line tools, though people wish they could use it for that (perhaps ClojureScript and/or something like clojurec will help here over time). As in prior years, people remain unsatisfied with documentation and development environments.
"Staffing concerns" is new as the #2 reported frustration, which I think is significant: I certainly know that companies using Clojure have a hard time filling openings lately. Perhaps this is correlated with (maybe) increased commercial use of Clojure, given many more people using Clojure at work this year; it may also be a reflection of current/recent macroeconomics.
Again, you should go look at the raw results to see what people highlighted as problematic areas in Clojure. I will call out this response though, as it was both at the top of the list of responses for this question, and made me chuckle:
"Where are the docs?" "Read the (tests|docstrings)." "Did you just tell me to go fuck myself?" "I believe I did, Bob."
ClojureScript is very new, and in general, all ClojureScript programmers are new, too: effectively all of us have been at it for a year or less.
Despite ClojureScript's youth, over 25% of its users are using it at work. I find that amazing, and is a testament to the relative maturity of the language, i.e. it started off benefiting from the lessons that were learned in building Clojure and bringing it to the point that it's at today. Of course, that doesn't yet reflect in the maturity of ClojureScript's implementation. Things there are getting better fast, and will continue to do so.
Everyone else is basically just tinkering, which makes total sense right now.
The tricky thing about this is what this implies for those of us targeting more than one environment with our Clojure[Script]ing: while 95% of a codebase may be perfectly portable among all sorts of runtimes one can target from Clojure and ClojureScript, many of the options available for dealing with that last 5% are suboptimal, especially insofar as adding an additional level of indirection to represent runtime differences conflicts with the typical objective of that 5%, namely performance-sensitive bits that need to touch runtime-specific / interop facilities. Fixing / working around this has been a defcon 3 yak for me for some time, thus cljx…maybe it'll help you out if you're contending with the same issues.
Just like with Clojure, Leiningen (with lein-cljsbuild) is the overwhelming favourite for ClojureScript build/project management. This is no surprise given huge overlap between those using ClojureScript and those using Clojure.
The results here are very surprising, and sad to me: more than a quarter of ClojureScript developers don't use a REPL at all. Looking at the responses around what can be improved about ClojureScript, the ease of use of existing REPL options is easily the #1 reported problem, and is clearly preventing people from using what is reported more generally as one of the most useful parts of Clojure/ClojureScript. This is absolutely something that is hurting ClojureScript adoption, especially insofar as one of the first things people reach for when language tinkering is the REPL and ways to make it work with one's other tools.
I'm doing what I can to help this problem by working on Austin, an alternative project- and browser-REPL implementation that aims to make ClojureScript REPL-ing as easy and as indispensable as it is in Clojure. If you've had a hard time getting ClojureScript's browser REPL going reliably, or would like to not depend on e.g. Rhino for project-connected REPLs, take a look; it's far from done, but what's there is easier to use and somewhat more flexible than the baseline.
Just like with the Clojure analogue, this was a free-form question that I'm not going to comment on here. Click through to the full survey results and look at some of these yourselves.
The last two questions both collected free-form responses, only the first of which is ClojureScript-specific. The second is always my favourite part of the survey, where people can write anything they want about the survey, our languages, or our community; it's overwhelmingly positive, and reminds me why I'm proud to be part of all of this. The only one I'll quote that appears a bunch:
Thanks for the survey Chas!
My pleasure, thank you for participating!
Complete access to the survey reports (with a pretty snazzy filtering and drilldown UI) as well as all the raw data are available here; the password for that shared view is "HvmqkIS3dx3".