Product Description

Erlang solves one of the most pressing problems facing developers today: how to write reliable, concurrent, high-performance systems. It's used worldwide by companies who need to produce reliable, efficient, and scalable applications. Invest in learning Erlang now.

Moore's Law is the observation that the amount you can do on a single chip doubles every two years. But Moore's Law is taking a detour. Rather than producing faster and faster processors, companies such as Intel and AMD are producing multi-core devices: single chips containing two, four, or more processors. If your programs aren't concurrent, they'll only run on a single processor at a time. Your users will think that your code is slow.

Erlang is a programming language designed for building highly parallel, distributed, fault-tolerant systems. It has been used commercially for many years to build massive fault-tolerated systems that run for years with minimal failures.

Erlang programs run seamlessly on multi-core computers: this means your Erlang program should run a lot faster on a 4 core processor than on a single core processor, all without you having to change a line of code.

Erlang combines ideas from the world of functional programming with techniques for building fault-tolerant systems to make a powerful language for building the massively parallel, networked applications of the future.

This book presents Erlang and functional programming in the familiar Pragmatic style. And it's written by Joe Armstrong, one of the creators of Erlang.

It includes example code you'll be able to build upon. In addition, the book contains the full source code for two interesting applications:

Product Details

• Amazon Sales Rank: #12078 in Books
• Published on: 2007-07-11
• Number of items: 1
• Binding: Paperback
• 536 pages

samzenpus, Slashdot.org, September 2007
I would like to thank the pragmatic programmers for publishing this book.

Synopsis
Describes how to build parallel, distributed systems using the ERLANG programming language.

About the Author
In his search to find better ways to implement fault-tolereant applications, Joe Armstrong designed and implemented the first version of Erlang in 1986. He wrote the first Erlang book and held the first Erlang course-he has worked with Erlang from the very beginning. He has taught Erlang to hundreds of programmers and held countless lectures and keynotes describing the technology.

Joe has a PhD in computer science from the Royal Institute of Technology in Stockholm, Sweden and is an expert in the construction of fault tolerant systems.

Joe was the chief software architect of the project which produced the Erlang OTP system. He has worked as an entrepreneur in one of the first Erlang startups (Bluetail) and has worked for 30 years in industry and research. Joe currently works for Ericsson AB where Erlang is used to build highly-fault tolerant switching systems.

Customer Reviews

A Top 5 Programing Book this Millenium, so far ...
This book is outstanding. It's easy to read, fun and, maybe, exciting. The exposition is lucid, and exploits a practical, hands-on, example-driven approach throughout. I enjoyed both the breadth and depth of coverage. It interweaves working code with full, clear explanation, background and valuable insight. It felt like discovering chair-lifts after years of sidling up mountain slopes on ski's.

Erlang and OTP are comparable to Java and core J2EE. Erlang/OTP is freely available, Open Source, software from Ericsson, the telecoms company. Erlang has several impressive attributes, but one is Ericssons claim it is used in telecom's hardware to deliver 99.9999999% (roughly 1 second in 30 years) availability, beating most Enterprise applications by a few 9's.

The excellent roadmap in chapter 1 explains the books organisation and chunking of content; roughly: sequential programming, concurrent programming, distributed programming, interfacing, data storage, databases, OTP and multi-core programming. There is good depth to the content. The order of material can be a little strange, but if you are familiar with programming, it's likely straightforward.

The book sets off at a good pace, quickly getting up and running with 'sequential Erlang'. Unlike many programming books, Armstrong deals with the practical nitty-gritty of downloading, installing, compiling, debugging and running Erlang on Mac, Linux and Windows. He returns to development practicalities at several points to support the increasing sophistication of applications. I felt that he really wants to make learning and applying Erlang straightforward, and he succeeded for me; everything worked 'silky smooth'.

The sequential subset of Erlang is a dynamically-typed functional programming language with all of the usual bits, like: single assignment, pattern matching, list comprehensions, first class functions, exceptions, etc. In use, Erlang feels as much like strict Scheme, with helpful syntax, as statically-typed FP languages like Haskell, OCaml, or Standard ML.

Next Armstrong introduces concurrency with light-weight processes, Erlangs powerful message passing mechanism, and failure handling. This is where this book really takes off. Before we're 1/3rd in, we can exploit our dual or quad-core processors, be ready for future many-core chips, with minimal complexity, and handle process failure by 'healing' the system. Gulp!

Distributed Erlang starts setting things up for the later OTP chapters by applying the distributed computing mechanisms. Erlang implements distributed systems by distributing multiple nodes (Erlang VMs) on and across machines. The earlier concurrent stuff, like messaging and failure handling, easily extends to this environment.

The Erlang data storage chapters on ETS, DEST, and Mnesia, the distributed real-time database, have working examples. I would have liked more depth on Mnesia, but there is on-line documentation at erlang.org. Interfacing covers TCP/IP, HTTP clients and servers, UDP, and integrating with external C programs and internal 'drivers'. There are plenty of nifty examples woven throughout, so enough to keep me experimenting.

The crowning glory is OTP. This provides components and frameworks for building distributed systems which require very little extraneous code or configuration. OTP implements distribution, fault-tolerance, self-healing, administration, error-management, hot-code-upgrading, etc. on behalf of the developer. If you've tried to build these capabilities for real, I think you'll find OTP breathtaking. I would have liked even more examples.

While many of the examples are short, it is testament to the compact, expressive power of Erlang that significant examples are included without making the book feel like a pile of code. There's plenty of explanatory meat too.

Weaknesses? There are a few. I would have liked more string or text processing. More complete comparison with 'traditional web application architecture' because that's perceived as the basic 'bread and butter'. The function-reference appendix is inferior to the free, on-line documentation. I'd also recommend also buying the searchable PDF to speed things up when your working. Finally, the front cover 'zebra-crossing' isn't as cool as the 'pickaxe book' :-)

This book won't make you a great Erlang programmer, but it does feel like a massive leap in an important direction. Even if you never use Erlang, you could benefit from reading it. I found myself hacking pieces of code, experimenting with toy servers, while I was supposed to be watching TV. Beware, Erlang can become addictive stuff.

I apologise for the long review, but the book review listed here was too sparse to do the book justice.

Summary: Easy to read, practical, engaging, and sometimes inspirational. If you are interested in building Enterprise-class distributed software systems, get the book, download the open source software, hack the examples, and revel in the experience; simply: "jump in the water is lovely".