The Complete Elixir and Phoenix Bootcamp
The course starts with an Elixir warmup, guiding you through installing Elixir and generating your first project.
You’ll dive into core Elixir concepts like modules, methods, lists, strings, functional programming, pattern matching, and working with Erlang.
As you progress, you’ll learn about data structures like maps and structs, which are crucial for modeling data in Elixir.
The course also covers testing and documentation, ensuring you write maintainable and well-documented code.
Moving on to Phoenix, you’ll learn about its MVC architecture, routing, controllers, views, and templates.
You’ll build a complete web application, covering everything from setting up the project to handling forms, working with databases using migrations and the Repo module, and styling with CSS.
The course doesn’t stop there – it dives into advanced topics like authentication with OAuth, using plugs to transform requests, and associating data between models.
You’ll also learn about WebSockets in Phoenix, building real-time features like a commenting system with channels.
One of the highlights is the Identicon generation project, where you’ll learn image manipulation techniques in Elixir.
You’ll create a pipeline to generate unique identicons (visual representations of data) by hashing strings, building grids, and drawing rectangles.
With the recent Phoenix 1.3 update, the course covers the latest changes, including CLI command updates, asset folder restructuring, and the new contexts feature.
Throughout the course, you’ll work on practical projects, reinforcing your understanding of the concepts.
The instructor provides clear explanations, making it easy to follow along, even if you’re new to Elixir or Phoenix.
Elixir and Phoenix: Real World Functional Programming
The course starts by teaching you the fundamentals of Elixir, the functional programming language that powers the Phoenix framework.
You’ll learn how to install Elixir on different operating systems like Windows, Linux, and Mac, and even get a taste of distributed code execution right from the start.
From there, the course dives into the core Elixir language basics, covering topics like maps/dictionaries, operations on data structures, and code structuring with pattern matching.
You’ll also learn about branching and decision making, modules, anonymous functions, and the powerful pipe operator.
The course even includes practice activities to solidify your understanding of these concepts.
Once you’ve got a solid grasp of Elixir, the course shifts its focus to the Phoenix framework itself.
You’ll learn how to set up Phoenix on different platforms and get introduced to the Model-View-Controller (MVC) architecture that Phoenix is built upon.
The course covers creating new pages, passing values to them, using path helpers and flash messages, and even making function calls in views.
But the real power of Phoenix lies in its ability to handle concurrency and database connectivity.
This course covers message passing and PubSub, as well as integrating with databases using Ecto.
You’ll learn how to add and validate constraints, use repositories for communication, and even implement authorization and session management.
The course also delves into structuring code through contexts, linking authorization credentials to users, and session management with plugs.
You’ll learn how to protect your web app by securing pages, adding authors, and associating new pages with logged-in users.
There’s even a section on adding page view counts.
And if that’s not enough, the course includes a capstone project for you to put your skills to the test.
Additionally, there’s an update covering Phoenix LiveView, which allows you to build real-time, interactive web applications with server-rendered HTML.
Build A TodoList with Elixir, Phoenix and Electron React
The course starts by introducing you to the Phoenix framework and Elixir programming language.
You’ll learn how to install Elixir and Hex, a package manager for Elixir.
Then, you’ll generate a new Phoenix project and create the initial files needed for a Todo application.
Next, you’ll dive into building the backend of the Todo app with Phoenix.
You’ll create database migrations, models, views, and controllers to handle CRUD operations.
The course covers how to make GET, POST, PUT, and DELETE requests in Phoenix, as well as how to view API requests.
After completing the backend, you’ll shift your focus to the frontend.
You’ll create an Electron project and add a UI library like React.
Then, you’ll build out the Todo application using Electron and React, including creating a service for interacting with the Phoenix API, implementing CRUD functionality, and building components like the TodoList and TodoItem.
Throughout the course, you’ll work with key technologies like Phoenix, Elixir, Hex, Electron, and React.
By the end, you’ll have a fully-functional Todo application with a Phoenix backend and an Electron React frontend.
Build A TodoList with Phoenix, Elixir and Angular
The course starts by introducing you to Phoenix, a web development framework for the Elixir programming language.
You’ll learn how to install Elixir and Hex, a package manager for Elixir.
Then, you’ll generate a new Phoenix project and create the necessary files and migrations for your Todo application.
Next, you’ll dive into building the backend API with Phoenix.
You’ll create controllers and views to handle GET, POST, PUT, and DELETE requests for your Todo items.
The course covers creating a changeset view, a fallback controller, and a Todo controller to manage these requests.
Once the backend is set up, you’ll shift your focus to the frontend.
You’ll install Angular, a popular JavaScript framework, and create a new Angular project.
To enhance the user interface, you’ll integrate Ant Design, a UI library for Angular applications.
With the frontend setup complete, you’ll build an Angular service to interact with the Phoenix API.
This includes creating a TodoList service, a post service, and a get and delete service.
These services will handle the communication between your Angular app and the Phoenix backend.
The course then guides you through building the actual user interface components.
You’ll create form methods to handle user input and build an HTML form using Angular.
Next, you’ll construct a TodoList component to display the Todo items and add functionality to toggle and delete items.
Finally, you’ll learn how to create new Todo items and implement notifications to provide feedback to the user.
The course concludes with a bonus section, offering additional resources or advanced topics related to building a Todo application with Phoenix, Elixir, and Angular.
Build A TodoList with Elixir, Phoenix and SolidJs
The course starts by guiding you through the installation process for Elixir, Hex, and setting up a new Phoenix project.
You’ll learn how to generate migrations and create the initial project files, including the changeset view, todo view, fallback controller, and todo controller.
From there, the course dives into handling different types of HTTP requests in Phoenix, such as GET, POST, PUT, and DELETE requests.
You’ll learn how to view API requests, which is essential for building robust web applications.
The course then shifts gears to the front-end, where you’ll learn how to create a SolidJS TodoList.
You’ll start by installing SolidJS and creating a service for the TodoList.
The course covers building UI components for the TodoList, including the TodoListItem component and the main TodoList component.
You’ll also learn how to implement various methods within the TodoList, such as creating and deleting todos.
The course ensures you have a solid understanding of integrating the SolidJS front-end with the Phoenix back-end, enabling you to build a fully functional TodoList application.
JWT Authentication with Elixir & Phoenix
This course will take you on a journey through building authentication with JSON Web Tokens (JWT) in Elixir and Phoenix.
You’ll start by setting up a new Phoenix project and configuring user registration with secure password hashing.
Next, you’ll dive into authentication, implementing login functionality that issues JWT tokens upon successful authentication.
You’ll learn how to use Phoenix plugs to protect routes, ensuring only authenticated users can access certain parts of your application.
The course also covers logging out and invalidating JWT tokens, an essential part of any authentication system.
Throughout the process, you’ll gain hands-on experience working with key concepts like user registration, password hashing, authentication, JWT tokens, Phoenix plugs, and route protection.
By the end, you’ll have a solid understanding of how to implement robust authentication using JWT in your Elixir and Phoenix applications.
Build A TodoList with Phoenix, Elixir and React
The course starts by introducing you to the Phoenix framework and setting up the development environment.
You’ll install Elixir, Hex, and generate a new Phoenix project.
Then, you’ll create the initial project files, including migrations, views, controllers, and a fallback controller for handling errors.
Next, you’ll dive into building the backend API with Phoenix.
You’ll learn how to handle GET, POST, PUT, and DELETE requests, allowing you to create, read, update, and delete Todo items.
You can view these API requests using tools like Postman or curl.
Once the backend is set up, the course shifts to building the front-end with React.
You’ll create the project structure and build a Todo service to interact with the Phoenix API.
Then, you’ll create a Todo form component, allowing users to add new Todo items.
The course continues by building the Todo item component, which displays individual Todo items and allows you to mark them as complete or delete them.
You’ll also create a Todo tab component to organize Todo items based on their status (active or completed).
To tie everything together, you’ll learn how to manage the application’s state using React hooks and create a TodoList component that displays all Todo items fetched from the Phoenix API.
Real-time GraphQL API in Elixir & Phoenix
You’ll start by setting up the development environment and learning the basics of Phoenix and GraphQL.
Next, you’ll dive into building a user authentication system, including user registration and handling Ecto changeset errors elegantly.
You’ll implement authentication and authorization mechanisms to secure your API.
The course then guides you through creating rooms and messages, allowing users to communicate in real-time.
You’ll learn how to set up GraphQL subscriptions, enabling real-time updates for room messages.
To enhance the user experience, you’ll implement cursor-based pagination for messages, ensuring efficient data retrieval.
Additionally, you’ll configure CORS (Cross-Origin Resource Sharing) to allow your API to be accessed from different domains.
Throughout the course, you’ll work with the User Entity, setting up its schema and handling various operations like creating, reading, updating, and deleting users.
The course covers key concepts like Rooms, Messages, Subscriptions, Pagination, and Configuration.
The course provides access to the source code on GitHub, a YouTube channel for additional resources, and a website for further learning materials.
Build A TodoList Fast with Elixir, Phoenix and Svelte
The course starts by guiding you through installing the necessary tools like Elixir and Hex.
You’ll then generate a new Phoenix project and create the initial files, including migrations, controllers, and views.
The course covers all the essential HTTP requests in Phoenix, such as GET, POST, PUT, and DELETE requests.
You’ll learn how to handle these requests in your TodoController and create a FallbackController for error handling.
The course also teaches you how to create a changeset view for data validation.
Moving on, you’ll dive into building the front-end with Svelte.
You’ll generate a new Svelte project and integrate the Carbon UI library for styling.
The course will walk you through creating a TodoList service and adding todo events to handle user interactions.
You’ll also learn how to build the TodoList UI component and fix any bugs related to the Carbon UI library.
Finally, the course covers creating a Todo form for adding new tasks to your TodoList app.
REST API in Elixir & Phoenix
The course starts by introducing you to the project and setting up the necessary tools like Elixir, Phoenix, Docker, and Ubuntu WSL.
This ensures you have a solid foundation before diving into the core concepts.
Once the setup is complete, you’ll learn how to create and read Posts using Phoenix.
This hands-on approach allows you to grasp the basics of building APIs with Phoenix.
The course then guides you through creating a simple GET API for pinging the server and a POST API for creating new Posts.
You’ll also learn how to fetch all existing Posts, giving you a well-rounded understanding of handling data with Phoenix.
It covers crucial aspects like authentication and authorization using JSON Web Tokens (JWT).
You’ll learn how to hash passwords securely and register new users.
Additionally, you’ll implement login functionality and issue JWT tokens for authenticated users.
This is a critical skill for building secure and robust APIs.
The course also delves into Phoenix plugs, which are like middleware functions that can be plugged into the request pipeline.
You’ll learn how to use plugs to protect routes and ensure only authenticated users can access certain endpoints.
This is a powerful feature that allows you to customize the behavior of your API.
Logging out and invalidating JWT tokens is another important topic covered in the course.
This ensures that users can securely log out and revoke access to their accounts, further enhancing the security of your API.
You’ll learn how to set up the development environment, handle data, implement authentication and authorization, and secure your API using industry-standard practices.