Results from the State of Clojure, Summer 2010 Survey

In my last post, I solicited the Clojure community to participate in a short survey to determine a few things in particular:

  1. Which language/community have Clojure programmers “come from”, or are primarily using now, if not Clojure?
  2. In which domain(s) is Clojure being used?
  3. To what extent is Clojure being used commercially?
  4. What are Clojure’s biggest weaknesses at this point in its development?

I tossed in a few other questions as well, but determining the above was my primary motivation.

I’m going to run through some highlights and my key takeaways from the data that was gathered, along with some potential TODO items that the Clojure community might want to focus on over the coming months. See the link at the end to get to the raw data to satisfy all your statistical urges. :-)

Responses and Context

The survey accumulated 487 responses, which I think is a hefty sampling (darn close to a typical political poll, for what that’s worth!), and a very strong turnout given the brief time the survey was held open (roughly three days) and the meager promotional efforts that were made (two posts to the main Cloure mailing list, and various people twittering). Note that results were not available while the survey was open – my attempt at limiting any incentives to respond multiple times in an attempt to game the results.

In any case, I’d say that the results are solidly representative of the Clojure community (though I’m hardly a professional when it comes to surveying, polling, or data collection in general, so I’m sure there are plenty more issues with the “methodology” used here). Some caveats warrant mention though. The nature of the survey and its promotion ensured that only the most “connected” Clojure programmers would have been aware of it; I suspect there’s an entire class of potential respondents that simply don’t frequent the mailing list or bother with Twitter. Further, there’s certainly some self-selection bias going on – people who are less enthusiastic about Clojure would be less enthusiastic about spending time answering the survey’s questions.

With that out of the way, let’s get on with it.

Highlights and Summary

What follows is a question-by-question summary, starting with the quantifiable stuff first. I’m also adding in my interpretation and thoughts, especially where the data indicates a weakness in the language, community, or other areas. I’m recreating the charts here because the charts in Google’s “summary” view seem to be falling down, especially when it comes to the language-related questions that had a few dozen options.

How long have you been using Clojure?

It seems clear that the Clojure community is growing, and growing fast. I’ll leave it to others to speculate on a specific growth rate, but it would appear that the curve is tilting far past 2x in Clojure’s third year. No shocker there.

How would you characterize your use of Clojure today?

The only thing I can add here is that I’m surprised that Clojure isn’t being used more in academic settings, at least in relative terms. Students becoming familiar with Clojure in school is the tip of the spear when it comes to Clojure being used more widely in commercial settings, so it might be worthwhile to think about what might specifically address students’ and professors’ academic requirements. Some of the comments further on about usability and ease-of-setup might be applicable.

What is the status of Clojure in your workplace?

These results make me quite happy: more than half of all respondents, 53%, are using Clojure at work or are lobbying to be able to do so. Clojure and its various libraries make for a decidedly “serious” development environment, and people haven’t been shy about introducing it into their workplace. These results are remarkable for a language that’s so young, and perhaps confirms that the historical prejudice against lisps is waning somewhat (which might turn out to be a demographic/generational issue from here on out, or so we can hope).

In which domain(s) are you using Clojure?

Random thoughts:

  • I was actually surprised that web development is the big winner here. I suppose no matter what else one does, web development is necessary at some point – and the existence of frameworks and libraries like Compojure/Ring, Enlive, and compojure-rest certainly make web development with Clojure a joy.
  • I knew people were doing a lot of maths with Clojure, but…wow! This is probably mostly attributable to David Liebke’s excellent Incanter library.
  • The fact that RDBMS usage is trailing usage of non-relational data stores (I try to avoid using the cringe-worthy “NoSQL” moniker as much as possible) is interesting. I take that as an indication that Clojure might be getting more use in new/green-field projects vs. being integrated into existing (call ‘em “legacy”! ) projects, which certainly wouldn’t be surprising if true.
  • A quick scan of people’s “other” domains doesn’t reveal any significant domains that I missed in the main list. There were 2-3 mentions of “music” here and there, which is interesting.

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

Note that respondents could choose more than one option here, so results add up to more than 100%.

Clojure development tools has been a favorite hobby horse of mine for some time (see my scratchpad about The Ideal Clojure Development Environment), and those that know my preferences can bet I’m eating my hat on this one.

  • Emacs ran away with it, actually moreso than I expected, in use by 70% all respondents.
  • I’m really surprised by the number of people using plain vanilla command-line REPLs.
  • vi also has a larger share than I expected, as it’s certainly not traditionally considered a good lisp editor (at least as far as I’m aware). It even outpaced usage of each of the Java IDE plugins.
  • Eclipse + Counterclockwise is the winner in the IDE category, followed by NetBeans + Enclojure and then IntelliJ + La Clojure.
  • In the “other” category, there were a few mentions of TextMate (!) , as well as mentions of Maven (presumably via the clojure-maven-plugin) and Leiningen.

I continue to maintain that broad acceptance and usage of Clojure will require that there be top-notch development environments for it that mere mortals can use and not be intimidated by…and IMO, while emacs is hugely capable, I think it falls down badly on a number of counts related to usability, community/ecosystem, and interoperability. But, I’m not here to harsh on emacs (at the moment! ;-) ). Let’s get our ducks in a row:

  • To restate: broad acceptance and usage of Clojure will require that there be top-notch development environments for it that mere mortals can use and not be intimidated by.
  • The various IDE plugins are simply being outpaced by the emacs world in terms of raw editing capability. There’s plenty of reasons to believe that this will continue to be the case (emacs has a bit of a head start in that department!), but I assume the plugins continue to improve in this area.
  • It is possible that the IDE plugins are in an acceptable state right now, and that emacs is simply a more natural/acceptable environment to Clojure early adopters for a variety of reasons. Even if the latter is true, this is a dodge: there is still a wide editing capability gap that must be narrowed at the very least, and as the respondents’ comments (highlighted below) show, the IDE plugins are not up to par.
  • Finally, there may be a matter of timing, or simply of time passing. The longer Clojure goes without an “accepted” “mainstream” development environment (super-big scary scare quotes there!), the more people who newly discover Clojure for the first time get the impression that emacs is the only game in town. And, when it comes to first impressions like that, it can take years for new developments to percolate back into people’s understanding. So, making this situation better – so that no matter who you are or where you come from or what your personal preferences are, there’s a Clojure development environment for you – should be a top priority for the community, insofar as broad adoption is a priority. If you’re interested in helping, get started with the existing Clojure environments, and then go talk to Eric and Laurent and find out what they need.

I’ll repeat again: I’d love to pay for a super-polished clojure dev env. I’ve got $500 (every two years, say) for whoever can make it happen. Seriously. There are comments in the raw survey results that indicate that others are ready to make a similar purchase. Pay attention if you’re a developer tools company, or aspire to have/be one.

Update: I’ve put together another survey, this one as a “petition” to would-be Clojure tool vendors that will hopefully provide some solid market data for them to go on. Petition / Market Research: For the development of a commercially-supported, polished Clojure development environment

Clojure is primarily a JVM-hosted language. Which other platform(s) would you be interested in using Clojure on, given a mature implementation?

“Other” is the big winner here, almost garnering a majority. The most commonly-noted “other” host/target was LLVM, followed by other mentions of “native”, “portable C”, and Parrot. I actually intentionally didn’t list LLVM/C; the nature of Clojure as a hosted language means that a lot of its core functionality (threading and concurrency primitives, GC, networking, standard library stuffs, etc, etc) comes from the host. Emitting C from Clojure source is probably a perfectly reasonable thing to do, except I’m not sure where all the great facilities that people associate with Clojure would come from; you’d have to have some standard libraries that cover a fair bit of of what Java and the JVM provides in order to have a reasonable native Clojure target. I would think that targeting a Scheme (Gambit, perhaps) that emits C yet has a rich standard library would be far, far easier. Perhaps there’s a wrinkle or easy out in this department that I’m not aware of.

(A full and proper Javascript Clojure implementation probably isn’t possible either, given the limited/crippled execution environment Javascript usually finds itself in. Given that, perhaps my biases were evident in the options I listed here.)

Another note about the “other” responses is that the need for “quick startup”, sometimes in connection with desktop application deployment, was mentioned a number of times. Perhaps this issue will be alleviated with the quicker JVM startup times promised for JDK 7. Tighter integration with nailgun could also help there.

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

I’m only showing options that garnered more than 1% of responses; this was not a multiple-choice question.

Java, Ruby, and Python have the largest representation here, with Java’s share double that of Ruby, the next most common response. This seems exactly right to me, based intuitionally on the time I’ve spent in #clojure and on the mailing list.

Interestingly, very few people have come directly from Common Lisp and Scheme. Those folks are presumably happy with their current environment.

I think it’s safe to say that Clojure is a cultural melting pot – the disparities in attitude, priorities, and domains among Java, Ruby, and Python developers (never mind you Ada expatiates!) can be vast. As the community grows, ensuring that the Clojure culture remains distinct, integrated, focused, and friendly will likely continue to be an important challenge. This is something that everyone can do something about:

  • help your neighbor in #clojure and on the mailing list, especially those new to Clojure
  • remember that it’s possible to disagree without being disagreeable
  • share and share alike, through contributions to Clojure open source projects, by sharing news of your successful usage of Clojure, and by offering up experience you’ve earned in your other/previous domains and environments

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

Again, only showing responses that cracked 2% of responses; respondents could choose multiple languages.

There’s a lot of really interesting bits here:

  • The big winner here is functional programming. Erlang, F#, Haskell, and Scala are all well-represented.
  • Not many people are interested in using Java without Clojure, at least relative to the number that came to Clojure from Java.
  • Big numbers for Common Lisp and Scheme, even though very few people came to Clojure from those languages. Clearly, Clojure has (re-)introduced lisp to a lot of people, and they like what they see. Those lispers that think Clojure is “evil” (especially in the CL community – and yup, I’ve heard exactly that term used, though I won’t bother helping their authors with a link) should pay attention. You’re welcome. ;-)

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

Time for us to take our medicine. This question took textual responses, so I’ll leave it to others to come up with some categorization of the data. I encourage you to go look at the full set of data and read through the answers to this question, especially if you lead, are involved, or help out with a Clojure project. There are likely tidbits there that you need to pay attention to.

Here are the most common issues I see from scanning the results, which I’ve tried to list in order of their prevalence:

  • Poor / incomprehensible error messages and stack traces are far and away the most common complaint.
  • Documentation is an issue for many – lack of clarity (“A lot of documentation assumes you are coming from either a Lisp or Java background, which isn’t the case for some of us.”), needing to go multiple places for docs, out of date screencasts, etc. This is a hard problem, relative to other issues listed here.
  • Getting started is a sore point – going from zero to having a fully-working environment with libraries, build tools, documentation, et al. properly set up is a nontrivial task for most
  • Related to that is lots of sentiment that better non-emacs IDE support is needed (“Richer support for non-emacs IDEs”, “A good IDE that’s EASY TO SETUP!”, “My company would easily pay several hundred dollars a seat for a hassle-free powerful IDE for Clojure”, “learning emacs and slime seems like a requirement”, etc), as discussed ad nauseum above. While there’s a lot of short, one-off comments about the failings of error messages and documentation, there are a number of (sometimes amusing) rants on the topic of development environments and editors. If you care about this issue, read them.
  • Some complain of a “lack of comprehensive Windows support”; I’m not sure what’s lacking on Windows, but the community is decidedly linux/unix/Mac biased, so I’m not entirely surprised that this is mentioned.
  • slow startup time / difficult to use for scripting
  • Points where Java juts up into Clojure where people would prefer otherwise is a common stumbling block (e.g. “[You end up needing] to know when you’re dipping into the Java world or not. Some of this rift is explicit, like when calling a Java method, but others are not. Protocols is a good example of this.”). With this I’d group various comments about classpath management and wanting TCO, continuations, and other features that would be host-provided, but which the JVM doesn’t provide.
  • Constant flux in APIs is a difficulty. Related to that, a proposal: “How about stopping at 1.2 for a bit and letting everyone sync to it so the supporting tools and libraries can get stable.”
  • Build tool diversity is an unwanted complication for most, with the main tension between Maven and lein. I personally think Clojure Polyglot Maven is the unified “compromise” path that, barring some other stellar solution or Sonatype gumming things up badly, should probably end up being the standard.
  • OSGi support/compatibility was mentioned a number of times.

There were a number of interesting solitary responses that I’ll just quote directly, for fear of mischaracterizing them:

  • “I worry that Clojure is becoming too popular too fast and is in imminent danger of being ‘enterprised,’ so to speak, by people whose gifts are limited to the gift of gab and the gift of garb.”
  • “The “EAI” enterprisey world at large uses Eclipse. I would say the biggest weakness for Clojure is really its biggest opportunity — make a completely badass mega-awesome Eclipse plugin for Clojure development. Counterclockwise is kind of a joke. Give it better code-completion, documentation lookup, trans-code navigation, etc. Give it a feature that lets developers easily create & “sneak in” Clojure-based code modules into existing, large EAI projects. This is how we can get Clojure’s foot in the door. We can tell our pointy-haired bosses ‘oh, it’s just a java library that helps increase performance’ – yes, the Clojure language permits this, but it would REALLY help if the tools promoted it.”
  • “Too much emphasis on Concurrency and not enough on solving everyday problems as a general purpose language. The top of the clojure community needs to start putting out real code written to access DBs, service web requests, do scatter gather integration etc. In short show how to solve the every day coding most Java (or JVM) software engineers face. If I see one more graph theory, or factorial, or primes example I think I shall puke, quit, and just stick with Groovy (which has piles piles of code solving every day problems).”

Again, go look at the raw response data, and check out what people have to say. You may not agree with what’s said, especially if you are a happy/satisfied Clojure programmer, but feedback like this is gold: criticism from people that are sticking it out with Clojure, despite the warts they feel it has.

General Comments?

OK, now that we’ve gotten the criticism out of the way, here’s a smattering of the general comments people offered in the last question. Virtually all of it was positive, probably because I gave people a dedicated text area to complain in! ;-) Good things to hear:

  • We’re in production with it since Jan 2009. Great language, great robustness and very sound concepts.
  • Life is good :-)
  • clojure is awesome!
  • Clojure is putting life back [into] LISP.
  • Clojure is the best language on the JVM. Period. It currently lacks tool support and exhaustive documentation, but I hope that will come along as time passes. I’d also like to see some evangelism for use of Clojure in the enterprise.
  • I haven’t been this excited about a new programming language in a long time :-)
  • Love the community!
  • Clojure is awesome. It’s like Lisp is alive again.
  • The Joy of Clojure is amazing. And Mike Fogus is very handsome.
  • Clojure is a lot of fun. I’d like to keep that as the language grows.
  • Clojure’s JVM interop seems far superior to anything else, and its hard to see another language being such a natural fit for us and our problem domain.
  • Clojure made programming fun again.
  • Great job Rich and the Clojure community.
  • I’ve never been more excited about a new language.
  • Writing in Clojure makes me happy.
  • <3
  • Clojure is the best thing that’s happened to programming since, uh, anything.
  • Clojure is making me fall in love with programming all over again
  • I have learnt a lot more by asking questions on the IRC then anywhere else…You guys are awesome.
  • Using Clojure makes me a better programmer.
  • go, go, go
  • I think Clojure is here to stay. I tried Scala for a while. No comparison. Tying a lisp like language to the JVM is genius.
  • Clojure is the first Lisp-alike I’ve encountered that I like instead of merely admire. Rich Hickey has performed a miracle in my books.
  • I like nachos. And Rich has fantastic hair.

And finally:

keep up the good work trying to keep clojure community organized. :-) It’s a thankless job. So thank you!

I’m not sure if I’m doing much more than gathering some useful data, all of which is from the great people in the community. So, no, thank you! :-D

Raw Data

You can get the raw response data either as a spreadsheet in Google Docs, or as an HTML table export from that spreadsheet. If you end up doing something interesting with it, I’d appreciate it if you left a comment with a link below.

Organizing the survey and this post has been a blast for me; I hope you enjoyed it as well. I presume I’ll follow up and do something similar again; State of Clojure, Winter 2010, perhaps?

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

16 Responses to Results from the State of Clojure, Summer 2010 Survey

  1. JParkins says:

    Clojure needs to work on its PR a bit – to form a wider acceptance:
    Break the mental link between Clojure being dependent on knowing emacs… yes counter clockwise and other plugins exist but most of the blogs entries and tutorials sell to you emacs either directly or indirectly. You feel as a new starter you are not getting the most from the language if you are not using emacs.

    Also i think there is a danger with Clojure that people can focus to much on introducing the different development paradigm of LISP and Functional programming instead on focusing on achieving practical tasks with the language

  2. Jeff Heon says:

    Thanks for taking the time to harvest and digest this survey.

    I used to think that I was weird for liking both Scala and Clojure although there are so different regarding types. But it turns out it would be the number one choice if Clojure disappeared. I really like static typing, but Clojure is so nice!

    I think the bottom line the Clojure community is awesome. It’s great that most IDEs already have some support for Clojure. I use counterclockwise and its a pretty fantastic plugin for a language so young and still evolving.

  3. Roy Flynn says:

    Interesting breakdown.

  4. Sean Crotty says:

    Thank you for compiling this, Chas.

    (As an aside: I may be crazy but a couple of the pie charts appear total more than 100%!)

    • citizen428 says:

      Some of the questions allowed for multiple answers (e.g. the dev enviroments), that’s why the sum up to above 100%.

      • Sean Crotty says:

        Aha, that makes sense. For me a pie chart isn’t the best visualization method for “multiple answer” questions (for example the total dominance of Emacs is not as accentuated as it should be). But I can’t think of a better way and I don’t want to quibble with Chas’s excellent analysis!

  5. Ryan Teo says:

    Thanks a lot for compiling this!

    Clojure newbie (using it for my studies),
    Ryan =)

  6. Hi, great article!

    I read it so enthralledly that I noticed that the graph for platforms is a repeat of the graph for environments.

    Thank you for gathering the data.

    I’m an emacs lover, so I’m reasonably happy with how things are, but we perhaps need to distinguish between ‘what we would like to use ourselves’, and ‘what will be accessible to the converts we wish to make’.

    This is a good question, but it’s important that we don’t fall into the trap of designing ‘tools for other people to use’. Which was arguably the whole problem with Java.

    I imagine that if the great majority of current clojure-lovers, who are mostly also emacs-lovers, tried to design plug-ins and environments solely to improve accessibility, then we’d end up with unusable plug-ins and ghastly environments!

    On the other hand, you’re evidence that there are current clojure people who’d like to use a non-emacs environment. If enough people like you scratch their own itch, we may end up with the best of both worlds. A huge community would be a wonderful thing.

    I can set up clojure-emacs-slime-maven in about 30 seconds on a clean linux install, but I have had little success showing my windows friends how to do it. Even clojure-maven-plugin was broken on windows last I looked, and the install procedures are too complex in windows. Also, everything quickly collapses under pressure of versioning issues.

    A good fast compromise would be to streamline the Windows/Emacs/Clojure install procedure. That might give us at least some accessibility to the Windows world. But it requires clojure enthusiasts who actually *use* windows, not just tolerate it. I only know one, and despite his enthusiasm for learning emacs, because he’s seen how useful it is to me, he writes his code in notepad and runs it from the command line because otherwise he spends all his time watching everything break.

  7. Rich Ware says:

    The table you display above, right after “Which other platform(s) would you be interested in using Clojure on, given a mature implementation?”, seems to be the wrong table: it’s identical to the previous table, showing favorite development environments.

    ;) I’m curious to see the correct table.

  8. Pingback: State of Clojure, 2011: What questions do you have? | cemerick

  9. Pingback: Intermediate Java | Meta-boilerplate is another name for design patterns

  10. Pingback: Results of the 2011 State of Clojure survey | cemerick

  11. Pingback: 2012 State of Clojure survey | cemerick

  12. Pingback: Develop in the Cloud - Keith Dawson - How Clojure Stands

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