Functional Programming using Elixir - The Complete Course

Explore Elixir basics by learning how variables are bound, not assigned, use pattern matching to extract values from tuples, and leverage wildcards and rebindings to control data flow.

Explore built-in data types in Elixir, including numbers (decimal, hex, binary, octal) with underscores for grouping and exponent notation, and atoms, booleans, lists with head and tail.

Master keyword lists and maps as key-value data structures in Elixir, and learn binary strings versus charlists, including access via dot and bracket notation and conversions.

Explore modules as namespaces in Elixir and defining public and private functions with def and defp. Use one-line definitions, camelCase module names, and the pipe operator to chain results.

Learn how arity defines how many arguments a function accepts, implement multiclass functions with the same name but different arities, and use guard clauses for pattern matching and safe fallbacks.

Explore anonymous functions in Elixir, bind lambdas to variables, pass lambdas as arguments, use the capture operator and placeholders, and understand closures in practice.

Explore recursion in Elixir by examining lists, maps, and comprehensions, and implement a recursive map function to multiply elements across lists.

Explore a bit more complex recursion by building a max-finding function over a list in Elixir, using guard clauses and a current-maximum accumulator.

Learn how tail calls optimize recursion in Elixir by converting non-tail recursive patterns into tail-recursive ones, reducing memory usage and improving performance with examples like multiplication and factorial.

Explore Elixir built-in functions for lists and maps, including delete, flatten, insert, pattern matching, and reduce with keyword lists.

Learn how streams in Elixir lazily compose map and drop transformations, enable efficient reductions, and even generate endless streams via iterate to process large data or files without intermediates.

Learn to stream large files in Elixir with the stream module, reading line by line to avoid memory load. Build a typewriter-like output that animates characters with delays.

Explore how comprehensions in Elixir create new collections from existing data using generators, filters, and multiple sources, including lists, ranges, and binary strings.

Learn conditional logic in Elixir, using if, else, and unless, explore case and cond, and leverage pattern matching and macros like keys to build maintainable, testable code and handle defaults.

Learn how to handle exceptions in Elixir with try and rescue, after blocks, and multiple clauses, and understand when to rely on supervision and normal process exits.

Learn how isolated processes, often called actors in Elixir, enable concurrency and fault tolerance by communicating through synchronous messages. This approach supports highly available, scalable, distributed systems with parallel execution.

Learn how to spawn and run concurrent processes in Elixir, observe isolated, independently executing tasks identified by process IDs, and explore closures and random execution order.

Elixir course teaches how to make processes communicate using synchronous messages, send and receive patterns, timeouts, and collecting results through spawning, self, and mailbox behavior, including linking and monitoring.

Build a long-running server process that preserves game state through tail-recursive messages, implementing a two-player take-away game with 1–3 stones per turn.

Explore GenServer in Elixir, learn how OTP behaviours, supervisors, and applications simplify building and managing long-running processes, implement callbacks, set the initial state, and start the server.

Respond to requests on a gen_server using synchronous calls and asynchronous callbacks, and manage the current state with timeouts. Explore arithmetic examples showing error handling and termination.

Refactor a game server with GenServer in Elixir, modeling a stones game with a state of the current player and stones, and handling synchronous calls and guards.

Refactoring a GenServer for a stone-taking game in Elixir, exposing three interface functions, handling start and play flows, and presenting a welcome message while validating moves.

Learn to use mix to create a new Elixir application, scaffold a project skeleton with lib modules, including client and server components. Explore dependencies and supervised versus unsupervised applications.

Install and manage third-party packages in Elixir using Hex, specify dependencies, and resolve them with mix. Understand semantic versioning, differentiate production and development dependencies, and generate project documentation with ex_doc.

Turn your Elixir project into a standalone executable using escript, parse command line arguments with the option parser, define a main function, and run a configurable game of stones.

Configure your Elixir application by moving default values to a config file and overriding them with environment variables. Access configuration keys at runtime to avoid magic numbers.

Learn how to use supervisors in Elixir to restart failed processes, implement one-for-one, one-for-all, and all-for-one strategies, and manage supervised trees for reliable applications.

Explore Elixir term storage with ETS and DETS, learning in-memory and disk-based persistence, table types like set and ordered set, and access control for durable game state across restarts.

Discover how to finalize a persistence mechanism with ETS, manage and clear stored game state, fetch the latest state from storage, and continue the game from that saved state.

Discover how Elixir nodes enable distributing tasks across multiple machines, including naming nodes, inter-node communication, and spawning remote processes with global names and shared cookies.

Explore how to use tasks and agents in Elixir to run background work, manage state, and distribute factorial computations across multiple nodes.

Explore how Elixir represents code as data through quoted expressions and abstract syntax trees, and learn how macros enable metaprogramming before program execution.

Explore metaprogramming with Elixir through quote and unquote, and learn how bindings affect evaluation. Inspect macro internals to understand hygiene and code injection.

Explore polymorphism in Elixir by implementing protocols as contracts. See practical examples with integers, strings, and employee and company structs, using each and related protocol functions.