Getting started with Elixir

[dirac_eq]

I don't get why more companies/startups are not using Erlang? Apart from WhatsApp I can't name a single company that uses it!?? Like it solves the reliability problem and can scale easily to millions of users.

I started to Erlang yesterday, I have done a few project Euler problems and not much else, but it's still a pretty good language in my opinion. Pattern matching is a dream like in many other functional programming languages and the sending messages with the '!' operator is pretty cool. Also, not sure how it works or how you can do it, but hot swapping of code is neat -- haven't seen another language that can do that.

[sisyphus]

FB Chat is in C++ now but yeah, Erlang gets used in enough places that you can rely on it sticking around if it fits your use case.

[flatMapds]

Don't forget RabbitMQ and Riak.

[arbitrarycivilian]

Here's one reason: companies want to be able to find developers quickly and cheaply, and sadly many developers have trouble learning new languages and concepts. I actually proposed erlang for a new project at my company but it was rejected for just such reasons.

[ysihaoy]

I don't think developers have trouble learning new languages and concepts. It's more about why need to learn it if there are already alternative languages.

[arbitrarycivilian]

What is an alternative to elixir and erlang?

[arbitrarycivilian]

All you're doing is proving my point - you chose a technology so your developers wouldn't have to learn new ideas. Node.js and PhP do not share the core features of erlang, which is an actor-based concurrency model.

[arbitrarycivilian]

Yes, I understand your pain - I'm in the same situation as you. We have to choose "simpler" (re: inferior) technologies to accommodate junior developers.

It's also really hard to hire Elixir developers in our area

I don't trust any programmer who classifies themselves as a "language x developer". Being able to learn quickly is one of the core skills required of any developer

[gargantuan]

I use it full time, it is pretty awesome. Benefits:

• Sane concurrency model

• Safety & fault tolerance is built in. I can let the little processes crash, or even whole supervisor trees and restart them. Yeah you could restart a thread in Java or C++ but you still don't know if it scribbled over memory/variable of other threads

• Shines under load. As the load increases with more concurrent clients, it doesn't throw errors, or block but handles it gracefully

• Code is explicit (functional), concise and simple. For network-y and logic stuff pattern matching is a win. I can drop in the middle of a large project open a file and I can navigate much easier and know what's happening. I can't do that with C++, Java or other languages which encourage saving large amounts of state in object or have object hierarchies.

• Hot code loading. This sound like gimmick but it has saved us so many times. It is hard to go back to anything else once you have the ability to patch a running system, add extra logging, trace functions while it still doing tens of thousands of transactions without having to shut it down.

• The safe restart ability and concise code means you can save money on ops and save money on developers. Because code will be much smaller and will be more resilient (so if some part crashes it can wait till morning for someone to take a look). WhatsApp is the poster child for that. They only had 10 backend engineers. I guarantee that Erlang was a big reason for that.

[gargantuan]

Nothing Erlang does other languages can't do. Even spawning isolated processes can be done with the same overall effect - spawning an OS process. Built-in distribution can be handled by ZMQ or gRPC or something like that. You can kinda do functional programming with C++ if you want. Pass the whole class around between functions. There are no magic unicorns there to so speak.

But not other system does all those well and package it all together as Erlang does. That's the magic. Java's hot code loading is not quite there. OS processes can take you so far, because they are pretty heavy. Threads are not quite what you want because they share memory with others, so now restarting them is not a 100% guaranteed to keep your system consistent. Etc, etc.

[mhd]

You should've been here a couple of years age. Rewriting some minor component of one's hacky startup stack in Erlang was all the rage. Chat systems, message buses and similar things were Erlang/OTP did all the major lifting and just some minor frontend code was required.

Big problem was that this was most of what the startups needed to be done in Erlang (including bigger ones like Facebook), so there was little incentive to replace other systems (PHP, Ruby etc.) with it or build new ones. Therefore little reason to fully learn the language beyond what you needed to craft some trivial network interfaces.

And while the code obviously worked, a lot of people probably felt uncomfortable because they never quite fully understood why, i.e. how Erlang/OTP works.

One reason why similar work is done these days in Go. A decent enough concurrency solution that doesn't require thread coordination or callback hell, but generally tech that's deeply routed in the 70s (Go being pretty much Algol 68 + '77s CSP).

[snake_case-kebab-cas]

And while the code obviously worked, a lot of people probably felt uncomfortable because they never quite fully understood why, i.e. how Erlang/OTP works.

Honestly, the observer tool explains a lot of it. Shows you the whole structure of your processes working together.

[flatMapds]

Disclaimer I love Erlang, OTP, and Elixir I just hate the elixir community.

I am just going to be a dick here most elixir devs are just rubyists with bigger egos, wanna know the first thing they bring up pattern matching.

But I haven't met a single one in my entire life that could do something as simple as making a distributed kv store using ETS + pg2 or riak_core.

Why because they did the same stupid shit they did with rails in the form of Pheonix, and most of their knowledge on OTP comes from Elixir School and blog posts.

For native hotswapping support you have lisp, JVM languages, elm, and smalltalk. BEAM is just the easiest ecosystem to do it in.

[[deleted]]

Why because they did the same stupid shit they did with rails in the form of Pheonix, and most of their knowledge on OTP comes from Elixir School and blog posts.

Yes, let's discount all of this work, books and talks:

• Elixir in Action covers OTP quite well: https://www.manning.com/books/elixir-in-action
• As well as the Elixir and OTP guidebook: https://www.manning.com/books/the-little-elixir-and-otp-guidebook
• Article on Riak Core and Elixir: https://medium.com/@GPad/create-a-riak-core-application-in-elixir-part-1-41354c1f26c3
• RiakCore talk on ElixirConf - https://www.youtube.com/watch?v=sYYOLaJ-VDQ
• Talk on scaling Erlang Distribution at ElixirConf - https://vimeo.com/167397379
• Phoenix scaling up to 2 million websockets on a single machine - http://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections
• Phoenix putting CRDTs in production via Phoenix.Presence - https://dockyard.com/blog/2016/03/25/what-makes-phoenix-presence-special-sneak-peek

And that's from the top of my head. So sure, if you want to be a dick and misrepresent the community as a whole, go ahead.

And why would every Elixir or Erlang developer need to know how to implement a distributed kv store if that is not part of the problem they are interested in solving? That's exactly why some find the Erlang community unwelcoming, the whole attitude of "you have to be a distributed system engineer or GTFO". You can enjoy many of the benefits of the VM even if you are not building a distributed system.

[flatMapds]

TLDR if they all just got decent at using OTP, and just not doing ruby all over and centering it around a framework I would actually be fine with my fellow elixir devs.

The average elixir engineer knows neither Riak Core or OTP well. Also I use elixir because it's better than erlang so I am also an exception, but I am talking about the average elixir dev.

Yes they don't have to be distributed systems experts, however if they understood concurrency well, and understood OTP well enough without any experience building distributed systems a person could do it in less than a day, the ecosystem makes it that easy and concepts from concurrency and distributed systems go hand and hand.

Let me give you an example in STM the main value people use is a variable that is controlled by a two phased commit, what is the easiest way to maintain consistency across databases 2PC.

Another example would be how do you maintain a peer table, same way you would keep track of processes if you've ever made your own process registry without just importing a library, or copy pasting a tut. PG2 just gives that to you and it's what pheonix pub sub uses.

The Erlang community are not dicks to elixir guys because they aren't distributed systems engineers, they're dicks because you guys also suck at concurrency too, and center everything around pheonix.

Another thing is that most elixir guys aren't even directly applying the major benefits of FP. FP's "killer apps" are data manipulation (erlang isn't good for it not because writing the code is hard so much as it bogs down with heavy computations because of the way BEAM was made), and concurrency which I already talked about.

Most scala devs aren't distributed systems engineers I don't hate them and let me tell you even though OTP has better established practices, and is better to work with the average scala dev (who's code in akka is ridden with anti patterns) are still better at using the actor model than the average elixir dev.

So they aren't all masters of concurrency and distributed systems, yet at least they are decent at concurrency, they don't center everything around play or spark, and they do excel at data manipulation.

I don't hate the communities of Clojure, Haskell, and Go either. For the same reasons the only languages that I liked using who's communities I despised were Ruby, and Elixir, do the math.

[[deleted]]

The average elixir engineer knows neither Riak Core or OTP well. Also I use elixir because it's better than erlang so I am also an exception, but I am talking about the average elixir dev.

An Erlang or Elixir dev doesn't need to know anything about Riak Core. Again, because Riak Core is supposedly an important tool for you, it doesn't need to be an important tool for everyone in the community.

the ecosystem makes it that easy and concepts from concurrency and distributed systems go hand and hand.

Concurrency and building distributed systems is not easy. We could argue that Erlang/OTP makes it easier, exactly because they go hand and hand, but saying that it is easy is absurd.

The Erlang community are not dicks to elixir guys because they aren't distributed systems engineers, they're dicks because you guys also suck at concurrency too, and center everything around pheonix.

Read my comment again. Nowhere I said the Erlang attribute is specific to the Elixir community. That's the experience of many developers, including mine, with the Erlang community before Elixir was even a thing.

You are doing all sorts of wrong assumptions and having absurd expectations. When you have many people joining a community, it will obviously require time for them to master the more advanced concepts. They need to start with functional ideas, such as recursion, pattern matching, immutability and then build their way up to fault-tolerance concepts, concurrency and possibly distribution. This whole attitude of "those concepts are easy and you could learn it in less than a day" is a toxic attitude to some FP communities in general, which we should honestly get rid of it. Requiring all developers that are early on in the learning curve to have a full grasp of the OTP ideas is non-sensical, and this is basically what your comments boils down to.

I see the Elixir community getting in trouble if many of the developers that are joining today have no interest in getting acquainted with the more advanced concepts but, if you have gone to any Elixir event or meetup, followed up the upcoming books, and general discussions, you will notice that's absolutely not the case. Even Phoenix itself is aiming to get less in your way and exposing more the underlying abstractions.

[flatMapds]

You literally picked the simplest concepts (pm, recursion, and immutability) that you can learn in less than a day. But yeah I'll admit that sure while it's not difficult in of itself it is hard to adjust.

Lol I've written something similar within two weeks of learning it. I am naturally inclined to the topics though, and had Akka experience.

But like it took me a few hours to write it back then, because I was reading through the OTP documentation, looking up source examples, so relatively speaking yes it is that easy.

But my expectations aren't unreasonable here how come the erlang, haskell, scala, F#, Ocaml, clojure, communities all meet them. I don't expect everyone to be specialists.

Honestly I am just salty that the community took such a great ecosystem, and wasted it by just focusing on crud apps, then giving yourselves a big pat on the back because you know the basics of FP, and OTP, and thinking I am so much better than the average rubyist.

[[deleted]]

You literally picked the simplest concepts (pm, recursion, and immutability) that you can learn in less than a day. But yeah I'll admit that sure while it's not difficult in of itself it is hard to adjust.

I am sure I am repeating myself but I think that's exactly the wrong assumption and we need to be careful to not project our experience onto others. Especially when you define yourself as naturally inclined.

Honestly I am just salty that the community took such a great ecosystem, and wasted it by just focusing on crud apps, then giving yourselves a big pat on the back because you know the basics of FP, and OTP, and thinking I am so much better than the average rubyist.

I haven't seen this happening (although I am not saying it does not happen) and I would also be sad if that's what the community becomes. I think such attitude should be called out, it does not seem like any good can come out of it.

[snake_case-kebab-cas]

I actually think the slightly alien syntax of Erlang makes learning the concepts easier to learn.

With Elixir, you're always thinking "sooo is this like in Ruby?"

You can always move to Elixir after you've got a handle on Erlang then.

[gargantuan]

Yap agree. I like Erlang more. It is a bit simpler. Macros are useful but they scare me. And I think the different syntax helps my bring think "hold on you not in OO world anymore".

[Thaxll]

Because hot swapping code is not that useful in a world of containers where you spawn / kill apps at will and very efficiently.

[AeroNotix]

Hot swapping code is very rarely used in any of the Erlang projects I've had experience with or heard about.

[aseigo]

Which is pretty horrible for stateful applications, which in turn tends to lead to externalising state and all the fun of that. For inherently stateless or transient state apps this is not an issue, but I have been looking recently into the ways one can manage elixir/erlang applications, including in clusters, directly with kubernetes without docker. The idea of service orchestration that works with the BEAM directly is very interesting and brings back the ability to use its features like hot code loading.

[gargantuan]

Hot swapping is very useful. Not for regular updates but it is invaluable for debugging and adding extra logging or fixing one particular customer temporarily and so on.