Add to Chrome
Add to Edge
Add to Firefox
Add to Opera
Add to Brave
Add to Safari
SpecsUpdate
Pros
Pro Static types
Very powerful Types, which can be inferred by the compiler. They provide guarantees about the behaviour of functions, which are very helpful. And no runtime exceptions.
Pro Great and simple way to learn Purely Functional Programming
You can try to apply some functional programming ideas in other languages that have an imperative basis, but you haven't seen the real power unless you tried it in the environment of purely functional programming. Elm is a simple language with great learning resources and easy graphical output, which makes it easy to explore the power of functional programming. Plus programming in Elm is very readable.
Pro No run-time exceptions
Lack of run-time exceptions makes it easy to produce large swathes of reliable front-end code without drowning in tests.
Pro Good documentation
Elm is gaining popularity, somewhat faster than many of the other solutions here. This translates to more code examples, more documentation, and more libraries.
Pro Super easy refactoring with very helpful compiler errors
In no other language, you can refactor so easy without any worries, since the compiler will guide you through. It is like TDD but than compiler-error driven.
Pro Reactive
In Elm every component is completely self responsible and instead of changing other components, all data is propagated through the program. Every component/module can listen to specific parts of that. To say it more clearly: state is a pure function of the past. See the first couple of paragraphs of this article for the best introduction I've read to the day ( https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 ).
Pro Awesome debugging
For example: all exceptions are handled at compile time (thats right no runtime exceptions) and the incredible time travelling debugger (http://debug.elm-lang.org/).
Pro Complete toolchain
You can start working with Elm as is. The toolchain is more or less baked in.
Pro Batteries included
The Elm Architecture means you don't need to spend valuable time and effort choosing the right frameworks, state management libraries, or build tooling. It's all built in.
Pro Inferred static typing
ML static typing is great because it's always there, you just choose how explicit you want to be and how much you want the compiler to do.
Cons
Con Opinionated
The Elm Architecture is great but it might be too opinionated for some people.
Con Poor tooling
There are editor plugins, but neither of them support basic features yet like
- navigate to referenced definition;
- show expression type.
Con Adds an additional layer of abstraction
Some users claim that Elm adds an additional layer of abstraction, meaning that it is one more hurdle between the brain and the product.
Con Difficult learning curve
A bit trickier to learn than a framework for those without prior experience with statically typed functional languages like Haskell.
Con Not database-friendly
It is lots of work to make a server or database your "one source of truth", as Elm makes you write endless JSON parse boilerplate to talk to the server.
Con Missing syntactic sugar ('where' clauses, pattern guards)
Elm is missing a lot of syntactic sugar that Haskellers may consider core, such as 'do' notation, 'where' clauses, pattern guards, and operator sections.
Recommendations
Comments
See Product Page for "Elm"