What do you LOVE about Elixir?

Two reasons for this thread:

  1. Am genuinely interested in hearing what everyone loves about the language
  2. Perhaps we can use quotes from this thread in future marketing initiatives :003:

Feel free to use separate paragraphs for different things (might make it easier for different projects to use your quotes that way).

So, please tell us, what do YOU love about Elixir? :049:

  1. Macros are significantly better than Erlang’s version (OhGodErlangASTHell).
  2. It runs on the BEAM.
  3. It fully inter-operates with Erlang

Perhaps we should have a thread of things in Elixir we want to see changed? ^.^


The big picture things I love:

  1. a sane concurrency model
  2. veteran libraries giving higher-level concurrency abstractions
  3. fault tolerance

The smaller, localized things I love:

  1. pattern matching
  2. immutability
  3. “acceptable lisp” macro system

A lot of the reasons I love it are really just what I love about Erlang.

The Elixir-specific reasons (aside from macros) are that it’s just a well designed language: Almost everything you need from a standard library is there and implemented right. The developer tools are great andthe non-Erlang abstractions and syntaxes are right.

It’s a language you can tell was done right and with care.


In the grand scheme of things:

  1. Great and nice commmunity that tries new things and can create new paradigms
  2. Parallelism from the ground up baked into everything and all of that with Actors :heart:
  3. Explicit over implicit (after being burned a bit in Ruby/Rails with quite some of the implicitness)
  4. A nice gateway into functional programming and OTP/reliability/distributed systems
  5. High level of trust into Jose and his views and experience about web programming

More focussed specifically on the language:

  1. Pattern matching, single feature I’d love to have in Ruby and other languages and that I accidentally code my ruby code with and then realize I don’t have the feature :frowning:
  2. Doctesting build in. I just LOVE this for coding and documentation, doesn’t get enough love imo
  3. Cool macro system as imo runtime meta programming isn’t needed so at compile time with a good system is great
  4. Nice standard library/familiar from ruby

Some great points already posted :023:

Just want to quickly comment on this…

Very glad you mentioned that! Totally blown away by how easy it is to test in Elixir!

I think we definitely need to scream from the roof-tops about this - I can’t see anyone not loving this aspect of Elixir :003:


big fat ones

  • pattern matching
  • pipes
  • Erlang VM with all its goodies and OTP

further niceties in no particular order

  • standard library has a lot to offer and the docs are nice
  • tools are good out of the box - project and package management, testing, doctests, Erlang’s observer
  • community is very active and friendly
  • there is Phoenix around
  • less code to write
  • macros are a nice to have, even when I try not to use them unless I really need to :slight_smile:

I really love the fact, that documentation is considered “first class” and available at runtime.

And since @AstonJ asked for a slogan… “Once you got it, it gets you”[1]

[1] Explanation: After I got at least some concepts in OTP I have problems to think in the more classical stuff. A project where I realized this was written in go. After about a week I took a step back and have seen things that try to act as Supervisors or GenServers, but still very crumpy…


What I love most about Elixir I also love about Erlang/OTP.

On top of that we get an improved core library, easy-to-navigate documentation, and best of all a standard build tool, package manager, and testing library. This, combined with OTP conventions, makes it easy to dive into any Elixir project to learn/use/share/modify.

In addition, I’ve found the Elixir core team to be very friendly, accessible, and responsive to feedback.

  1. Pattern matching, I love this a lot.
  2. All the features of erlang, I love how easy it is to use erlang and all its features.
  3. Love phoenix.
  4. Love the idea of being explicit, I think as programmers mature, they really don’t want surprises :slight_smile:
  5. Macros! I love them to death.

Interop with Erlang
friendly community
pattern matching
fast pace of progress

1 Like

I love that Erlang has been around a long time. Really starting to hate JS-based languages and tooling that becomes obsolete after a few years.


I don’t have too much knowledge about Elixir yet, since I just started to read the book “Programming Elixir 1.3” and the course “The complete Elixir and Phoenix Bootcamp”. But what I had a few wow effects when I learned:

  • Elixir has a built in doc generator which looks pretty cool
  • Elixir has a built in testing framework
  • Elixir will also test your doc examples! How AWESOME is that!

So, batteries are included (this is so amazing, especially if you know dozens of JavaScript libraries which become obsolete every couple of months)

What I also like is the functional programming aspect and pattern matching - which are both new to me.

I am so excited about the language that I want to read “Programming Elixir 1.3” and learn in my spare time as bad as I want to watch a great movie. I am looking forward to finish the book and start a few small projects in order to really become familiar with this language.


Focus on “Producing system”


Watching beam.smp go to 2400% cpu in top on my server and knowing it’s actually doing something useful.

  • Community
    • If someone asks a question, they get a thoughtful response no matter who they are or what the question. This includes what I’ve read on the Google Groups, on the (incredibly clean) GitHub issue tracker, and of course - here on Elixir Forum.
    • Even though the documentation is so good (see next bullet section),I have yet to come across an RT(_)M response.
    • This is a huge deal for me. :grey_exclamation:
  • Documentation
    • Docs are first class citizens.
    • Clear and simple guidance on documentation from the get-go.
    • Bad documentation is a :bug:
    • A bad error msg is a :bug:
    • So the installation just works. The tutorials just work. The onboarding just works.
  • Parallelism Juggernaut
    • With the combination of the BEAM’s massively parallel, stateful-but-functional actors…
    • Each process running with its own single-threaded execution in its own isolated memory space…
    • All wrapped in an extremely elegant and thoughtful syntax…
    • Wow. :103:
1 Like

A post was split to a new topic: What do you think is missing or needs improving in Elixir?

There are many reasons already stated in this thread, but as for me, coming from the (in)famous JavaScript world, there’s one thing that I really like about Elixir: that my code (thus far) is sequential.

I’ve just realized how awesome being able to write sequential code is. It really helps keeping your mind sane. In JS we try to mimic it using Promises, but it isn’t exactly the same. async/await is still in ES2016/ES7 so it’s kind of bummer that most platforms haven’t supported it yet.

It’s maybe the case that I haven’t used most of Elixir’s features yet, but it’s great to be able to query the DB (using Ecto) in one line and use it directly after that.

Several other reasons:

  1. Phoenix. It’s kind of nice to have decisions canonically made for you, especially when you’re learning.
  2. I love how fast dependency resolving and fetching are in Elixir. In contrast, I tried Haskell, but given up halfway trying to bootstrap an example Yesod project. The fetching and compiling the dependencies took so long.

And of course, echoing many in this thread, the community :slight_smile:


As a newbie in elixir:

  • doctest
  • community

One thing I love the most is no god classes, or functions spanning across god knows how many lines. Splitting big chunks of code into small functions just come naturally here. You don’t do nested If’s and null checking. “With” is so freaking awesome :smiley:

I know that most of this are code smells in every language, but in Elixir when you write code you naturally avoid them, because code more then ever begs to be extracted to a separate function.