Is anyone finding it difficult learning Elixir or Phoenix?



I think Elixir itself is not hard to learn, I would say it was quite easy as everything is well documented and there are plenty of good resources, but not so many that you get confused. For example in Javascript or PHP even more, there are so many articles with very questionable content, because there are just so many people producing it. Here generally everything is really well documented so you don’t need to search for external resources.

For me the hardest part was getting into functional mindset and how to design applications/libraries. I didn’t find much resources on this topic, so I read some other languages articles discussing this and actually found that most high level principles are actually the same. The problem was that I expected everything to be different.


I’m learning Elixir while I learn Phoenix. I’m thrilled and really want to get better. I have experience with Javascript (mostly frontend).

The most challenging part is the lack of up to date and beginner friendly resources. :confused:



Welcome aboard! Have you been thru the Phoenix getting started guides? Were there gaps that left you behind, or did they not go far enough? Would love to know how we can improve <3


Just an FYI, most of the older tutorials and guides are still compatible with the current version of phoenix.


Yeah, I have all the books except for Ecto Cookbook. It’s been awhile since I looked at it because I tried emailing the author about a problem that I had and never got back an answer so I kind of rage quit after that. It was about the acceptance tests not working with Hound but this was awhile back and I’m willing to bet something has stabilized by then so I’ll try looking over everything again while it’s the weekend.


@kennethuy Interesting. I recall that I was getting some kind of error with Hound, and it went away when I installed phantomjs via npm, instead of apt-get, because apt-get was installing version 1.9, at the time (about a year ago). Using npm installed version 2.1. So you might try using npm -g install phantomjs-prebuilt (you might need sudo), instead of sudo apt-get install phantomjs (if you’re on Ubuntu), as instructed in the book. However, like you said, things might have stabilized, by now, and either command might be fine, now.


Hello @chrismccord, thanks for chiming in!

Yes, I’ve read the guides on the official site, they are well written and well structured (thank you for that) - I’m also complementing my learning with Programming Phoenix 1.4 (currently in Beta in PragProg).

The information I’m specifically looking for is related to how to build REST APIs; I know that I could use most of what’s in the official documentation, but sometimes it feels like it’s too much information to digest if I only need to build APIs - Also, I don’t have plans to build a complete site (backend + frontend) using Phoenix at the moment.

Thank you very much, and let me know if I can help with something else!

Looking forward to your response :slight_smile:


Also, I consider that I learn more by doing, so having a small project around building something close to real world with best practices will be golden.

I know that building that kind of tutorial is quite difficult and time consuming - please don’t feel like I’m demanding it or something like that :smiley:


+1. I could be wrong but I don’t see any Phoenix samples included. I was looking at the Iris framework recently and the collection of examples is really impressive (still prefer Phoenix though :wink: ) .


My background is with JS, Rails, MySQL for medium sized projects. (Clients with approx GBP 50M turnover)

Moving from the above to Elixir the biggest challenge for me has been getting my head around Functional Programming. I’ve read a lot of stuff on the subject and every time I think I’ve ‘got it’ and then try putting it into practice I’m struggling.

I think what help me would be a guide which showed various software patterns in a procedural (pseudo) language and then an equivalent FP version. That would help immensely.


In my view it simply doesn’t work that way

  • the core of procedural/imperative programming embraces mutability and iteration
  • the core of functional programming embraces immutability and recursion

So the constraints are quite different which means that a different way of doing things is required - so the mindset for the functional way needs to be built from the ground up - typically starting with tuples, lists, how to operate on them and how to compose them. Ultimately I suspect that is what Learn Functional Programming with Elixir (Pragprog) is for.

Every once in a while there seems to be an equivalency like that the strategy pattern is the OO equivalent of higher order functions - but those are few and far between.

Scott Wlaschin’s Functional Programming Design Patterns is a great talk the should be regularly revisited.


@peerreynders Many thanks for your response. I already have the Pragprog book that you mention. As I said, each time I read this stuff it makes sense but when I try to put it into practice I struggle.

Perhaps I’m too far gone done the imperative route to change tracks. I do hope not.

I do understand what you are saying about there not being easy x-refs between FP and imperative.

Oh well I’ll just struggle until it falls into place.


It’s simply a matter of determination - unlearning acquired habits can require significant effort.

I’ve been “visiting” Haskell since ~2000 and while early on that introduced me to the idea’s of fold, map and filter it just seemed too strange from where I was at (C, C++, Java, C#) to feel that I could “program Haskell” when I hit Real World Haskell (these days go straight to Haskell Programming from First Principles).

Even followed F# since 2005 - but in hindsight I believe its association with the .NET framework made it too easy (and to some degree necessary) to stick to the old imperative habits (straight OCaml may have been a different story).

So it wasn’t really until about late 2015 when I tried Clojure that things started clicking. It embraced immutability and I wasn’t getting bogged down with adapting to a real type system (classes aren’t types etc.). So I’m inclined to say that one may need to find a language that is different enough to keep one away from those old habits (e.g. Racket) while not going so far that you are totally lost (e.g. Haskell).

To a certain degree Elixir’s Ruby-like syntax and name rebinding can make a certain imperative style more easily possible. So if you do find that even after Learn Functional Programming with Elixir (Pragprog) (though doing the exercises should certainly help) it doesn’t quite click maybe take a detour into Erlang - to move into even more unfamiliar territory - like with Learn You Some Erlang for Great Good!.

Other than that seek out small focused katas - some people seem to like to learn more by doing.


Hi @nexar, I found the first half of Dave Thomas book Programming Elixir (Pragprog) invaluable as a Ruby developer to initially “get it”. As @peerreynders alluded to it is best done from the ground up focusing on data structures, immutability, recursion, and pattern matching. It took me a little time to think in terms of map, filter, reduce and recursion instead of imperative for loops relying on mutable index but in his book he has a lot of exercises for each chapter which really helped speed up the learning process.


I believe a HUGE part of my problem is that I still need to work with my current toolset on a day to day basis and therefore switching between the 2 different paradigms is perhaps proving more difficult than it needs to be. I’ve some ‘holiday’ time coming up which I hope to use to immerse myself in FP and see if that complete divorce from the ‘old ways’ will help.

Many thanks for all your comments and suggestions.


Although I am not an expert with JS and had (I think still have) some issues grasping asynchronous JS, I would complement @peerreynders links with these that I found a month ago and helped me a lot:


I guess one of the most difficult things in Elixir (and Erlang) is to accept and adopt the “let it crash” philosophy/mindset, it’s just so different from any other programming language. The concept itself is simple though.


Sorry it’s taken me so long to get back to this! But I have finally put up my thoughts/tips for learning :smiley:

Hopefully it covers the two points I touched on in the original post of this thread:


I found out my lack of patient in reading the document have caused me to make several false statements about phoenix.

One such false statement was how scatter the information is to add role. Yet the package I’m using, Coherence have a doc on the github page which give an example of using Canary package in tandem to Coherence to do exactly what I want. To be fair this is only on github it doesn’t seem to be on hex.

I think I should be blogging about what I’ve encounters and solutions as a newbie to help other people new to phoenix.