Don’t forget you can get 35% off the ebook using the code ‘devtalk.com’ 
2 Likes
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.
1 Like
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? 
1 Like
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.
2 Likes
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 
5 Likes
$7.15 for the ebook, that’s a steal!
3 Likes
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!
2 Likes
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).
3 Likes
That’s good to know! Bought the book ages ago, just haven’t got round to it yet…
1 Like
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?
Yes and no. With the techniques in this book, you’ll know how macros work. How to implement your desired syntax is up to you.
No, but typespecs are just “code”, which turn into abstract syntax trees anyway, so there’s no difference between “normal” Elixir code and typespecs.
Around 130 pages. I personally feel this book is not thick enough, so don’t expect in-depth explanations. In order to write your own macros, you’ll experience a whole lot of try and errors.
Read the book and can confirm the praises. Currently working on my first lib which is macro heavy. Chris’ book took the magic out of macro’s, they are now ‘just plain Elixir’ to me.
1 Like
Yeah, I finished reading it, too. When I was trying to build an ecto_query-ish library, I also learned a lot beyond that book.
