Elm, what does the future have in store?

featured-31

Elm is a functional language that compiles to JavaScript. It competes with projects like React as a tool for creating websites and web apps. Elm has a very strong emphasis on simplicity, ease-of-use, and quality tooling.

Evan Czaplicki, the creator of Elm, is very considered in his approach to its development. All of the individual pieces of Elm are very well thought out. What makes it truly amazing is that the whole of Elm is much better than the sum of its parts.

Elm has a core focus on being easy to learn. This is embodied in both the getting started guide and very much the supportive community around it. The guide is simple and easy to follow. Public Elm packages are well documented. Elm’s Slack is alive. This gives developers a wealth of resource to draw from when they have questions and this resource is growing.

Another piece that makes it easy to learn is it’s compiler. Elm’s compiler is very much an assistant rather than an adversary. Not only does it detects bugs, it helps developers understand why. It gives specific hints that helps developers write better code. Ultimately, it makes programming faster and easier.

Elm mitigates classes of problems that in other languages, developers would need to think about. For example, it will not allow the use of null or undefined. Instead it captures this intent in an explicit way as a “Maybe” type.. By forcing the use of a “Maybe”, Elm ensures that developers always handle the “Nothing” case, resulting in explicit and robust code.

Unlike handwritten JavaScript, Elm code does not produce runtime exceptions. Instead it uses type inference to detect problems during compilation and give friendly hints when compilation fails. Any problems are resolved during development and never have the opportunity to make it in front of end users.

What really intrigues me is what happens to an Elm project over time. Because Elm enforces semantic versioning, upgrading dependencies is relatively trivial, especially for minor and patch level changes. For those trickier upgrades, changes and refactors the compiler has the developers back and guides them to success. As a side effect, Elm projects tend to stay more nimble, enabling development teams to keep developing without accruing tech debt.

The future of Elm looks bright. The current roadmap is focused is on creating singlepage apps in Elm. This includes:

  • Server-side rendering
  • Tree shaking (trimming out unused code)
  • Code splitting (cutting up code into smaller chunks for better caching)
  • Lazy loading (only sending the code chunks needed for a particular page)
  • Expanding web platform support
  • Unfortunately progress can be excruciatingly slow and is frustrating for those waiting. Consideration takes time. That aside Elm is an amazing tool to build web applications with. We are definitely looking for an opportunity to use it when the right problem comes along.

 

 Read the Tech Round Table now.