
A list of companies using Elm in production - mc3
https://github.com/jah2488/elm-companies
======
antew
The company I work at ([https://halogen.tv](https://halogen.tv)) has been
using Elm in production for a few years now, we have around 90k LOC in Elm for
the front-end, and it has mostly been a pleasure to work in.

The biggest upsides in my view are:

\- The compiler is your best friend, the error messages are great, and you can
enforce a lot of things with the type system. Have a list that should never
been empty? Use a NonEmptyList, need to manage a selection? Use a
Zipper/SelectList. Forgot to handle a possibility in a case statement? The
compiler will catch it for you.

\- Refactoring, even large scale refactors, are tractable and actually fun.
Change the architecture in whatever way you want and follow the compiler
errors, when you fix the last compiler error things usually work like you
want!

\- (Almost) No runtime errors. There are still a few rough edges where you can
get a runtime exception, but they are uncommon.

It is not to say it is all roses, there are negatives as well:

\- Lack of a roadmap or timeline, there is zero visibility into what is being
worked on and when things may happen. This has been a deliberate choice by the
core team I think because when they had a roadmap and parts of it didn't fit
into the next release people were angry.

\- Bugs can take a long time to be fixed, even if there is a PR that fixes it,
it is unlikely to be merged.

\- Experimentation is discouraged. The 0.19 update removed the undocumented,
unsupported, here-be-dragons hooks that allowed writing effect managers except
for repos in the elm or elm-explorations organizations on github. I agree with
not allowing those modules to be published to the elm package site, but
intentionally blocking people experimenting on their own is unnecessary in my
opinion. Of course you can always fork the compiler and remove the
restrictions.

\- Ports are a pain. We generally use custom elements in place of ports where
it makes sense, but they are really a hack around some of Elm's pain points,
if I could do it all nicely in Elm I would.

~~~
agumonkey
> \- Lack of a roadmap or timeline, there is zero visibility into what is
> being worked on and when things may happen. This has been a deliberate
> choice by the core team I think because when they had a roadmap and parts of
> it didn't fit into the next release people were angry.

this is a bit sad (the fact that mobs are still mobs)

in any case I wonder if they couldn't make some kind of core partner club with
people that have been long and deep Elm users

~~~
dwohnitmok
I've always seen Elm as being between a rock and a hard place socially. On the
one hand, a lot of people with no FP experience dismiss it for being a "weird"
FP language. On the other hand, a lot of people with FP experience dismiss it
for not having some FP feature they really want (e.g. one that keeps coming up
and just won't die is typeclasses).

Also there is a core Elm team consisting of something like half a dozen
people, unless you mean a partner club of e.g. tech teams that use Elm.

I have an immense amount of respect for Evan Czaplicki for how he tries to
thread the needle here and the huge amount of thought and craft he puts into
the UI and UX of Elm to make it accessible. Unfortunately you can't please
everyone (hell he doesn't even please me with all his decisions, the gall of
him! ;)) and Elm has had its share of vocal naysayers. Elm may or may not die
out, but the impact it's had on raising the bar for the UI/UX of dealing with
a compiler has been IMO one of the most valuable advancements for statically
typed languages in recent years.

~~~
vmchale
> a lot of people with FP experience dismiss it for not having some FP feature
> they really want (e.g. one that keeps coming up and just won't die is
> typeclasses).

You still can't write a generic sort function. It's not only typeclasses,
there's also no module system and Evan is patronizing about it.

------
jlengrand
I feel like Elm has been stalling a bit the last year. Communities in my area
are less vibrant, and I feel like I hear about it less than say 2 years ago.

But where we used to have only 1 european conference in 2017, there are now at
least 3. The list is still short, but growing and there is no crazy push for
adoption so it's understandable.

Most of the core libraries haven't been updated for over 2 years, which is OK,
since they work :). That's something that is quite far from the 'there has to
be noise about it' habits from our tech world, and it might be one of the
reasons it doesn't raise.

I still love writing it more than anything else. Elm makes me happy, more than
anything else I've ever written, and that's all the counts for me

~~~
matsemann
The conference in Oslo is going from a single day to two-days this year, so
not stalling here so far I think.
[https://osloelmdays.no/](https://osloelmdays.no/)

~~~
jlengrand
Awesome :).

------
Fr0styMatt88
I haven’t followed Elm very actively for quite awhile. My workplace has a
kiosk product where I, along with two others, did the entire front-end UI in
Elm. Multiple screens, a full configuration interface and talking to a C#
back-end. I think we’re on Elm 0.17 or Elm 0.18 still. At least at the time we
shipped the first version, it was larger than any example app I’d seen and
there weren’t a lot of non-toy applications or examples to compare against.

I certainly have overall positive feelings about it, with some frustrations
(like any language really). I’ll say that the most stand-out thing about that
code is that I can be off it for six months, come back to it and within an
hour or so I’m back to comfortably knowing what’s going on.

I’d played around with functional languages before Elm; I’m a bit of a
language nut. One thing that’s easy to forget is how intimidating the syntax
can be to people who haven’t seen anything like it before.

I don’t know that I would do such a large project in Elm again though. Or at
least, it’s not something I’d push for wider adoption within work; some has to
do with factors like finding developers and fact it’s just really early days
for the languages in the grand scheme of things. It needs more time to grow.

On the technical side, having subpages and doing the routing of messages can
be really painful and I don’t really like the ‘huge flat data model’ approach.
I abstracted the core routing boilerplate away by using a JavaScript
templating library to make a boilerplate generator. You specify the screens
you want and your main.elm gets generated from a template, with the
appropriate message routing and handling for update and view calls and the
structure of the top-level data model being generated for you into an Elm
source file that actually gets compiled. it worked out for us, but I still
feel like it’s working around a shortcoming of the language.

~~~
gdotdesign
Since you are a language nut, I would like your opinion on the language I've
been developing for more than a year now - Mint ([https://www.mint-
lang.com](https://www.mint-lang.com)) :)

It's something between Elm and React (while actually using React as a
platform) with a lot of built-in functionality like routing, styling, data
storage and more.

~~~
eyelidlessness
This looks really interesting, and I'd certainly consider trying it out for a
personal project.

If I may ask a question about syntax... Mint `render` returns look so very
close to JSX syntax, but slightly different. It appears bare text variables
are annotated `<{ varName }>` rather than `{ varName }`, and the
`<Component::style ...>` syntax is unfamiliar. What is the motivation for
providing a syntax so close to JSX but slightly different?

~~~
gdotdesign
For this particular syntax, the motivation here was to make it look like more
of a tag than an interpolation.

------
aguzubiaga
We at PINATA (gopinata.com) just built one of our newest features with Elm and
Elm UI.

We finished it on time, which is already uncommon and especially when you
don't have any real prior experience with a new language. We shipped it to
production, and it has been working flawlessly!

The simplicity of Elm fundamentals make the language easy to learn, your code
readable, and the solution to your problems almost obvious. On top of that,
the "If it compiles, it works" feeling helps you trust your code and prevents
most of the bugs introduced in refactors.

We aren't going back any time soon :)

------
starman100
Virtual Airwaves uses it for their web-based walkie-talkie WebRTC client with
a custom endpoint (in Erlang!) that emulates radio.

(This link takes you to public channel 1)
[https://cb.virtualairwaves.com/channel/1](https://cb.virtualairwaves.com/channel/1)

More information here:
[https://virtualairwaves.com/](https://virtualairwaves.com/)

------
gscho
Concourse CI is another example of an application UI written in elm:
[https://github.com/concourse/concourse/tree/master/web/elm](https://github.com/concourse/concourse/tree/master/web/elm)

------
kweinber
Elm has been out a long time and that is a really short list. Are there key
reasons elm hasn’t seen more adoption? (Please don’t bother with comments
about corporate drones etc.... companies are pretty good at taking advantage
of a good thing)

~~~
Karupan
I tried introducing Elm at my workplace and failed because:

1\. Development of compiler and core libraries strictly BDFL driven (at least
used to be)

2\. Fixing some important compiler/library bugs takes years

3\. No way to host private package repositories

I still use Elm personally, although these are very valid concerns.

~~~
idoubtit
It was also rejected at my workplace, with the extra reasons:

4\. The language is still unstable. Porting our code to the next release could
be a huge task.

5\. Elm + JavaScript is generally painful.

6\. Few libraries, some of them unmaintained. Combined with the near-
impossibility to use JS libraries from Elm, it would increase our work too
much.

~~~
vmchale
I did a side project in it; then the dependencies broke because of a compiler
update (frustrating), and that's never been updated.

I would never use such a thing in production.

------
wolfadex
We're in the process of a rewrite into Elm at the moment and have been loving
every moment of it. Even the devs who are seeing Elm for the first time are
enjoying it.

------
mac_was
EDIT: Would like to see something similar with svelte.

------
frozenlettuce
I have hard criticism about Elm, but I concur that it has a good onboarding
experience when compared to PureScript, Miso and GHCJS.

------
mettamage
Add brilliant.org to the list.

I'm currently not in the position to do a pull request.

------
berns
> Microsoft - the world's second largest software company, has used Elm for
> the frontend...

Should I take the list with a grain of salt? Just kidding, I'm just curious
which they think is the first.

~~~
Cederfjard
I guess Oracle has more employees? Or perhaps they’re using a wide definition
of software company.

------
tin-foil-hat
Not looked at Elm before, but it does look interesting

~~~
vmchale
I'd avoid it. The community is weird and the language is hobbled in various
ways and they insist on keeping it that way.

I'd try PureScript next, or ReasonML. But not Elm. Definitely not in
production.

~~~
the_gipsy
You have been outed for spewing elm-hate just yesterday, and now you're all
over this thread as well
[https://news.ycombinator.com/item?id=22236258](https://news.ycombinator.com/item?id=22236258)

------
bapcyk
As I understand, some of companies don't know that they use Elm: they paid
money for "some modern frontend" and got it written in Elm. It looks like
deliberate technological lock.

------
danabrams
Interesting that the list is so heavy in education.

~~~
bussierem
The company that employs the author of the language (Evan) is NoRedInk, an
edusoftware company, so that may be a large reason.

------
dentemple
So... uh... which of these companies are hiring?

------
johnklos
These companies are using an older email client? Great! How does that affect
me, and how does anyone else know specifically who's using elm?

~~~
mc3
No not the email client. It's about choice of timber for TV studios.

