The "production ready" / "beta" duality
Added 2019-06-28 14:00:00 +0000 UTCI tried Elm and Rust out in 2013. They both seemed interesting in that they had conceptual models that promised to make programming easier. Elm was particularly compelling to me since its model wasn't too different from how I think about hardware design, which I'd done for almost a decade at that point.
Neither language was really ready at the time. Documentation was poor, the compiler was buggy, stable libraries were almost non-existent, etc. Both languages would go on to make major changes that fundamentally change the programming model, so I'm glad I didn't commit to either at the time.
Back then, Rust made it very clear that it wasn't even close to being ready for "real" use (if you read the official Rust tutorial, there was a huge warning at the top about how it was a feature-unstable work in progress), but Elm's marketing pitch was a lot slicker and there wasn't really any indication that the language was undergoing major overhauls and would have multiple fundamental conceptual changes coming in the future.
I recently looked at both languages again. Rust seems to be in a relatively stable state, and I even wrote some production code in it (my team is already maintaining some Rust, so this wasn't too out there).
On the other hand, Elm seems to be in a similar state as it was in 2013 in some ways. It's obviously much more mature, the error messages are better, the documentation is better, etc., but if you read people's comments on the last releases (0.19, 0.17, etc.) some were major breaking changes that cause some people to move away from Elm rather than update their apps. The response from a lot of the Elm community has been something like "well of course, it's pre-1.0, it's not production ready, that's not our fault, WTF were you thinking?", but if you go the Elm's front page, it brags about "no production runtime errors" and prominently displays "customers" who use Elm in production.
Curiously, if you look at the archive.org from 2 years ago, 6 out of the 9 production customers are no longer listed.
The simultaneous bragging about how the language is being used in production combined with brushing off breakage and bugs with how it's a young language and it's your fault that you relied on it isn't unique to Elm, it seems to be the common case for new languages. Of course there are exceptions (Java and C# way back when, Go, Kotlin, and Swift more recently, and arguably perl and, Python, and Ruby in the distant past, although Python and Ruby have had major breaking changes at some point, they both managed to grow for a long time before making huge breaking changes, and of course Rust, which is mentioned above as having big warnings about being very immature back when it was very immature), but relative to the number of promising new languages out there, these seem rare.
I don't really understand why people want to oversell their language. It generates more uptake and hype in the short run, but in the long run, it also generates a lot of dissatisfied former "customers" who discourage people from trying the language if and when the language matures. Even though I haven't been personally burned by Elm, the steady stream of Elm horror stories and migrations away from Elm is enough to put me off of it indefinitely.
Rust has a lot going for it and may have succeeded regardless of the marketing strategy, but it seems like being up front about the maturity of the language has paid off. Why isn't this strategy more popular?
Sure, the two-faced strategy lets you sell to potential users and also brush off any concerns users have, but after a release or two, you end up with a PR debt that seems to put you behind a language that's more transparent about its state.
