Elixir is a functional programming language built on the Erlang virtual machine. It combines the productivity and expressivity of Ruby with the concurrency and fault-tolerance of Erlang. Elixir makes full use of Erlang's powerful OTP library, which many developers consider the source of Erlang's greatness, so you can have mature, professional-quality functionality right out of the gate. Elixir's support for functional programming makes it a great choice for highly distributed event-driven applications like IoT systems.
The Little Elixir & OTP Guidebook gets you started programming applications with Elixir and OTP. You begin with a quick overview of the Elixir language syntax, along with just enough functional programming to use it effectively. Then, you'll dive straight into OTP and learn how it helps you build scalable, fault-tolerant and distributed applications through several fun examples. Come rediscover the joy of programming with Elixir and remember how it feels like to be a beginner again.
I was asking myself a question - do we really need another book about Elixir? I mean - there are not that many already present, but those that are represent a truly remarkable quality ("Elixir in Action", "Programming Elixir"). So, what's the point?
Fortunately this book aims a specific niche (& it helps to make it stand out a bit) - it's far less about Elixir & far more about OTP (the platform). Intro to the language itself does not cover everything, just what is need to start playing with OTP. OTP part doesn't cover everything either (it focuses on GenServer & supervising mainly) - but it good & comprehensive enough to show the reader the key possibilities & advantages this platform enables. It doesn't go as deep as Cesarini's book ("Desiging for scalability ...") but it not the goal.
Ok, so you know what book is about - but is it worth buying? If you're new to the platform & you're more interesting in distributed systems built on actor-model than the "beautiful language" approach that is a common value that guides development of Elixir as a language, than it's a book for you. If you've already went through any of the books mentioned above, you won't benefit much of it.
In general - very approachable, well edited, good code examples & illustrative pictures. I'd give 4.5 stars, but I'll give 5 - just because it's Elixir & OTP ;D
Good overview of OTP. I thought theme throughout the book to implement OTP and erlang/elixir features was the most useful. It helps break through the magical aspects of these features and reason about how one would implement these into a larger system. I thought the Supervisor tree was the most useful section but the distributed/fault tolerance chapters were the most fun and impressive.
Would recommend to those that want to get a good taste of what comprises OTP.
I have to admit that I am totally in love with how this book is written. Benjamin has a real gift of teaching others. All, here, in this book, is written in simple and easy to understand manner, so even if you are not a senior developer you will understand almost everything.
Another, even bigger than previous, plus of this book is that it aiming to explain not only Elixir but also OTP and it's a most important feature like GenServer & Supervision and debugging techniques and how Erlang distribution works. It's worth mentioning the last two chapters here, one explains Dialyzer (static analysis tool) and how to use it in its Elixir project, and seconds add some new great tools to test elixir application using property-based and concurrent testing mechanisms. The only thing I miss a lot is the lack of ets/dets and mnesia information.
This was a good book that went into Elixir and specifically OTP in good detail, it did not spend too much time on the basics at all. The challenge with this book will be that elixir is moving so fast, some of the code was dated by the time that I went to code up some of the examples. I was able to find most of the answers to my problems and that helped me understand what was happening even more.
This is by design an intermediate book, and I think some priming would be helpful before jumping into this one.
I really liked this book. As its title already states it is a guidebook on how to use Elixir and OTP together. It has valuable examples which give you a good start and options to explore further.
This is not a book by which to learn Elixir. It _is_ the book to learn processes and OTP, but it helps to be familiar with many of the concepts ahead of time.
Definitely a good read. I'd probably recommend for someone who is starting with OTP and wants to learn step by step with some examples.
While I think that it's not the best book to read from cover to cover from the sofa because it's very example-heavy and doesn't have that much actual literature, it is a good choice if your objective is to gain a good thorough understanding of OTP mechanics by trying out the examples yourself.
Regarding the content, it barely covers distributed Erlang, no more than how to create an application with a couple of nodes and connect them, so it might not be the best book if you want to read on that specifically. However, I did find good insights in the chapters which go through an example of how to create a worker-pool library with supervision trees, basically a copy of Poolboy. Benjamin does a great job at picking some complex examples to make sure the readers grok how to orchestrate non-trivial supervision trees.
Very useful for speed learning Elixir. It's a bit hard to follow if you're a complete beginner to Elixir and you need to research the language while reading, in order to understand the contents, though this way one seems to learn faster... The examples are a bit outdated, though. The Supervisor.Spec way of writing Supervised applications is deprecated but most of the examples are built on it. The writing style is quite good as well.
If you are new to Elixir / OTP this is definitely a must-read. However, for those new to Elixir, I recommend reading Programming Elixir: Functional > Concurrent > Pragmatic > Fun first. That's because "Little Elixir..." does not delve much into Elixir as a language but rather concentrates on its concurrency and other OTP features. And that's what I really like about it - it addresses the areas hard to find in other Elixir books - like property based testing or concurrency testing. The examples are neat and valuable as the author tries to show some real-world applications, like pool management, load balancing, etc. The biggest downside of this book are errors in the code samples (mostly the missing parts), in my opinion there are too many of them and also some of the functions used are deprecated as of the current version of Elixir. However the compiler will help you in getting rid of them. Alternatively, you can read the errata or download the samples from the author's github.