Browse Books

Reviewer: Amy Zwarico

ERLANG is a declarative language for programming concurrent and distributed systems, including soft real-time systems. It was developed by the authors at the Ericsson and Ellemtel computer science laboratories, and grew out of an investigation into the use of a declarative programming paradigm for programming large industrial telecommunications switching systems. The language design includes constructs to handle heterogeneous systems, network delays, network errors, security, clock synchronization, common address spaces, naming conventions, fault tolerance, adaptive load distribution, and the implementation of transaction-based systems with locking, rollback, and fault tolerance. The first half of the book describes the syntax of the language. The second half is devoted to a more in-depth exposition of typical concurrent and distributed systems and how they can be realized in ERLANG. Both halves contain extensive examples of actual ERLANG code, making the book useful for learning both ERLANG and distributed system design. Although the examples are written in ERLANG, this book provides excellent descriptions and techniques for implementing distributed and concurrent systems in other languages. The writing is clear, and the code examples are abundant. ERLANG is a declarative language that will look familiar to both ML programmers and those familiar with Occam, CSP, or Dijkstra's Guarded Commands. The language contains constructs for implementing modules, error handling, concurrency, synchronization, timing constraints, single assignment variables, and runtime modification. The model of concurrency is process-based. A process is created by explicitly spawning a module. There can be multiple process instances associated with a module running concurrently in a system, each with a unique identifier. Modules may execute in a physically distributed system over multiple machines. The communication paradigm is asynchronous message passing. Shared memory is prohibited. There are some basic data types including numbers, atoms, tuples, and lists. However, the language is operationally untyped, much like Lisp. Anyone familiar with writing declarative programs can quickly understand the ERLANG code in the book. Missing from the book is a discussion of the decisions made in the language design, such as why the language is basically untyped (like LISP ), why the communication primitives are asynchronous, and why variables are single-assignment. Such a discussion would be useful in assessing other distributed and concurrent languages. The language also lacks explicit semantics. The second half of the book describes the ERLANG implementations of a variety of typical distributed and concurrent applications. It includes an excellent discussion of distributed programming and data handling techniques. This section also describes the Standard ERLANG operating system. ERLANG supports both dynamic loading of code on a running system and the use of multiple versions of the same module within a system. This is particularly useful in industrial applications such as telephony, where a system cannot be brought down in order to update it. There is a chapter devoted to telephony and using ERLANG to program telephony systems. According to the authors, ERLANG has been used to implement complex telephony applications on an Ericsson MD110 PABX. These programs are tens of thousands of lines long. The book ends with a discussion of the relationship between object-oriented design and ERLANG. Not surprisingly, the authors have shown that the basic concepts of object-oriented programming can be either directly implemented or simulated in ERLANG. Abstraction takes the form of ERLANG modules. Processes spawned from modules represent objects and provide encapsulation. The implementation of an object-oriented interface is similar to that found in Abelson, Sussman, and Sussman's Scheme book [1]. Inheritance, including multiple inheritance, can be simulated through the use of a variable containing the identifier of the superclass.