The Pragmatic Studio
🥳 All courses 40% off through Dec. 2! Use coupon code 2024THANKS.
Sale ends in
days hrs mins

Elixir & OTP

Elixir 1.17

Learning a functional language may seem daunting, but what if it was delightful instead?

This is by far one of the best tutorials I've ever paid for! So many other tuts just cover the basic entry level things such as types and immutability along with building a toy application (no real world basis). Building the HTTP Sever was excellent because as it shaped up I was like, 'We are building a rough draft of Phoenix'.”

Cody Brunner Cody Brunner

Elixir is a fantastic functional language that's practical, enjoyable, and easy on the eyes. 🤩

But it's more than just syntax sparkle and cool language features.

What sets Elixir apart is that it runs on the BEAM (the Erlang VM).

And the BEAM totally rocks.

It was designed specifically for creating scalable, fault-tolerant systems. Spinning up a million supervised processes is just table stakes for the BEAM. After decades of production use, it's still the undisputed king of reliability. 👑

And then there's OTP.

It's a set of battle-tested abstractions for building highly concurrent, distributed applications. GenServers and Supervisors are the two main workhorses. The OTP libraries give you a huge amount of leverage.

Elixir + OTP + BEAM = 💜

Indeed, Elixir is uniquely positioned for building today's demanding systems.

It's a versatile language with many real-world uses:

  • real-time, interactive web applications with Phoenix
  • machine learning and concurrent data processing systems
  • high-volume request and messaging apps
  • and even fleets of IoT devices managed by Nerves

Aside from that, adding Elixir to your repertoire will make you a more well-rounded (and employable!) developer. 🤓

Sounds pretty great, right?

And it's tempting to jump straight into Elixir and hope for the best.

But that's like being airdropped into a foreign city without a map or translator.

Haphazardly trying to "feel" your way around a new language is disorienting and frustrating. You don't know where things are or how things are connected. So you bounce from one topic to the next hoping to fill everything in. But you just end up with learning gaps that become pitfalls when you try to build something real with Elixir.

At the worst, you simply give up.

At the best, you copy-paste code without knowing how or why it works. 🥲

Imagine writing Elixir as effortlessly as any other language in your toolkit.

Everything would finally click:

  • You'd know all the idioms and best practices.
  • You'd confidently design code in the spirit of Elixir.
  • You'd wield all the power of OTP.
  • Writing Elixir would be fun, not frustrating.

“Best zero to hero course I've ever taken!”

Jake Wood Jake Wood

This comprehensive course has everything you need, in the right order, and in one place! 👍

No need to scour the web and waste your time piecing together resources. We distilled everything you need to know about Elixir and OTP into an approachable and—dare we say—pragmatic video course.

Our course has worked for thousands of developers because it builds an application step by step in a clear, logical progression.

It starts with Elixir fundamentals and gently builds up to the OTP abstractions so you know when and why to use them. And yeah, there are a few bad puns along the way, but we do try to make it fun. 🤪

The level of depth that the course goes into is insane. Anything that seemed like magic before has been entirely explained in such a clear way that I feel like I would know exactly when to use the features and even have ideas of real world implementations in my head now.”

36 Videos • 6 Hours

We build an app feature-by-feature in the videos so you see and understand exactly how it's done. Each live-coding video is:

  • tightly-edited to respect your time
  • straight to the point without any rambling or fumbling
  • perfectly paced so you're not left behind or nodding off
  • streamable with English subtitles and also downloadable
Module-21 Module-29

“In other courses, I just learn how to use Phoenix, GenServer and Supervisor like magic. Here I learned the foundations, how those components were built, and how it works under the hood. This course was awesome!”

Maxsuel Maccari Maxsuel Maccari
Animations

Seeing code is hardly enough. You also gotta see the big picture. Each of the 22 visual explanations throughout the course give you:

  • a solid mental model for how everything fits together
  • a visual explanation that takes the mystery and magic out of OTP
  • the key to becoming the magician rather than the mystified
Animation-1 Animation-2

“I loved the graphics that were used to introduced concepts, the practical examples, and how it all demonstrated the features of Elixir in a way that removed the magic surrounding things like supervisors, GenServers and routing that is used in Phoenix.”

Brendon Otto Brendon Otto
Source Code

Of course you get all the source code for the final app, and also versions of the app for each course module. Yup, that includes the tests, too!

Exercises & Notes

You need deliberate and directed practice to make all this "stick". That's why you also get a workbook with 56 guided exercises and supplemental notes. Each hands-on exercise:

  • immediately reinforces what you learned in the video
  • includes the solution, of course
  • spotlights handy tips and tricks
Workbook-1 Workbook-2

“I've worked with Elixir for a couple years now, but learned more in your course than I did in all the other Elixir books I've read. It is far superior to other guides which tend to cover a broad range of things and make it hard to associate the content with real-world problems. Each new idea, technique, feature and library in your course was introduced at relevant points that really helped me connect the dots.”

Rocky Neurock Rocky Neurock

Course Outline

Videos just the way you like 'em: easy to digest, straight to the point, and paced for experienced developers.

1 Intro and Setup Watch

Welcome! After taking a peek at the type of app we're going to build in this course, we'll help you get your development environment set up so you can start coding Elixir.

Module-1
2 Create a Mix Project Watch

Elixir has conventions for organizing projects and great tooling to automate project tasks using mix. We'll get a quick lay of the land, learn various ways to run Elixir, and jump right into code!

Module-2
3 High-Level Transformations Watch

Our web server will make three high-level transformations—parsing, routing, and formatting a response—with each step being a function. We'll set up an initial pipeline using modules, named functions, strings, maps, and the pipe operator.

Module-3
4 Pattern Matching Watch

To transform a request into a response, we first need to parse the request string into a more usable data structure. This presents a great opportunity to learn the match operator, pattern matching techniques, atoms, and built-in functions.

Module-4
5 Immutable Data

Formatting the response string takes us deeper into Elixir maps and introduces us to programming with immutable data, which is a hallmark of functional programming.

Module-5
6 Function Clauses

In Elixir you don't use conditional expressions as often as you would in imperative languages such as Ruby. Instead, it's more idiomatic to control the flow of a program using function clauses and pattern matching. Routing HTTP requests gives us an ideal context for learning how to design code in this declarative style.

Module-6
7 Advanced Pattern Matching

Designing a web server presents interesting scenarios that let us explore many of Elixir's features. How do we handle a request that has parameters? What happens if a route doesn't match? And how should we respond? The solutions require more pattern matching techniques and multi-clause functions.

Module-7
8 Pattern Matching Maps

Once we have requests flowing through a pipeline, we can plug in specialized functions that transform requests and responses in unique ways such as rewriting paths and tracking 404s. By pattern matching maps we can run these functions conditionally—a powerful techniques that's used extensively in Elixir applications.

Module-8
9 Serving Files

Even something as familiar and straightforward as reading a file involves pattern matching. Serving static files, and properly handling successes and failures, introduces us to tuples and case expressions.

Module-9
10 Module Attributes

Sometimes you need to attach metadata to a module, be it for documentation or to squirrel away a compile-time constant. In this section we use reserved and custom module attributes.

Module-10
11 Organizing Code

Modules let us organize functions with similar concerns in a namespace. We'll co-locate related functions in properly named modules, put them in separate files, and knit it all back together using aliases and imports.

Module-11
12 Modeling with Structs

One of the benefits of modeling our request/response conversation as a struct (as compared to a generic map) is we can ensure that the functions in our pipeline always get the expected type. In this section we compare structs vs. maps and refactor our design to use a struct.

Module-12
13 Matching Heads and Tails

Handling a POST request means we have to take into account the list of request headers and the POSTed parameters. To do this, we'll process the request by matching head and tail patterns: a technique used pervasively in Elixir apps.

Module-13
14 Recursion

Recursion makes Elixir go 'round and 'round. You've no doubt seen simple examples of recursion, but what about real-world use cases? Turns out, recursion is exactly what we need to parse the HTTP headers in our POST requests. And while Elixir has convenience functions that often let you sidestep using recursion directly, Elixir pros know how to use recursion to their advantage.

Module-14
15 Slicing and Dicing with Enum

You'll find familiar high-order functions in the Enum module for transforming data. But to use them effectively you need to be comfortable with anonymous functions and how to capture functions. We also put guard clauses to good use as our application begins to take the shape of a familiar web framework.

Module-15
16 Comprehensions

Now it's time to generate dynamic content by reading and evaluating template files. We make quick work of this using comprehensions to iterate through collections of data and generate HTML.

Module-16
17 A Peek At Phoenix

Since Elixir is the language you use to build Phoenix web apps, a peek at a Phoenix app reveals a lot of familiar syntax and design concepts. Alas, you discover there really is no magic after all!

Module-17
18 Test Automation

It's time to automate with ExUnit tests! We look at two different ways to write unit tests, and various ways to run them. By the end we have green dots across the board.

Module-18
19 Rendering JSON

To build a JSON API, we install an external JSON library and use it to render JSON and handle POSTed JSON data in response to API requests.

Module-19
20 Web Server Sockets

Now that we have a fully-functioning HTTP request handler, it's time to write a TCP socket server so that any HTTP client can interface with our application. To do that, we use Erlang's gen_tcp library and learn how to transcode Erlang to Elixir. Cue the browser!

Module-20
21 Concurrent, Isolated Processes

At this point our web server can only handle one request at a time. We need a way to handle multiple requests concurrently and also isolate the failure of one request so it doesn't affect other requests. Concurrent, isolated processes are what set Elixir apart from other functional languages! We also look inside the Erlang VM to see how it takes full advantage of multicore computers to achieve remarkable levels of concurrency and parallelism.

Module-21
22 Sending and Receiving Messages

So if processes are isolated and run concurrently, how do they communicate? Just like people! They send asynchronous messages to each other. In our app, we spawn a series of API requests that run in independent processes. They send back their results as messages to be received by the request-handling process. We also look at how to avoid unwanted synchronization points in our code.

Module-22
23 Asynchronous Tasks

With several one-off asynchronous tasks now running and getting results at a later time, we're starting to see a definite pattern. In fact, running functions (or tasks) in a short-lived process is so common that Elixir provides a helpful abstraction: the Task module. By the end you'll know how the Task module works under the hood.

Module-23
24 Stateful Server Processes

Now we turn our attention to long-running server processes that manage internal state and respond to various messages. We build up from a basic receive loop to a client API that sends synchronous and asynchronous requests to a registered server process. Along the way, we see how a server process preserves the integrity of its state while under load from multiple concurrent client processes. By writing a server process from scratch, we begin to demystify the "magic" of a GenServer.

Module-24
25 Refactoring Toward GenServer

Looking at our stateful server process, we see two flavors of code: code that's common to all server processes and application-specific code. So what happens when we move all the common code into a generic module? Well, we're not the first ones to have that idea! GenServer is a design pattern (an OTP behavior) that helps us write server processes with greater ease. By refactoring our server process, you'll come away with a better understanding of how (and why!) GenServer works.

Module-25
26 OTP GenServer

When you're starting out with Elixir, writing a GenServer can be confusing and it's tempting to just cargo cult from example code. But we want you to feel really confident, so we've been incrementally building up to using a GenServer. Spoiler alert: Now that you understand the underlying design pattern and how it's implemented, actually using a GenServer is a snap! Besides converting our app to use a GenServer (and eliminating a bunch of code!) we also add new application-specific behavior to our GenServer.

Module-26
27 Another GenServer

As another practical example of when and how you'd use a GenServer in a real application, we write a server process that performs background work on a periodic interval. This lets us explore the power of the handle_info callback in greater depth so you can take full advantage of all that GenServer has to offer.

Module-27
28 Linking Processes

At this point we have three server processes that should run continuously without missing a beat. Alas, things don't always go according to plan! We need a way to monitor the server processes and recover when trouble strikes. To do that, we start by linking processes, which is fundamental to understanding how the OTP Supervisor behavior works.

Module-28
29 Fault Recovery with OTP Supervisors

Normally, designing an application that's resilient to failures is a tall order. With other languages, the best you can do is to code defensively. Elixir is different: it frees you to "let it crash." That's only possible because OTP Supervisors offer unparalleled support for detecting and recovering from process failures. Indeed, Supervisors are the key to building high-availability, fault-tolerant systems. We design a supervision tree so our application can elegantly recover from unforeseen failures.

Module-29
30 Final OTP Application

Up to this point we've been using the term "application" fairly loosely. But an Elixir application is a first-class OTP entity. We look at how an application works behind the scenes, and then specialize the OTP Application behavior to start our supervision tree.

Module-30

“This was by far the greatest single course I've ever watched start to finish (it was just that good)! This course sets the bar like none other.”

Toran Billups Toran Billups

Get started today!

No monthly subscription or time limit. You own it for life.

Full Course
Developing with Elixir/OTP
  • 36 videos (6 hours)
  • 56 exercises
  • Lifetime access
$165
Only $99 during sale!
Best Deal
2-Course Bundle
Elixir and Phoenix Bundle: Both courses
  • Elixir Course
  • Phoenix Course
  • 94 videos (14 hours)
  • 110+ exercises
  • Lifetime access
$465
Only $279 during sale!

Questions? Email Mike and Nicole.

There's no risk. This course is 100% guaranteed for an entire 30 days. If you find it's not a good fit for you, we'll be happy to refund your money.

Live in a country where our courses aren't affordable? We offer purchasing power parity discounts.

“The way that you start off with plain ol' Elixir and build up to the point where we need the things that you are explaining is brilliant! Before long I was starting to deeply understand things that I'd been taking for granted like processes, tasks, and GenServers.”

Alan Gardner Alan Gardner

For Developers New to Elixir

No functional programming experience required.

To keep this course focused and paced just right, we assume you've programmed in another language.

With that background, you definitely don't need a whole video on Elixir numbers and strings. Reference courses like that are booooring. But you also don't want to jump right into asynchronous messaging between two supervised GenServers. Whoa, that's totally frustrating too.

When a course makes the wrong assumption about your experience and the pacing is flawed, you're left hung out to dry.

Most courses have the wrong pace for experienced devs. Yours is balanced perfectly (enough detail to learn and not get lost, but also a relatively fast pace and focus on idiomatic aspects).”

This course aims for the sweet spot by:

  • taking a practical project-based approach, not a sluggish syntax-approach
  • deconstructing the underlining principles before introducing abstractions
  • assuming you have programming experience, just not with functional programming or Elixir

“I loved this course! It really hit the sweet spot of teaching me Elixir and OTP. Building a web server from the ground up really helped me to understand how Elixir apps fit together.”

Michael Twomey Michael Twomey

Created with 💜 by
Mike and Nicole Clark

Mike and Nicole

Howdy! We're the friendly couple behind The Pragmatic Studio.

We've been making courses for developers since 2012. It's a privilege to get to teach together and serve everyone who supports us.

We've been using Elixir since the early days. Initially we struggled because every book and course felt either mind-numbingly slow or mind-blowingly fast. We made this course to give developers an approachable, pragmatic, and enjoyable way to learn both Elixir and the OTP libraries.

We hope you enjoy it!

Thousands have loved learning Elixir using this course!

Here's what some of them have to say…

Garrett Julaka
I have a MUCH better understanding of Elixir and all the intricacies of the language after this course! Both the videos and exercises were easy to follow and helped demystify a lot of things. It was a great course, very enlightening, and enjoyable humor too. I would definitely recommend it to anyone getting involved with Elixir.” Garrett Julaka
Gabe Lafontant
I loved everything about this course, especially how you build out the behavior provided by the OTP library in order to understand what is happening underneath the hood. It was very useful in order to grok GenServers and Supervisors. Over the years you have helped me progress in my career as a programmer. I don't know where I would be without your courses. Thank you so much!” Gabe Lafontant
Allan Egidio
Best course of my life! I really learned all the key concepts of the Elixir language as well as how the things works behind scenes.” Allan Egidio
Marlo Major
“It's incredible the way you break down a concept and explain it! Love your content so much!Marlo Major
Tony Stenberg
“This is by far one of the best courses I have ever taken! It is so incredibly thought through! I absolutely loved that we built the HTTP stuff almost as Phoenix names things.Tony Stenberg
Benjamin Patton
“I love that this course starts out with basic concepts that are core to Elixir and by the end we're setting up OTP supervisor trees and working with processes and understanding how it all works. It was truly mind blowing! Also, as an instructor myself, this was an education in great instructional design.” Benjamin Patton
Weronika Łabaj
“I wish I found these courses when switching to RoR. After a few videos it seems like my dive into Elixir will be waaaay easier (even though I hate video courses in general)... Most courses have the wrong pace for experienced devs. Yours is balanced perfectly (enough detail to learn and not get lost, but also a relatively fast pace and focus on idiomatic aspects).” Weronika Łabaj
Toran Billups
“This was by far the greatest single course I've ever watched start to finish (it was just that good)! This course sets the bar like none other.” Toran Billups
Łukasz Mikołajczak
I have ~10 years of experience as a software engineer/developer and this is the best online video course that I ever tried and finished from cover to cover (usually I prefer books and documentation). It was clear, concise, and covered the most important topics to help me to systematize my Elixir knowledge. It also helped me to pass job interviews for Elixir/Erlang related roles. :)” Łukasz Mikołajczak
Angelo Albiero Neto
“I have to say that a big part of why I'm so excited about Elixir was because of the great/amazing online course Elixir + OTP from @pragmaticstudio. The program and the instructors are really top notch. Highly recommended!Angelo Albiero Neto
Josef Richter
“Best course I've ever taken. Even if Elixir is not your weapon of choice, this is a fascinating journey over some incredibly powerful concepts and ideas, that will make you a better developer. Amazing. 🙌  Always hated learning the language before "doing stuff", but this one makes it super interesting and very clear.Josef Richter
Samuel Toms
“I love this course! The presentation style is genuine and warm, and left me feeling those definite 'ah ha!' moments when something clicked. I also really appreciate that it's concise and didn't get bogged down with details superfluous to the objective. The notes were also great at calling attention to key points and elaborating where necessary.” Samuel Toms
Ragheed Al-midani
“I really got a lot out of this course! I've used Elixir/Phoenix for 2 years professionally, but always wondered how the system worked under the hood. The example project, lesson delivery, and great sense of humor make for a very educational, engaging, and enjoyable Elixir course!” Ragheed Al-midani
Slobodan Erak
“I gained so much knowledge from this course in just a few days, way more than I learned from jumping between different documentations in the past few years!” Slobodan Erak
Bill Peregoy
“I'm so impressed with the @pragmaticstudio Elixir course. They show you how to build parts of Phoenix/OTP rather than just how to use them. [The course] is also great for learning best practices for designing and refactoring Elixir APIs. The @pragmaticstudio Elixir course is worth much more than the purchase price. If you want to get deeper into Elixir, you should own it! Really awesome learning experience!” Bill Peregoy
Rajesh Pillai
“This is an absolutely amazing course! Each lesson is concise and to the point. The content is presented with relevant conceptual background and the concepts incrementally build lesson by lesson. It's the perfect blend of basics to intermediate topics covered in a very succinct and easy to understand way. Rajesh Pillai
David Gunter
The concise introduction to OTP was the biggest benefit I got from this course! I was a little intimidated by OTP and the concurrency methodology coming into the course. Even though I had some experience with Elixir, this course helped me understand, end-to-end, how Elixir fits into modern web architectures.” David Gunter
Ralph Bankston
“Learned a lot from the pragmaticstudio [Elixir course] and couldn't recommend it highly enough.” Ralph Bankston
Mariano Colabraro
This course was so much fun! The course evolved smoothly from "hello world" to the full application. The speed of the course was great, the sizes of the chapters were perfect, and the exercises were helpful. And I love the sense of humor you two have!” Mariano Colabraro
Kim Godard
“The way you built an application piece by piece worked really well. This is my favorite way to learn a language, and building an HTTP server was an ideal project for learning Elixir's full range of capabilities. This is one of the best video courses I've ever seen!” Kim Godard
John Joseph Sweeney
I've read almost 3 books on Elixir yet this course taught me small tricks that I didn't know before. I attribute that to the realistic project that is being developed throughout the course instead of the typical book-style teaching in which the language features are presented almost like documentation. This course is taught with just the right amount of detail and speed, and the realistic example project really helps to solidify the concepts being taught. The course notes are well thought-out and thought provoking in that they anticipate questions a developer may have which extend naturally from what is being taught, especially questions like 'could I do this a different way?'” John Joseph Sweeney
Franco Catena
“The course was great! I'm starting on Elixir (coming from Ruby) and the course helped a lot. Awesome work! It's worth every cent and, most importantly, every second spent watching it!Franco Catena
Nathan Hopkins
“The @pragmaticstudio course on Elixir/OTP is excellent. They walk you through creating a lightweight version of the Phoenix router, controller, view & templates... so you gain a better understanding of how @elixirphoenix is built. Highly recommended.Nathan Hopkins
Justin Walters
This course gave me a much deeper level understanding of how Elixir as a system operates in a way that probably would have taken me months of reading docs and experimenting. I had always heard Elixir/Erlang/OTP was great for concurrency and fault-tolerance, but now I understand why. It was kind of a mind-blowing experience for me when it started to click how all the process and supervision tree stuff fits together. Another thing I really liked is that we were writing code throughout the entire course. I'm a learn by doing kind of person. Other courses spend too much time explaining theory without delving into application. I really enjoyed how every module we built not only built on previous lessons, but set us up for the next lesson. I definitely got my money's worth.Justin Walters
Edison Yap
Loved the Elixir course! Amazing flow! I really loved how you took the time to explain things that matter (without glossing over small details) and that we basically built GenServer from scratch. This gaves me a much much better understanding of how Elixir/Phoenix works.” Edison Yap
Steve Corona
“@elixirlang is the coolest tech I've using lately. Not 100% sure if I find it more enjoyable than Ruby, but mind blowing idioms + so fast. Best I've found to learn is the course by @pragmaticstudio...project-based always works better for me.” Steve Corona
Alan Gardner
“What a fantastic job you've done with the Elixir course. I was a little reticent at first to buy the course because I've been doing Elixir for almost 4 years now, including a couple of production apps, but I needn't have worried. I was soon picking up things that had passed me by. Before long I was starting to deeply understand things that I'd been taking for granted like processes, tasks, and GenServers. The way that you start off with plain ol' Elixir and build up to the point where we need the things that you are explaining is brilliant! The way you introduced GenServers in particular is perfect.” Alan Gardner
Jørgen Orehøj Erichsen
Excellent explanation of Elixir and OTP concepts” Jørgen Orehøj Erichsen
Jacob Atzen
“I really loved the explanation of the various parts of OTP / Tasks / etc. I've been trying to wrap my head around GenServer, Task, Agent, and Supervisor. This course finally made these things click for me! I especially liked the way you made your own variant of GenServer first and then moved from there to using Elixir's version. At that point it finally dawned on me that it's all just functions, not magic!” Jacob Atzen
Paul Fioravanti
I really enjoyed this course and will recommend it to any budding or experienced Elixir devs. I liked the project-focused lessons and the pacing of progression through Elixir fundamentals within the context of building an app. The animations were great and really served the course explanations well. And the sections towards the end dealing with Tasks, Agents, GenServers and Supervisors were all excellent!” Paul Fioravanti
David Tang
Really enjoying the @pragmaticstudio Elixir course. It doesn't waste any time. The notes add extra interesting tidbits and the exercises allow me to practice. I also like that the main thing built is a web server, which gives some insight into Phoenix. Highly recommend!” David Tang
Johannes Rubenz
“I have done all your courses, but I think this is the best one, which is quite staggering as all the other courses were top-notch, too. I liked how you unpacked existing libraries and especially the Phoenix framework. It was a wonderful experience to see how all the things you carefully set up came to together. Also, the notes were not just summaries but contained so much valuable extra information. So well done!” Johannes Rubenz
Nathan Queija
“Awesome work! Definitely the best resource that I've found on Elixir. Can't wait to start the next course!” Nathan Queija
Eleni Lixourioti
“Even though I'd used a bit of Elixir / Phoenix before, it was super helpful to build these Elixir features from the ground up in your course. I got a much better understanding of how things work under the hood. Your attention to detail is unparalleled and the course was engaging and fun. Thank you for the great quality course..” Eleni Lixourioti
Chase Pursley
“I've been working with Elixir for two years now but never had the need to dive into OTP much. This course absolutely exceeded my expectations. Building up a web framework from scratch was quite an eye opener. I only wish I took it sooner!” Chase Pursley
Andrés Felipe Gallego S.
“Thanks for the way that you make learning Elixir a joy! I really like the way you explained the topics and helped me understand how things work under the hood.” Andrés Felipe Gallego S.
George Millo
“I'd already learned a bit of Elixir but this course solidify my understanding and demystified OTP. I don't normally like video courses for coding, but yours was highly professional and explained the concepts very well. Well worth the money.” George Millo
Ian MacDonald
“I was familiar with Elixir coming in, but this course removed the veil of "magic" that hid the inner workings of an Elixir or LiveView application! The course was great at breaking down complicated topics into easily digestible chunks, and the extra practice in the notes reinforce everything covered.” Ian MacDonald
“Really well done course! The recursion explanation was the best example I've come across for us newbs. I like how it was built step-by-step with output, never rushing the discussion.” Dan McHarness
“I've stuck my toe in Elixir before, but this course really made it click for me. I loved that everything was built from the ground up. So rather than simply saying, "Here's what a GenServer is and how it is used" we built our own version - running into problems, coding solutions, and eventually understanding the entire thing. Then, it was just a matter of moving it over to GenServer. I feel much more confident that I could jump into Phoenix now that I understand Elixir and OTP better.” Josh Cochran
“I also appreciate the way you made the learning curve into a learning line. What I mean is that each new step feels like a consistent and comprehensible increase in complexity. It is not 'Lecture 1: 1 + 1 in Elixir. Lecture 2: Asynchronous messaging between statefull processes'.” Ondrej Pinka
“This is one of the best courses I have taken in my life! It's concise and covers the most important topics about Elixir and OTP and has a lot of exercises. The notes are fantastic and the instructors are so captivating, with a great chemistry between them. What a pleasure it was to take this course!” Francisco Breno Barbosa Soares
Two things made your Elixir/OTP course stand out compared to the other numerous online courses I have gone through. First, your top-level discussions of Elixir as a language and its design principles were excellent. These concepts are difficult to communicate, and you really excelled here. Secondly, you did not skimp on any of the important details nor did you get bogged down on unnecessary minutiae. This is a hard balance to strike, but you all really nailed it!” Johan Uribe
The flow of this course was very well thought out, and the material was presented at a pace that was just right. Mike and Nicole did a great job avoiding tangents and minutia while still conveying the necessary information. I’m very pleased and glad I bought this course!” Ed Barstad
“I am a Pragmatic Studio alumn and have always thought the quality of their courses is top notch! Mike and Nicole's style is really friendly, welcoming and easy to follow. The pace is great with short videos that tackle one thing at a time. Very much like functions (wink).” Miguel Barcos
“What I liked best about this course was that we built our own implementations first, before using the built-in Erlang/Elixir solutions. Keep on making awesome courses and I'll keep buying them!Bas Bloembergen
“What an excellent course! Right when a question came to mind, you cleared it up, plus a little bit extra with all the gotchas. I originally hadn't planned to use Elixir any time soon for a real project, now I can't wait to use Phoenix and LiveViews for my next project.Thomas Keppler
Ramón Pin
I generally hate online courses because they pass over the materials too quickly and do not teach me anything useful. But this course is totally different. I LOVE IT!! The pace is just perfect and I really love how you teach first principles before introducing OTP abstractions. I never learned so much with so little effort.” Ramón Pin
Jake Wood
Best zero to hero course I've ever taken!Jake Wood
Bob Nadler
I loved the deep dive into the inner workings of Elixir, specifically around GenServers. I already had some experience with the language, but this course helped me understand the intricacies of GenServers and how they contribute to the robustness and scalability of Elixir applications. The clear, well-structured progression of the course made it easy to follow along. I learned a lot!” Bob Nadler
Sofia Simanke
“The way this course gradually ramps up in complexity is amazing! I had no trouble keeping up with any part of it even as it got more and more complex, despite being a beginner. I learned so much doing this course, on HTTP servers in general as well, not just Elixir specifically.” Sofia Simanke
Szymon Jednac
I assumed this course would be super basic... and boring, but I was completely wrong. I truly enjoyed every bit of it and I learned a lot, while having a lot of fun on the way!” Szymon Jednac
Dan Dorman
“I liked that many of the lessons in the Elixir course started with simple code to solve the problem at hand, and then "shazam!" there was a big reveal transforming it into idiomatic Elixir code using the standard OTP libraries. That approach really helped me get a handle on why things are the way they are in Elixir. The whole production was very well put together. It was well constructed, and had an excellent flow to it.” Dan Dorman
Mahmoud Saeed
“You have done an amazing job! This is by far the best educational material I have ever seen. It's just perfect.” Mahmoud Saeed
Jacek Szarski
“I've worked with Elixir for almost 2 years and was afraid I would be mostly listening to stuff I already knew. But it turns out that with almost every chapter—even at the beginning—I got to understand something a little deeper or learn a new simpler way to solve a problem. It was pretty great!” Jacek Szarski
Enrico Tuvera Jr.
“I like how focused it was—no wasting time with unnecessary stuff. It's perfect for experienced developers looking to make a switch!Enrico Tuvera Jr.
Agilso Oliveira
“You guys rock! Honestly I wasn't expecting such a great course. As I instructor myself I was amazed by the way you could give so much on point information. The GenServers lessons and the OTP finale, oh, that was gold. And the Servy app was the perfect context to teach every single concept. Only experienced developers could think of that. Amazing job!” Agilso Oliveira
Arda Tugay
I tried learning Elixir 4 times and coming from an OO background, it has always been difficult to take on a functional programming mindset. What really helped was that instead of immediately using GenServers in this course, you built up towards GenServers. I so appreciated the incremental approach to functional programming as we implemented something every software engineer is familiar with (HTTP servers).” Arda Tugay
Rocky Neurock
“I've worked with Elixir for a couple years now, but learned more in your course than I did in all the other Elixir books I've read. It is far superior to other guides which tend to cover a broad range of things and make it hard to associate the content with real-world problems Each new idea, technique, feature and library in your course was introduced at relevant points that really helped me connect the dots. Thank you for this really helpful course!” Rocky Neurock
Roberto Pando
“Finished the Developing with Elixir/OTP course by @pragmaticstudio I have to say the level of depth that the course goes into is insane. Anything that seemed like magic before has been entirely explained in such a clear way that I feel like I would know exactly when to use the features and even have ideas of real world implementations in my head now. I think this course is an absolute must to anyone learning @elixirlang.” Roberto Pando
Dave Sanders
“@pragmaticstudio's Elixir/OTP course was outstanding. Really helped me get my head wrapped around Elixir finally. I really recommend it!” Dave Sanders
Kevin Hoffman
“We rarely take the time to appreciate how much better educational material is when the presentation order is well thought out. @pragmaticstudio's course does this so well, after each chapter you can feel the understanding sink deeper in your brain than with other courses.” Kevin Hoffman
Monte Johnston
“I really like how you built up the different parts of the language piece by piece, dispelling the magic, whether that was a web server, Phoenix, or a GenServer. You are phenomenal teachers! Thanks for sharing your gifts, your passion, and your knowledge.” Monte Johnston
Conrad Taylor
“I have been taking courses with The Pragmatic Studio since 2006 and I'm always amazed by the careful attention to detail that's displayed throughout all their coursework. I really like the animated diagrams and code examples throughout this course. Mike and Nicole totally knocked it out of the park for me! Thank you for being truly awesome educators throughout my educational journey.” Conrad Taylor
Josef Richter
“This is hands down the best online course I've ever taken on anything! You kept me interested at every step and I now understand complex concepts I never thought I would. You opened a whole new way of thinking for me. For the first time in my life, I have a solid understanding of a programming language and know what I'm doing 99% of the time. Amazing!” Josef Richter
Levi Kennedy
“I had heard good things about The Pragmatic Studio before taking the Elixir course, but now I know for myself that you two are top notch educators. Things were spaced out just right to help "exercise" my memory. I just absolutely loved the course. I don't think it could have been better.Levi Kennedy
Ed Wallitt
“Fun afternoon learning some functional programming with Elixir. Wonderful course from @pragmaticstudio. Highly recommended.Ed Wallitt
Chaz Watkins
“I loved that this course showed the primitives of Elixir and Erlang in detail before introducing the nice-to-have abstractions. This was fantastic for understanding the "why" behind the abstractions!Chaz Watkins
Dan Bye
The content was well paced for someone like me with plenty of experience as a developer coming to a completely new paradigm. Your lightness of touch and humor make the material really appealing. I also really appreciated the way you hand-rolled a task or a generic server before going on to demonstrate the implementations in the standard library. That really helped to demystify these most "magical" of aspects of using Erlang/OTP/Elixir.” Dan Bye
Tom McGurl
“I jumped right into Phoenix but I was glossing over a lot of the details of how things worked, which proved troublesome later on. I now have a strong understanding of Elixir and OTP. Thank you! I can't wait to get started with my own project!” Tom McGurl
Bruno Dusausoy
“If you want to learn Elixir in a practical way, I strongly suggest the @pragmaticstudio course. Definitely the best online course.Bruno Dusausoy
Sergio Tapia
“This is the best Elixir material I've used. You build a simple HTTP server using Elixir and learn a lot of the core language and architecture choices when writing Elixir code. It doesn't pester you with 'this is an int, this is a string.' You just start building this HTTP server out and learn about Elixir along the way. Thanks Mike and Nicole for writing such a tremendous course! It really cemented my Elixir knowledge and I feel much more comfortable in my Elixir role.Sergio Tapia
Hunter Stewart
“I love the pace. It feels more like a series of really good pair programming sessions with a mentor and less like a lecture.” Hunter Stewart
Omar Bahareth
“This course by @pragmaticstudio cleared everything up for me 😀 ” Omar Bahareth
Haiz Oppenheimer
“I really enjoyed the thoroughness of your Elixir and Rails courses. I think you guys have the best programming courses on the web. Your explanations are consistently clear, the pacing is excellent, and I particularly appreciate the way you focus on conceptual understanding and orientation, rather than just rattling off how to do something. Thanks for offering such great training” Haiz Oppenheimer
Jason Lotito
I loved everything about this course...the project-based approach, the realistic project in terms of technologies and choices, and how we built out things that also taught us how Phoenix worked. This course demystified a lot of things, and made approachable a lot of different concepts. Simply put, amazing work! I feel comfortable now looking at Elixir as a solution to problems. As a pair, you two do a great job. Hurry up and make more video courses! I'd serious learn a new language just because you two teach it.” Jason Lotito
Arif Yayalar
Great Elixir course!Arif Yayalar
James Schorr
I love the clear explanations as well as all the diagrams— they've helped me tremendously! The section on Sending and Receiving Messages in particular is wonderful.” James Schorr
Yong Bakos
“Superb job! The course has been very thoughtful in creating problem situations that iteratively lead to an ideal solution, with the benefit of helping the student understand the rationale (the "why and how") along the way. The experience has been fantastic!Yong Bakos
Maxsuel Maccari
This course was awesome! In other courses, I just learn how to use Phoenix, GenServer and Supervisor like magic. Here I learned the foundations, how those components were built and how it works under the hood.” Maxsuel Maccari
Kenny Parnell
Building from first principles in this course was very helpful. Solid course!” Kenny Parnell
Cody Brunner
“I liked the depth at which Elixir was covered. So many other tuts just cover the basic entry level things such as types and immutability along with building a toy application (no real world basis). Building the HTTP Sever was excellent because as it shaped up I was like, 'We are building a rough draft of Phoenix.' The real money of this tutorial was from Section 20 on. WOW! I was so impressed with what was covered and the ideas were really churning. This is by far one of the best tutorials I've ever paid for! I’m really impressed with your teaching methods and delivery; keep up the amazing work!” Cody Brunner
Kyle Oba
Loving @pragmaticstudio's Elixir course.Kyle Oba
Ohad Frenkel Keshet
A really fun course, presented stellarly! Your obvious mastery of both the language and tooling made for a smooth-flowing, informative course. The notes at the end of each section are also helpful and enlightening. Loved the course! I've already bought the Elm and Unpacked Bingo courses too. Excellent job!” Ohad Frenkel Keshet
Donald L. Merand
“I feel like I have a much firmer grasp of things like process creation, spawning, linking, and how those lead to setups like OTP because of this course (after having read a zillion articles and at least one book already on the topic). I'll definitely be signing up my other developers for this course!Donald L. Merand
Napoleon Ahiable
“Want to learn @elixirlang (and you should), then you owe it to yourself to check out @pragmaticstudio. Awesome!Napoleon Ahiable
Steve Forkin
“I have done a reasonable amount of Elixir & Phoenix programming and I’ve started to use OTP a lot more. The way this course builds up everything without Phoenix and goes through OTP step by step is really good! Lots of "gaps" in my understanding have been filled. I really liked the approach you have taken to build up an app!” Steve Forkin
Peter Hood
“I highly recommend the Elixir/Phoenix courses from @pragmaticstudio. Best dev learning videos I've ever seen and built by great people.” Peter Hood
“Really outstanding job of incrementally teaching the basics and moving on to more advanced concepts. Honesty, this is one of the best online courses I've taken for any programming language.Dave Holtzhouser
“I've been learning a lot of Elixir for the past few weeks. And thanks to the Elixir/OTP video course by @pragmaticstudio, with their great teaching and real code examples, I've found a programming language that I already love. And that wouldn't have happened only with books” Jorge Ania
“I absolutely love this course! You have one of the most complete and easy to understand tutorials on GenServers out there. Pragmatic Studio is certainly THE BEST site for online developer training! Thank you for all you both do.” Clinton De Young
“The way you designed this course to reveal the 'magic' behind the libraries is fantastic. The pacing was spot on. One of the best programming courses I have ever taken!Aaron Graham
“Elixir is an itch I've been wanting to scratch for sometime, but having tried to learn it using manuals or website tutorials, I've not found the experience engaging. This course, however, has been so rewarding! The pace, level of detail, assumption of prior knowledge, and depth of explanation are all perfect. The video quality, font sizing, colour scheme and sound reproduction all add to the quality of the whole course. And your approach of developing a web server app in the course and getting to see how all the pieces fit together is so much more absorbing than trying to learn by writing bite size chunks of unrelated code. Well done!” Tony Sutton
“I love the logical, sequential way you build up an increasingly robust application and explain at each step of the process why things work as they do. Your visuals are thoughtfully crafted to illustrate important concepts. I wish the course hadn't come to an end. I not only would recommend this course, but I bought a 10-person license for my team!” James Lavin
“I really enjoyed the structure of the Elixir course which really helped me understand many of the core ideas, such as GenServers. You helped take away the magic that can come when learning a new language and ecosystem. Great job!” Michael Degli-Angeli
“Best course ever! It has a unique way of explaining the whole Elixir ecosystem in detail with real-world examples and use cases, and also one of the best explanation of the OTP internal functionality. Totally worth the money.” Emilio Forrer
“The material was presented in a really well structured way so that learning was gradual. I particularly loved hand-rolling the GenericServer before revealing that it was pretty much a GenServer, thus increasing understanding and making GenServer less magic. Everything was well-paced too!” Ben Booth
I liked everything about this course: it was well organized, well paced, interesting, and fun!” Kevin Shank