Books & Videos

Table of Contents

  1. Chapter 1 Getting Comfortable

    1. Installation

    2. Firing It Up

    3. First Steps

    4. Doing Something

    5. Calling Functions

    6. Numbers in Elixir

    7. Working with Variables in the Shell

  2. Chapter 2 Functions and Modules

    1. Fun with fn

    2. And the &

    3. Defining Modules

    4. From Module to Free-Floating Function

    5. Splitting Code Across Modules

    6. Combining Functions with the Pipe Operator

    7. Importing Functions

    8. Default Values for Arguments

    9. Documenting Code

  3. Chapter 3 Atoms, Tuples, and Pattern Matching

    1. Atoms

    2. Pattern Matching with Atoms

    3. Atomic Booleans

    4. Guards

    5. Underscoring That You Don’t Care

    6. Adding Structure: Tuples

  4. Chapter 4 Logic and Recursion

    1. Logic Inside of Functions

    2. The Gentlest Side Effect: IO.puts

    3. Simple Recursion

  5. Chapter 5 Communicating with Humans

    1. Strings

    2. Multiline Strings

    3. Unicode

    4. Character Lists

    5. String Sigils

    6. Asking Users for Information

  6. Chapter 6 Lists

    1. List Basics

    2. Splitting Lists into Heads and Tails

    3. Processing List Content

    4. Creating Lists with Heads and Tails

    5. Mixing Lists and Tuples

    6. Building a List of Lists

  7. Chapter 7 Name-Value Pairs

    1. Keyword Lists

    2. Lists of Tuples with Multiple Keys

    3. Hash Dictionaries

    4. From Lists to Maps

    5. From Maps to Structs

  8. Chapter 8 Higher-Order Functions and List Comprehensions

    1. Simple Higher-Order Functions

    2. Creating New Lists with Higher-Order Functions

    3. Beyond List Comprehensions

  9. Chapter 9 Playing with Processes

    1. The Shell Is a Process

    2. Spawning Processes from Modules

    3. Lightweight Processes

    4. Registering a Process

    5. When Processes Break

    6. Processes Talking Amongst Themselves

    7. Watching Your Processes

    8. Breaking Things and Linking Processes

  10. Chapter 10 Exceptions, Errors, and Debugging

    1. Flavors of Errors

    2. Rescuing Code from Runtime Errors as They Happen

    3. Logging Progress and Failure

    4. Tracing Messages

    5. Watching Function Calls

  11. Chapter 11 Static Analysis, Typespecs, and Testing

    1. Static Analysis

    2. Typespecs

    3. Writing Unit Tests

    4. Setting Up Tests

    5. Embedding Tests in Documentation

  12. Chapter 12 Storing Structured Data

    1. Records: Structured Data Before Structs

    2. Storing Data in Erlang Term Storage

    3. Storing Records in Mnesia

  13. Chapter 13 Getting Started with OTP

    1. Creating Services with GenServer

    2. A Simple Supervisor

    3. Packaging an Application with Mix

  14. Chapter 14 Using Macros to Extend Elixir

    1. Functions Versus Macros

    2. A Simple Macro

    3. Creating New Logic

    4. Creating Functions Programatically

    5. When (Not) to Use Macros

  15. Chapter 15 Using Phoenix

    1. Skeleton Installation

    2. Structuring a Basic Phoenix Application

    3. Presenting a Page

    4. Calculating

    5. Sharing the Gospel of Elixir

  16. Appendix An Elixir Parts Catalog

    1. Shell Commands

    2. Reserved Words

    3. Operators

    4. Guard Components

    5. Common Functions

    6. Datatypes for Documentation and Analysis

  17. Appendix Generating Documentation with ExDoc

    1. Using ExDoc with Mix