Joe Armstrong - Programming Erlang: Software for a Concurrent World

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer, Pragmatic Programming, Pragmatic Bookshelf and the linking g device are trademarks of The Pragmatic Programmers, LLC.

Every precaution was taken in the preparation of this book. However, the publisher assumes no responsibility for errors or omissions, or for damages that may result from the use of information (including program listings) contained herein.

Our Pragmatic courses, workshops, and other products can help you and your team create better software and have more fun. For more information, as well as the latest Pragmatic titles, please visit us at http://pragprog.com.

New hardware is increasingly parallel, so new programming languages must support concurrency or they will die.

The way the processor industry is going is to add more and more cores, but nobody knows how to program those things. I mean, two, yeah; four, not really; eight, forget it. Steve Jobs, Apple

Well, Steve was wrong; we do know how to program multicores. We program them in Erlang, and many of our programs just go faster as we add more cores.

Erlang was designed from the bottom up to program concurrent, distributed, fault-tolerant, scalable, soft, real-time systems. Soft real-time systems are systems such as telephone exchanges, banking systems, and so on, where rapid response times are important but its not a disaster if the odd timing deadline is missed. Erlang systems have been deployed on a massive scale and control significant parts of the worlds mobile communication networks.

If your problem is concurrent, if you are building a multiuser system, or if you are building a system that evolves with time, then using Erlang might save you a lot of work, since Erlang was explicitly designed for building such systems.

Its the mutable state, stupid. Brian Goetz, Java Concurrency in Practice

Erlang belongs to the family of functional programming languages . Functional programming forbids code with side effects. Side effects and concurrency dont mix. In Erlang its OK to mutate state within an individual process but not for one process to tinker with the state of another process. Erlang has no mutexes, no synchronized methods, and none of the paraphernalia of shared memory programming.

Processes interact by one method, and one method only, by exchanging messages. Processes share no data with other processes. This is the reason why we can easily distribute Erlang programs over multicores or networks.

When we write an Erlang program, we do not implement it as a single process that does everything; we implement it as large numbers of small processes that do simple things and communicate with each other.

Its about concurrency. Its about distribution. Its about fault tolerance. Its about functional programming. Its about programming a distributed concurrent system without locks and mutexes but using only pure message passing. Its about automatically speeding up your programs on multicore CPUs. Its about writing distributed applications that allow people to interact with each other. Its about design patterns for writing fault-tolerant and distributed systems. Its about modeling concurrency and mapping those models onto computer programs, a process I call concurrency-oriented programming .

The target audience for this book ranges from the experienced Erlang programmer who wants to learn more about Erlang internals and the philosophy behind Erlang to the absolute beginner. The text has been reviewed by programmers at all levels, from expert to beginner. One of the major differences between the second and first editions has been the addition of a large amount of explanatory material especially targeted at the beginner. Advanced Erlang programmers can skip over the introductory material.

A second goal has been to demystify functional, concurrent, and distributed programming and present it in a way that is appropriate to an audience that has no prior knowledge of concurrency or functional programming. Writing functional programs and parallel programs has long been regarded as a black art; this book is part of an ongoing attempt to change this.

While this book assumes no specific knowledge of either functional or concurrent programming, it is addressed to somebody who already is familiar with one or two programming languages.

When you come to a new programming language, its often difficult to think of problems that are suitable for solution in the new language. The exercises give you a clue. These are the kind of problems that are suitably solved in Erlang.

First, the text has been brought up-to-date to reflect all the changes made to Erlang since the first edition of the book was published. We now cover all official language changes and describe Erlang version R17.

The second edition has been refocused to address the needs of beginners, with more explanatory text than in the first edition. Material intended for advanced users, or that might change rapidly, has been moved to online repositories.

The programming exercises proved so popular in the first edition that exercises now appear at the end of each chapter. The exercises vary in complexity, so theres something for both beginner users and advanced users.