Results of the 2013 State of Clojure & ClojureScript survey

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:

  • The survey was open for ~7 days, from Nov. 5th – Nov. 12th.
  • I announced the survey here, on my personal Twitter feed, and via a total of four messages to the main Clojure & ClojureScript mailing lists.
  • 1,061 responses were received.

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.)

Per-question tl;dr

What follows is a super-brief summary of the results, with my own opinions interspersed.

Do you use Clojure, ClojureScript, or both?

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.

To me, this implies that ClojureScript has not (yet?) attracted a population looking to use it, and it only (as opposed to other languages that target JavaScript, e.g. CoffeeScript, that are used in conjunction with a diverse set of backend languages / architectures as appropriate).  A rosy speculation might be that those coming to ClojureScript from other languages are so enamoured of the language and its model that they also adopt Clojure, but it’s probably more realistic to say that most ClojureScript usage is simply a result of Clojure developers wanting to target JavaScript environments with a minimum of language and data model pain.

In which domains are you applying Clojure and/or 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.

Order these aspects of Clojure/ClojureScript to reflect how useful each have been to you and your projects…

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.

What is your *primary* Clojure/ClojureScript development environment?

This question changed from prior years (people could choose only one development environment this time around), so comparisons with prior years would be inappropriate.

  • Emacs is preferred by over half of respondents, and nearly all of them are using cider/nrepl.el now; effectively no one is using SLIME or slimv anymore.
  • Likewise, vim users have largely moved over to vim-fireplace.
  • Light Table is the third most preferred development environment, just beating out Counterclockwise.
  • In a very short period of time, Cursive Clojure has overtaken the usage of the La Clojure IntelliJ plugin.

There are now a number of Clojure/ClojureScript implementations targeting runtimes aside from the JVM and JavaScript. To what degree are you aware of or using each of these implementations?

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.

Re: Clojure

How would you characterize your use of Clojure today?

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.

What version of the JRE/JDK do you target?

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.

What tools do you use to compile/package/deploy/release your Clojure projects?

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.

Name *one* language feature you would like to see added to Clojure.

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!

In general, are the following statements true when applied to the Clojure libraries available within your domain(s)?

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.

What has been most frustrating for you in your use of Clojure; or, what has kept you from using Clojure more than you do now?

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.

What do you think is Clojure’s most glaring weakness / blind spot / problem?

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.”

(Apologies to @jrecursive.)

Re: ClojureScript

How long have you been using ClojureScript?

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.

How would you characterize your use of ClojureScript today?

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.

Which JavaScript environments do you target?

Browsers dominate here, which makes sense.  However, people target a bunch of other environments with ClojureScript too, from node.js to app containers to plv8 to Riak’s mapreduce.  Basically, if it can run JavaScript, I’m guessing someone is going to target it with ClojureScript.

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.

Which tools do you use to compile/package/deploy/release your ClojureScript projects?

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.

Which ClojureScript REPL do you use most often?

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.

Name *one* language feature you would like to see added to ClojureScript.

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.

What has been most frustrating for you in your use of ClojureScript; or, what has kept you from using ClojureScript more than you do now?

As mentioned before, difficulty using REPLs is the biggest deal here, followed by “difficulty debugging generated JavaScript” (something that I know has been a big focus of David Nolen & co. with source maps and such).  Other big problems include using JavaScript libraries (something I’m queued to improve), followed by the eternal frustration around documentation, and my personal favourite, “coping with JavaScript”.

That last one is not something we can do much about very quickly in the ClojureScript community, but it’s definitely one I share; having relied on the JVM and JDK for the last 15 years, it can sometimes be incredibly frustrating to have to work around the shortcomings of the JavaScript runtime environment, language problems, and holes and misfeatures in the standard library.  Hopefully we’ll be saved eventually by some potential improvements coming from the ECMAScript standardization/evolution process.  In the meantime, perhaps there are some clever things we can do to blunt the pain a bit.

What do you think is ClojureScript’s most glaring weakness / blind spot / problem?

Here is where you can leave any general comments or opinions you have…

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!

Survey data access

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″.

About these ads
This entry was posted in Clojure. Bookmark the permalink.

2 Responses to Results of the 2013 State of Clojure & ClojureScript survey

  1. Pingback: Most interesting links of November ’13 « The Holy Java

  2. Pingback: Clojure 2013 Year in Review | Digital Digressions by Stuart Sierra

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s