What are your top three features of Elixir/Erlang?



I’ve seen some interesting responses to some other threads recently, which I actually found quite surprising, so I’m wondering, here in 2019, what are your top three features or aspects of Elixir/Erlang?

Let’s make it easy, and take community out of the equation (it’d probably (I hope!) come up in 99.9999999% of your lists anyway :003:).

Feel free to also add your top three features for Phoenix and Nerves :smiley:

  1. It’s a functional language
  2. It’s aesthetically pleasing to code in
  3. It’s new(ish) and exciting to watch grow :grin:

Other notable thing: my most proficient language is Python, and I love Django, and seeing something like Phoenix was really nice after trying out Clojure and not really finding anything Django tangent.

  1. BEAM
  2. OTP
  3. Standard lib and tooling (of them both combined)

Them being functional is not a feature in my mind, but if it were I’d have to mention it :slight_smile:

  1. Processes
  2. Pattern matching
  3. Immutability


I swear I didn’t wanna copy from @rodrigues but…

  1. Processes/Actors
  2. Pattern matching
  3. Immutable data structures


Coming from .NET, I appreciate some things that C# programmers doesn’t have.


  • Awesome tooling out of the box
  • Extensible via macros
  • Immutable by default


  • Fault tolerant
  • Highly concurrent
  • OTP

I know we have similar solutions / alternatives inside the .NET ecosystem, but I don’t want to go all in with Microsoft (they don’t hire me lol). F# is really nice, but it’s a great language within a questionable ecosystem, and eventually C# will inherit most of its relevant features.


Please keep in mind that I’m still new to Elixir.

  1. functional, immutable with nice syntax
  2. pattern matching
  3. concurrence

It has great learning resources which make it more accessible than other functional languages.


Here’s my list:

  1. Immutability and functional programming
  2. Culture that values explicitness over magic
  3. Pattern matching

  1. Functional language / immutable data
  2. Concurrency model
  3. Blazingly fast compared to the language I used at work previously (ruby)

  1. BEAM
  2. Let it crash mentality
  3. Pattern matching

  1. Pretty logo
  2. defimpl is the cutest keyword
  3. Got to spend 6 months not 100% sure how to pronounce “Elixir”

  1. OTP and the concurrency model (process/actor model)
  2. Encourages documentation as first-class citizen
  3. Functional programming (immutability, pattern matching, referential transparency, …)

  1. Hello Joe - Hello Mike
  2. Hello Robert - Hello Joe
  3. Hello Mike - Hello Robert

  • Link/ Monitor
  • releases
  • QuickCheck

  1. despite my best efforts as a programmer, Let It Crash and OTP supervision trees restart and keep the stuff running so that I never get called out.
  2. Almost pure message passing semantics make stuff easy to write, test, and refactor.
  3. Most of the time, all the functionality I need is already in the runtime so there’s no need to cache, run an external DB, & so forth. This makes deployment and upgrades really really easy.