State of Elm 2018 Results

The State of Elm survey takes the pulse of the Elm community. What experiences do newcomers have, and are they learning at decent pace? What companies have Elm in production?

This year, the survey ran from the end of Janary to the beginning of March, and collected 1,176 responses (about the same as last year.) After the survey ended, I scrubbed each field for 17 of the questions to make sure we had good data, reduced five of the questions to tags, and performed the analysis below. I know it’s been a long wait; thank you for your patience while I did this, and to all the people who checked in and asked if they could help!

Let’s get going!

Reading This Data

This year, we got 6 more responses than last year. That means that I’ve left the raw counts in instead of converting to percentages, as you don’t introduce much error by comparing them directly. If you want to do that yourself: last year we had 1,170 responses, this year was 1,176.

Except for the map question, all the numbers are available if you hover over the bars. (I would have liked to embed them without hovering, but couldn’t figure out how to do it for faceted plots in vega-lite.)

About You

This was a multiple-choice answer, so the numbers don’t add up to the total—mostly because people use Elm both at work and in side projects.

When you consider these together, about 80% of peple (953) respondents are using Elm in some capacity. Of those, 459 (48%) are using Elm at work, which is cool. It’ll be fun to see at how this changes year-over-year—I hope these numbers increase!

This year we don’t have as many people answering that they didn’t have any experience whatsoever. Other than that, we have roughly the same shape of the distribution this year as last year.

This question is designed to get at the idea of how confident people are when using Elm. I think it may be redesigned next year, since these past two years it has not revealed anything useful (other than people click about the middle of the scale.)

The differences here year-over-year are pretty significant, but it has more to do with survey design than respondent differences. Last year we asked “What language are you ‘coming from’?” where this year we asked “What programming languages, other than Elm, are you most familiar with?” The new language clarified the intent of the question a lot—and we’ll use it next year—but it meant that we got a lot more responses!

The upshot of this is that most of these languages can’t be compared year-over-year except people’s top language: JavaScript. Not really surprising, at least to me!

Some surprising changes this year:

Blog posts tops the list. This is a new category this year!

The Elm Discourse is both a new category, and came into existence just before this survey was published. (It replaced the elm-discuss mailing list, and has about the same number of respondents.)

The Elm Weekly newsletter dropped off since it stopped being published in 2016. It’s back now, though, and you can sign up at elmweekly.nl.

The Elm Guide—since rewritten for 0.19—dominates this list. It’s the go-to learning resource!

Below that, we have some interactive resources (the Elm Slack, StackOverflow, and Reddit threads), and books like Elm in Action, Programming Elm, and The JSON Survival Kit.

About 40% of respondents have an Elm user group near them! Fantastic!

This shows the city-level view of respondents. There are hotspots in:

San Francisco and the Bay Area

London

Oslo

Berlin

Here’s the same data organized by country. When viewed in this way, the United States dominates the list, but all told EU countries plus the UK had 433 respondents, or about the same as the US.

Where do you use Elm?

I’m not sure why gaming dropped last year, but it sure picked up again this year! I was curious what kinds of games people were writing, so I asked! The folks in #gamedev on the Elm Slack pointed me to rofrol/awesome-elm-gamedev as a nice overview, and rofrol/elm-games as a comprehensive list of games in Elm. Enjoy!

A note about “Web Development”… I tried as hard as I could to avoid a situation where people answered this, and was very careful when tagging to try and figure out exactly what people were doing with Elm. “Web Development” isn’t exactly the most helpful answer! As a result, this category dropped way off this year.

Overall, people are using Elm longer over time. Makes sense, since people who have been using Elm for one year are likely to use it for another, and another, and so on.

(Note: sorry for the messiness in the chart above; I used vega-lite for these and could not figure out how to get facets to order properly. If you’re a vega-lite expert and want to help fix this, get in touch.)

When people use Elm at work, they tend to get it into production. Hooray!

When work projects are in Elm, they’re mostly closed source, which you can see in these responses. When work projects are open-source, it’s interesting to note that permissive licenses (like BSD-3, under which the compiler and most packages are licensed) are more popular than share-alike licenses like the GPL.

The highest response here is “Buy-In”. Most of these were things like “my boss wouldn’t approve it” but some were “my peers don’t like functional languages, or typed languages.” This leads into the second most answered item: Elm (and languages in the ML family) are unfamiliar, especially to people who mostly come from a C-style language background. I think most of the rest of these items stem from these two.

In contrast with the “how far along is your work project” above, it’s much easier to start a side project but much harder to finish it—there are usually no external deadlines or project managers asking for updates. It makes sense to em, then, that the rate of projects in development would be higher than before, and we see that here.

The Elm compiler and most open-source Elm libraries are licensed as BSD-3, which falls under the top category here.

This is pretty self-explanatory: people don’t have a lot of time for side projects!

For lessening learning cost, here’s a tip: try challenges like Advent of Code or Project Euler! They provide the framework for trying new languages with small, well-defined problems.

0.19 is out now, but it wasn’t when this survey ran. That means that we need to be looking at the usage of 0.18 vs 0.17 and prior. Happily, usage of old versions fell, and current versions rose. I hope to see a similar trend next year with adoption of 0.19!

How do you use Elm?

Last year the data showed that people were generally in favor of using elm-format. This year, the effect is even stronger! More people have heard of elm-format, and the amount of people who prefer to use it rose.

This result—most people using plain CSS or SCSS—tells me that people are integrating Elm into larger existing codebases.

Somewhat unsurprisingly, the first two Elm libraries used are elm-css and style-elements elm-ui. Both are great options for styling Elm apps in a type-safe way!

Most people use Webpack to build their Elm applications. Kind of unsurprising, given the support in elm-webpack-starter and elm-webpack-loader.

It was surprising to me to see that the second two results are elm-make and elm-reactor. I’m curious what this means about how people’s applications are delivered and built overall.

VSCode is surprisingly popular! We didn’t previously have a question like this but I would have expected to see Atom at the top, followed by one of Vim or Emacs. That nearly happened here, but I was really surprised to see Atom a third place!

One editor (which fell of the list as fewer than 1% of people answered it) was Kakoune—I was curious so I wrote part of this post in it. It’s got some really interesting ideas about selections. If you’re interested in text editors. maybe check it out!

Most people use external JavaScript libraries; things like the AWS SDK and D3 were common.

Next most common is localStorage.

“Files” came in third. I’m curious to see if that’ll hold up next year, now that elm/files and elm/bytes have been released.

Almost 50 / 50 “I don’t use this at all” vs “I use the thing you would expect”. This tells me that the split of testing is roughly “50% of people don’t test their Elm applications”.

A useful quetsion, but in retrospect it could have been simpler: “do you test your Elm projects”?

This is more enlightening: people write tests mostly when faced with complex functions whose behavior the compiler can’t check. This is when I write tests too, especially to avoid logical errors or changing values in incompatible ways.

We’ve got a big peak at the top here for functional programming—it’s something a lot of people want to try out, which I’m happy about! Similar thing going on for types; I’m glad people are exploring these areas for themselves. I’ve found them really rewarding!

The third and fourth responses (“No Runtime Exceptions” and “Not JavaScript”) are more in line with what I expected from this question. These are things that are really painful in languages (like JavaScript) for which Elm is a commonly-listed alternative. People want to find solutions to their pains, and if we can help them with that we can grow the Elm community!

(n.b. there’s a looooong tail here, which I’ve cut off by only including items which occurred in 1% or more of responses.)

A note about these questions: getting this data is difficult and time-consuming since I have to distill nearly 1,200 plain text inputs into a smallish number of tags for presentation. That means that there are some tags that completely change year-over-year depending on what people type in, and that may not always be accurate. I’ve tried to minimize errors wherever possible, but it’s still a completely human-driven process. That said, I find them particularly valuable as a pulse on how people are feeling year-over-year, so they’ll probably always be in the survey!

This year slightly more people had trouble with JSON Decoders than they did with the learning curve. This flips the #1 and #2 spots year-over-year.

People also had notably less trouble with interop this year, but more problems with documentation.

I find it encouraging that respondents are having much more problems with scaling this year. To me, that means they’ve grown their Elm codebases in such a way that they’re having to think in the bigger picture instead of “hmm, what does Maybe a mean?”

We did see a big drop in people explicitly requesting type classes (or other forms of interfaces), but the total number of requests for type system features remains unchanged.

More of the usual culprits for this question!

People like the error messages and types, of course, but we saw a big jump in people saying things like “If It Compiles, It Works” year over year. We also saw a big jump in “Refactoring”, which I think supports my point above about people having more trouble scaling their Elm apps since they’re now having to do that as they’ve grown more advanced.

Another big change was the drop in “Not JavaScript” (47 responses to 18—nearly a 70% decrease!) I hope that long-term Elm is seen as something good in it’s own right, not just a refuge for people who have had a bad experience with JavaScript, so this kind of drop encourages me.

There were a lot of responses saying things like “Elm makes me a better programmer” and “Elm has improved the way I think about my work.” In addition to “Makes Me A Better Programmer”, I tagged those as “Confidence” which roughly doubled in response this year. Those were really nice to tag!