Books & Videos

Table of Contents

  1. Chapter 1 Getting Comfortable

    1. Installation

    2. Firing It Up

    3. First Steps: The Shell

    4. Doing Something

    5. Calling Functions

    6. Numbers in Erlang

    7. Working with Variables in the Shell

  2. Chapter 2 Functions and Modules

    1. Fun with fun

    2. Defining Modules

    3. 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:format

    3. Simple Recursion

  5. Chapter 5 Communicating with Humans

    1. Strings

    2. 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 Higher-Order Functions and List Comprehensions

    1. Simple Higher-Order Functions

    2. Creating New Lists with Higher-Order Functions

    3. Beyond List Comprehensions

  8. Chapter 8 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

  9. Chapter 9 Exceptions, Errors, and Debugging

    1. Flavors of Errors

    2. Catching Runtime Errors as They Happen

    3. Raising Exceptions with throw

    4. Logging Progress and Failure

    5. Debugging through a GUI

    6. Tracing Messages

    7. Watching Function Calls

  10. Chapter 10 Storing Structured Data

    1. Mapping Your Data

    2. From Tuples to Records

    3. Storing Records in Erlang Term Storage

    4. Storing Records in Mnesia

  11. Chapter 11 Getting Started with OTP

    1. The Origins of OTP

    2. Creating Services with gen_server

    3. A Simple Supervisor

    4. Packaging an Application

  12. Chapter 12 Next Steps Through Erlang

    1. Moving Beyond the Erlang Shell

    2. Distributed Computing

    3. Processing Binary Data

    4. Input and Output

    5. Testing, Analyzing, and Refactoring

    6. Networking and the Web

    7. Data Storage

    8. Extending Erlang

    9. Languages Built on Erlang

    10. Community

    11. Sharing the Gospel of Erlang

  13. Appendix An Erlang Parts Catalog

    1. Shell Commands

    2. Reserved Words

    3. Operators

    4. Guard Components

    5. Common Functions

    6. Strings and Formatting

    7. Data Types for Documentation and Analysis

  14. Appendix OTP Templates