My original plan for EiA was to discuss some medium-level concurrency patterns, and include a more involved real-world-like example inspired by a production system I worked on at the time. However, quite early in the game it became clear to me that my plan was way too ambitious , and so I ditched patterns and the involved example.

I absolutely agree that a book which discusses various intermediate/advanced techniques would be very interesting, and that it would bring something to the table. I’d personally love a book which assumes that a reader is familiar with mechanics of Elixir/OTP/Phoenix (so it wastes no space on that), and instead it focuses more on applying various functional/concurrent techniques, explaining hows/whys along the way.

I also feel that there’s room for more than one such book. Perhaps it would be interesting to have a few shorter ones, e.g. one discussing functional techniques, another discussing concurrency/fault-tolerance, yet another focusing on troubleshooting production (basically Elixir in Anger), etc.

I have thought a couple times about, for lack of a better word, a “design patterns” book. There are data/functional patterns (enum vs stream, keywords vs maps, with), application patterns (facade, behaviours, protocols), concurrency patterns (cast vs call, async replies, genstage vs gen_event, ets, registry, task, async_stream), and fault tolerance patterns (supervisor, monitoring, signal trapping, etc).

The Adopting Elixir book explores some of those and goes deep into the “dirty schedulers and nifs vs ports vs… that whole mess” one.

I think I’ve powered through the curve on my own, but I’ve always maintained that there is still a void for a really solid, Elixir-first exploration of concurrency abstrations and tooling of both OTP and Elixir-native ecosystems, since they are so unique compared to many incoming programmer’s fluencies––akin to the excellent Little Elixir and OTP Guidebook, but explicitly highlighting the common, core, intimidating decisions you must make as a fluent Elixir developer trying to understand and introduce the right abstractions into their app for the first time by robustly contrasting:

• spawning vs linking vs monitoring
• start vs start_link
• signal trapping and handling
• supervision strategies
• cast vs call and the various clever strategies inbetween
• keywords vs maps vs records vs structs
• behaviours vs protocols
• applications vs libraries
• Enum vs Stream vs Flow
• gen_event vs GenStage vs Flow
• parse transforms vs macros
• ets vs dets vs mnesia vs ecto
• dirty schedulers and nifs vs ports vs… that whole mess

I know like this seems like a laundry list of distinctions, but I think it’d be really useful to have a resource that was explicitly indexed like this: I know of these n concepts, but I need to understand their similarities and differences better because it’s go time; preferably updated with the consistency and ease of most pragpub resources.

While I’m daydreaming, an Elixir-first example-driven analog of Erlang in Anger with all of the lovely sys tips and amazing tracing other hidden gems presented during this year’s ElixirConf would be a hell of a publication.

Thanks guys for the kind words. Bruce Tate, co-author of this book and line editor of the Elixir books here. I don’t know if you’ve noticed, but folks don’t always like to pay for books in other language ecosystems, and quality suffers. What I am saying in a way too verbose way is that you, the community, make all of this work, and I genuinely thank you.

The process of picking a cover is pretty simple. Authors get votes, and the prag support team gets votes. Our team builds a half dozen covers or so, and then if we don’t like them we build more. I think this system lets us get the egos out of the room, and we can generally converge on something interesting. My favorite book covers of all time were the tower of Babel for the initial seven languages book and the passport for the second seven language book.

On how we choose our books, the process is very much the same. We get proposals, some hand delivered (to me, or the prags), and then we have two meetings per month to talk about them. We vote on whether we’d like to publish. The owner doesn’t throw his weight around, and the editors don’t either. Everyone gets a fair chance. That leads to interesting books, often on topics we hadn’t considered. So if you want to write an Elixir book, it’s hard but you can just drop me an electronic note (bruce at rapidred dot com) and I’ll tell you if someone is already writing a book, or to write a proposal. Then it’s pure darwin. We’ll look at the topic with the committee, and if we like it we’ll read your TOC and sample chapter and give you a thumbs up or down.

Let’s see some proposals!

On the Elixir ecosystem and books you like and would like to see, are there any books that you need that we don’t provide? Here’s what we’re thinking now:

• a graph QL book
• an Ecto book
• an advanced book on API and service design with OTP, Phoenix, and Elixir
• a book on Nerves
• Lance’s book will eventually have Elm

And of course the stuff we’ve already announced. Is there anything else we’re missing?

The book is broken in three parts, the first two (concept and development) are still relevant and up to date. The third part is slightly outdated, which is where Elixir and ecosystem have mostly solidified in the last years. It has three chapters:

1. On the releases chapter, we talked about distillery but releases are now part of Elixir. Some specific instructions are now outdated but I would say though most of the lessons are still appropriate. You can close the gap by reading Elixir docs for releases

2. On metrics and performance, we have unified around telemetry, so a good amount has changed. This is probably the most outdated chapter now but there are a lot of resources online too

3. “Making your app production ready” is mostly up to date, maybe two or three links that would need to be updated