Metaprogramming Elixir (Pragprog)

I’ve already bought this book a few weeks ago, along with most of the other Elixir-related books at Pragprog. I think it’s a bit too advanced for me right now, but I’m looking forward to reading it after I’ve gotten through Programming Elixir and Programming Phoenix.

Let us know how you get on Leif! I also have the book, but haven’t got around to reading it yet

Anybody read it? Thoughts?

I’ve read it and I liked it. It covers generating code from an external file, which is about 80% of the macro code I write. The section on generating an HTML DSL, is probably the least useful for me. I believe at some point it started using an actor to track changes, which I didn’t really like. The Phoenix router DSL is pretty interesting, but the patterns used there weren’t in the book. So, I recommend diving into the Phoenix, Plug, and Ecto code after reading the book. I’d say the book gave me the building blocks to read and understand those. Reading those, personally gave me a better idea of what’s possible.

@chrismccord, are there any plans for 2nd edition of this book?

The book is still 100% relevant and there’s not yet a need for a 2nd edition as Elixir’s AST and metaprogramming features are fortunately quite stable. I think the only thing that needs updated in the book today is the break feature of the while macro will warn on null arity parens

$7.15 for the ebook, that’s a steal!

I have just followed the book with no stumbling blocks along the way. I honestly expected to face some issues considering when the book was released, but other than some deprecation warnings which were expected, everything else was smooth sailing.

Solid book with very practical examples. Thank you Chris!

I picked up Metaprogramming Elixir during PragProg’s recent Christmas in July sale; the book is already modestly priced but was a steal with the discount.

I’m fairly new to Elixir, so my original intent was to read the book once I had a bit more exposure and experience under my belt.

But then I thought, “Well, I already have a rudimentary familiarity with macros from dabbling in Clojure (a lisp). I’ll be learning Ecto and Phoenix soon and I know there are some DSLs and use going on there, so it’d be really nice to have some intuition about what’s happening under the hood. Let’s just take a little peek at the first chapter and see.”

I was hooked.

Chris McCord’s clear writing style and obvious focus on reader ergonomics, e.g., repeating relevant bits of code, makes the book very readable and engaging.

Regarding content, there were plenty of moments where I thought, “wait, we’re going to do what next?! Okay, I’ve got time to read a few more pages…”

And, as I had hoped, the book covers DSLs and use, but it also covered so much more.

I was introduced to Elixir’s AST and the concept of macro hygiene, along with repeatable recipes for building DSLs and testing macros.

As an Elixir noob, I don’t think I’ll be writing my own for-real macros just yet, but I feel that I’ve gain a lot of valuable intuition about how the language works, which was my goal.

This is definitely a resource I’ll revisit once I get more experience.

Thank you @chrismccord!

Other notes:

I read the book cover-to-cover in about three days, mostly during lunch breaks and at bedtime.

I recommend reading the book start-to-finish.

I found the book to be e-reader friendly (Kindle Paperwhite, landscape).

That’s good to know! Bought the book ages ago, just haven’t got round to it yet..

Hello all, recently this book came into my attention, namely I am trying to do a macro that creates a module dynamically. Let’s say, something like this:

defmodule Name do
  @opaque t :: {:name, String.t()}

  @spec new(val :: String.t()) :: t
  def new(val) when is_binary(val), do: {:name, val}

  @spec extract(name :: t) :: String.t()
  def extract({:name, val}), do: val

  @spec name?(data :: any) :: boolean()
  def name?({:name, val}) when is_binary(val), do: true
  def name?(_data), do: false

  @spec is_name(data :: any) ::
          {:__block__ | {:., [], [:andalso | :erlang, ...]}, [],
           [{:= | {any, any, any}, [], [...]}, ...]}
  defguard is_name(value)
           when is_tuple(value) and elem(value, 0) == :name and is_binary(elem(value, 1))
end

which would be generated by invoking:

deftype Name, String.t() 

Now I have checked the mini-video for the book:

And as an intro, it covers a lot. But after checking the index I have some questions:

• does the book cover my specific use case? (does it teach how to dynamically generate modules?)
• does the book cover how to include typespecs in the generated code?
• How many pages does the book have?