Elixir for Beginners: Learn Functional Programming

Explore Elixir's mix build tool, create and test a new project, and implement a custom mix task, then run apps and tasks from the terminal and Visual Studio Code.

Create a basic Elixir app, write hello world in a main file, run with Elixir or IEx, and later scaffold a Mix project to manage tasks.

Explore the basic data types in Elixir, including integers, floats (64-bit double precision), booleans, nil, atoms, strings, and comments, with binary, octal, and hex numbers in IEx.

Elixir variables follow snake case and lowercase, with a leading underscore indicating ignored values. See variables as labels, not memory, and explore io.puts and functions like is_integer, round, and string.length.

Explore Elixir basics: arithmetic with +, -, *, / and precedence rules, integer division with div and rem, string concatenation with <> and interpolation, and truthy, falsy values in comparisons.

Learn how to handle user input in Elixir by using IO.get and IO.puts, trimming input, converting strings to floats, and adding two numbers to display the result.

Explore Elixir collections, focusing on lists and tuples, creation with square brackets and linked lists, and operations ++ and --, plus head and tail HD TL and fast tuple_size access.

Explore how tuples use a contiguous memory block for fast indexing and size calculation, contrasted with linked lists that store elements in separate blocks, making prepending faster than appending.

Explore pattern matching in Elixir, using the match operator to bind values, destructure tuples and lists, and handle match errors; learn pin operator for rebinding and underscore for ignored values.

Learn how to use Elixir control flow with case, cond, and if, and practice pattern matching, guards, and the pin operator through practical code examples.

Learn how the if macro works as an expression with else, observe variable scoping inside and outside if, understand truthy values, and use cond for multi-condition checks.

Explore keyword lists in Elixir as square brackets containing ordered key-value pairs where keys are atoms, duplicates are allowed, and options pass to functions.

Explore maps as key-value data structures in Elixir, learn atom and non-atom keys, accessing values, pattern matching, updating keys, and converting maps to keyword lists.

Identify named functions in Elixir by name and arity using the slash notation (name/arity) with examples like node/0 and div/2, and use iex to access docs with h/arity.

Explore anonymous functions in Elixir, learn how to define them with fn, call via dot syntax, and use closures, arity checks, and pattern matching with guards.

Explore the capture operator (&) for referencing named functions and creating anonymous functions in Elixir, using &1, &2, operators, and spawning processes and modules like Enum and Stream.

Learn how to create modules and named functions in Elixir, distinguish public and private helpers, and apply pattern matching, guards, and one line expressions to build function clauses.

Demonstrates recursion to count list elements via head and tail until the empty list, and shows function overloading by arity with default arguments and pattern matching.

Explore the Elixir pipe operator, which passes the result of one expression as the first argument to the next function, improving readability and reducing nesting, and include parentheses for clarity.

Explore Elixir comprehensions, a syntax sugar for looping through enumerables, with examples of for loops, pattern matching, filtering, multiple generators, and using into to produce maps.

Explore strings in Elixir as UTF-8 binaries, learn code points, graphemes, and byte size, and practice conversions between strings, char lists, and binaries using real examples.

Explore sigils in Elixir to create literal strings, lists, and regex with lowercase and uppercase forms, using delimiters, interpolation, and escape sequences.

Explore Elixir ranges and lazy enumerables and streams, learn how the Enum module powers map, filter, sort, unique, and each, and see how piping improves readable, memory-efficient data transformations.

Explore Elixir's stream module and lazy enumerables, comparing streams with enums. Learn how lazy streams avoid intermediate lists, boost memory efficiency for large infinite collections, and use take and sum.

Define a book struct as a blueprint with title, author, pages, genre using defstruct, then create, access with dot, update with bar, and enforce keys.

Introduce functional programming concepts like immutability, avoiding side effects, and first-class functions, contrasting with imperative approaches, and show declarative goals guiding Elixir code.

Compare pure functions and side effects in Elixir, showing how pure functions deliver predictable outputs and ease testing, while isolating side effects with a wrapper function for cleaner, safer concurrency.

Explore immutability in Elixir, where data structures are immutable and updates create new values through rebinding, keeping originals intact, enabling thread safety and pure functional style.

Explore functions in Elixir as first-class data, learn higher-order functions, and practice partially applied functions using examples like double, apply twice, and the capture operator.

Explore how functional languages avoid mutable state by using recursion instead of loops, illustrated with summing a list via head and tail, base case, and tail-recursive accumulator.

Master concurrency concepts in Elixir by learning how lightweight BEAM processes with PIDs run tasks in parallel, avoiding blocking and enabling scalable, responsive apps.

Spawn lightweight Elixir processes to enable concurrency, using anonymous functions or named module functions, and track them with pid, inspect, process_alive?, and self, while sleeping via Erlang timer.

Learn to pass messages between Elixir processes using mailboxes, the send and receive pattern with guards, and after timeouts. Spawn long-running processes, and use flush to inspect messages.

Explore how linking in Elixir enables fault tolerant, restartable processes; embrace the let it crash philosophy with supervision, catch exits with a process flag and trap exits, use spawn_link.

Explore how the Task module abstracts spawn and spawn_link for concurrency in Elixir, with better error reporting, debugging, and introspection. Use task.async and task.await for non-blocking background work.

Explore managing state in Elixir with manual process loops using a counter, handling increment and decrement and returning the new count; compare to agents for get and update with naming.