Elixir and Phoenix: Real World Functional Programming

Explore Elixir basics in the interactive shell, including dynamic typing, atoms, lists, tuples, and immutability, while contrasting with Python and learning rebinding and expressions.

Explore maps in Elixir by turning Python dictionaries into maps with atom keys and colon syntax. Retrieve values with atom keys using map lookups and dot notation for quick access.

Master key data-structure operations in Elixir, including integer division and remainder, boolean checks, and type checks. Learn string interpolation, list head-tail patterns, tuples, and arity-based function errors.

Learn pattern matching and rebinding in Elixir, including the pin operator, case statements, and handling file read results with ok and error tuples, plus list patterns for heads and tails.

Explore branching in Elixir with if, cond, and unless; learn how the last expression determines return values, handle nil, and use unless for readable negative conditions.

Define modules in elixir and treat a module as a package, using public and private functions. Compile, load, and call functions from scripts to explore module behavior and pattern matching.

Explore pattern matching to define functions in Elixir, using clauses like div(_,0) and div(x,y) to handle errors and general cases for clean Phoenix code.

Learn how guards in Elixir function definitions use pattern matching to dispatch on arguments, enabling readable clauses that return booleans for zero and fall back when inputs are not integers.

Identify anonymous vs named functions in Elixir, define and call them with def and end, and apply default values for arguments to control string join with a separator.

See how the Elixir pipe operator improves readability and reduces repetition by composing functions to compute the square of a list's sum, with practical use in Phoenix.

Explore loops and recursion in Elixir by using for loops to transform lists, and by implementing a recursive sum with pattern matching and an accumulator.

Explore file handling in Elixir by opening, writing, and reading files, using pattern matching, case expressions, and cross-platform path joining with Path.

Explore requiring and importing modules in Elixir, define structs with defaults (name and age), and understand copying updates in a Phoenix context.

Explore concurrency in Elixir on the beam by building a simple server that listens for messages with a receive loop and uses spawning for multi-threading.

Install hex and rebar, set up Phoenix on Windows, create a new Phoenix project, install assets with npm install, run mix ecto.create, and start the Phoenix server at localhost:4000.

Set up Phoenix on Ubuntu by installing Postgres and Node via nvm, configuring notify tools, then create a new project, install dependencies, and run at localhost:4000.

Learn to set up Phoenix on Mac by installing homebrew and PostgreSQL, creating a database user and password, installing node via nvm, and running a local Phoenix project at localhost:4000.

Learn how Phoenix uses MVC concepts to structure data, transformation, and presentation. Create a new page by editing the router, page controller, and templates.

Create a new page in Phoenix by adding a route, Hello controller, view, and template; render hello world from Phoenix with live reload.

Pass data to a page by using a route parameter and controller to render a template that displays the provided value, such as hello John, via a messenger variable.

Use path helpers to generate dynamic links that adapt when controller or route changes, render with the connection, and use put_flash to show welcome back or error messages in templates.

Learn how controllers pass variables to views using assigns and the pipe operator, render dynamic values in templates, and share common functions across layouts; also set text/plain responses for downloads.

Explore real-time messaging with Phoenix channels and pubsub, using a chat room example to broadcast new messages to all subscribers.

Learn how Phoenix interacts with databases through Ecto, creating schemas and migrations, validating data with changesets, and switching adapters without changing the web app code.

Explore adding and validating constraints in a real world Elixir and Phoenix app, enforcing required fields and a minimum bio length via schema validations in the interactive shell.

Use repo to query the users table, insert new users with emails, and view results as maps mapping user IDs to emails, leveraging Phoenix scaffolding.

Build a small Phoenix project, a content management system with user authentication via email, session maintenance, and article posting, organized into an accounts context with user and credential modules.

Learn to add credentials for accounts by creating a credentials schema with a unique email, linking it to users, and preloading credentials in the accounts context before migrating.

Learn how to link authorization credentials to users in a phoenix app by extending the user form with an email input, credential validation, and error handling.

Alias the user and credential, modify changesets to auto-insert emails, and apply the credential chainset on create and update to enable a linked user credential system with two-factor authentication.

Master session management in elixir and phoenix by authenticating users with email and password, handling authorized and unauthorized flows via a session controller, flash messages, and redirects to home page.

Define a login form and session view, build Phoenix templates, and implement an authentication plug that uses sessions, flash messages, and redirects to protect routes.

Protect CMS pages by using an authenticate user plug, define a CMS scope and routes, and require login before accessing the protected content.

Create a dedicated authors context and authors table in the CMS, linking authors to users with bio and role, enforcing cascade delete, and attaching author_id to pages.

Preload authors and their associated user credentials when loading pages, and link each author to its pages; implement plugs to ensure author existence and authorize page actions.

Associate new pages to the logged in user by updating create, edit, update, and delete flows to use the current author from the session and display it on page view.

Increment a page’s views in Elixir and Phoenix by piping updates through a function that updates database with the page id, returning views, and wiring it into the show function.

Explore real-time user experiences with Phoenix live view, building a minimal Twitter-like timeline using server-rendered HTML and live components in a new Elixir project.

Learn to implement real-time updates with live view in Phoenix: broadcast post creation and updates via pubsub, subscribe clients, and handle live updates with temporary assigns and sorted timelines.

Click the like button to broadcast updates over the socket, updating the likes count in real time and refreshing the UI automatically, with no Ajax or JavaScript.