The Art of Erlang

Building Concurrent, Fault-Tolerant Systems with the Language of the Telecommunications Era

Introduction

1. What Makes Erlang Different
2. Who This Book Is For
3. How to Read This Book
4. A Note on Code Examples
5. The Promise of This Book

Chapter 1: The Origins of Erlang

1. The Telecom Crisis of the 1980s
2. Joe Armstrong, Robert Virding and Mike Williams
3. From a Research Project to Ericsson’s Secret Weapon
4. The Design Philosophy: Let It Crash
5. Open Source and the Birth of the Modern Ecosystem

Chapter 2: Philosophy and Architecture

1. Immutability and Pure Functions
2. The Actor Model and Message Passing
3. The BEAM Virtual Machine
4. Garbage Collection in a Concurrent World
5. Comparing Erlang to Other Languages

Chapter 3: Getting Started with Erlang

1. Installing Erlang/OTP
2. The Erlang Shell (REPL)
3. Your First Module
4. Build Tools: Make, Rebar3 and Mix
5. Editor Setup and IDEs

Chapter 4: Language Fundamentals – Syntax and Data Types

1. Variables, Atoms and the Assignment Model
2. Numbers: Integers, Floats and Bignums
3. Tuples, Lists and Maps
4. Binaries and Bit Syntax
5. Operators and Expressions

Chapter 5: Pattern Matching and Control Flow

1. The Power of Pattern Matching
2. Function Clauses and Clause Selection
3. Case Expressions and Multi-Clause Functions
4. Guard Expressions
5. If Expressions and the Receive Construct

Chapter 6: Functions, Modules and Recursion

1. Named Functions and Module Organization
2. Anonymous Functions and Closures
3. Higher-Order Functions and the Lists Module
4. Recursion Patterns: Tail Recursion and Accumulators
5. Recursive Data Processing

Chapter 7: Concurrency – Lightweight Processes and Message Passing

1. What Is an Erlang Process?
2. Spawning and Communicating with Processes
3. The Mailbox and Receive Semantics
4. Linking and Trapping Exits
5. Monitoring and the Monitored Process Registry

Chapter 8: The Open Telecom Platform (OTP) – Overview

1. What Is OTP and Why Does It Exist?
2. OTP Application Structure
3. The Behaviour Pattern
4. OTP Design Principles
5. Building Your First OTP Application

Chapter 9: GenServer – The Workhorse of OTP

1. What Is a GenServer?
2. Implementing a GenServer
3. Handling Calls, Casts and Info Messages
4. State Management and the Code Change Callback
5. Real-World GenServer Patterns

Chapter 10: Supervisors and Fault Tolerance

1. The Supervision Tree
2. Supervisor Strategies
3. Building Robust Supervision Trees
4. Dynamic Child Processes
5. Fault Tolerance in Production

Chapter 11: Applications, Releases and Deployment

1. The Application Behaviour
2. Application Resource Files
3. Release Management with Rebar3
4. Deployment Strategies
5. Monitoring and Observability

Chapter 12: Data Storage – ETS, DETS and Mnesia

1. ETS – In-Memory Tables
2. DETS – Disk-Based Storage
3. Mnesia – Distributed Database
4. Choosing the Right Storage Mechanism
5. Performance and Scalability Considerations

Chapter 13: Distributed Programming

1. Erlang Nodes and the Distributed Runtime
2. Remote Procedure Calls and Node Communication
3. Distributed Processes and Global Names
4. Building Distributed Systems
5. Network Partitions and Split-Brain

Chapter 14: Networking and Interoperability

1. TCP and UDP Sockets
2. Building Network Servers
3. HTTP and Web Frameworks
4. NIFs – Native Implemented Functions
5. Ports and External Program Communication

Chapter 15: Error Handling, Testing and Debugging

1. The Error Handling Philosophy
2. Try-Catch and Exception Types
3. Testing with Common Test and EUnit
4. Property-Based Testing with PropEr
5. Debugging, Tracing and Profiling

Chapter 16: Performance Optimization and Advanced Patterns

1. Understanding Erlang Performance Characteristics
2. Memory Management and Garbage Collection Tuning
3. Compiler Flags and Code Optimization
4. Design Patterns in OTP Applications
5. The Modern Erlang Ecosystem

Chapter 17: Real-World Applications and Case Studies

1. WhatsApp and the Scale of Erlang
2. Riak and Distributed Databases
3. RabbitMQ and Message Brokers
4. Heroku’s Platform Architecture
5. Lessons from Production Deployments

Conclusion: The Future of Erlang

1. Where Erlang Stands Today
2. Elixir and the BEAM Family
3. The Continuing Relevance of OTP
4. Your Path Forward

References