CF

The Complete Elixir and Phoenix Bootcamp

17h 22m 4s
English
Paid

Elixir and Phoenix are two of the most exciting technologies in web development. In this course, you'll delve into Functional Programming, explore the intricacies of Phoenix with OAuth, leverage Postgres for data storage, and gain proficiency with Websockets. This course is designed to quickly get you up to speed and equip you with the essential knowledge to build exceptionally fast web applications using Elixir and Phoenix.

Course Overview

We kick off by mastering the fundamentals of functional programming with Elixir, covering key concepts like functions, modules, and the fantastic 'pipe' operator. You'll see how functional programming stands apart from classic object-oriented programming through various practical examples. With a solid foundation in Elixir, we'll transition to the Phoenix Framework to develop high-speed applications, enriched by an in-depth app project. Each lecture comes with source code to ensure you can keep pace with the lessons.

Who Should Enroll?

If you're new to Elixir or struggling to fully grasp it, this is the course for you. By understanding Elixir and Phoenix in depth, you can master both technologies.

Key Learning Objectives

  • Utilize Elixir's built-in library to enhance and streamline your code
  • Differentiate between functional and object-oriented programming
  • Understand the diverse elements of syntax in common Elixir programs
  • Engage with projects that are both interesting and have practical applications
  • Develop a versatile web app using Phoenix
  • Dive deep into the workings of Phoenix
  • Perfect the OAuth flow by authorizing users via the Github Public OAuth service
  • Integrate Postgres to practice database interactions within your app

Course Prerequisites

Requirements:

  • Basic understanding of another programming language, such as Javascript, Ruby, C#, PHP, or similar

Ideal Audience

Who this course is for:

  • This course is perfect for anyone eager to learn Elixir and Phoenix

Learning Outcomes

What you'll learn:

  • Adapt to a Functional Programming mindset
  • Deploy Phoenix for crafting fast and engaging web applications
  • Comprehend common Elixir syntax and design patterns
  • Master OAuth flow with Phoenix for user authentication
  • Uncover the hidden aspects of Phoenix

I've curated this course to align with the journey I wished for when learning Elixir and Phoenix. The content is structured to unravel concepts in a manner that facilitates thorough comprehension and application.

About the Authors

Stephen Grider

Stephen Grider thumbnail

Stephen Grider is one of the longest-running and most prolific instructors on Udemy, with a catalog covering essentially every major JavaScript framework, plus Docker, Kubernetes, AWS, and the broader full-stack development landscape. His teaching style is patient and project-oriented — most of his courses are structured around building a substantial application from scratch rather than working through disconnected tutorial examples.

The catalog covers React, Redux, Next.js, Vue, Angular, GraphQL, Node.js, Docker / Kubernetes, AWS infrastructure, React Native and Flutter for mobile, the algorithm / data-structure interview prep track, and the modern TypeScript / Bun / Rust adjacent material that working JavaScript developers increasingly encounter. Few independent instructors have maintained Stephen's breadth this consistently for this long.

The CourseFlix listing under this source carries over 25 Stephen Grider courses spanning that range. Material is paid; Stephen Grider courses are typically sold individually on Udemy. Courses are aimed primarily at developers picking up a specific technology through working through a complete project.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 149 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: 1.1. How to Get Help
All Course Lessons (149)
#Lesson TitleDurationAccess
1
1.1. How to Get Help Demo
02:53
2
1.4. Installing Elixir
02:01
3
1.5. Project Outline
04:06
4
1.6. Generating a Project
02:52
5
1.7. Elixir Modules and Methods
06:05
6
1.8. Lists and Strings
03:23
7
1.9. Object Oriented vs Functional Programming
09:13
8
1.10. Method Arguments
04:49
9
1.11. The Enum Module
05:55
10
1.12. Immutability in Elixir
03:58
11
1.13. Searching a List
06:03
12
1.14. Comprehensions Over Lists
07:12
13
1.15. Not Everything Works the First Time
05:03
14
1.16. Solving Nested Arrays
06:48
15
1.17. Importance of Index with Tuples
08:35
16
2.1. Pattern Matching
10:44
17
2.2. Elixir's Relationship with Erlang
05:16
18
2.3. Saving a Deck
03:53
19
2.4. Pattern Matching Continued
10:24
20
2.5. Pattern Matching in Case Statements
14:15
21
2.6. The Pipe Operator
04:24
22
2.7. The Pipe Operator Continued
04:06
23
2.8. Module Documentation
03:50
24
3.1. Writing and Generating Documentation
03:35
25
3.2. Creating Function Docs
06:19
26
3.3. Introduction to Testing
02:54
27
3.4. Amazingly Productive Doctests
03:38
28
3.5. Writing Effective Doctests
05:17
29
3.6. Case Tests
06:53
30
4.1. Introduction to Maps
04:08
31
4.2. Updating Values in a Map
07:56
32
4.3. Keyword Lists
08:22
33
5.1. Project Overview
03:44
34
5.2. Identicon Generation Process
02:34
35
5.3. Identicon Generation Process Continued
03:03
36
5.4. The Main Pipeline
03:21
37
5.5. Hashing a String
04:06
38
5.6. The Purpose of the Hex List
05:47
39
6.1. Modeling Data with Structs
06:47
40
6.2. Pattern Matching Structs
10:40
41
6.3. Updating Structs
10:09
42
6.4. Building the Grid
08:17
43
6.5. Mirroring a Row
05:10
44
6.6. Mapping with Custom Functions
06:33
45
6.7. Grid Structure
08:32
46
6.8. Giving an Identicon Shape
09:35
47
6.9. Planning Image Creation
07:42
48
6.10. Creating the Pixel Map
05:49
49
6.11. Drawing Rectangles
09:47
50
7.2. Phoenix Installation
04:11
51
7.3. Postgres Setup on OSX
06:38
52
7.4. What is Phoenix
06:35
53
7.5. App Overview
07:18
54
7.6. Into Phoenix We Go
08:10
55
7.7. Server Side Templating
03:40
56
7.8. Templates vs Layouts
09:31
57
8.1. Phoenix's MVC Model
07:38
58
8.2. Exploring the Router and Controller
09:48
59
8.3. Views vs Templates
10:01
60
8.4. The Model Layer in Phoenix
08:29
61
8.5. Migration Files
05:29
62
8.6. A Game Plan for Creating Topics
09:46
63
8.7. Routing to the Topic Controller
07:25
64
8.8. Setting Up the Topic Controller
06:06
65
8.9. Code Reuse with Import, Alias, and Use
09:17
66
8.10. Phoenix's Code Sharing Model
08:10
67
8.11. Phoenix's Conn Struct
08:25
68
8.12. A Phoenix Approach to Forms
04:54
69
9.1. The Topic Model
03:55
70
9.2. Model Changesets and Validations
12:07
71
9.3. More on Changesets
08:28
72
9.4. Generating Changesets for the Form
06:05
73
9.5. New Topic Form
07:49
74
9.6. Phoenix Template Syntax
10:03
75
9.7. Handling Form Submissions
10:42
76
9.8. A Quick Review and Breather
08:16
77
10.1. Introduction to the Repo Module
11:59
78
10.2. Handling Failed Form Submissions
04:28
79
10.3. Styling with CSS in Phoenix
06:35
80
10.4. Breaking Restful Conventions Safely
06:44
81
10.5. Using the Repo Module for Queries
07:04
82
10.6. Building Lists in EEX Templates
06:49
83
10.7. Redirects in the Controller
08:18
84
10.8. Generating Anchors with Link Tags
12:10
85
10.9. Router Wildcards
07:58
86
10.10. Setting up the Edit Form
09:38
87
10.11. Defining the Update Route
06:49
88
10.12. Editing a Topic
11:21
89
10.13. Linking to the Edit Topic Form
06:25
90
10.14. The Resources Helper
07:01
91
10.15. Deleting a Topic
09:44
92
10.16. Wrapping up TopicController
06:59
93
11.1. OAuth Overview
06:28
94
11.2. OAuth Setup with Ueberauth
07:51
95
11.3. Creating a Github OAuth App
09:53
96
11.4. Defining OAuth Routes
11:58
97
11.5. Receiving User Info From Github
09:42
98
11.6. Users Migration
07:41
99
11.7. Digesting the OAuth Response
07:01
100
11.8. The User Changeset
08:03
101
11.9. Creating New Users
07:49
102
11.10. Our Auth Grand Plan
07:09
103
11.11. Handling OAuth Success
07:30
104
12.1. Introduction to Plugs
12:45
105
12.2. Using a Module Plug to Set the User
11:45
106
12.3. Implementing Module Plugs
09:03
107
12.4. Allowing Users to Signout
10:28
108
12.5. Restricting Access of Users
05:49
109
12.6. The Require Auth Plug
13:05
110
12.7. Controller Scoped Plugs
04:24
111
12.8. Associating Users with Topics
06:57
112
12.9. Altering Existing Tables
02:28
113
12.10. Playing Around with Associations
09:08
114
12.11. Using the Build Assoc Function
08:36
115
12.12. Finalizing the Association
03:04
116
12.13. Checking the Topics Owner
12:11
117
13.1. Introduction to Websockets
04:18
118
13.2. Showing Individual Topics
06:41
119
13.3. Making the Comments Migration
03:52
120
13.4. The Comments Model
03:46
121
13.5. Overview of Channels in Phoenix
06:14
122
13.7. Introducing the Comments Channel
10:20
123
13.8. Making Progress with Sockets
09:11
124
13.9. Quick Breather and Review
07:29
125
13.10. Publishing Messages
07:30
126
13.11. Figuring Out What Topics to Show
05:08
127
13.12. Refactoring to Determine Topic Id
09:08
128
13.13. Fetching Topics on Join
05:41
129
13.14. Debugging Topic Fetching
02:45
130
13.15. Building the Comment Form
05:54
131
13.16. Inserting Comments into the Database
07:58
132
13.17. Remaining Items with Sockets
04:57
133
13.18. Poison Encoder
08:42
134
13.19. Rendering a List of Comments
08:25
135
13.20. Broadcasting Updates
06:45
136
13.21. Updating the Client
06:16
137
13.22. The Socket Event Object
03:08
138
13.23. Authentication with Sockets
07:53
139
13.24. Transporting Tokens to the Server
04:51
140
13.25. Verifying the Current Socket User
04:42
141
13.26. Associating Comments with Users
05:18
142
13.27. Fetching Users with Comments
08:02
143
13.28. Rendering Associated Users
03:57
144
14.1. New in Phoenix 1.3
03:42
145
14.2. CLI Command Changes
03:26
146
14.3. Assets Folder Changes
04:13
147
14.4. Directory Structure Changes
05:20
148
14.5. Contexts
07:49
149
14.6. More on Contexts
12:31
Unlock unlimited learning

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

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are needed before starting this course?
The course is designed for beginners who are new to Elixir or those struggling to understand it. No prior experience with Elixir or Phoenix is required. However, familiarity with basic programming concepts can be beneficial, as the course will delve into advanced topics like functional programming and syntax differences between Elixir and object-oriented languages.
What projects will I build during the course?
You will engage with several practical projects, including generating an Identicon, which involves hashing a string and creating a pixel map. The course also includes a comprehensive app project within the Phoenix framework, allowing you to develop high-speed web applications using Elixir.
Who is the target audience for this course?
This course is ideal for individuals new to Elixir and those who are struggling to grasp its concepts. It aims to provide an in-depth understanding of Elixir and Phoenix, making it suitable for anyone interested in mastering these technologies for web development.
What specific tools or platforms are covered in this course?
The course covers several specific tools and platforms, including Elixir's built-in library, the Enum module, and the Phoenix framework's MVC model. Additionally, you will learn to set up Postgres for data storage and leverage Websockets for real-time communication.
What topics are not covered in this course?
The course does not cover in-depth object-oriented programming, as the focus is primarily on functional programming with Elixir. Additionally, it does not delve into non-Elixir related backend technologies or front-end development frameworks, centering instead on Elixir and Phoenix.
How much time should I expect to commit to this course?
The course comprises 149 lessons, each designed to be digestible and progressively build your knowledge. While the total runtime is not specified, students should prepare to dedicate a substantial amount of time to practice coding, especially to experiment with the source code provided in each lecture.
How will the skills learned in this course be applicable to other career opportunities?
The skills learned in this course, such as functional programming with Elixir, understanding the Phoenix framework, and managing data with Postgres, are highly applicable to web development careers. The foundational understanding of functional programming will also benefit those looking to explore other functional languages or frameworks in their careers.