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.
Functional Programming using Elixir - The Complete Course
This course goes from the basics of Elixir and functional programming, and gradually building up to more advanced concepts.
You’ll begin by learning about variables, pattern matching, and built-in data types in Elixir.
This lays a solid foundation for understanding modules, functions, and lambda functions.
The course then dives into iterations and recursion, which are fundamental concepts in functional programming.
One of the key strengths of this course is its focus on processes and concurrency.
You’ll learn about the importance of processes in Elixir, how to spawn them, and how to make them communicate with each other.
This is a crucial aspect of building scalable and fault-tolerant applications in Elixir.
The course also covers GenServer, a powerful abstraction for writing concurrent processes.
You’ll learn how to respond to requests and refactor your code using GenServer, which is essential for building robust and maintainable applications.
Moving on, you’ll explore the Mix tool, which is used for creating new applications, adding third-party packages, and making executables.
This is a valuable skill for any Elixir developer.
Fault tolerance is another important topic covered in the course.
You’ll learn about supervisors, which are responsible for monitoring and restarting processes in case of failures.
This is a key feature of Elixir that enables building highly available and resilient systems.
The course also delves into Elixir Term Storage (ETS), which is a powerful in-memory data store.
You’ll learn how to persist state using ETS, which is essential for building stateful applications.
Additionally, you’ll gain insights into distribution, tasks, and agents, which are crucial for building distributed and concurrent applications.
Metaprogramming and protocols are also covered, allowing you to write more expressive and extensible code.
Throughout the course, you’ll work with practical examples and exercises, ensuring that you not only understand the concepts but also gain hands-on experience in applying them.
Elixir for Beginners (programming language)
The course starts with an introduction, setting the stage for your learning journey.
It quickly dives into the practical aspects, teaching you how to use Replit, an online coding environment.
From there, you’ll learn the basics of Elixir programming by creating a “Hello World!” program.
You’ll then explore strings and math operations, essential building blocks for any programmer.
As you progress, the course covers user input and decision-making, two critical concepts for building interactive programs.
You’ll learn about relational and logical operators, which allow you to make decisions based on user input or other conditions.
The course then delves into data structures like lists, maps, and tuples, which are fundamental to organizing and manipulating data in Elixir.
You’ll learn how to create, access, and modify these data structures, giving you the tools to handle complex data effectively.
Moving forward, you’ll dive into enumerables and functions, two powerful features of Elixir.
Enumerables allow you to work with collections of data efficiently, while functions enable you to modularize and reuse code, promoting good programming practices.
Throughout the course, you’ll have the opportunity to apply these concepts through hands-on exercises and projects, solidifying your understanding of Elixir programming.
Learn ELIXIR Programming from ZERO to HERO
The course starts by introducing you to Elixir and providing an overview of the language.
You’ll learn how to install Elixir on your system, which is essential for getting started.
Once you have Elixir set up, the course dives into the basics of the language’s syntax, data types, variables, and operators.
You’ll learn about different data types like strings, lists, tuples, and maps, as well as how to work with variables and perform operations using various operators.
The course then covers decision-making constructs like if statements, unless statements, cond statements, and case statements.
These are crucial for controlling the flow of your programs based on certain conditions.
Moving on, you’ll explore strings in depth, including basic string operations and functions for manipulating strings.
Lists and tuples, which are fundamental data structures in Elixir, are also covered extensively, including char lists and the differences between lists and tuples.
The course delves into modules and functions, which are essential for organizing and reusing code in Elixir.
You’ll learn how to create and use modules, define functions, and work with aliases.
Recursion and loops are important concepts in Elixir, and the course dedicates sections to teaching you how to use them effectively.
Recursion is a powerful technique in functional programming, while loops provide a way to iterate over collections.
Additional topics covered in the course include structs, protocols, file I/O, processes, sigils, comprehensions, typespecs, behaviors, error handling, and macros.
These are advanced concepts that will give you a deeper understanding of Elixir and its capabilities.
Finally, the course explores various libraries available in the Elixir ecosystem, which can greatly enhance your development experience and productivity.
You’ll gain a solid foundation in the language and be well-prepared to tackle real-world Elixir projects.
Getting Started with Elixir
The course starts by introducing you to Elixir.
You’ll learn what Elixir is and how functional programming works.
Next, you’ll dive into the basics like types, operators, and literals in Elixir.
The course covers essential collection types and pattern matching, a powerful feature in Elixir.
You’ll understand pattern matching versus regular assignment and different forms of pattern matching.
Functions are a core concept, so you’ll learn about functions, modules, pattern matching in functions, and anonymous functions.
For control flow, you’ll explore recursion and conditionals.
The course also teaches you how to handle exceptions and work with input/output, including standard IO and files.
As you progress, you’ll learn how to create an Elixir application, import dependencies, and run tests.
Testing is crucial, so you’ll understand what unit tests are and how to automatically test your application.
You’ll learn to isolate components for effective testing.
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.
Elixir Programming Interview Prep: 300+ Most Asked Questions
This course will prepare you for Elixir programming interviews by covering 300+ most asked questions.
You will learn the core language concepts of Elixir, which form the foundation.
The course then dives into concurrency and parallelism, which are key strengths of Elixir.
It covers error handling and functional programming principles that are essential in Elixir.
The course also explores OTP (Open Telecom Platform) and distributed systems, which are crucial for building robust and scalable applications.
You’ll gain insights into development environments, tooling, and best practices, including Mix (the build tool), ExUnit (for unit testing), and Hex (the package manager).
Additionally, the course touches on web development with Phoenix, an optional but valuable skill.
You’ll learn about the Elixir style guide, code organization, and idiomatic patterns to write clean and maintainable code.
Testing is emphasized, covering unit testing with ExUnit and property-based testing with tools like ExCheck and PropEr.
You will gain a deep understanding of the language, its ecosystem, and best practices for building robust and scalable applications.