jeramyRR

jeramyRR

I don’t have enough money, or time, to keep up! :slight_smile:

1
Post #13
josevalim

josevalim

Creator of Elixir

The book will cover deployments using mix and distillery and give a tour of the tools that come as part of Erlang/Elixir. And while we won’t explore any particular container/orchestration/cloud platform, we will provide enough background for you to confidently deploy to any of these.

Can you please expand on what you mean by efficiently using a supervision tree? The book is currently thin on supervisors but it is a topic we will gladly expand if there are common contention points. We do talk about Distributed Erlang in terms of architecture and operations.

It is worth noting this is not a tutorial/example kind of book. It is rather an exploration of what is available in the platform, ecosystem and how to avoid common pitfalls. You will get plenty of breadth and learn new concepts but it will be up to you to go deeper into them.

3
Post #14
PatNowak

PatNowak

Thanks for your reply.
I meant that I would like to read a book that covers how supervision tree works in general, in Phoenix application and how we can build a robust, fault-tolerant app - to basically - prevent app from real crashing at all.

0
Post #15
AstonJ

AstonJ OP

This is now out in beta :023:

6
Post #16
kokolegorille

kokolegorille

Long awaited :slight_smile:

Is there a coupon for forum members?

2
Post #17
AstonJ

AstonJ OP

Yup - use coupon code ElixirForum to get 25% off :003:

5
Post #18
cjen07

cjen07

just bought it, great opportunity to learn from guru

1
Post #19
christhekeele

christhekeele

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.

11
Post #20
josevalim

josevalim

Creator of Elixir

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.

14
Post #21
sasajuric

sasajuric

Author of Elixir In Action

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 :smiley:, 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.

15
Post #22