Luke Plant

I would recommend reading the post that Hillel is responding to instead, namely Luke Plant's "Breaking 'provably correct' Leftpad" (https://lukeplant.me.uk/blog/posts/breaking-provably-correct-leftpad/)…

This 'reminder to be kind' bullshit is why I got so frustrated with Elm, and ultimately quit using it. For the same reasons, I actively recommend against using it, and I will recommend any place I find using it to migrate away. And I love the actual language and approach, it's in many ways the best experience I ever had in web programming. Ruined by this awful passive aggressive approach to management which itself triggers criticism (by the Elm 'team' disengaging at the slightest hint of 'negativity' such that everyone is always walking around Evan on eggshells). For an example see e.g. https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/

Elm has done some great work, even the ones, who left elm for other tech, acknowledge elm's elegant design. However, elm is not pragmatic. the issues mentioned in Luke plant's "leaving elm" [0] are valid. and Evan's response to that was far from satisfactory[1] and this has affected Elm's popularity. The disagreement between BDFL and community has happened in many other cases as well. and there is a way to solve them amicably. Most recently, Vue faced it when community caused uproar over composition API RFC. and Vue solved it nicely and amicably[2]. If Elm has followed similar approach, Elm too would be praised for it, and gained even more popularity. [0] https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/ [1] https://www.reddit.com/r/elm/comments/g070sz/evans_response_to_why_im_… [2] https://dev.to/danielelkington/vue-s-darkest-day-3fgh

For more context, I believe Luke Plant summed it up best in "Why I’m Leaving Elm" (https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/). This title should be searchable on Hacker News for even more discussion.

Wish them all the best, I really respected the efforts made to normify some of ideas with unapologetic mathematic names like monads and such But then you see stuff like this https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/ The author is very charitable in their description of the Elm Core teams actions in these interactions, but you read it and they come off entirely unaccountable and dismissive. If they want to make a purely functional language locked down, you really should be upfront that they don't have time to make sure basic parts of the web ecosystem are arbitrarily locked off like i18n until they decide users of their langauge are permitted to use it after ruling out any suggestion it doesn't undermine the purity they were going for. https://discourse.elm-lang.org/t/bindings-for-intl/1264 Gonna be honest, really got the impression the maintainer here couldn't be stuffed looking to it, and wasn't personally impacted and largely didn't give a shit. Proceeds to run off some bullshit to dismiss the issue entirely about it being too risky (he had better things to do, and anyone he can delegate this too does too), the poster offers to do the work write a report, etc, etc. Then he's ghosted and for some reason the thread is shut after 10 days lol??? I guess giving him the dignity of a reply is out of the core teams hands because of how they arbitrarily configured their discourse. Don't blame that dude for leaving Elm, glad I never made the mistake of wasting my…

The year in this link is very important. In the following year, the Elm team decided to not pay attention to the maxim "perfect is the enemy of good" and crippled their FFI story, making it impossible to actually use the language in production[1]. I would recommend to steer clear of a language that makes these sorts of decisions -- that certain features are off-limits to the regular developer because they can't be trusted to use them correctly -- because if you find yourself in a situation where you need that to solve your problem, you're trapped. I included Go in the set of languages I would recommend steering clear of for years, due to their decision to allow their own `map` type be a generic[2] type but no user-defined types could be[3], leading to ridiculously over-verbose codebases, but they have finally corrected course there. If you're looking for something kinda like Elm but not likely to break your own work in the future, I'd recommend checking out ReasonML[4] instead. [1]: https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/ [2]: https://go.dev/blog/maps [3]: https://go.dev/doc/faq#beginning_generics [4]: https://reasonml.github.io/

There is nobody else who could have written good code, except developers. There is nobody else who kept rewriting X-Screensaver clones insecurely for 17 years[1] except developers. Nobody else who has knowledge or experience to standardise on tools for the greater good. There is nobody else who wrote Jira but developers. There is nobody else who only wants to do Electron, or who refuses things like UAC because security is fine on their OpenBSD ThinkPad. Reddit blames capitalism, HN blames managmenent, 4chan blames 'Pajeet' Indian stereotype, Slashdot blames Microsoft, very few developers take a look in the mirror and say things like "we need less powerful languages"[2] or "ignore the firehose of new technologies"[3] or "If I want to ship my software, as opposed to just write it, I need to use tech that's a couple of clicks back from "bleeding edge," and spend a lot of time, "polishing the fenders. B O R I N G [but I do it]"[4]. Civil engineers have legal duties and responsibilities to make sure the things they build are fit for purpose and sign off on them before they get deployed, and can be personally fined or imprisoned or lose licenses if they weren't fit for purpose. Want to make a text editor at home? Knock yourself out, pick any language you want, dabble all you like. Want to make something that handles millions of people's data, sign your name to it and put your professional reputation on the line before every release. And it may well make salaries go up for the…

that's something I've been looking for a long while and the only places where I find it is usually on interviews from programming language creators who have been successful and talk about the topic tangentially, but I've seen no book on the ergonomics of programming language design. Some common resources which I already identified are the talk simple made easy[1] or the famous everything is an X[2] which was here in HN a few days ago. Also a common problem I see, is that many scholars and intellectual people confuse what the meaning of "semantic" is. For example they might mistake "semantic" with "meaning" and do not understand as semantic problem collapsing two different variables in a single variable (e.g. the classic "0 means unlimited" like some old C programs did). If you do find a resource, just let me know, but I hope there is more on the topic beyond using a regular math model, just for the sake of uniformity, and try to make everything "as easy as possible" based on a gut feeling. [1] https://m.youtube.com/watch?v=SxdOUGdseq4&t=1250s [2] https://lukeplant.me.uk/blog/posts/everything-is-an-x-pattern/

Configuration doesn't have to be declarative, for example see https://lukeplant.me.uk/blog/posts/less-powerful-languages/, in particular the section about python configuration, where an imperative configuration language is discussed. How imperative? Very. It's a line-oriented language, where the program reads a line and changes something in an internal data structure accordingly then continue reading the file. This is imperative, the person writing the configuration file has to think about state and time while writing the file, not just abstract goal states and facts. Declarative vs. Imperative is a spectrum. For instance, there is a declarative language hiding inside most imperative languages : Infix Math. 1+2*3/71**7 is declarative because it under-specifies the order of operation, only the data flow dependencies implied by operator precedence needs to be respected. In the precedence hierarchy I had in mind when I wrote it, You can do 2*3 first or 71**7 first, it's unspecified and irrelevant. I only ask that you do both before you perform the division of their results, and that the addition is the last operation. Meanwhile, in Forth, math is imperative, you have to unroll the expression tree into an exact sequence. Declarative is any language that under-specifies the task being described. Therefore, every language worth using is declarative to some degree or the other. After all, that is the very purpose of a high level language : to under-specify a task by describing…

Rust's Send/Sync made multithreading easier, teaches people to write proper multithreaded code, and results in more reliable programs with less data races and race conditions. Rust's dependency managers makes dependencies easier, teaches people to add dependencies and transitive dependencies, and results in programmers not understanding their own programs. I think that building tools to teach better programming (eg. teaching memory-safe programming or safe languages, teaching patterns immune to SQL injection or parsing exploits) is a great thing. But given the choice between bad and no code, I feel that it's almost better for people to not complete projects, than to release code with serious functional errors (memory leaks and segfaults and dozens of runtime race conditions that each show up every month or so, requiring herculean effort to debug, or more often go unsolved and haunt users indefinitely) or security defects (eg. https://lukeplant.me.uk/blog/posts/wordpress-4.7.2-post-mortem/). It's obviously better to teach good coding than to discourage people doing bad coding, but it's a lot harder (Send/Sync was a non-obvious innovation, and Rust required immense effort to push to 1.0 and build an ecosystem) and I don't think I can do it. And I'm opposed to the principle of trading off your understanding of a program to get more functionality from leaky abstractions (complex languages, optimizing compilers, big library trees, and GPU drivers all leak, whereas out-of-order…

Could you do the following in TypeScript? Can you, for any button in your interface, at any point in time, reliably calculate at runtime what your page's data model would look like, and if there were going to be any side effects, if you were to click on that button - but without clicking on it or invoking its callbacks (which could potentially change all kinds of things)? You can do that with Elm (more info here - https://lukeplant.me.uk/blog/posts/two-experiences-with-elm/ ), due to The Elm Architecture and everything being immutable. (In theory you could do this in TypeScript, but it would be a lot of work and its reliability would depend on everyone coding everything a certain, very unnatural way, with no help from the compiler). I'm using Elm in production, version 0.18, it is an extremely robust way to make front end code. You just don't have runtime issues. However, like IBM folks (mentioned in another reply) who said in the their post they didn't know how they would upgrade to 0.19, I also don't know how I will be able to upgrade. Specifically, 0.19 adds some cripple-ware restrictions (you can't use native modules unless you are contributing to certain projects). So, if you want to use something like Intl - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Glob… - not only is there no wrapper provided, the restrictions in 0.19 attempt to stop you from writing your own wrapper. Only the core team can do it, which requires them having…

My first thought was this blog article I saw on HN a while back: https://lukeplant.me.uk/blog/posts/should-we-use-llms-for-christian-ap… He argued, persuasively I thought, that "this is an area where truthfulness is of paramount importance" and consequently would be extremely ill-suited to AI.

Breaking "Provably Correct" Leftpad https://lukeplant.me.uk/blog/posts/breaking-provably-correct-leftpad/

The “his comment” link here for this article: https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/#forkability In the HN submission I linked, the author of the article is the same.

Well, not according to the author of the post, and we know how concerned he is with truth, so this must be correct? “That leaves us with atheism, which provides us with not the smallest scrap of a foundation on which to build any claims about the purpose of life, or what is a good or bad.” [0] This is confusingly supported by a quote from C.S. Lewis making the point that it’s better to believe in something that “feels important”, whether or not it’s true. [0] https://lukeplant.me.uk/blog/posts/what-if-none-of-it-is-true/

These are the issues https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/

Yeah, I can see the similarity. Thanks for the links. Also, vaguely related, and a way to achieve this goal of making things composable, is the "everything is an X" pattern: https://lukeplant.me.uk/blog/posts/everything-is-an-x-pattern/

A very specific but related tip about not disabling zoom: You can stop using user-scalable=no and maximum-scale=1 in viewport meta tags now https://lukeplant.me.uk/blog/posts/you-can-stop-using-user-scalable-no…

Ironic, given what Feldman said about other Elm forks. https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/#forkability

> And it being open source means nothing stops you from forking it and adding your own native modules. Reason no one has done it is it's no need, and doing thinga that way would break the promises the compiler makes about no runtime bugs. No, it's because one of the core team members made threats against everyone who said they were thinking of forking it: https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/#forkability

> you can update the definition of a class in a running system and update all existing instances of that class Like this? >>> class MyClass: ... attr = 0 ... >>> my_object = MyClass() >>> MyClass.attr = 42 >>> my_object.attr 42 >>> MyClass.method = lambda self: self.attr >>> my_object.method() 42 > When an error occurs you can inspect local variables in any of the stack frames and execute commands in them What is the difference with https://lukeplant.me.uk/blog/posts/pythons-disappointing-superpowers/#… ?

This was one of Luke Plant's YAGNI exceptions: https://lukeplant.me.uk/blog/posts/yagni-exceptions/

God is an X. https://lukeplant.me.uk/blog/posts/everything-is-an-x-pattern/

correct me if I'm wrong but people using bitcoin in oppressed countries will basically be rendered penniless by simply cutting off network access. source: https://lukeplant.me.uk/blog/posts/the-technological-case-against-bitc…

There is no reason to present a personal attack with your non-argument. As I said before in other threads there are alternative ways they can receive grants for funding of Tor projects without endorsing crypto scams. I mentioned Mozilla and Rust foundation as examples. On the crypto tokens, there are tons of reasons not to use them as I have mentioned on this thread and others have mentioned as well. [0] [0] https://lukeplant.me.uk/blog/posts/the-technological-case-against-bitc…

I was initialy excited to try learning Elm, until I saw some of the drama on the GitHub issues and a blog post about leaving the Elm ecosystem after having a bad experience with the project leads (I think [1] was the post). I've since put it in my little red box of "hot but you'll be better off staying away from", depsite the numerous podcasts praising the incredible effort and design that went into the language. Has anyone got any thoughts on this? [1]: https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/

some examples https://news.ycombinator.com/item?id=27808306 https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/ and there's also the elm-pine issue, where an independent package manager was shunned by the core developers (note that the official package manager doesn't support basic features as repos not on Github)

I have heard otherwise, both in comments here and via https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/#forkability, but it’s entirely possible I’m wrong. Added: This comment is also not terribly friendly. https://github.com/gdotdesign/elm-github-install/issues/62#issuecommen…

I assume it's a reference to https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/

Elm as a language is really nice, and I do like the goals of the project. I tried it out a bit, its a mind-bending paradigm for someone coming from OOP/prototype (Python, Java, JS) and I enjoyed the challenge. The community, on the other hand, is what turned me off. It does seem very unfriendly to newcomers. In addition, https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/ amongst others, is an entire turnoff. And seems like this perception isn't isolated and has been discussed at https://news.ycombinator.com/item?id=22821447 I hope things work out well for you in this project with Elm, now and in the future. But it doesn't seem like any of the issues with the community have been even attempted at being addressed, so I don't think I will give Elm another try.