Hacker News Reader

Comment by matsemann | Hacker News Reader

The safety isn't an exaggeration, though I can understand it can be hard to believe when not experienced first hand just how hard it is to introduce bugs in elm. Like type safety eliminates one type of bugs, elm's stricter safety eliminates even more. When there is only one place in the whole code base that is allowed to have side effects, that removes lots of the bugs normally seen in frontend. Can't recall we ever having a runtime bug. And most logical bugs are also eliminated since they are harder to actually make.

It's ready for production. We've been using it for years without issues or bugs. It works as it is right now, and has done for years. It's not like it would stop working out of the blue.

View on HN

> It's not like it would stop working out of the blue.

Unless the benevolent dictator pushes out a new Elm version that is not backward compatible.

And, if the process is the same it was a few years ago, it could happen next month and only a happy few know it. The development is done behind closed doors.

It happened to a project of mine, from version 0.17 to 0.18 IIRC. The choice was between letting the code slowly rot, rewriting a large part of it still in Elm but with the new paradigm, or switching to some stable JS framework. I had overall enjoyed working with Elm until that.

Same here. Still on 0.18, no upgrade path as 70% of my deps never upgraded. Awaiting rewrite in vue/react/etc

You can just vendor those dependencies, that's what I did, but I only had one that didn't update. And that one was trivial to fix.

FWIW, no significant changes to the language are expected in the next couple of years.

Another side of this argument is that the rate of Elm ecosystem change is far more manageable than for JS.

A "stable JS framework" is an oxymoron, I'm afraid. My JS tools and NPM packages continuously change from under me, but somehow that's considered normal and not a problem.

I've just looked up a project I have with a mere 9 dependencies, and 7 of them have gone through multiple major version changes since the end of 2019. The other two have had minor releases. None are unchanged, even though all were already "stable" when I added them! Will the code still work if I update them? I don't know. Do I want to spend the time continuously tracking the changes to these dependencies, testing, making new releases of my project? Not really.

Perhaps I could continue deferring dependency updates, but that might make my job that much more painful when I have a legitimate reason to update (eg. for some new features I need) as half the package APIs will have changed beyond recognition by then.

I have so much less trouble with going back to Elm projects and picking up where I left off. That should be taken into consideration too.

> Unless the benevolent dictator pushes out a new Elm version that is not backward compatible.

That wouldn't break your build/deploy out of the blue, as you don't get force updated to the latest version.

And having worked on the 0.19 transition, it was in public preview for about 3/4 of a year and regularly discussed in the elm slack. When 0.19.1 came about, there were some more pre-release versions, where evan asked people to test and give feedback in slack. Can't speak for versions before that.

a true believer I can tell. But you could easily say the same thing about a well architected typescript/react frontend app, its just that it has several orders of magnitude more experienced developers and billions in corporate sponsorship behind it. Which is significantly more important than any cool feature the hip esoteric language of the week may have.

I couldn't say the same thing for even well-architected TS apps. There are important escape hatches that TS gives that make it unreliable, as summarized in this article: https://incrementalelm.com/tips/typescript-blind-spots/

Refactoring code or updating dependencies is and feels a lot safer in Elm than in TS, and doesn't require asking for every npm package author to add TS type definitions.

I'd also argue that TS/JS have the esoteric/cool features. Elm is a very simple language, complete enough to be able to write most programs, but small enough to give you a lot of guarantees about how the code will behave.

| There are important escape hatches that TS gives that make it unreliable

This is one way to mitigate those escape hatches:

https://github.com/cyrilletuzi/typescript-strictly-typed

But in my experience, you had better be starting a new project. They aren't joking when they say laying it on an existing codebase is a nightmare.

Do you know if that somehow fixes https://github.com/microsoft/TypeScript/issues/8677 ? That's still the most annoying thing about typescript for me.

You need to try elm. Elm is better despite not having everything you mentioned. I’m not a fanboy either. I just used elm for one project, but from that it’s already enough to know.

> a true believer I can tell

Just fuck off with that kind of comment. I provided a well reasoned post, dismissing my views like that just because they don't align with yours is dishonest on your part and no way to have a discussion.

To answer your claims: No, I couldn't easily say the same about TS/react. In elm the language forces the architecture and safety. In react it can be whatever you want with leaks and unsafe modifications all over the place.

That was mostly in response to your statement "it can be hard to believe when not experienced first hand just how hard it is to introduce bugs in elm"

Is just about the most ridiculous thing I ever heard (and certainly what a "true believer" would say even if you obviously and predictably disagree)

That a true believer will react angry to criticism is entirely self evident.

There are thousands of times more developers and companies using typescript over Elm, there is inherent value in this simple fact. No matter how much steam escapes your ears, its true.

Cussing the GP out for a light joke does not inspire confidence in you or your cause.

I don't have "a cause". I'm just providing insight, not trying to convert anyone to anything. So you're no better than GP in irrelevant accusations.

Dude, you told a fellow HN-er to fuck off at the drop of a hat. That’s not “giving insight”, that’s just vitriol.

I feel like since TS's rise in popularity so many people who've never used a type system other than Typescript's believe that all static systems are equal and fail to appreciate the benefits of something like Elm. I personally haven't used it in a year or two for anything but it shifted my perspective as a developer.

> But you could easily say the same thing about a well architected typescript/react frontend app, ...

A badly-written Elm app can still be reliable, even if it ends up slow or sometimes acts funny. A badly written TS app is completely inscrutable.

> you could easily say the same thing about a well architected typescript/react frontend app

Having built extensively in both Elm and TypeScript, I'd disagree, there's no comparison, even after importing Elm-ish concepts like discriminated unions, functional purity, decoders and immutability into my TypeScript approach. As others mention, TS leaves some type ambiguity.

Reply on news.ycombinator.com