I have now finished the course completely.

Issues I faced

• I will say, at the time of this writing, you will find quite a number of typos in the text. However, do not despair, the course is of good quality and you understand what the author means from context.
• The Windows experience is quite detrimental. Admittedly, this is not the authors fault, but if you are doing the course on a Windows machine there are some exercises you simply won’t be able to do. This happens because of limitations regarding IEx and the shell. I have reported this and afaik this is being investigated: Autocomplete in IEx broken (on Windows) · Issue #4103 · elixir-lang/elixir · GitHub
• Dave makes a wild trip through Nodes and rpc calls. While interesting as a mechanism to understand how erlang machines communicate, it is something you will very likely never use in your life. The author states the same. In fact, unless you are building your own framework, you really shouldn’t use any of it. This kinda breaks the flow of the course and it was (for me) the hardest part to digest because I knew I was not really going to use it … (and it is also a gatekeeper from the sections that are also the coolest).

Things that I liked

• The humour. I am not sure if it is the fact he is originally British and that I like Monty Python, but I did enjoy it.
• IEx customization. Yah, he mentions IEx customization and shares his own file. It is really cool and immediately motivating.
• Personalized font for your editor. He also shares his cool font , Fira Code which I absolutely love.
• Dialzyer types. He makes a use of the opaque type. When I saw it in the wild I never understood why - but now thanks to his course I do. And I think it makes a lot of sense for functional programming. Overall he covers the basics of dyazlier, which is something I support in any project.
• The architecture. When I first made his course I liked the idea of small apps, but I had never really adopted it. I left it as a cool idea. Years later, I have read a few more books and with this course I got to revisit the idea. I still wonder why he didnt go for an Umbrella, but I can definitely say his architecture principles had a major impact on how I code today.
• Phoenix and LiveView. It is a perfect first dive for anyone wanting to learn. Last year I started a project that I could not complete. This year when picking it up, I found everything had changed in Phoenix and I had no idea on how to start. Now I picked the project and I am close to finishing it. All of it because of Dave’s introduction to both Phoenix and LiveView. I cannot stress how much this helped me.

Cool apps

You also get some cool apps to show off in your portfolio.
I made a Git repo with some of the lessons I learned. I invite you to have a look, maybe this will help you decide if this course is what you are looking for. I can say, it was for me:

I absolutely enjoyed the course and recommend it. For someone who is just 0.000000001% of the world’s population, his opinions resonate with me more than I expected, even years after completing the first edition.

(PS, the population joke is a reference to his course. I guess you now have to buy it to understand what it is all about! Mwuahahahahah).

I can confirm that the new phx.new generators are used in the 2nd edition, but before the switch to HEEx. As far as the course content is concerned though, those are very minor changes that you’d have to do yourself.

Main focus of the course (and main takeaway for me) is the code organization and use of poncho projects. The apps are divided into separate projects and you go through the creation of three different clients (CLI, Phoenix, LiveView) for the hangman game without major changes to the core logic, which is great imho. You also implement a game server as a service that can be run on a different beam instance.

You get a very well thought out but I’d say pretty basic introduction to Phoenix and LiveView. In general, I would see those chapters as a demo for why the separation mentioned above should be considered. Also, there’s no use of Ecto at all, in case that’s important to you. Other than that - I cannot recommend this course highly enough. Fantastic content, well presented with accompanying detailed explanations.

This is a great description of the course! There are plenty of opinions about the best way to organize Elixir projects. But this is great exploration of how and why even simple applications can benefit from a clear separation of concerns.

The latest updates to the sample code does in fact use HEEX templates and sigils. Migrating manually is not very difficult. But it’s still nice and saves time when sample code works “out of the box”.

I also just finished the course. I did not find the typos terribly intrusive and I appreciated that Dave provides a mechanism for reporting the typos directly from each lesson.
I actually really enjoyed the lessons on Nodes and rpc. The topic seems to be the actual killer app feature of Erlang/BEAM but one that is hard to find tutorials on.
I probably benefited most from Dave’s explanation of the architectural choices he made in setting up the app.
I do wish he had at least touched on deployment, or at least building in production versus dev. To be fair though he explicitly states why he does not address it and his point is valid. It seems quite easy to find tutorials and other information on building apps in dev mode but much more difficult to find the same for building production releases and deploying them.
I have paid for a handful of online courses over the last couple of years. Dave’s course is easily the best value of any I have done. He could charge triple and I would have been satisfied with the value.

I have done this course and updated the code to use Phoenix 1.7.2, here it’s the code

Hope it helps