Elm is still my favorite programming language. It's just so much fun! Elm changed the way I think in such a substantial way that even when I'm writing programs in other programming languages, I structure my thoughts and programs in a similar way to how I do when programming in Elm.

Here are some examples of how Elm changed how I think and structure programs:

• I model the entire state and state changes with simple types

• I use types that make impossible states impossible and all state variants clearly shown

• I validate unknown types at the edge of the program (similar to Elm's JSON decoders)

• I keep side effects at the edge of my program rather than everywhere in my program

• I write my programs as mostly pure functions so everything is easy to understand and test

• I don't throw errors or return vague/generic catch-all error types, instead I return all the possible error states clearly shown in the types so that they must all be explicitly handled and checked by the compiler

• I use the most strict static typing and lint settings to emulate the strictness of Elm in other languages

• I try to emulate exhaustive checking similar to Elm's exhaustive pattern matching in other languages and avoid leaving unchecked open-ended expressions

• I think of compiler errors as a helpful guide that eliminates bugs and saves time and makes my life easier and more enjoyable

• I try to catch errors at compile-time instead of at runtime

• I view programming as a fun activity, sort of like a game

I'm wondering if there are any other programming languages that you learned that significantly changed the way you think and structure your programs similar to how Elm did this for me. If so, I'm wondering if you could share examples of how those languages changed how you think and structure programs.

I'm your typical nerd, but with taste (self-admitted). I enjoy the code just as much as I enjoy a delightful product. Sadly, the grand AI hypothesis is that you can leapfrog the code, straight to the "product." While I do confess that I vibe code at work (like a madman), I've nonetheless been hand-coding at home (the video is my current project, all hand-coded Elm, no libraries :). I'm leaning into my silly little hypothesis that "code" and "product" are one and the same.

So here I am testing my little hypothesis with Elm. Come to find, the Elm compiler told me "no" more than it told me "yes" (cue AI-withdrawal symptoms). Rather than leap-frogging to a solution, Elm exposed new, fundamental problems with my approach. I muscled through these problems, and in the process, I found myself increasingly delighted in the code I was writing and the solutions I was crafting. I started giving this same touch even to the UX, wanting to find that same delight in every facet of the product.

Again, the hypothesis is silly, but if you're feeling a little discouraged, give Elm a try, and you might just rediscover your love for the craft :)

Just wanted to share this. I'm currently working on a ELM project I did in 2020 and I haven't been this excited about development since a long time! The project is not really interesting and does not pay the bills but just the fact that I get to use ELM makes it worthwhile.

elm-json makes dependencies management a blast

elm-format is doing a great work

elm-review is such an AMAZING refactoring tool. It found me 1300+ errors ! I removed a single rule to make it digestable (NoMissingTypeAnnotationInLetIn). Then it automatically refactored hundreds of code bits, and I got 30 errors left. Mostly unused variables and unused constructor args (which is great at showing me that I did ignore so many errors!)

I don't use elm-test at all, I never test frontend work... is that bad?

I feel so confident working with this stack!

New versions of the server and the vscode extensions are out, welcome to version 2.0.0.

It's a very big release, so read the changelog below and ask questions. Here's the complete diff https://github.com/elm-tooling/elm-language-server/compare/1.13.2...master

The most obvious behavior changes, will probably be, that we try to report errors whenever you type and only run `elm make` when you save a file. Followed by that elm-analyse has been removed and replaced by our own linter.

Features

- Enabled type checking diagnostics that update on document change. These include parsing errors, type mismatch errors, value not found errors, etc

- Support file events APIs (Previously VSCode only)

- On file create, the module name will be inserted

- On file rename, the module name and all references will be updated

- A new "extract function" code action. Select a complete expression and it can be extracted to a function in the top level or the enclosing let expression (if there is one)

- A new "install package" code action. When you try to import a module that is not installed, a code action will offer to install it. (we only check your local elm cache for possible packages and there is a setting to control skipping confirmation)

- Replaced elm-analyse with our own diagnostics, there might be missing rules for you due to this

- Show inferred type information on hovers

- Support linked editing ranges. When editing a function name, the type annotation name will auto rename, or vice versa (needs to be enabled in most clients)

- Watch elm.json for changes. The server will restart when a change is detected

- Run elm make on server init

- Improve record completions

- Ports now have codeLenses, can find references and have correct types on mouseover

Bug Fixes

- Greatly improve performance of diagnostics and type inference

- Fix some type inference cases

- Fix module resolution to be more like how the compiler resolves modules

- Fix some incorrect unused value diagnostics

- Fix how errors from third party binaries are shown

- Fixed test dependencies being available in non test modules

Other Changes

- Update package rankings

- Update our parser

We had contributions from jmbockhorst, dmy, lydell and myself this iteration.

Please consider sponsoring our work on this and other projects:- https://github.com/sponsors/jmbockhorst/- https://github.com/sponsors/Razzeee/

If you find any bugs or have ideas for new features, feel free as always to create an issue on GitHub.

https://marketplace.visualstudio.com/items?itemName=Elmtooling.elm-ls-vscode

Hey everyone, I'm excited to share a project I've been working on since a while now: It’s an online guitar tablature editor built (almost) entirely with Elm! While working on this I became a big fan of the language and after some failed attempts with React and different state management libraries I‘m convinced that Elm is an extremely powerful tool. 🌳

It‘s called tabinator and allows you to easily notate guitar tabs online, making it convenient for musicians to jot down their musical ideas or share tabs with others. 🎸

With this I hope to somehow contribute to the Elm community to show a use case and hopefully inspire others to explore its capabilities. Feel free to check it out at tabinator.com and let me know what you think! It is aimed to be used on desktop devices. From the menu at the top right you can load some examples.

A big thanks to Evan and everyone involved for creating this amazing language which got me into purely functional programming! I hope that the development of Elm will continue. 🤟

Looking forward to your feedback and discussions!

Cheers!

Hello,

I'm the author of patchgirl.io, a web app rest client written with Elm, and other Functional programming languages (Haskell, NixOS). I'm writing a series of articles relating my experience with them and just released the first article about Elm. Second article also on Elm will follow soon !

The last blog post is nearly 3 years old at this point as well as the last update to the language. Does it seem like we are never gonna see a version 1? What are your thoughts on the subject is elm dead?

I love Elm, it's nice how there's minimal configuration, no "any" type, no side effects everywhere (just commands and subscriptions), no mutation, no reassignment, tagged unions with exhaustively checked pattern matching case expressions, simple records that work how you want them to and encourage simple design, no classes, no inheritance, no complex language features, the language is really small and easy to learn and has everything you need to be productive, and Elm has a really nice type-safe way to do JS/TS interop, and Elm has really nice clean syntax that makes me happy, I like how I can design the Model and Msg and then just listen to the nice compile errors and it feels almost like the program writes itself, it's hard to explain but it's just so enjoyable and nice! Elm is my favorite programming language!