What do you think?
Rate this book
Programming Phoenix: Productive |> Reliable |> Fast
Don’t accept the compromise between fast and beautiful: you can have it all. Phoenix creator Chris McCord, Elixir creator José Valim, and award-winning author Bruce Tate walk you through building an application that’s fast and reliable. At every step, you’ll learn from the Phoenix creators not just what to do, but why. Packed with insider insights, this definitive guide will be your constant companion in your journey from Phoenix novice to expert, as you build the next generation of web applications.
298 pages, Paperback
First published January 10, 2016
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 38 reviews
September 2, 2016
This book probably provides the best introduction you can currently get for the Phoenix web framework. And yet, there were some things I didn't like: The constant raving about how great Phoenix and Elixir are more annoying than motivating. At the same time, the book is a bit too superficial when it comes to explaining Phoenix. It does not really help to understand the underlying concepts. Too often for my taste, it's about what you are supposed to do to build the example application instead of explaining why and how specific parts of Phoenix work in detail. I found this especially troubling for the parts on channels and OTP.
June 23, 2016
Overall the book is a good introduction to Phoenix - a tutorial on how to build something that leverages Phoenix.
The book tries to cover too much ground and does so in a diluted manner. Completeness is nice, but I think that opening your appetite for more is the essential part and what I normally look for in a technical book like this.
I did not see an explanation of what Phoenix is composed from and pointers to help me dissect it further if I am to use if for anything that's non-trivial.
I also did not like the "stabs" at Rails and it's shortcomings. I think that just limiting the discourse to explaining the differences should have been enough. Rails (and Ruby) for that matter did bring a lot of good things to the table, that everybody borrowed from to a certain degree and did make our lives easier (directly or indirectly).
At the end of the day, I think the book is worth reading if you're into Elixir and/or experimenting with new things. Elixir and Phoenix are still young and there is a lot of untapped potential there.
The book tries to cover too much ground and does so in a diluted manner. Completeness is nice, but I think that opening your appetite for more is the essential part and what I normally look for in a technical book like this.
I did not see an explanation of what Phoenix is composed from and pointers to help me dissect it further if I am to use if for anything that's non-trivial.
I also did not like the "stabs" at Rails and it's shortcomings. I think that just limiting the discourse to explaining the differences should have been enough. Rails (and Ruby) for that matter did bring a lot of good things to the table, that everybody borrowed from to a certain degree and did make our lives easier (directly or indirectly).
At the end of the day, I think the book is worth reading if you're into Elixir and/or experimenting with new things. Elixir and Phoenix are still young and there is a lot of untapped potential there.
November 24, 2016
It's been a while since I've read technical book, written in such an accessible way.
The first part gets you in speed in showing Phoenix's structure and standard tooling for classic web applications. The second part is focused on the stuff the framework shines – channels and the integration with OTP.
It got me excited to rewrite some of our apps in Elixir/Phoenix.
One more thing – the dummy application that's used to illustrate these is actually really cool :)
The first part gets you in speed in showing Phoenix's structure and standard tooling for classic web applications. The second part is focused on the stuff the framework shines – channels and the integration with OTP.
It got me excited to rewrite some of our apps in Elixir/Phoenix.
One more thing – the dummy application that's used to illustrate these is actually really cool :)
June 25, 2016
Programming Phoenix is a joy to read.
While the book is fairly thin, it manages to pass on a lot of knowledge. Novices may feel lost as a lot of the things presented in the book feel like magic - things from channels/websockets to OTP. It's definitely a book for intermediate developers.
The writing is upbeat and clear, which makes the book easy to follow. Knowledge is imparted in a sequence that goes from "things that are out of your comfort zone" to "whoa, this is totally wicked!".
I don't know if it was the aim of the authors, but this book clearly shows how Phoenix approaches everyday problems that a developer has to wrangle with and solves them in an extremely clean manner. Caught in a maelstrom of mocking? Dependency injection for your tests has never been easier. Your functions are hard to test? It's never been easier to build small and composable functions. Your codebase getting a little big? Just split and move your stuff over into an umbrella application.
Aside from making me choose Elixir and Phoenix as a stack to focus on this year, the information I've gotten out of this book has made me a better developer as well.
While the book is fairly thin, it manages to pass on a lot of knowledge. Novices may feel lost as a lot of the things presented in the book feel like magic - things from channels/websockets to OTP. It's definitely a book for intermediate developers.
The writing is upbeat and clear, which makes the book easy to follow. Knowledge is imparted in a sequence that goes from "things that are out of your comfort zone" to "whoa, this is totally wicked!".
I don't know if it was the aim of the authors, but this book clearly shows how Phoenix approaches everyday problems that a developer has to wrangle with and solves them in an extremely clean manner. Caught in a maelstrom of mocking? Dependency injection for your tests has never been easier. Your functions are hard to test? It's never been easier to build small and composable functions. Your codebase getting a little big? Just split and move your stuff over into an umbrella application.
Aside from making me choose Elixir and Phoenix as a stack to focus on this year, the information I've gotten out of this book has made me a better developer as well.
August 5, 2016
I liked the first half, it got me up and running with Phoenix pretty quickly.
However, I wasn't a big fan of the second. I couldn't see when I'd use video annotating in any real world scenario, so found it hard to be enthusiastic about the project. I think I would have preferred a chat app, or something similar.
I also felt that the app become overly complicated. Functionally is added for multiple backends, but we only add one. So I became quite confused over what code was needed, versus what was added to allow multiple backends to be supported. I still don't understand what some of the code does in the demo app.
However, I wasn't a big fan of the second. I couldn't see when I'd use video annotating in any real world scenario, so found it hard to be enthusiastic about the project. I think I would have preferred a chat app, or something similar.
I also felt that the app become overly complicated. Functionally is added for multiple backends, but we only add one. So I became quite confused over what code was needed, versus what was added to allow multiple backends to be supported. I still don't understand what some of the code does in the demo app.
June 18, 2020
I loved working through this. Tip: actually work through everything step by step. The way “Rumbl” was spelled and the way I would typo it let to several errors that actually contributed to my learning. Not sure if this was intentional or not, but it helped!
July 31, 2022
An essential resource for programming Phoenix. While I wouldn't say there are any mind blowing things that you wouldn't have found elsewhere in the documentation or on the internet on general; it explains much of the rationale behind the framework and how the creators envisioned how you would write code for it. Especially considering testing.
I liked the reoccurring little footnotes sprinkled in the book with quotes from the authors with themes tangent to the chapters but very helpful. Like a little "by the way" to the chapters. For example; "Should I use atoms or strings as map keys?" Explaining that strings should be used for reading external input but atoms where you can trust the input.
Sometimes I would like the book to dig a little bit deeper. It feels more like an introductory book to Phoenix than a deep dive for someone more familiar.
Some learnings from my notes:
I got a better understanding of Ecto. For example about Virtual schema fields (that can be used for validation but doesn't need to exist as a field in your actual database) and the migration "alter" macro (which does both up and down migrations)
About a test helper bypass_through that makes in possible to test request pipelines without going through the the request dispatch, thus we can then only test the controller or plug that we wanted to, without caring about the dependencies on the routing layer.
The difference between giving Routes.x_path and Routes.x_url the connection vs an url. Where the first is the most straightforward way and gives you the the possibility of using a custom base uri but with the appended path.
And the little discussion on one-off fire-and-forget processes on page 310 (which is too long to recite here).
I also liked the discussions about for example if you should or shouldn't introduce code to help with your testing. The authors decide that it's worth making a small change to the production code to drastically simplify the testing of that function. The change is not test-specific per se but it is only done to help the testing. This changed my perspective a little bit as my general position is that "tests should help you write better code" not - "code should help you write better tests". But the case presented in the book makes me agree with the authors. Code should never be dogmatically and you should be able to reevaluate your position.
Overall a good, but even more so a must reference literature - book.
I liked the reoccurring little footnotes sprinkled in the book with quotes from the authors with themes tangent to the chapters but very helpful. Like a little "by the way" to the chapters. For example; "Should I use atoms or strings as map keys?" Explaining that strings should be used for reading external input but atoms where you can trust the input.
Sometimes I would like the book to dig a little bit deeper. It feels more like an introductory book to Phoenix than a deep dive for someone more familiar.
Some learnings from my notes:
I got a better understanding of Ecto. For example about Virtual schema fields (that can be used for validation but doesn't need to exist as a field in your actual database) and the migration "alter" macro (which does both up and down migrations)
About a test helper bypass_through that makes in possible to test request pipelines without going through the the request dispatch, thus we can then only test the controller or plug that we wanted to, without caring about the dependencies on the routing layer.
The difference between giving Routes.x_path and Routes.x_url the connection vs an url. Where the first is the most straightforward way and gives you the the possibility of using a custom base uri but with the appended path.
And the little discussion on one-off fire-and-forget processes on page 310 (which is too long to recite here).
I also liked the discussions about for example if you should or shouldn't introduce code to help with your testing. The authors decide that it's worth making a small change to the production code to drastically simplify the testing of that function. The change is not test-specific per se but it is only done to help the testing. This changed my perspective a little bit as my general position is that "tests should help you write better code" not - "code should help you write better tests". But the case presented in the book makes me agree with the authors. Code should never be dogmatically and you should be able to reevaluate your position.
Overall a good, but even more so a must reference literature - book.
November 6, 2018
Written by the developers who created Phoenix, this is an invaluable guide for people just starting out in the Elixir framework. It covers the basics of creating an application, using the default Ecto library for database transactions, the use of channels and OTP for concurrency, and testing. Everything you need to know to get started, really.
The form this takes is the now-familiar "create a toy project from scratch" programming book example. As such, all code examples are basic and build on the application of choice, a real time video annotation app. The example project is well thought out to demonstrate the strengths of the Phoenix platform, and I'm glad they included the Wolfram Alpha integration, as API integration is a requirement of almost every modern app.
The only reason this didn't get five stars is that I wish it were more comprehensive about potential stumbling blocks in the described libraries. Obviously, an intro book cannot include a fully comprehensive overview of the default libraries, but I wish there had been some more discussion of common errors users make and how to resolve them.
The form this takes is the now-familiar "create a toy project from scratch" programming book example. As such, all code examples are basic and build on the application of choice, a real time video annotation app. The example project is well thought out to demonstrate the strengths of the Phoenix platform, and I'm glad they included the Wolfram Alpha integration, as API integration is a requirement of almost every modern app.
The only reason this didn't get five stars is that I wish it were more comprehensive about potential stumbling blocks in the described libraries. Obviously, an intro book cannot include a fully comprehensive overview of the default libraries, but I wish there had been some more discussion of common errors users make and how to resolve them.
May 13, 2020
If you want to get started with the Phoenix framework, there may be better beginner's guides out there - since I'm still a beginner myself it's hard to judge. But you could definitely do a lot worse than this book. After working through it I feel like I've got a reasonably solid grasp on the fundamentals, and some ideas for what comes next - which is all a beginner can ask for really.
The only other thing I'd say if you're considering buying this is that I wouldn't recommend you bother, or make any serious attempt with Phoenix, until you have a working knowledge of Elixir. You don't need to be an erudite expert in every detail of the language (I'm not), but the book assumes a basic familiarity with Elixir concepts and syntax and if you try to learn both technologies at once you'll just confuse yourself.
(As for how to learn Elixir, what worked for me was to work through the guides on elixir-lang.org, then play around with the Elixir tests on Exercism.io until I got bored. Again, not saying this is definitively the right strategy for everybody - just that it worked okay for me.)
The only other thing I'd say if you're considering buying this is that I wouldn't recommend you bother, or make any serious attempt with Phoenix, until you have a working knowledge of Elixir. You don't need to be an erudite expert in every detail of the language (I'm not), but the book assumes a basic familiarity with Elixir concepts and syntax and if you try to learn both technologies at once you'll just confuse yourself.
(As for how to learn Elixir, what worked for me was to work through the guides on elixir-lang.org, then play around with the Elixir tests on Exercism.io until I got bored. Again, not saying this is definitively the right strategy for everybody - just that it worked okay for me.)
March 3, 2020
This might be the best programming book I've read to date. I'm probably a tad biased as I love the Elixir language and its ecosystem, but I think the Phoenix framework is simply elegant and powerful. The authors really did a great job at providing just the right amount of context and explanations needed as they take you on a journey to build a modern web-app.
They give you a great overview of how you can get up and running in little time, and how you can extend your application with more modern functionality such as channels and web-sockets, or the lightweight, self-healing GenServer processes. Coming from Ruby, and having a lot of experience with the Rails framework, I'm amazed at how transparent and accessible Phoenix turns out to be.
They give you a great overview of how you can get up and running in little time, and how you can extend your application with more modern functionality such as channels and web-sockets, or the lightweight, self-healing GenServer processes. Coming from Ruby, and having a lot of experience with the Rails framework, I'm amazed at how transparent and accessible Phoenix turns out to be.
December 31, 2018
I've read the beta 5.0 version of the new edition of this book (>=1.4) because I think it is not worth reading the old version.
The version I read lacks the final 3 or 4 chapters, about Phoenix Presence, Umbrella Apps and some other topics, but what I read was a great intro to the framework and the way of thinking of an "Elixirian". I hope to get the final version soon with some mistakes fixed and then I will write a more complete review, but meanwhile, if you want to learn Elixir for the web, with a robust framework, this is THE BOOK.
The version I read lacks the final 3 or 4 chapters, about Phoenix Presence, Umbrella Apps and some other topics, but what I read was a great intro to the framework and the way of thinking of an "Elixirian". I hope to get the final version soon with some mistakes fixed and then I will write a more complete review, but meanwhile, if you want to learn Elixir for the web, with a robust framework, this is THE BOOK.
February 7, 2022
It was fascinating learning more about elixir and it's wonderful web framework. I was amazed with how easy it is to do things that are really hard with other technologies which has got me quite excited. I think like anything it has weaknesses, but for certain kinds of problems it can't be beat. This book on the whole was really well explained and I think will serve as a good reference going forward as I write phoenix applications.
February 23, 2019
This book walks the reader through the creation of a Phoenix app meant to add annotations to videos.
The most useful part was that covering user authentication. The rest of the book doesn't extend much beyond the online documentation for Phoenix, and it has little of what one might hope for in a book about Phoenix: a systematic overview of Phoenix features and design philosophy.
The most useful part was that covering user authentication. The rest of the book doesn't extend much beyond the online documentation for Phoenix, and it has little of what one might hope for in a book about Phoenix: a systematic overview of Phoenix features and design philosophy.
May 5, 2017
A good read and great introduction to phoenix. Get's you up and running. But because the book is written by the framework authors, expected detailed design decisions and why the framework was built the way it is. May be an "In-depth Phoenix" I'm looking for.
September 8, 2017
Methodical presentation of architecture.
January 2, 2018
Clear and probably the most accessible intro to Phoenix & Elixir
July 31, 2019
Nice introduction and kind-of a tutorial. Helps to understand how to structure the code and what you can achieve with Elixir.
January 8, 2020
nhiều insight từ Elixir/Phoenix core member
March 20, 2021
Useful but many of the examples did not work as written which made the book a little more challenging than necessary to get through
July 4, 2021
It doesn't use idiomatic elixir at some places probably to keep newbies at ease. Although I think showing true power would encourage not deter.
July 16, 2021
It's a great introduction to Elixir, and well, the Phoenix framework. It teaches you a lot of the common things you would normally encounter when building non-trivial web applications.
November 28, 2021
Probably, the best phoenix introduction you can read so far!
January 1, 2023
Easy to follow, great way to get the feeling of Elixir - and start building things.
June 13, 2016
The first dozen pages or so can be skipped—they are just selling the framework. In fact, about a fifth of the book overall seems to be centered on reiterating the greatness of Phoenix.
Probably my biggest gripe with this book—and with most Phoenix publications out there today in general—is the stream of allusions to Ruby on Rails. The entire introduction is a "why Phoenix is better than Rails" tongue in cheek story. The rest of the book assumes the reader is coming from Rails and explains things in a sort of manner like "this is/isn't like Rails" without actually saying "Rails" but we all know it's Rails that's being referred to. I get that the many of the core team members are former (or sitting in some cases) Rails contributors, but the analogies need to be worked out in a more experience-agnostic way. Personally, I come from a Django background. The text isn't completely unapproachable for a non-Rails dev, but it is annoying to be distracted by "Rails speak" when I'm trying to learn Phoenix.
Otherwise, this is a good introduction to the number one Elixir web framework.
Probably my biggest gripe with this book—and with most Phoenix publications out there today in general—is the stream of allusions to Ruby on Rails. The entire introduction is a "why Phoenix is better than Rails" tongue in cheek story. The rest of the book assumes the reader is coming from Rails and explains things in a sort of manner like "this is/isn't like Rails" without actually saying "Rails" but we all know it's Rails that's being referred to. I get that the many of the core team members are former (or sitting in some cases) Rails contributors, but the analogies need to be worked out in a more experience-agnostic way. Personally, I come from a Django background. The text isn't completely unapproachable for a non-Rails dev, but it is annoying to be distracted by "Rails speak" when I'm trying to learn Phoenix.
Otherwise, this is a good introduction to the number one Elixir web framework.
March 25, 2016
I'm tentatively giving this four stars. I'm tempted to give it three. When I reread the final release, my rating might go up to five stars. I read the Beta 6 version, so it's hardly fair to rate the book on a prerelease version. However, there were a few things that annoyed me.
In my opinion, the book spent too much time explaining the benefits of functional programming. Most readers reading the book are already sold on the "why." Some of the content in the opening chapters was an unnecessary attempt to justify the choice of Phoenix and Elixir. That said, I think the book did a wonderful job of explaining how Phoenix worked at the superficial level. And it was easy to grok given that this is a complicated framework. Much of this owes to Elixir and Phoenix's modular design--the top level isn't hard to understand.
I'm going to reread this now that it reached a release version.
In my opinion, the book spent too much time explaining the benefits of functional programming. Most readers reading the book are already sold on the "why." Some of the content in the opening chapters was an unnecessary attempt to justify the choice of Phoenix and Elixir. That said, I think the book did a wonderful job of explaining how Phoenix worked at the superficial level. And it was easy to grok given that this is a complicated framework. Much of this owes to Elixir and Phoenix's modular design--the top level isn't hard to understand.
I'm going to reread this now that it reached a release version.
April 22, 2021
I'm migrating all my reviews to my blog. If you want to read the full review with my raw notes, check it here: https://pothix.com/programmingphoenix/
It is a great book for web developers learning Elixir (yeah, not just Phoenix).
I'm on the path of playing with Elixir and was looking for a book to amplify my knowledge. I first started with Programming Elixir, from Dave Thomas but I was looking for something more practical.
I decided to try Programming Phoenix and found that it shows everything I need to know about Elixir to build a web application. For me, it was really great to start with this one. Now I know what needs to be done to build a web application and I can go back to programming Elixir to do a deep dive in the language.
It is a great book for web developers learning Elixir (yeah, not just Phoenix).
I'm on the path of playing with Elixir and was looking for a book to amplify my knowledge. I first started with Programming Elixir, from Dave Thomas but I was looking for something more practical.
I decided to try Programming Phoenix and found that it shows everything I need to know about Elixir to build a web application. For me, it was really great to start with this one. Now I know what needs to be done to build a web application and I can go back to programming Elixir to do a deep dive in the language.
Read
October 26, 2015Reviewed version: Beta 2.0
I won't star-rate it, as it's still an early version (part II is far from being finished), but even at this stage I think I already can recommend this book:
* it's the most comprehensive source of information on Phoenix I've found
* it doesn't try to cover the stuff you can easily find anywhere else: like Elixir syntax or MVC pattern
* plenty of code samples
Some things are described better (plugs, how to write them), some a bit worse (changesets) - but even the latter can be easily polished & improved until book is finally published - so for now I don't see any major drawbacks other than the fact that we have to wait a bit more until book gets it final shape.
I won't star-rate it, as it's still an early version (part II is far from being finished), but even at this stage I think I already can recommend this book:
* it's the most comprehensive source of information on Phoenix I've found
* it doesn't try to cover the stuff you can easily find anywhere else: like Elixir syntax or MVC pattern
* plenty of code samples
Some things are described better (plugs, how to write them), some a bit worse (changesets) - but even the latter can be easily polished & improved until book is finally published - so for now I don't see any major drawbacks other than the fact that we have to wait a bit more until book gets it final shape.
September 10, 2018
I just finished reading beta 9 (after stopping and starting with earlier betas). This is a solid technical book that covers enough of the Phoenix framework to whet your appetite for more. It has a good balance of explaining the "why" as well as the "how." Besides explicitly choosing not to give examples of full-stack acceptance testing, I can't think of anything that I feel was glossed over. I feel this is the proper go-to intro book the framework needed.
Now I just need to figure out how to work Phoenix into daily grind. ;)
Update:
I just finished the beta 4 for the 1.4 rewrite and it was still a solid 4 stars.
Now I just need to figure out how to work Phoenix into daily grind. ;)
Update:
I just finished the beta 4 for the 1.4 rewrite and it was still a solid 4 stars.
December 14, 2015
The book was informative and helpful, I read the beta 4.0 version. My only beef is that everything is done for you and there aren't additional exercises. I feel like I learned more figuring out why certain things weren't working properly than reading the book.
That being said, I think the book did a great job of introducing the reader to Phoenix, Ecto, Plug and how OTP will work with Phoenix. Because of the lack of exercises, it is a quick read/study.
I do plan to give this a once over again after the final version is completed.
That being said, I think the book did a great job of introducing the reader to Phoenix, Ecto, Plug and how OTP will work with Phoenix. Because of the lack of exercises, it is a quick read/study.
I do plan to give this a once over again after the final version is completed.
June 27, 2016
Excellent introduction into the Phoenix Web framework, with a modern sample application that shows most features the framework has to offer, including the full stack, Ecto, Channels, OTP and how to test all aspects of an application. It's a very concise, well explained and easily understandable book. It could have been a bit more comprehensive with a few more examples but there is an increasing number of open source projects written in Elixir & Phoenix already available that cover all aspects.
Displaying 1 - 30 of 38 reviews