Erlang and OTP in Action [ペーパーバック]

An excellent book on Erlang, with an emphasis on writing production-worthy code.

The book is divided into 3 sections, as follows:
1) Erlang and OTP basics.
2) Building a production Erlang application.
3) Integration and tuning.

Section one covers basics of Erling and the OTP framework. Material is presented in a format suitable for beginners, with plenty of simple diagrams every couple of pages to illustrate key concepts. OTP in particular is covered in great detail, something intermediate-and-above users will appreciate. Section one alone would be a good Erlang book, but there is much more.

Section two built upon an application-building scenario. The scenario is a web application that's suffering from poor performance, so Erlang is used to build a caching mechanism. Erlang is strong on networking, so the reader builds everything needed from the bottom up. This section adds much value, as there is a pointed difference between knowing language syntax and knowing best practices in writing an application. (This book gives you the best practices as well as the language basics.) The chapters in this part of the book usually start by describing some desired functionality, then explaining how Erlang can provide that functionality, then finally going step-by-step through implementing the change. It reads like an in-depth tutorial.

Section three is about integrating your Erlang application with external entities. Integration-by-messaging is covered via JSON, while deeper integration needs are explained as Erlang's language integration mechanisms are explained. One notable point: JInterface, the Erlang-Java interface, is given a whole chapter (other Erlang books give this topic very little coverage in comparison.)

I found the book well-written and very informative. This is a big book-- almost 400 pages-- and all of it is worthwhile and nicely explanatory. I would recommend this book for Erlang coders of all experience levels.

I fell in love with this book after reading about half of it and previewing the rest.

Erlang is quite radically different from O-O/Imperative languages such as C# and Java, and I expected a steep learning curve, when I started reading Joe Armstrong's book Programming Erlang: Software for a Concurrent World. It is overall a good book, but some parts of Joe's book were not very clear to me even in the earlier several chapters, so I also got the O'Reilly Erlang book Erlang Programming. It was a bit of an easier read, but I still had some issues. [[And all this despite some background from graduate school in the late 80s and early 90s in the underlying CompSci topics such as Unification and Deductive Databases, Functional Programming, Lambda Calculus, Gul Agha's Actors Concurrent programming and Distributed Databases]]. In particular, the OTP coverage in the last 2 books left me a bit perplexed. Then I got this, Logan et al's book, and started from the first chapter, and I must say I admire the authors' ability to serve up concise yet clear explanations with a more practical tone and real world examples. Now all makes sense, both OTP and Erlang, in just a few days! Chapter 2 was a quick but great introduction to Erlang programming. And the OTP and tool introduction chapters have been even better. This is the book to get if you intend to use Erlang for real-world production applications as opposed to a passing 'academic interest'.

Now if you will indulge me in straying a bit beyond the review of this book: Having sampled Erlang/OTP and its suite of related tools and utilities such as Mnesia, Ejabberd XMPP server with EXMPP library, Mochiweb and YAWS web servers, etc. (the LYME platform); I think they constitute a great (imhop and dare i say - probably the best) platform for developing robust, world class application systems quickly and with less hassle. Many people eulogise about their performance, scalability, concurrency, distribution, fault-tolerance and integration advantages; but for me personally it is more about the overriding productivity advantages as all these architectural attributes are obtainable with lots of difficulty, time and cost on other platforms such as Java EE, LAMP and .NET. When a large portion of a development platform can be so well covered in under 400 pages, it surely must be not just the book authors' ability but more the platform's own compactness and expressive power. Try that for .NET or Java EE!!

But, then you ask yourself, with all the evidence, why has the open source LYME stack not taken the development world by storm after two or so decades of existence, given how costly, difficult and failure-prone development projects are? In particular, it would seem to be the likeliest choice for 1-man and small development teams and software entrepreneurs, with resource and time-to-market constraints. And you realise there is quite a steep entry barrier due to its functional and unusual nature and relative lack of literature. I think this concise, but excellent book will facilitate entry by the average programmer and finally a larger cross section of the software development community can leverage the power and productivity advantages of the awesome LYME. Sounds like I gulped down the Erlang koolade? Well, do yourself a favour and get this book and see for yourself or try out Ejabberd, CouchDB and other noSQL databases YAWS, etc.; compare them to better known alternatives and see for yourself.

Finally, if you're like me now entering Erlang/OTP, please do yourself another favour and additionally read Mitchell Hashimoto's Erlang blog articles series, [[...]] on OTP which greatly complement this book in covering aspects of OTP that Logan, et al have not prioritised for coverage, but rather refer the reader to the online Erlang documentation.

"Erlang and OTP in Action" is not a repeat of the existing introductory books on the Erlang language, although there is a brief introduction to the language in Chapter 2. This book continues where other books leave off. If you are just learning Erlang, this book is probably not the best place to start, however it is an excellent reference for more advanced topics.

"Erlang and OTP In Action" is divided into 3 major sections. Each chapter builds on the examples and concepts from the previous chapters working towards getting your server live and robust.

I. Getting Past Pure Erlang: The OTP Basics

This section helps to clarify the distinction between Erlang and OTP. There is only brief coverage of the Erlang language and syntax, as there are other resources which cover this in much greater depth. The reader is exposed to some of the many modules and functions which make up OTP.

Early in the book you are shown how to write a RPC server as well as some basics on writing unit tests for that server. While this is advanced material, the flow and delivery are easy enough to understand to someone with minimal exposure to Erlang. Process supervision, caching, distributed Erlang, and Packaging are also covered in a similar manner of clarity.

II. Building a Production System

The second section starts off by creating a local cache for a web server in order to remedy a website which has become sluggish as the system grew. This is a real-life problem and solution, not a contrived example which are present in so many other books.

The remainder of this section goes into distributed Erlang which is quite an exciting topic. Erlang takes the pain out of communicating between multiple computers (aka nodes), and there are examples show you how to quickly establish communications between many nodes. It's easy and fun with Erlang.

The previously-created caching scheme will also be part of the distributed system and is implemented using a distributed database called Mnesia.

III. Integrating and Refining

The final section shows how to interface programs written in other languages to Erlang using the foreign function interface, ports and Natively Implemented functions (NIFs).

The final chapter shows you how to profile and tune your program for optimal performance. Fortunately, Erlang comes with two tools for profiling, cprof and fprof which make it easier.

The book identifies which parts of a program to profile and show several examples using each of the profiling tools.

Conclusion

"Erlang and OTP in Action" is written very well and conveys the information clearly. The book takes the user all the way from development to deploying production-ready software. This book will be a big boost to in promoting awareness of Erlang/OTP. I recommend this book to everyone who is interested in learning how to implement distributed systems using concurrent and fault-tolerant process handling and recovery.