A few weeks ago, I opened the 2012 State of Clojure survey. Per usual, I wanted to take the Clojure community’s collective temperature, see where we all came from, what we’re using Clojure for, what weaknesses and problems exist, and hopefully provide some results that would allow everyone to calibrate priorities and such. This was the third such survey I’ve conducted, and it was a little different than prior efforts:

Now that there are a bunch of rapidly-maturing alternative Clojure implementations targeting non-JVM platforms, I wanted to see how those alternatives were faring in terms of uptake and usage. So, the survey asked participants to characterize their usage of each of the Clojure implementations that I knew of that have matured to some minimal level.

A FAQ among language and library implementers has always been, “Which version of the JVM should I target?” I can’t say why I didn’t include a question relevant to that topic from the beginning, but it was included in this one — and the answers were surprising, at least to me. A similar question was included that deals with which environment(s) people are targeting with ClojureScript.

As Clojure is used more widely and it becomes more and more clear that the language itself is stable, effective, and reliable, the next most pressing concern is the state of Clojure libraries. Survey participants were asked to grade Clojure libraries, in general, on a number of different scores, from effectiveness to ease of discovery to documentation.

I hope you find the results interesting and useful.

Vitals

First, some facts about the survey and how it was conducted. It was available for approximately 7 days (Wednesday night through Monday afternoon), during which time results were not available. The survey was announced primarily via Twitter and two messages to the main Clojure mailing list, which has approximately 6,700 subscribers. 1,372 responses were received — a surprising 2x increase in participation over last year’s 672 responses. As I’ve said before, I’m not a statistician, nor am I a professional when it comes to surveying, polling, or data collection of this sort in general, but this would seem to be a very fair sampling of the Clojure community.

(I’m not sure what to make of the huge increase in participation. I don’t think there’s any question that more people are using Clojure now than there were last year, but a 2x increase seems overoptimistic, especially given my bias.)

Now, on to the survey results. See the links at the end to the raw data to satisfy all your statistical urges.

(Note: Any question with results that sum to more than 100% allowed respondents to select more than one response.)

Q: How long have you been using Clojure?

Good things to see: more new people trying Clojure, and those that were around last year and the year before sticking around.

New this year is the addition of the “I’ve stopped using Clojure” option. Now that Clojure’s been around for long enough that some may have used it, and eventually stopped using it, I thought there might be lessons to be learned in what prompted such decisions. I was surprised that only ten participants indicated that they’d stopped using Clojure; of course, people that have checked out are less likely to fill out a survey, but I was expecting more than ten nonetheless. Only three of those left explanatory comments, so there’s hardly anything to generalize over. But, there is one comment I’d like to highlight:

Clojure’s greatest strength is also it’s greatest barrier to acceptance into the mainstream corporate IT world – namely, it’s LISP syntax (which I personally like quite a bit). Scala appears to be easier to pitch to corporate IT. Thus, (for now) I’ve been working on pitching functional programming via Scala to our IT department. The LISP syntax is to difficult a promote in a world dominated by Java and .Net.

Ah, the overwhelming power and ease of curly braces and monadic contravariant type classes? ;-) (That phrase may be meaningless; my Scala vernacular is rusty these days.) In the end, I don’t know that pitching Scala as a “better Java” because it can be made to look like Java is doing anyone any favors; as far as I can tell, idiomatic Scala is as different from Java as Clojure is from Java, in both syntax and semantics.

If you’re involved in corporate IT environments and have an interest in Clojure, you would do well to take in Neal Ford’s master plan for Clojure enterprise mindshare domination from last year’s Conj if you haven’t yet. There’s no silver bullet therein, but I think it’s quite reasonable to expect “engaged” development organizations to be receptive to anything that will allow them to raise their game, regardless of parens vs. braces or similar silliness.

Q: What language did you use just prior to adopting Clojure — or, if Clojure is not your primary language now, what is that primary language?

Per usual, the majority of Clojure programmers “come from” Java, Ruby, and Python. This is the third year of identical results, so this question will likely not return.

Q: If Clojure disappeared tomorrow, what language(s) might you use as a “replacement”?

Again, nearly identical to prior years’ results: relative to where people came from prior to using Clojure, functional programming (Haskell, Scala, Erlang) and lisps (Scheme, Common Lisp) are preferred. Also mirroring prior years’ results, a number of people left “Other” responses like:

too depressing to contemplate

I agree.

Q: How would you characterize your use of Clojure today?

The proportion of people reporting at-work usage of Clojure is up again, 3 points higher than last year, and 11 points higher than in 2010. As important and promising as this is, I’m actually more heartened by the fact that the proportions of people that are using Clojure for hobby projects has remained constant: I think it would be a great loss if Clojure ever became one of those languages that is used at work, but shunned when one wants to do some hacking for fun. That capacity for enabling play is a huge source of the creativity and liveliness that makes using Clojure not only sensible, but satisfying.

Q: In which domain(s) are you using Clojure?

This chart is identical to last year’s results. Web development and math/data analysis remain ubiquitous and lots of people are contributing to open source Clojure projects.

Most of the “Other” domains are scientific in nature, interestingly enough:

scientific computing

biological research

bioinformatics

healthcare

medical (mass spec) data analysis

…and so on. There’s also a solid chunk of people doing AI, NLP, and semantic web stuff.

Q: While Clojure started as a JVM-only language, there are now multiple implementations targeting different runtimes and environments. To what degree are you using each of these implementations?

The last year has seen an explosion in the number of runtimes targeted by various Clojure ports, reimplementations, and adaptations. This question was answered via a grid of options, but a better visualization than a set of typical bar charts is not ready at hand; so, first the charts, and then a couple of words:

ClojureScript clearly has the most traction and attention of all of the alternative implementations — nearly 20% of respondents are using it in some non-investigatory capacity — but clojure-py, clojure-scheme, and clojurec are also each being evaluated by nontrivial numbers of programmers, despite their relative youth. Targeting JavaScript, Python, Scheme, and C (and thus to all sorts of platforms, including iOS, embedded devices, and so on) have long been of interest to Clojure programmers, so this immediate attraction is not surprising.

This is in contrast with ClojureCLR, and demonstrates how critical the targeted platform is to the success of a language implementation: despite ClojureCLR being complete and well-supported by the tireless David Miller, 70% of respondents just don’t have any interest in it, and only 17 respondents are using it in any capacity. My best guess at explaining this is that those targeting .NET are fundamentally unwilling to consider languages not officially supported by Microsoft…witness the stasis of efforts like IronRuby and IronPython compared to JRuby and Jython and the other dozens of stable, active languages on the JVM.

Aside from any technical matters, this dynamic alone is enough to justify Rich Hickey’s prehistoric decision to focus Clojure on the JVM rather than the .NET CLR, and should be a factor for anyone considering working on or adopting alternative Clojure implementations: the target platform cannot be a footnote or secondary consideration.

Finally: a couple of comments elsewhere either pined for a Clojure implementation that targeted Lua, or helpfully pointed out the existence of clojurescript-lua. Clojure / Lua fans, check it out! (If a couple someones let me know it’s up to snuff, I’ll definitely include it next year.)

Q: If you are using Clojure on the JVM, which JRE/JDK version do you target?

Only 5 respondents indicated that they target Java 1.5. I honestly expected that number to be much, much higher. I concede that there are surely plenty of Clojure programmers who aren’t floating around on the mailing list and twitter and who aren’t likely to participate in surveys — and such programmers might be more likely to be targeting older JVMs. But, all caveats aside, this is fantastic news.

This means that, in general, library authors can safely target Java 1.6. And, if it yields any benefits, Clojure moving to require Java 1.6 would appear to have few downsides (apologies to the few still targeting 1.5).

Q: If you are using ClojureScript, which environments do you target?

What surprised me here was that there’s a bunch of people using ClojureScript to write node.js apps! That surely exposes my personal biases.

Notable “Other” selections here include Android and iOS (presumably through embedded web views?), as well as usage of various mobile-deployment toolkits like PhoneGap, Cordova, and so on.

In hindsight, I probably should have added “Mobile devices” and “Databases” (e.g. CouchDB, PostgreSQL) to the available options.

Q: How true are the following statements when applied to the Clojure libraries available within your domain(s)?

The JVM and other targeted platforms are known, stable quantities; and, especially with the release of Clojure 1.3 and 1.4 in the last year and the ongoing maturation of ClojureScript, the language is stable as well. This leaves libraries as a certain unending “last frontier” of usability, in terms of programmers being able to get things done using Clojure and Co. So, the survey asked if Clojure libraries, in general, are aptly described by a series of statements.

First, the charts, and their corresponding statements:

Sweeping conclusions made from this data are probably suspect, but I’ll make a stab at it:

Clojure libraries are generally of high quality, and more effective than libraries people have used in other languages. Further, library maintainers are generally collaborative and easy to work with.

On the other hand, the right Clojure library isn’t always easy to find, and many libraries are poorly or inaccurately documented.

There have been a couple of stabs at easing discovery, but not yet anything that’s caught fire (or, been regularly maintained, unfortunately). At the very least, everyone should keep search.maven.org bookmarked for those libraries that are deployed to Maven central. But, in the end, it may be that there’s no solution to this problem, insofar as it’s damn hard to track distributed development efforts with a centrally-planned solution; just look at how essentially rudimentary search.maven.org is, and that’s servicing one of the largest software development ecosystems in the world. It may be that time and internalized community knowledge (e.g. “What is the best library for X?” “Y, of course!”) are the only things we’ll be able to count on.

(Those shouting “CPAN, CPAN!” at their screens now should really calm down.)

The documentation issue is, as we’ve seen in previous surveys and as we’ll see again later here, the most common thread of complaint amongst Clojure programmers. More on this in a bit.

In hindsight, I should have offered only two options (Yes/No), which would have pushed people off the fence of “Some are”, and thus made it easier to get a clear picture of the state of things.

Q: What have been the biggest wins for you in using Clojure?

Compared to last year, mentions of protocols, records, and types went up by 50%, probably due to people starting to grok how to best utilize them. The proportion that called out multimethods doubled, which I’m even happier to see. Beyond that, functional programming, JVM interop, and the joys of the REPL continue to be people’s favorite benefits of Clojure.

Notably, very, very few people reported that the extensible reader introduced in Clojure 1.4.0 was a big win. This is understandable given how new 1.4.0 is (released just four months ago), and so it may take some time for people to learn how and when to use tagged literals well.

Q: Which development environment(s) do you use to work with Clojure?

There’s been some movement in the area of development environments:

Emacs usage dropped 10%

Eclipse + Counterclockwise gained 4%

Usage of “Command-line REPL”s gained 5%

…but, I think most of the shifts from last year are noise. What isn’t noise is the total collapse of usage of NetBeans + Enclojure; it was used by 13% of respondents in 2010, and now is used by just 1%.

Popular mentions in the “Other” column include:

vim + slimv (SLIME)

Sublime Text

Light Table

Emacs + nrepl.el (a project aiming to add nREPL support to Emacs)

I’ll talk a bit more about development environments later.

Q: Which toolchain(s) do you use?

Everyone uses Leiningen. The other 5% just wish they could. ;-)

There’s no data from previous years to compare this to, but whatever the curve of growth of Leiningen, technomancy & co. deserve a ton of credit for shaving the yaks and herding the cats to build it up into what it has become today. People’s everyday Clojure experience is greatly enhanced by the get-out-of-the-way approach taken by Leiningen, and I think we’re all better off for it.

Q: Describe how you have participated in the development of the Clojure implementation or “contrib” libraries.

This is a bit of inside baseball, but I was curious to see how widespread participation is in the development of Clojure itself and the surrounding “contrib” libraries, and what might be standing in the way of people that might otherwise participate.

A couple of things jump out at me:

66% of respondents haven’t had a need to contribute to Clojure, to the point of not even needing to report bugs. I think that’s a damn good number of people that have presumably had a distinctly positive experience re: language quality and completeness.

There’s rarely a week (or, day, perhaps?) that goes by on Twitter or in irc without some griping about Clojure’s contributions process and policies. However, just 85 respondents (~6%) cite that process or the Clojure contributor agreement (the most contentious part of those policies) as barriers to their contributing to the language and surrounding libraries; this makes me think that these issues are the favorites of a loud minority more than anything else. On the other hand, 85 respondents represent 28% of the group that have the desire and need to contribute (i.e. excluding those that “haven’t needed” to contribute and those that are “unsure of their ability” to contribute). It does seem worrisome that more than a quarter of potential contributors are opting out at least some of the time for reasons orthogonal to the code and documentation and work involved.

Q: 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?

A lot of the most common and most frustrating problems were expanded upon in the free-form responses, so I talk about them a bit there (see below). Otherwise, just a couple thoughts:

The Clojure community remains a nice place to be, with only 2% of respondents indicating that they’ve had unpleasant interactions with others, the same proportion as last year.

I didn’t think it possible, but an even larger proportion of respondents than last year — now up to a third — indicate that documentation is a key problem. This ties into the feedback seen earlier that library documentation is generally not what it should be. To a large degree, this is a self-inflicted wound: both Clojure and its libraries are technologically sufficient and effective and useful, but many, many people are tripping on their way towards using them.

Given that the only other problems within 10 percentage points of the documentation issue are largely out of everyone’s direct control (issues using Clojure for scripting, likely hampered by the JVM’s startup time; and future staffing concerns, more of a communications and psychological issue than a technical or content problem), the best thing anyone can do to help Clojure succeed is to help make documentation and tutorials better for every skill level and domain, anywhere. I do what I can in my projects and elsewhere; please do what you can, too.

Free-form topics

Per usual, I included two free-form fields where people could write whatever they like: one dedicated to the biggest problems people think Clojure has (which allowed people to point out topics I didn’t offer as options in the prior question, or to further emphasize their choices there), the other for “general comments”. Responses from their fields are included in the raw data linked below, as well as in separate HTML files for easier reading (spreadsheets are really poor for reading long-form text). I encourage you to take a look, as I only provide a selective, slanted, biased, self-interested, unscientific overview here…

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

Predictably, the topics named in the responses to this question ranged all over the place. Here’s a selection of common complaints, or tidbits I found interesting.

Documentation & getting started

I already flogged this above, but it’s worth noting the level of “enthusiasm” (a.k.a. “vitriol”) many people have with regard to the documentation for and around Clojure. This is easily the most common topic in the “weak spot” comments. There are few areas that are immune from such criticism, but much of it inevitably lands on clojure.org, its (lack of) connection to the development wiki (flawed as it is), and so on.

Specifically, there are a number of comments along the lines of:

http://clojure.org/getting_started should be replaced with https://github.com/technomancy/leiningen/blob/master/README.md

There’s been a lot of griping over the years about the “getting started” section of clojure.org, insofar as it leads newcomers through bootstrapping Clojure through a direct java -cp ... invocation on the command line, leaving them with the default, not-particularly-nice (sorry) REPL. I’ve previously thought that the neutral stance taken on clojure.org is reasonable, insofar as a language shouldn’t be dictating (explicitly or otherwise) the use of a particular toolchain. However, given the clearly universal acceptance of Leiningen into people’s hearts, and relatively high degree of difficulty that newcomers clearly feel with regard to the official first steps, I think it may be time to revisit that neutrality. Leiningen, especially its v2.x incarnation, makes Clojure look and feel good “right out of the box”; since so many of the difficulties people report are around the immediate getting-started process, this simple recommendation could alleviate a lot of pain people are having.

Development environments

Many remain unhappy with the available development environments, and many express frustration with Emacs and the learning curve it entails (this not necessarily being an indictment of Emacs; if another editor were the most popular, it might receive the majority of scorn as well). However, I’ll go out on a limb and say that the number and strength of complaints on this topic were down somewhat from last year, which would correspond well with the 8% drop in reports of editors and IDEs being a leading frustration in the previous question compared to 2011.

Along these lines, a number of respondents wrote something similar to:

…every time counter clockwise gets another release, the world gets better.

I wholeheartedly agree. Laurent has made a ton of progress with Counterclockwise in the past year, with Leiningen 2 integration that’s never failed me. By all means check out the latest betas for absolutely excellent, dead easy-to-use Clojure code completion. If you’re not happy with what you use today, give Counterclockwise a shot. (Disclaimer: I am — though not lately :-( — a Counterclockwise contributor.)

And, thanks to Relevance as well, for their ongoing sponsorship of Laurent’s work.

Hubris

I found this complaint interesting:

The hubris it’s champions have about functional programming.

I might be a good prototype of this commenter’s claim: I champion Clojure, am convinced that functional programming is superior to nearly all alternatives for most applications that I care about and that I see friends and peers building, and I share that conviction broadly. Perhaps “hubristic Clojure goon” is the new “smug lisp weenie”?

The notion of “hubris” — excessive pride and arrogance — is interesting though. Should we scrape along with caveats and disclaimers, giving equal time to procedural programming and object oriented programming and the power of pointer arithmetic in order to prove our humility? One of the great things about the Clojure community in general is that it expects people to be adults capable of independent and self-motivated thought. So, if someone — anyone — says something confidently, you should be happy and proud to disagree as long as you have good reason to do so. There is nothing more cherished among Clojure programmers than well-reasoned discussion, and admitting error, mistake, or fault isn’t a taboo sign of weakness.

To me, this sounds like vitality and honesty, not hubris.

Development process snark

Whatever its merits or demerits, people have grown accustomed to laissez-faire collaboration styles (exemplified currently by the typical Github project), so comments like this:

contrib doesn’t seem very contrib-y.

and

Clojure/core’s apparent unfriendliness to community contributions.

aren’t uncommon, and underline the sentiment some expressed in the contribution-related question earlier. Fair or not, there is definitely an undercurrent of frustration among some.

Android pain

An example comment:

One would expect clojure to have a better Android story.

Many people lamented Clojure’s apparent difficulty in being used to program Android apps. I confess I’ve never tried myself, but I know that some people have gone to great lengths to build and publish Android apps written in Clojure, apparently needing to produce custom builds of the language in order to work around particularities in the Dalvik VM (stack size, JIT limitations, and classloader idiosyncrasies being some of the problems I’m vaguely aware of). Making Clojure work well on Android is an effort being tracked, but one that I don’t really know the status of.

It’s surprising how many Android-related complaints showed up, even though only 3% of respondents reported using Clojure for mobile development earlier. Perhaps that figure is so low because Clojure’s Android support is apparently just not up to snuff (and thus driving people to build apps using ClojureScript + e.g. Phonegap, or punting entirely and using Java or Scala or …)?

“General comments?”

Thankfully, the “general comments” field immediately followed the dedicated bitch-box ;-), so nearly all of the responses here were filled with whimsy and joy about how great Clojure is, e.g.:

Thanks to RH. It’s a lovely language. I love it. Programming became fun again like it was 15 years ago. Missing question: “Do you like the direction Clojure’s going in?” – Yes! :) Clojurescript is the shit <3 Clojure put the fun back in software development for me at a point where I was disillusioned and close to a career change (even though I started programming when I was 10yrs old). Now I’m programming Clojure 12hrs a day for the tech startup I founded and I absolutely love it.

…and, my personal favourite:

I love Clojure so much, I want to give it a kitten.

Me too! So, Clojure, have a kitten; her name is Mittens:

She’s seen enough Clojure at this point that she should be able to get a job writing the stuff by now…

Raw Data

All of the data gathered by the survey form are available:

If you are particularly interested in the Clojure community, are involved in Clojure projects, or write about, teach, or promote Clojure, you would be well-served to browse around the survey data to draw your own conclusions.

I’ll wrap this up with one final thought that came while combing through the survey data and compiling this post: all while Clojure and its community has stayed healthy and continued growing like a weed, and while ambitious hackers have helped the language bloom into a family of languages targeting different platforms, no fatal risk has yet shown itself. Five years on, there’s been no crucial flaw found in the principled underpinnings of the language, and no poisonous dynamic has twisted its way into the community. While problems do exist, they are tractable, and many will yield through time and goodwill, a commodity for which we thankfully do not want.

For anyone considering placing a bet on Clojure, and for those of us that already have, these are all very, very good signs.

Thus ends the third State of Clojure survey. I hope you’ve found the above interesting, thought-provoking, and perhaps useful.