A multi-user game, web site, cloud application, or networked database can have thousands of users all interacting at the same time. You need a powerful, industrial-strength tool to handle the really hard problems inherent in parallel, concurrent environments. You need Erlang. In this second edition of the bestselling Programming Erlang, you'll learn how to write parallel programs that scale effortlessly on multicore systems.

Using Erlang, you'll be surprised at how easy it becomes to deal with parallel problems, and how much faster and more efficiently your programs run. That's because Erlang uses sets of parallel processes-not a single sequential process, as found in most programming languages.

Joe Armstrong, creator of Erlang, introduces this powerful language in small steps, giving you a complete overview of Erlang and how to use it in common scenarios. You'll start with sequential programming, move to parallel programming and handling errors in parallel programs, and learn to work confidently with distributed programming and the standard Erlang/Open Telecom Platform (OTP) frameworks.

You need no previous knowledge of functional or parallel programming. The chapters are packed with hands-on, real-world tutorial examples and insider tips and advice, and finish with exercises for both beginning and advanced users.

The second edition has been extensively rewritten. New to this edition are seven chapters covering the latest Erlang features: maps, the type system and the Dialyzer, WebSockets, programming idioms, and a new stand-alone execution environment. You'll write programs that dynamically detect and correct errors, and that can be upgraded without stopping the system. There's also coverage of rebar (the de facto Erlang build system), and information on how to share and use Erlang projects on github, illustrated with examples from cowboy and bitcask.

Erlang will change your view of the world, and of how you program.

What You Need

The Erlang/OTP system. Download it from erlang.org.

Table of Contents

Part I — Why Erlang?

1. Introducing Concurrency

2. A Whirlwind Tour of Erlang

Part II — Sequential Programming

3. Basic Concepts

4. Modules and Functions

5. Records and Maps

6. Error Handling in Sequential Programs

7. Binaries and the Bit Syntax

8. The Rest of Sequential Erlang

9. Types

10. Compiling and Running Your Program

Part III — Concurrent and Distributed Programs

11. Real-World Concurrency

12. Concurrent Programming

13. Errors in Concurrent Programs

14. Distributed Programming

Part IV — Programming Libraries and Frameworks

15. Interfacing Techniques

16. Programming with Files

17. Programming with Sockets

18. Browsing with Websockets and Erlang

19. Storing Data with ETS and DETS

20. Mnesia: The Erlang Database

21. Profiling, Debugging, and Tracing

22. Introducing OTP

23. Making a System with OTP

Part V — Building Applications

24. Programming Idioms

25. Third-Party Programs

26. Programming Multicore CPUs

27. Sherlock’s Last Case

A1. OTP Templates

A2. A Socket Application

A3. A Simple Execution Environment

About the Author

Joe Armstrong is one of the creators of Erlang. He has a Ph.D. in computer science from the Royal Institute of Technology in Stockholm, Sweden and is an expert on the construction of fault-tolerant systems. He has worked in industry, as an entrepreneur, and as a researcher for more than 35 years.