Step zero is definitely the OTP Design Principles doc (part of the OTP distribution):

https://www.erlang.org/doc/design_principles/users_guide

There are some good texts that have more examples:

Erlang & OTP in Action - https://www.manning.com/books/erlang-and-otp-in-action

Designing for Scalability with Erlang/OTP - https://www.oreilly.com/library/view/designing-for-scalabili...

One big example of distributed Erlang is Riak:

https://github.com/basho/riak

For me, Erlang was the ladder to functional programming. Once I’ve mastered Erlang to be able to write gossiperl (http://gossiperl.com, not maintained in a long time), all immutable programming became easy. Maps, flat maps, recursion, no side effects, all became clear.

After Erlang, I’ve enjoyed Scala a lot. Especially Akka.

I do tons of go now and when I need actors in go (not very often because channels are rather straightforward), I use proto.actor: https://github.com/AsynkronIT/protoactor-go.

Erlang is awesome. I can definitely recommend the “Designing for scalability with Erlang/OTP”: https://www.oreilly.com/library/view/designing-for-scalabili.... This is the book which finally made me “get it”.

If you like the O'Reilly format then I liked Designing for Scalability with Erlang/OTP. I thought it was light on the details beyond scaling beyond single node OTP apps but it covers a lot of the built-in Erlang functionality pretty well

http://shop.oreilly.com/product/0636920024149.do

Designing for Scalability with Erlang/OTP is pretty good so far.

http://shop.oreilly.com/product/0636920024149.do

I don't actually agree that the ecosystem is weaker than Rails. There may be fewer hex packages than Ruby gems, but after 10 years worth of doing my own Rails work and cleaning up other people's messes, I can safely say that most of the gems in the ecosystem are antithetical to well-designed modular software.

Bottom line, learning to write software well is hard, no matter what language you're in. What is probably weaker in the Elixir sphere is the amount of blog posts that go deeper than "Yay elixir", but there are some really high-quality books that are a good subsitute. Here's the order I usually recommend for new Elixirians:

1) Dave Thomas' Programming Elixir 2) Sasa Juric (http://theerlangelist.com/) Elixir in Action (blog is also great) 3) Programming Phoenix (Jose Valim, Chris McCord, Bruce Tate) 4) Lance Halvorsen's Functional Web Development with Elixir, OTP, and Phoenix should probably be in there somewhere but I'm not sure where, as I haven't had a chance to read it yet. 5) Designing for Scalability with Erlang and OTP is a good followup when you're comfortable with the syntax and concepts from OTP

[1] https://pragprog.com/book/elixir13/programming-elixir-1-3

[2] https://www.manning.com/books/elixir-in-action?a_aid=sjuric

[3] https://pragprog.com/book/phoenix/programming-phoenix

[4] https://pragprog.com/book/lhelph/functional-web-development-...

[5] http://shop.oreilly.com/product/0636920024149.do

http://shop.oreilly.com/product/mobile/0636920024149.do

The first part is mainly about erlang and the choices they made. But the last part is not at all specific to erlang and walk you all the way through all decisions to take to build that type of architecture.

Thanks for sharing this. A few questions from someone interested in learning how to use BEAM-based systems in production:

* How did you debug the issue?

I know Erlang in Anger [1] is kind of written just for this but it feels pretty intense to me as a newbie. I don't know enough to tell whether the issues there are only things I'd need to worry about at larger scale but I found it pretty intimidating, to the point where I have delayed actually designing/deploying a Erlang solution. Designing for Scalability with Erlang/OTP [2] has a chapter on monitoring that I'm looking forward to reading. Wondering if there's some resources you could recommend to get started running a prod Erlang system re: debugging, monitoring, etc.

* How do you decide when to use a message queue (like sqs, RabbitMQ) vs regular processes? Do you have any guidelines you could share or is it more just, "use processes when you can; more formal MQ if interfacing with non-beam systems"? I struggle since conceptually each sender/receiver has its own queue via its mailbox.

1. https://www.erlang-in-anger.com/

2. http://shop.oreilly.com/product/0636920024149.do

I don't have the perspective yet to compare this to other works on OTP but this book may be of value to you: "Designing for Scalability with Erlang/OTP" [1]. It is co-authored by Francesco Cesarini, founder of Erlang Solutions and one of the master-class instructors.

1. http://shop.oreilly.com/product/0636920024149.do