Programming Erlang: Software for a Concurrent World

Erlang is the language to use for developing concurrent or distributive systems. I first used Erlang when I worked for Ericsson in 1997 programming Telecom switch control systems. We developed an elegant monitoring and control system that managed thousands of switches across the world, and is still in use today offering "Nine-Nines" of reliability. Ten years on and Erlang would still be the best choice - stackless python being the other - and in these passing ten years Erlang has really matured. Now if you like books and would like to learn more about Erlang I recommend this book. Its author, Joe Armstrong, one of the fathers of Erlang, has a clean and elegant style that makes reading his book a pleasure, and although I'm an old hand I learned a lot from his book. So briefly here are the books Pros and Cons: The Pros: * Written by a real expert. * Great introduction to Erlang * Up to date with the language * Full of great examples, such as the quick sort in Chapter 3, or showing how to implement "Google's" Map/Reduce in a few lines, or building pipes in Chapter 12. The Cons: * I would have liked more on philosophy and design. Erlang is different and you just can't come from the OO world of C++ or Java and program in Erlang. You have to change the way you think. It would be great if Armstrong gave us some help here, just as Stroustrup gave us in Part IV of his second edition. * I would also liked a whole section on OPT or the authors equivalent framework. * Also More on distribution and robust development. Otherwise the book is great and with the very good material you can find on the web at the Erlang site or trapexit.org you should be set to make your millions writing a distributed financial analytical engine for all those very rich and greedy banks!

I read this book to see whether I like Erlang or not. I don't think I will have a real Erlang project in near future, but I wanted to see what the buzz is about. At the moment the book appears one of the few scarce printed Erlang resources around and it should have better been attracting curious people like myself. And the book did its job - I liked Erlang. To a point that I actually installed the language, Ecliplse IDE plugin for it and tried to throw together a program or two. Neat stuff, you have to pull your hair out to understand how to get a simplest thing done. Not because the language is complex, but because the common programming habits are opposite to Erlang's approach: [quote] The programming world went one way (toward shared state). The Erlang community went the other way [... toward message passing]. [/quote] But solving such puzzles will give you a different perspective and certainly will make you a better programmer. The book is a good introduction, that's all. It shows you the language clearly and consistently. As a joke, the book presents not little and not much information, but "lagom" information: [quote] Erlang comes from Sweden, where the expression "lagom är bäst" (loosely translated as "just enough is best") is often said to summarize the national character. [/quote] The book starts with simple things like variables and syntax, then proceeds to sequential programming primitives such as functions, touches exceptions and goes on to parallel programming with processes and message passing. Finally it proceeds to the application development framework called OTP (Open Telecom Platform) - the standard in Erlang world as it would seem. Therefore, upon reading this book you will know the language and how to build distributed applications with it. I have to admit, I skipped samples that were more than a page long, but luckily those were next to none. Small and clear samples, a few lines long, just to get the idea - that's what I like in introductory books - and those are plenty. One other good characteristic of the book is that the author not only shows what facilities the language has to offer, but also why you need them. For instance with OTP explanation - it approaches the OTP principle in few steps - first start the server, what may you be needing now, add it, then you will be needing this, add it as well, and then - voila - what you get is OTP ! The book and the language will give you a different perspective on building distributed applications, whether it be Erlang, OTP or not. Like I said - I liked Erlang upon reading this book.

Functional programming (Erlang, haskell, OCAML, mainly) has returned to devs' mindshare, look at lambda-the-ultimate, artima, reddit. It's produced a lot of blogs, online tutorials, but if you want a current book that's a complete overview, carefully written and vetted? Pretty slim pickings. This book is an offshoot (or inspired by, or something) of Armstrong's PhD thesis. It is (or was) a pragmatic beta product, reviewed by 100's of developers, and this shows in exposition of data structures and algorithms. It's as good as intro dev texts get. The intro bits, like where the math teacher says "all X's mean the same thing" are kind of helpful but after that there's not a lot of handholding of the type of "how to do __ in java and erlang, side by side" (except the Exceptions chapter), or "Here's my definition of functional programming". There's lots of things similar to the ruby or python or smalltalk dev environment, some counter-intuitive things as well(no short-circuits of boolean expressions) but this book's an exposition of Erlang features, common tasks, and best practices. I liken this to the best software books, K & R, Python in a Nutshell, SICP, it's rigorous and intellectually and viscerally satisfying ;-) If you know prolog or lisp, or read the arguments about DSLs /metaprogramming that java and smalltalk/lisp/ruby/javascript devs are wont to have, you may say it fits your brain. Others have noted that the syntax is a complete rework of how they approach programming, that unification/pattern matching and constraint satisfaction is nothing like programming the algol-family. But i think all devs have to understand how regular expression engines work, so you can draw parallels there (tho no backtracking in erlang). (extremely) minor drawbacks of the book: preachy tone of superiority of COP (concurrency-oriented programm'g), fault-tolerance, many processes, etc. Some of the typesetting (code bits in footnotes against grey background) is hard to read. Division of the book into chapters is kinda odd (there's a couple 2-page chapters)

...because I was impatient, and now I'm buying the hard copy because it's more convenient for most uses. The book is an excellent introduction to the subjects of Erlang, building fault-tolerant software, and concurrency in software. If you're new to Erlang, you'll be very surprised at how advanced the language and the doctrine for its use is, how large a body of software has been written in it, and at how many platforms it's been ported to. It's been one of those treasures hidden in plain sight for years. (It probably hasn't helped that the language germinated in Europe--cross-continental pollination hasn't been as good as one could wish.) Many of the well-known geniuses in the software world are natural writers as well as programming gurus. Joe Armstrong is the equal of any of them in the field of software engineering and development, but he is less well known than many others, possibly because he is not a natural writer (I've read his dissertation). Fortunately, he's had plenty of well-qualified help with this book, and I recommend you buy it.

The computer language Erlang is mature and impressive, with primitives for concurrent, fault-tolerant, and distributed programming that make it a natural for internet applications. So why isn't Erlang more popular in America? The lack of recent accessible introductions in English is probably one reason. This book fills that void. If you've been wondering what Erlang is about, you need to get this book. It's very readable and does not require any prior experience with functional languages to make headway. It's packed with examples and the book encourages experimenting with them; in fact the first chapter explains how to get an installation of Erlang. My one complaint is that some areas are omitted or only lightly treated, for instance mnesia and parse transformations. However there is extensive documentation on the internet available for these and other advanced Erlang features. This book will get you to journeyman level and allow you to leverage those online resources. Even if you never plan to use Erlang, you should read this book, since Joe Armstrong's wisdom on how to build fault-tolerant software is sprinkled throughout (of course, why implement half of Erlang in a bug-ridden fashion in some other language, when you can get the real thing).