Learn Elixir | Plans & Pricing

Self Guided

A sample of Elixir Mastery

Update your subscription anytime

Includes
Videos Only
14 Day Free Trial
Intro to Elixir
  1. Course Overview
  2. What you need to do well in this course
  3. Why Elixir is poised for the future
  4. What is functional programming and how does it apply to Elixir
The Syntax and Fundamentals
  1. Overview and Installation
  2. Syntax Basics
  3. Pattern Matching
  4. Advanced Syntax
  5. Keeping Flow Clean
  6. Functional Descriptive Flow
REST and GraphQL with Phoenix
  1. Overview and Phoenix Installation
  2. Introduction to Phoenix and its Architecture
  3. Creating a REST API
  4. GraphQL vs REST
  5. Creating a GraphQL API
  6. Creating Web Pages with Phoenix
  7. Phoenix Channels and GraphQL Subscriptions
Ecto DB and Architecture
  1. Overview
  2. Creating Schemas and Migrations
  3. Data Integrity Through Changesets
  4. Writing and Composing Queries
  5. Managing Schema Relationships
  6. Integrating Ecto with Phoenix
OTP & Testing
  1. Overview
  2. 1 - What is OTP
  3. 1.1 - OTP Supervisors and Workers
  4. 1.2 - OTP Process Communication
  5. 1.3 - OTP Agent, GenServers & Tasks
  6. 1.4 - OTP Application
  7. 1.5 - OTP 'Let it Crash'
  8. 1.6 - OTP Process Limitations
  9. 2 - ExUnit
  10. 2.1 - Writing Testable Code
  11. 2.2 - Testing OTP
  12. 2.3 - Testing Ecto
  13. 2.4 - Testing REST
  14. 2.5 - Testing GraphQL
  15. 2.6 - Testing GraphQL Subscriptions
  16. 3 - Writing Maintainable Tests
  17. 3.1 - Cleaning up Tests with Support
  18. 3.2 - Stubbing & Mocking
  19. 3.3 - Testing Side Effects
  20. 3.4 - Crushing Bugs with IEx, Logger and IO.inspect
Absinthe Deep Dive & Pre-emptive error Handling
  1. Overview
  2. 1.0 - Thinking About Errors
  3. 1.1 - Erroring Gracefully
  4. 1.2 - Writing to Handle Unknown Errors
  5. 2.0 - Adding Logging to Aid Debugging
  6. 2.1 - Creating Error Systems for Debugging
  7. 2.2 - Using IEx to Debug Code
  8. 2.3 - Debugging with Observer
  9. 3.0 - Absinthe's Middleware
  10. 3.1 - Absinthe's Resolution Object
  11. 3.3 - Absinthe Fields and Objects
  12. 3.4 - Writing Documentation With Absinthe
Planning for scalability & How to go distributed
  1. Overview
  2. 1.0 - Elixir Limitations
  3. 1.1 - Statistics to Measure Scale
  4. 1.2 - Side Effects of Scaling
  5. 2.0 - Bottlenecks from Elixir
  6. 2.1 - Pooling for Increasing Bottleneck Width
  7. 2.2 - ETS to Eliminate State Access Bottlenecks
  8. 2.3 - How to Architect with Bottlenecks in Mind
  9. 3.0 - Connecting Elixir Nodes
  10. 3.1 - Sending Messages Across Nodes
  11. 3.2 - Clustering Nodes with LibCluster
  12. 3.3 - Distributing Work with Tasks
  13. 3.4 - Distributing Phoenix & Absinthe
  14. 4.0 - Using GenStage to Process Lots of Data
  15. 4.1 - GenStage Dispatchers
  16. 4.2 - GenStage Consumer Producers
Metrics & Distributed tooling
  1. Overview
  2. 1.0 - What are Metrics
  3. 1.1 - Beam Telemetry
  4. 2.0 - Setting up Prometheus and Grafana
  5. 2.1 - Gathering Metrics with Prometheus
  6. 2.2 - Prometheus Counters, Gauges & Histograms
  7. 2.3 - Grafana Deep Dive
  8. 2.4 - Building Good Grafana Dashboards
  9. 3.0 - Using Global for Distributed Communication
  10. 3.1 - CAP Theorem Basics
  11. 3.2 - Creating Distributed Supervisors with Horde
  12. 4.0 - Replicating State Across Clustered Nodes
  13. 4.1 - Using DeltaCRDT to Create a Caching System
  14. 4.2 - Distributed Hash Rings
  15. 4.3 - Using Redis as a Cache
  16. 4.4 - Distributed Caching Types & Trade-offs
Advanced Elixir Application Architecture & Development
  1. Overview
  2. 1.0 - Directory Organization & Module Structure
  3. 1.1 - Umbrella & Poncho Projects
  4. 2.0 - Connecting to Other Languages
  5. 2.1 - Developing with NIFs
  6. 3.0 - Architecting a Green Field Application
  7. 3.1 - Architecting Data Flow
  8. 3.2 - Architecting Clean Applications
  9. 3.3 - Thinking about the VM & Reductions
  10. 4.0 - Oban Intro & Setup
  11. 4.1 - Oban Deep Dive
  12. 4.2 - Architecting Systems with Oban
  13. 5.0 - Evaluating Development Tradeoffs
  14. 5.1 - The Importance of Delaying Architecture Decisions
  15. 6.0 - Assessing Workload
  16. 6.1 - Shortening Development Time with Libraries
  17. 7.0 - Setting up Credo
  18. 7.1 - Setting up Dialyzer
  19. 7.2 - Setting up Code Coverage
Tuning the VM & How to Create and Manage Releases
  1. Overview
  2. 1.0 - Remote Debugging Tools
  3. 1.1 - Finding Bottlenecks with Recon
  4. 1.2 - Remote Tracing with RexBug
  5. 2.0 - Analyzing VM Memory & CPU
  6. 2.1 - Debugging High VM CPU
  7. 2.2 - Debugging High VM Memory
  8. 3.0 - Knowing the VM's Limits
  9. 3.1 - Where the VM Limits Bend
  10. 3.2 - When to Tune the VM
  11. 4.0 - Drafting Releases with mix release
  12. 4.1 - Deploying Bare Metal Releases Over SSH
  13. 4.2 - Deploying Releases with Docker Containers
  14. 4.3 - Using Hot-Code Upgrades to Deploy
  15. 5.0 - How to setup CI
  16. 5.1 - How to Manage Releases
  17. 5.2 - How to Setup a CD Pipeline