Books & Videos

Table of Contents

  1. Chapter 1 Introduction

    1. Why Should I Use Erlang?

    2. The History of Erlang

    3. Erlang’s Characteristics

    4. Erlang and Multicore

    5. Case Studies

    6. How Should I Use Erlang?

  2. Chapter 2 Basic Erlang

    1. Integers

    2. The Erlang Shell

    3. Floats

    4. Atoms

    5. Booleans

    6. Tuples

    7. Lists

    8. Term Comparison

    9. Variables

    10. Complex Data Structures

    11. Pattern Matching

    12. Functions

    13. Modules

    14. Exercises

  3. Chapter 3 Sequential Erlang

    1. Conditional Evaluations

    2. Guards

    3. Built-in Functions

    4. Recursion

    5. Runtime Errors

    6. Handling Errors

    7. Library Modules

    8. The Debugger

    9. Exercises

  4. Chapter 4 Concurrent Programming

    1. Creating Processes

    2. Message Passing

    3. Receiving Messages

    4. Registered Processes

    5. Timeouts

    6. Benchmarking

    7. Process Skeletons

    8. Tail Recursion and Memory Leaks

    9. A Case Study on Concurrency-Oriented Programming

    10. Race Conditions, Deadlocks, and Process Starvation

    11. The Process Manager

    12. Exercises

  5. Chapter 5 Process Design Patterns

    1. Client/Server Models

    2. A Process Pattern Example

    3. Finite State Machines

    4. Event Managers and Handlers

    5. Exercises

  6. Chapter 6 Process Error Handling

    1. Process Links and Exit Signals

    2. Robust Systems

    3. Exercises

  7. Chapter 7 Records and Macros

    1. Records

    2. Macros

    3. Exercises

  8. Chapter 8 Software Upgrade

    1. Upgrading Modules

    2. Behind the Scenes

    3. Upgrading Processes

    4. The .erlang File

    5. Exercise

  9. Chapter 9 More Data Types and High-Level Constructs

    1. Functional Programming for Real

    2. Funs and Higher-Order Functions

    3. List Comprehensions

    4. Binaries and Serialization

    5. References

    6. Exercises

  10. Chapter 10 ETS and Dets Tables

    1. ETS Tables

    2. Dets Tables

    3. A Mobile Subscriber Database Example

    4. Exercises

  11. Chapter 11 Distributed Programming in Erlang

    1. Distributed Systems in Erlang

    2. Distributed Computing in Erlang: The Basics

    3. The epmd Process

    4. Exercises

  12. Chapter 12 OTP Behaviors

    1. Introduction to OTP Behaviors

    2. Generic Servers

    3. Supervisors

    4. Applications

    5. Release Handling

    6. Other Behaviors and Further Reading

    7. Exercises

  13. Chapter 13 Introducing Mnesia

    1. When to Use Mnesia

    2. Configuring Mnesia

    3. Transactions

    4. Partitioned Networks

    5. Further Reading

    6. Exercises

  14. Chapter 14 GUI Programming with wxErlang

    1. wxWidgets

    2. wxErlang: An Erlang Binding for wxWidgets

    3. A First Example: MicroBlog

    4. The MiniBlog Example

    5. Obtaining and Running wxErlang

    6. Exercises

  15. Chapter 15 Socket Programming

    1. User Datagram Protocol

    2. Transmission Control Protocol

    3. The inet Module

    4. Further Reading

    5. Exercises

  16. Chapter 16 Interfacing Erlang with Other Programming Languages

    1. An Overview of Interworking

    2. Interworking with Java

    3. C Nodes

    4. Erlang from the Unix Shell: erl_call

    5. Port Programs

    6. Library Support for Communication

    7. Linked-in Drivers and the FFI

    8. Exercises

  17. Chapter 17 Trace BIFs, the dbg Tracer, and Match Specifications

    1. Introduction

    2. The Trace BIFs

    3. Tracing Calls with the trace_pattern BIF

    4. The dbg Tracer

    5. Match Specifications: The fun Syntax

    6. Match Specifications: The Nuts and Bolts

    7. Further Reading

    8. Exercises

  18. Chapter 18 Types and Documentation

    1. Types in Erlang

    2. TypEr: Success Types and Type Inference

    3. Documentation with EDoc

    4. Exercises

  19. Chapter 19 EUnit and Test-Driven Development

    1. Test-Driven Development

    2. EUnit

    3. The EUnit Infrastructure

    4. Testing State-Based Systems

    5. Testing Concurrent Programs in Erlang

    6. Exercises

  20. Chapter 20 Style and Efficiency

    1. Applications and Modules

    2. Processes and Concurrency

    3. Stylistic Conventions

    4. Coding Strategies

    5. Efficiency

    6. And Finally...

  1. Appendix Using Erlang

    1. Getting Started with Erlang

    2. Tools for Erlang

    3. Where to Learn More

  2. Colophon