Mind blowing Elixir



I have to say the let it crash mentality, before meeting Elixir I always thought I should avoid crashes make sure that nothing crashes and deal with different crashes all the time.
After meeting Elixir threads finally clicked threads can crash we deal with it and are not afraid of it.
That basically changed my whole view point to threads, they are our friends not our enemy, at least when you know how to use them.
Immutability was great too, but let it crash mentality is the best thing that happened to my coding and made 10 times better in my job.
I think that since I met this forum I only had one instance of singleton problem and that was because ruby duplicate sometimes do weird things.


I can’t even begin to say how much it opened my mind to FPs in general. Particularly, for me, as I do full time OOP every day ( aka, from jvm world).

There isn’t just one thing that I’ve come across and I’d say shut the f* up… this can be done? apart from what others have said, the absolute one thing that still astonishes me is the simple, yet most powerful concept of Erlang/Elixir is the pattern matching.

There’s this simple, argument pattern matching for argument – which is ok I believe, but slicing & dicing the input, simply blew my socks off!

Below is something I’m currently on

  defmodule Decoder do
    # 10 byte metadata
    # 5 bytes
    @redis_signature <<"REDIS"::utf8>>
    # 4 bytes - big endian
    @version <<3::big-size(24)>>
    # 1 byte
    @db_selector <<254::size(8)>>

    def read_metadata(
          <<@redis_signature, version::big-size(24), @db_selector,
        ) do


honestly, coming from a main JS background, I was already doing fp anyhow, but the simplicity and elegance that elixir provide makes it a pleasure to work with it. I can’t say i have ever been in love with a language, but I think I am starting too fall for it… hahaa


Although I was already familiar with some functional programming concepts, and had a glimpse of pattern matching and using tail-call recursion, I found Elixir quite approachable compared to other languages (at least for me) and Erlang/OTP’s approach to concurrency using processes/actors is what I found the most mind-blowing. I learn something cool and useful every few days and I’m just scratching the surface.

The core concepts of the language are straightforward: I doesn’t have a huge standard library and many things boil down to modules, functions and macros (which I’m not very familiar with yet), but when you need more advanced things (like concurrency, async code, additional standard libraries from Erlang, distributed computing, etc.) they’re there for you, and the whole tooling/documentation and conveniences of iex just make the whole experience of experimenting, debugging and coding more enjoyable.


Threads as an actual PL abstraction, like objects, instead of a nasty implementation detail that you avoided unless you really needed them.

Processes: 4684 and, from what I’ve heard, that’s still not very much.


Javascript will have pattern matching some time in the future :slight_smile: https://github.com/tc39/proposal-pattern-matching


That is far from certain.

It’s a Stage 0 proposal with an initial commit of 2017-07-03 which hasn’t even been presented to the committee at this point.

Proposals at Stage 3 may be included in ES2019.

So a lot can happen and it is going to take some time …



If you wrap your head around that function, you’ll be blown away at what you can do.


I am using Elixir to mentor some people who have not been professional programmers. In some ways it’s easier for them to use a functional language after never having had experienced object oriented languages.

We are trying to invite 10-20 scholarship attendees to women and minorities for GigCityElixir, and we don’t want them to be lost when they get to hear the big guns: Dave Thomas, John Hughes, Chris McCord, Stu Halloway, etc.

Very cool.


Well, for me, the day I really understood the BEAM is the day Elixir blown my mind. And two talks helped to understand that.

In the first one @josevalim takes some time to explain the concepts behind Elixir (which are pretty much the concepts behind the BEAM), and it blown my mind because it’s so much simpler and more organized than OO that I cannot call it other way than a masterpiece!

And in the second one, @sasajuric explains in a very practical way what is the real power of the BEAM: its concurrency model, the runtime guarantees it gives you, the price you pay to have them, and why this price is fair. :slight_smile:

I know one can argue that it was not Elixir that blown my mind then, but the thing is: other BEAM languages never got me interested enough since I felt too productive with Ruby compared to them, and Elixir changed that! The efforts on making it easy to learn and productive really paid out!


I also watched this. This talk is truly amazing and an eye opener for the devs from other programming environment/languages. This talk alone is enough to establish erlang/elixir as mind blowing


Code maintainability and comprehension for decent multi-core performance on a stable VM.
I rarely get that sinking feeling of technical debt
i.e. oh crap why am I doing this… this is going to be hard to maintain or change 10 years from now.

As a part-time programmer and business manager, Elixir is incredibly refreshing to write and maintain systems with.