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 has been building complex Javascript front ends for top corporations in the San Francisco Bay Area. With an innate ability to simplify complex topics, Stephen has been mentoring engineers beginning their careers in software development for years, and has now expanded that experience onto Udemy, authoring the highest rated React course. He teaches on Udemy to share the knowledge he has gained with other software engineers. Invest in yourself by learning from Stephen's published courses.

udemy

udemy thumbnail
By connecting students all over the world to the best instructors, Udemy is helping individuals reach their goals and pursue their dreams. Udemy is the leading global marketplace for teaching and learning, connecting millions of students to the skills they need to succeed. Udemy helps organizations of all kinds prepare for the ever-evolving future of work. Our curated collection of top-rated business and technical courses gives companies, governments, and nonprofits the power to develop in-house expertise and satisfy employees’ hunger for learning and development.

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