Erlang Programming by Cesarini, Francesco -- Read -- Imperial Library of Trantor

Index

Erlang Programming

SPECIAL OFFER: Upgrade this ebook with O’Reilly Foreword Preface

Francesco: Why Erlang? Simon: Why Erlang? Who Should Read This Book? How to Read This Book Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us Acknowledgments

1. Introduction

Why Should I Use Erlang? The History of Erlang Erlang’s Characteristics

High-Level Constructs Concurrent Processes and Message Passing Scalable, Safe, and Efficient Concurrency Soft Real-Time Properties Robustness Distributed Computation Integration and Openness

Erlang and Multicore Case Studies

The AXD301 ATM Switch CouchDB Comparing Erlang to C++

How Should I Use Erlang?

2. Basic Erlang

Integers The Erlang Shell Floats

Mathematical Operators

Atoms Booleans Tuples Lists

Characters and Strings Atoms and Strings Building and Processing Lists List Functions and Operations

Term Comparison Variables Complex Data Structures Pattern Matching Functions Modules

Compilation and the Erlang Virtual Machine Module Directives

Exercises

Exercise 2-1: The Shell

A. Erlang expressions B. Assigning through pattern matching C. Recursive list definitions D. Flow of execution through pattern matching E. Extracting values in composite data types through pattern matching

Exercise 2-2: Modules and Functions Exercise 2-3: Simple Pattern Matching

3. Sequential Erlang

Conditional Evaluations

The case Construct Variable Scope The if Construct

Guards Built-in Functions

Object Access and Examination Type Conversion Process Dictionary Meta Programming Process, Port, Distribution, and System Information Input and Output

Recursion

Tail-Recursive Functions Tail-Call Recursion Optimization

Two accumulators example

Iterations Versus Recursive Functions

Runtime Errors Handling Errors

Using try ... catch Using catch

Library Modules

Documentation Useful Modules

The Debugger Exercises

Exercise 3-1: Evaluating Expressions Exercise 3-2: Creating Lists Exercise 3-3: Side Effects Exercise 3-4: Database Handling Using Lists Exercise 3-5: Manipulating Lists Exercise 3-6: Sorting Lists Exercise 3-7: Using Library Modules Exercise 3-8: Evaluating and Compiling Expressions Exercise 3-9: Indexing Exercise 3-10: Text Processing

4. Concurrent Programming

Creating Processes Message Passing Receiving Messages

Selective and Nonselective Receives An Echo Example

Registered Processes Timeouts Benchmarking Process Skeletons Tail Recursion and Memory Leaks A Case Study on Concurrency-Oriented Programming Race Conditions, Deadlocks, and Process Starvation The Process Manager Exercises

Exercise 4-1: An Echo Server Exercise 4-2: The Process Ring

5. Process Design Patterns

Client/Server Models

A Client/Server Example

A Process Pattern Example Finite State Machines

An FSM Example A Mutex Semaphore

Event Managers and Handlers

A Generic Event Manager Example Event Handlers

Exercises

Exercise 5-1: A Database Server Exercise 5-2: Changing the Frequency Server Exercise 5-3: Swapping Handlers Exercise 5-4: Event Statistics Exercise 5-5: Phone FSM

6. Process Error Handling

Process Links and Exit Signals

Trapping Exits The monitor BIFs The exit BIFs BIFs and Terminology Propagation Semantics

Robust Systems

Monitoring Clients A Supervisor Example

Exercises

Exercise 6-1: The Linked Ping Pong Server Exercise 6-2: A Reliable Mutex Semaphore Exercise 6-3: A Supervisor Process

7. Records and Macros

Records

Introducing Records Working with Records Functions and Pattern Matching over Records Records in the Shell Record Implementation Record BIFs

Macros

Simple Macros Parameterized Macros Debugging and Macros Include Files

Exercises

Exercise 7-1: Extending Records Exercise 7-2: Record Guards Exercise 7-3: The db.erl Exercise Revisited Exercise 7-4: Records and Shapes Exercise 7-5: Binary Tree Records Exercise 7-6: Parameterized Macros Exercise 7-7: Counting Calls Exercise 7-8: Enumerated Types Exercise 7-9: Debugging the db.erl Exercise

8. Software Upgrade

Upgrading Modules Behind the Scenes

Loading Code The Code Server

Loading modules Manipulating the code search path

Purging Modules

Upgrading Processes The .erlang File Exercise

Exercise 8-1: Software Upgrade During Runtime

9. More Data Types and High-Level Constructs

Functional Programming for Real Funs and Higher-Order Functions

Functions As Arguments Writing Down Functions: fun Expressions Functions As Results Using Already Defined Functions Functions and Variables Predefined, Higher-Order Functions Lazy Evaluation and Lists

List Comprehensions

A First Example General List Comprehensions Multiple Generators Standard Functions

Binaries and Serialization

Binaries The Bit Syntax

Sizes Types

Pattern-Matching Bits Bitstring Comprehensions Bit Syntax Example: Decoding TCP Segments Bitwise Operators Serialization

References Exercises

Exercise 9-1: Higher-Order Functions Exercise 9-2: List Comprehensions Exercise 9-3: Zip Functions Exercise 9-4: Existing Higher-Order Functions Exercise 9-5: Length Specifications in List Comprehensions Exercise 9-6: Bitstrings

10. ETS and Dets Tables

ETS Tables

Implementations and Trade-offs Creating Tables Handling Table Elements Example: Building an Index, Act I Traversing Tables Example: Building an Index, Act II Extracting Table Information: match Extracting Table Information: select Other Operations on Tables Records and ETS Tables Visualizing Tables

Dets Tables A Mobile Subscriber Database Example

The Database Backend Operations The Database Server

Exercises

Exercise 10-1: Pretty-Printing Exercise 10-2: Indexing Revisited Exercise 10-3: ETS Tables for System Logging

11. Distributed Programming in Erlang

Distributed Systems in Erlang Distributed Computing in Erlang: The Basics

Node Names and Visibility Communication and Security

Distributing the Erlang code: A warning

Communication and Messages Node Connections

Hidden nodes

Remote Procedure Calls The rpc Module Essential Distributed Programming Modules

The epmd Process

Distributed Erlang Behind Firewalls

Exercises

Exercise 11-1: Distributed Associative Store Exercise 11-2: System Monitoring

12. OTP Behaviors

Introduction to OTP Behaviors Generic Servers

Starting Your Server Passing Messages Stopping the Server The Example in Full Running gen_server

Supervisors

Supervisor Specifications Child Specifications Supervisor Example Dynamic Children

Applications

Directory Structure The Application Resource File Starting and Stopping Applications The Application Monitor

Release Handling Other Behaviors and Further Reading Exercises

Exercise 12-1: Database Server Revisited Exercise 12-2: Supervising the Database Server Exercise 12-3: The Database Server As an Application

13. Introducing Mnesia

When to Use Mnesia Configuring Mnesia

Setting Up the Schema Starting Mnesia Mnesia Tables

Transactions

Writing Reading and Deleting Indexing Dirty Operations

Partitioned Networks Further Reading Exercises

Exercise 13-1: Setting Up Mnesia Exercise 13-2: Transactions Exercise 13-3: Dirty Mnesia Operations

14. GUI Programming with wxErlang

wxWidgets wxErlang: An Erlang Binding for wxWidgets

Objects and Types Event Handling, Object Identifiers, and Event Types Putting It All Together

A First Example: MicroBlog The MiniBlog Example Obtaining and Running wxErlang Exercises

Exercise 14-1: Selecting the Blog File Exercise 14-2: Saving Blog Items Separately Exercise 14-3: Multiple Blogs in Separate Tabs Exercise 14-4: Extending the Entries—Rich Text Exercise 14-5: Tagging Entries Exercise 14-6: Multiple Users and Comments Exercise 14-7: Layout and wxErlang Sizers

15. Socket Programming

User Datagram Protocol Transmission Control Protocol

A TCP Example

The inet Module Further Reading Exercises

Exercise 15-1: Snooping an HTTP Request Exercise 15-2: A Simple HTTP Proxy Exercise 15-3: Peer to Peer

16. Interfacing Erlang with Other Programming Languages

An Overview of Interworking Interworking with Java

Nodes and Mailboxes Representing Erlang Types Communication Putting It Together: RPC Revisited Interaction The Small Print Taking It Further

C Nodes

Going Further

Erlang from the Unix Shell: erl_call Port Programs

Erlang Port Commands Communicating Data to and from a Port

Library Support for Communication

Working in Ruby: erlectricity

An example using erlectricity

Linked-in Drivers and the FFI Exercises

Exercise 16-1: C Factorial via a Port Exercise 16-2: Factorial Server in Another Language

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

Introduction The Trace BIFs

Process Trace Flags Inheritance Flags Garbage Collection and Timestamps

Tracing Calls with the trace_pattern BIF The dbg Tracer

Getting Started with dbg Tracing and Profiling Functions Tracing Local and Global Function Calls Distributed Environments Redirecting the Output

Redirecting to sockets and binary files

Match Specifications: The fun Syntax

Generating Specifications Using fun2ms

Odds and ends with fun2ms

Difference Between ets and dbg Match Specifications

Match Specifications: The Nuts and Bolts

The Head Conditions The Specification Body Saving Match Specifications