The Pragmatic programmers - Joe Armstrong - Programming Erlang Software for a Concurrent World 2 edition [2013, PDF, ENG]

Introduction
Part I —Why Erlang?
1. Introducing Concurrency
1.2 Benefits of Concurrency
1.3 Concurrent Programs and Parallel Computers
1.4 Sequential vs. Concurrent Programming Languages
2. A Whirlwind Tour of Erlang
2.1 The Shell
2.2 Processes, Modules, and Compilation
2.3 Hello, Concurrency
Part II —Sequential Programming
3. Basic Concepts
3.2 Simple Integer Arithmetic
3.3 Variables
3.4 Floating-Point Numbers
3.5 Atoms
3.6 Tuples
3.7 Lists
3.8 Strings
3.9 Pattern Matching Again
4. Modules and Functions
4.2 Back to Shopping
4.3 Funs: The Basic Unit of Abstraction
4.4 Simple List Processing
4.5 List Comprehensions
4.6 BIFs
4.7 Guards
4.8 case and if Expressions
4.9 Building Lists in Natural Order
4.10 Accumulators
5. Records and Maps
5.1 When to Use Maps or Records
5.2 Naming Tuple Items with Records
5.3 Maps: Associative Key-Value Stores
6. Error Handling in Sequential Programs
6.2 Trapping an Exception with try…catch
6.3 Trapping an Exception with catch
6.4 Programming Style with Exceptions
6.5 Stack Traces
6.6 Fail Fast and Noisily, Fail Politely
7. Binaries and the Bit Syntax
7.1 Binaries
7.2 The Bit Syntax
7.3 Bitstrings: Processing Bit-Level Data
8. The Rest of Sequential Erlang
8.2 Arithmetic Expressions
8.3 Arity
8.4 Attributes
8.5 Block Expressions
8.6 Booleans
8.7 Boolean Expressions
8.8 Character Set
8.9 Comments
8.10 Dynamic Code Loading
8.11 Erlang Preprocessor
8.12 Escape Sequences
8.13 Expressions and Expression Sequences
8.14 Function References
8.15 Include Files
8.16 List Operations ++ and --
8.17 Macros
8.18 Match Operator in Patterns
8.19 Numbers
8.20 Operator Precedence
8.21 The Process Dictionary
8.22 References
8.23 Short-Circuit Boolean Expressions
8.24 Term Comparisons
8.25 Tuple Modules
8.26 Underscore Variables
9. Types
9.1 Specifying Data and Function Types
9.2 Erlang Type Notation
9.3 A Session with the Dialyzer
9.4 Type Inference and Success Typing
9.5 Limitations of the Type System
10. Compiling and Running Your Program
10.1 Modifying the Development Environment
10.2 Different Ways to Run Your Program
10.3 Automating Compilation with Makefiles
10.4 When Things Go Wrong
10.5 Getting Help
10.6 Tweaking the Environment
Part III —Concurrent and Distributed Programs
11. Real-World Concurrency
12. Concurrent Programming
12.1 The Concurrency Primitives
12.2 Introducing Client-Server
12.3 Processes Are Cheap
12.4 Receive with a Timeout
12.5 Selective Receive
12.6 Registered Processes
12.7 A Word About Tail Recursion
12.8 Spawning with MFAs or Funs
13. Errors in Concurrent Programs.
13.1 Error Handling Philosophy
13.2 Error Handling Semantics
13.3 Creating Links
13.4 Groups of Processes That All Die Together
13.5 Setting Up a Firewall
13.6 Monitors
13.7 Error Handling Primitives
13.8 Programming for Fault Tolerance
14. Distributed Programming
14.1 Two Models for Distribution
14.2 Writing a Distributed Program
14.3 Building the Name Server
14.4 Libraries and BIFS for Distributed Programming
14.5 The Cookie Protection System
14.6 Socket-Based Distribution
Part IV — Programming Libraries and Frameworks
15. Interfacing Techniques
15.1 How Erlang Communicates with External Programs
15.2 Interfacing an External C Program with a Port
15.3 Calling a Shell Script from Erlang
15.4 Advanced Interfacing Techniques
16. Programming with Files
16.1 Modules for Manipulating Files
16.2 Ways to Read a File
16.3 Ways to Write a File
16.4 Directory and File Operations
16.5 Bits and Pieces
16.6 A Find Utility
17. Programming with Sockets Using TCP 17.1
17.2 Active and Passive Sockets
17.3 Error Handling with Sockets
17.4 UDP
17.5 Broadcasting to Multiple Machines
17.6 A SHOUTcast Server
18. Browsing with Websockets and Erlang
18.1 Creating a Digital Clock
18.2 Basic Interaction
18.3 An Erlang Shell in the Browser
18.4 Creating a Chat Widget
18.5 IRC Lite
18.6 Graphics in the Browser
18.7 The Browser Server Protocol
19. Storing Data with ETS and DETS
19.1 Types of Table
19.2 ETS Table Efficiency Considerations
19.3 Creating an ETS Table
19.4 Example Programs with ETS
19.5 Storing Tuples on Disk
19.6 What Haven’t We Talked About?
20. Mnesia: The Erlang Database
20.1 Creating the Initial Database
20.2 Database Queries
20.3 Adding and Removing Data in the Database
20.4 Mnesia Transactions
20.5 Storing Complex Data in Tables
20.6 Table Types and Location
20.7 The Table Viewer
20.8 Digging Deeper
21. Profiling, Debugging, and Tracing
21.1 Tools for Profiling Erlang Code
21.2 Testing Code Coverage
21.3 Generating Cross-References
21.4 Compiler Diagnostics
21.5 Runtime Diagnostics
21.6 Debugging Techniques
21.7 The Erlang Debugger
21.8 Tracing Messages and Process Execution
21.9 Frameworks for Testing Erlang Code
22. Introducing OTP
22.1 The Road to the Generic Server
22.2 Getting Started with gen_server
22.3 The gen_server Callback Structure
22.4 Filling in the gen_server Template
22.5 Digging Deeper
23. Making a System with OTP
23.1 Generic Event Handling
23.2 The Error Logger
23.3 Alarm Management
23.4 The Application Servers
23.5 The Supervision Tree
23.6 Starting the System
23.7 The Application
23.8 File System Organization
23.9 The Application Monitor
23.10 How Did We Make That Prime?
23.11 Digging Deeper
Part V —Building Applications
24. Programming Idioms
24.1 Maintaining the Erlang View of the World
24.2 A Multipurpose Server
24.3 Stateful Modules
24.4 Adapter Patterns
24.5 Intentional Programming
25. Third-Party Programs
25.1 Making a Shareable Archive and Managing Your Code with Rebar
25.2 Integrating External Programs with Our Code
25.3 Making a Local Copy of the Dependencies
25.4 Building Embedded Web Servers with Cowboy
26. Programming Multicore CPUs
26.1 Good News for Erlang Programmers
26.2 How to Make Programs Run Efficiently on a Multicore CPU
26.3 Parallelizing Sequential Code
26.4 Small Messages, Big Computations
26.5 Parallelizing Computations with mapreduce
27. Sherlock’s Last Case
27.1 Finding Similarities in Data
27.2 A Session with Sherlock
27.3 The Importance of Partitioning the Data
27.4 Adding Keywords to the Postings
27.5 Overview of the Implementation
27.6 Exercises
27.7 Wrapping Up
A1. OTP Templates
A1.1 The Generic Server Template
A1.2 The Supervisor Template
A1.3 The Application Template
A2. A Socket Application
A2.1 An Example
A2.2 How lib_chan Works
A2.3 The lib_chan Code
A3. A Simple Execution Environment
A3.1 How Erlang Starts
A3.2 Running Some Test Programs in SEE
A3.3 The SEE API
A3.4 SEE Implementation Details
A3.5 How Code Gets Loaded in Erlang