At this point, I'm going to take a pause in learning to take a step back and look at what I've learned and I have left to learn. I feel like I'm reaching the end of the beginner stage of learning Elixir and I'll soon be getting into the intermediate stage.

So far, I think we've probably covered about 85% of features of the core Elixir language. That's just a guess, so I may find out later that there is more left than I expected. :) What we've learned so far has mostly been stuff that's part of the Elixir language and has little crossover into the underlying Erlang environment.

Up to now, we've just covered the core Elixir language and some of the Elixir standard libary modules, but there's much more to Elixir than that. There's the rest of the Elixir standard library, the Elixir tools, and all the stuff that is part the Erlang environment and the accompanying OTP conventions and functionality. This includes all the concurrency stuff that makes Elixir so interesting.

We'll be getting starting to get more into the intermediate to advanced functionality, which is not contained entirely within the Elixir language, but is a product of integration between Elixir and the functionality in the Erlang VM. Much of this stuff is common to both Elixir and Erlang. Elixir has some nice interfaces and keywords that allow easy access to this functionality in a way that almost invisibly integrates it into Elixir, so it isn't obvious that we are using Elixir features that extend beyond the core language into the Erlang VM. Much of the functionality we will be learning predates Elixir. It's the combination of the Elixir language and tools and the nice features of the Erlang VM environment that has lead to the increasing popularity of Elixir.

So in the future, we'll continue to learn more about the Elixir standard libraries and the language features I haven't learned about yet, but we'll also be branching out into learning about the Elixir tooling and the functionality that comes from the Erlang VM and OTP. I think this is where it will start to get even more interesting than before.

Here are some subjects that I'll be learning about in the future in no particular order. I know very little about these at this point other than they exist.

  • Elixir Projects
  • I/O libraries
  • Concurrency
  • Processes
  • Tasks
  • Agents
  • Servers
  • Macros
  • Protocols
  • Type Specifications and Type Checking
  • Unit Testing
  • Documentation
  • Automated Source Code Formatting
  • Running and managing applications
  • Elixir packages

There's no doubt other stuff I'm completely unaware of at this point.

The amount of stuff I still have to learn is daunting, but I'll get there eventually. I feel like I've only understand a very small piece of it so far. I just have to be patient and make sure I take the time to practice what I've learned. Without being able to use what I've learned and learning from my mistakes, I don't feel like I've truly learned it.

I'll also be engaging in more projects, both small and large, to practice what I've learned so far. What I've done so far has been mostly confined to IEx sessions and a few code files, and I expect those to still play a role, but I'll be also working on some larger-size projects.

I expect the frequency of posts in this series will decrease as I get into the more complex subjects, and as it takes significantly more work and effort to understand and explain concepts. It's a lot more work to create a working project than it is to quickly create some examples in IEx. I also expect that it will require far more time to create and debug projects as they grow in size.

So I'm looking forward to the next phase of Elixir learning, and I hope you'll keep following along!

If there's any particular Elixir topic you're particularly interested in me learning and writing about about, send me an e-mail at I probably won't get to it right away, but I will tend to learn a topic sooner if I know someone else is also interested.

Doing a lot of web development, I definitely will get to learning Phoenix as soon as I feel I have learned enough about the underlying concepts. I tend to like learn the fundamentals first so that I better understand what's happening in frameworks that are built on top of those fundamentals.