CF

Elixir for Programmers, Second Edition

8h 21m 11s
English
Paid

Elixir gives you a new way to think about code. This course helps you see how it differs from other languages and how you can use it in real projects. You move fast from basic syntax to clear, practical skills.

What You Will Learn

You go beyond surface‑level features. You learn how Elixir uses functional code, data flow, and safe concurrency. You see how these ideas shape real app design. This helps you write code that is easy to read, test, and grow.

You also work with core tools such as IEx and Mix. You build comfort with OTP and Phoenix, which power most production Elixir apps. These tools form the base you will use in your own work.

How You Will Learn

The course mixes short videos, clear text guides, and small tests to check your understanding. You also solve hands‑on tasks. These help you turn ideas into working code.

About the Author: Coding Gnome (Bruce Tate)

Coding Gnome (Bruce Tate) thumbnail

Coding Gnome is the Elixir teaching brand of Bruce Tate — author of Seven Languages in Seven Weeks, multiple Elixir books, and one of the most widely cited educators on the Elixir / Erlang BEAM ecosystem. His material is taught at the level of someone who has implemented production systems on the platform across multiple major versions.

The CourseFlix listing carries two Coding Gnome courses: Elixir for Programmers and Elixir for Programmers, Second Edition (the latter covering Phoenix as well). Material is paid and aimed at developers from other backgrounds picking up Elixir as a serious back-end language.

Watch Online 64 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 64 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1. Introduction to IEx
All Course Lessons (64)
#Lesson TitleDurationAccess
1
1. Introduction to IEx Demo
09:34
2
2. What We're Going to Do
05:13
3
3. Create a New Project
03:04
4
4. Start Coding
06:26
5
5.1. Start Writing the Dictionary
09:52
6
5.2. Start Writing the Dictionary
07:32
7
6. Make it More Functional
07:32
8
7. Lists and Recursion
16:16
9
8.1. The API
05:15
10
8.2. The API
02:34
11
9.1. Typespecs
03:22
12
9.2. Typespecs
06:30
13
10. Start Coding (2)
16:24
14
11. And Start Testing
11:14
15
12.1. Pattern Matching Game State
04:07
16
12.2. Pattern Matching Game State
10:09
17
13. Check for Duplicate Moves
08:43
18
14. Score a Good Guess
16:48
19
15. And a Bad Guess
05:55
20
16. Mostly About Loops
03:59
21
17. Create the Text Client App
14:23
22
18. Finish Up the Text Client
11:39
23
19. Then I'll Do It
05:14
24
20. Why We're Looking At This Backwards
00:35
25
21. spawn Create a New Process
05:26
26
22. Sending and Receiving Messages
03:49
27
23. Pattern Matching Messages
04:26
28
24. Linking Our Fate to Our Child's Fate
03:52
29
25. Agents An Abstration Over State
04:53
30
26. Keeping the Wordlist in a Process
02:12
31
27. The Runtime vs Implementation Time Divide
02:55
32
28. Implement Dictionary Runtime
07:30
33
29. Applications Are Projects That Can Run Themselves
01:58
34
30. Run Dictionary as an Application
10:47
35
31. No Mr Dictionary, I Expect You To Die
03:05
36
32. Add a Supervisor to Dictionary
09:30
37
33. Supervisors and Servers
14:27
38
34. Make Hangman a Server
10:58
39
35. Change to API to Use the Server
04:43
40
36. How Others Do It
05:30
41
37. Nodes and Remote Processes
07:14
42
38. Playing With Nodes in IEx
13:15
43
39. A Chain of Nodes
01:15
44
40. Writing the Chain
10:02
45
41. From Server to Service
04:24
46
42. Make Hangman a Service Using a Dynamic Supervisor
07:37
47
43. Update The Text Client to the New API
02:22
48
44. Don't Run Hangman Automatically
02:02
49
45. Creating Remote Servers
09:52
50
46. Introduction
01:36
51
47. Installing Phoenix
04:55
52
48. Playing with Phoenix Views and Templates
16:52
53
49. Create an HTML Hangman App
11:09
54
50. Paths and Routes
13:55
55
51. Integrate the Game server with the Phoenix Front End
16:42
56
52. Start to Tidy Up
13:28
57
53. More Tidying
13:39
58
54. LiveView What's The Big Deal
06:46
59
55. Example Dynamically Display Memory Use
18:08
60
56. Starting on LiveView Hangman
13:10
61
57. Writing the WordSoFar Component
09:33
62
58. Writing the Alphabet Component
08:37
63
59. Finish the Hangman Game
03:20
64
60. Congratulations!
02:57
Unlock unlimited learning

Get instant access to all 63 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

  • Elixir & Phoenix for Beginners thumbnailUpdated 3y ago

    Elixir & Phoenix for Beginners

    By: KnowThen (James Moore)
    The above statement is conventional wisdom that I'm sure most of us programmers would generally agree with, but let me ask you this, do you think each of the 20
    17h 24m
  • Programming Nerves thumbnailUpdated 1mo ago

    Programming Nerves

    By: Alex Koutmos, Hugo Barauna
    Unlock the world of embedded systems with Elixir and Nerves. Learn how to advance from simple projects to industrial solutions and develop unique IoT devices.
  • The Complete Elixir and Phoenix Bootcamp thumbnailUpdated 3mo ago

    The Complete Elixir and Phoenix Bootcamp

    By: Udemy, Stephen Grider
    Elixir and Phoenix are two of the hottest technologies of 2017. Functional Programming? You will learn it. Phoenix with OAuth? Its here. Postgres for data sto
    17h 22m

Frequently asked questions

What are the prerequisites for enrolling in this course?
The course is designed for programmers who already have some experience with coding but want to learn Elixir. Familiarity with basic programming concepts and comfort with command-line tools will help you follow along, especially as you work with IEx and Mix, which are core tools in the course.
What kind of projects will I build during the course?
Throughout the course, you'll work on projects like building a text client app for a Hangman game and integrating it with a Phoenix front end. You will also create applications that run themselves using Elixir's OTP framework and work with dynamic supervisors to turn servers into services.
Who is the target audience for this course?
The course is aimed at programmers who want to understand functional programming and concurrency using Elixir. It is especially useful for those interested in building scalable applications using Elixir's tools such as OTP, Phoenix, and LiveView.
How does the depth of this course compare to similar courses?
This course goes beyond surface-level features of Elixir by focusing on practical skills like building functional applications, understanding data flow, and implementing safe concurrency. It covers essential tools like IEx, Mix, OTP, and Phoenix, which are crucial for developing real-world Elixir applications.
What specific tools or platforms will I learn to use?
You will learn to use several core tools and platforms, including IEx for interactive Elixir sessions, Mix for project management, OTP for building concurrent applications, and Phoenix for web development. The course also introduces LiveView for dynamic web interfaces.
What topics are not covered in this course?
The course does not cover advanced topics outside of the Elixir ecosystem, such as integrating Elixir with other languages or databases beyond the basics required for the projects. It focuses on fundamental aspects of Elixir and its primary tools and frameworks.
How much time should I expect to commit to this course?
The course consists of 64 lessons that mix short videos, text guides, and interactive tasks. While the exact time commitment can vary based on your pace, you should plan for several weeks of study, including time for hands-on projects and tests to reinforce your learning.