Buy New

or
Sign in to turn on 1-Click ordering.
Buy Used
Used - Good See details
Price: 22.28

or
 
   
Trade in Yours
For a 4.75 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Colour:
Image not available

 
Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Erlang and OTP in Action [Paperback]

Martin Logan , Eric Merritt , Richard Carlsson
5.0 out of 5 stars  See all reviews (2 customer reviews)
RRP: 31.99
Price: 27.43 & FREE Delivery in the UK. Details
You Save: 4.56 (14%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 3 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Want it tomorrow, 28 Aug.? Choose Express delivery at checkout. Details

Formats

Amazon Price New from Used from
Paperback 27.43  
Trade In this Item for up to 4.75
Trade in Erlang and OTP in Action for an Amazon Gift Card of up to 4.75, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Book Description

8 Dec 2010 1933988789 978-1933988788 1

Concurrent programming has become a required discipline for all programmers. Multi-core processors and the increasing demand for maximum performance and scalability in mission-critical applications have renewed interest in functional languages like Erlang that are designed to handle concurrent programming. Erlang, and the OTP platform, make it possible to deliver more robust applications that satisfy rigorous uptime and performance requirements.

Erlang and OTP in Action teaches you to apply Erlang's message passing model for concurrent programming--a completely different way of tackling the problem of parallel programming from the more common multi-threaded approach. This book walks you through the practical considerations and steps of building systems in Erlang and integrating them with real-world C/C++, Java, and .NET applications. Unlike other books on the market, Erlang and OTP in Action offers a comprehensive view of how concurrency relates to SOA and web technologies.

This hands-on guide is perfect for readers just learning Erlang or for those who want to apply their theoretical knowledge of this powerful language. You'll delve into the Erlang language and OTP runtime by building several progressively more interesting real-world distributed applications. Once you are competent in the fundamentals of Erlang, the book takes you on a deep dive into the process of designing complex software systems in Erlang.

Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.


Frequently Bought Together

Erlang and OTP in Action + Erlang Programming + Learn You Some Erlang for Great Good!: A Beginner's Guide
Price For All Three: 68.37

Buy the selected items together


Product details

  • Paperback: 500 pages
  • Publisher: Manning Publications; 1 edition (8 Dec 2010)
  • Language: English
  • ISBN-10: 1933988789
  • ISBN-13: 978-1933988788
  • Product Dimensions: 2.3 x 18.7 x 23.5 cm
  • Average Customer Review: 5.0 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Bestsellers Rank: 201,464 in Books (See Top 100 in Books)

More About the Authors

Discover books, learn about writers, and more.

Product Description

About the Author

Martin Logan

is a leading Erlang developer, a frequent conference presenter, and

the primary developer of the Faxien OTP/Erlang package management system.

Currently he works for Orbitz Worldwide, developing solutions for their large

scale distributed service based infrastructure.

Richard Carlsson was an original member of the High-Performance Erlang group

at Uppsala University, and has contributed to many parts of the standard libraries,

the Erlang compiler, runtime system, and the language itself.

Eric Merrit specializes in concurrent languages and distributed systems. He’s a

core developer for the Erlware family of open-source products.


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more


Customer Reviews

4 star
0
3 star
0
2 star
0
1 star
0
5.0 out of 5 stars
5.0 out of 5 stars
Most Helpful Customer Reviews
7 of 7 people found the following review helpful
Format:Paperback
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.
Read more ›
Comment | 
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars A great addition to the Erlang library 30 Sep 2012
Format:Paperback|Verified Purchase
Unlike some software languages, Erlang is not blessed with a large amount of literature for those interested in learning the language. While it has improved somewhat from the early days, there still are only 3 books(including this one) readily available. Firstly there is Joe Armstrong's book 'Programming Erlang' which is a good beginners guide, Francesco Cesarini and Simon Thompson's Erlang programming builds on this to provide a more advanced view of the language.

So what does it bring to the party? As good as those previous books were, there was still a gap between learning the language and creating your first Erlang application with the type of enterprise features that Erlang so readily provides. This book by looking at Erlang and it's OTP library more than fills that gap.

This book shows you not only how to program in Erlang but also how to provide multi-processor fault tolerance though the OTP library and various standard templates such as gen_server.

Although it is some years since I used last used Erlang in anger(got the certificates and the tee shirt), it was an interesting experience to renew my acquaintance with it through this book. One thing that hit me while reading it was its description of Erlang use of processes as first class objects. While I have always been aware of Erlang's efficient threading mechanism, it had never really occurred to me before that in Erlang processes could be utilised in the same way another language may use integers. Coming from an embedded C background, this casual use of multi-threading is a revelation.

The book came into it's own when it provides an example of creating a HTTP caching server.
Read more ›
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 4.7 out of 5 stars  18 reviews
20 of 21 people found the following review helpful
5.0 out of 5 stars Wow! This book is excellent for Beginner to Advanced Erlang and OTP Developers 19 Dec 2010
By Mr. Bookish, Mild and Meek - Published on Amazon.com
Format:Paperback
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.
15 of 16 people found the following review helpful
4.0 out of 5 stars Covers more ground than other books 4 Dec 2010
By Richard J. Wagner - Published on Amazon.com
Format:Paperback
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.
6 of 6 people found the following review helpful
5.0 out of 5 stars A great boost for Erlang and OTP 11 Feb 2011
By MrC - Published on Amazon.com
Format:Paperback
"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.
4 of 4 people found the following review helpful
5.0 out of 5 stars A Wonderful Book On Erlang 28 Jan 2012
By Sardar - Published on Amazon.com
Format:Paperback|Verified Purchase
Erlang is considered the bete noire of programming languages with it's weird syntax and radical constructs. It's roots are in Prolog. Erlang is not pretty like Ruby but it has raw and brute power. It has a reputation of being very difficult to learn and even more difficult to master. But it is a language of many great virtues. In my opinion it is the only language which handles the concurrent programming problem properly. Erlang has all of the language constructs to build massive concurrent systems. This is the siren call or mantra as massive distributed systems start to become ever more important in application development. Erlang eschews threads for processes. Processes are the basic unit of concurrency in Erlang. Erlang processes are very lightweight and a computer with commodity hardware can easily host hundreds of thousands of Erlang processes. What makes this magic possible is BEAM, the Erlang virtual machine. Beam is the Bodgan Abtsract Erlang Machine. BEAM has been refined over some twenty years. Erlang is a functional programming language and message passing is the basic unit of inter-process communication in Erlang. The Erlang concurrent programming model implements the Actor design pattern. Erlang was developed from the git go to solve some very hard concurrent programming problems at the Swedish Telecom provider Eriksson; and the lineage shows in the language. Erlang is very pragmatic.

One of the strange aspects about Erlang is that it eschews the use of the assignment operator. In fact, Erlang does not have an assignment operator and the = operator is a pattern matching operator. In Chapter 2, the authors comment that once you get used to the pattern matching operator you will wonder how you ever lived without it. Now as every programmer knows the assignment operator = is so fundamental to programming languages as to be almost burned into our DNA. When I first studied the pattern matching operator = I found it to be weird, contrived and unnatural. But after a a few months of Erlang it seems to be the most natural primitive operator that subsumes assignment as well as the relational operators ( == and !=). And every language that lacks it seems to be missing an essential operator. Erlang will put your brain on a different wavelength,

I initially tried to master Erlang in 2008 by reading Joe Armstrong's book but gave up after seventy five pages. I was completely new to functional programming and got bogged down in language details which were not properly explained. I looked briefly at the Ceserini book. In 2010 I started reading Erlang and OTP In Action. This is a very good book and is very well written. Bear in mind that explaining Erlang properly is not the easiest thing in the world. The authors have a lot of experience in designing Erlang systems and the expertise shows through in this book. This book has a great virtue, it is designed to provide you with the knowledge to build a real world massively concurrent Erlang application quickly. The approach is very pragmatic. Chapter 2 of the book teaches you the Erlang language. Despite being a very lucid presentation, I had to read this chapter twice very carefully. Chapter 3 to 5 leads you though the construction of a concurrent Erlang application using OTP (the Open Telecom Platform). OTP is a general behavior framework for building massive, scalable, fault tolerant, distributed Erlang applications. It is a very nice and refined piece of work. By the time you finish these first five chapters you will know Erlang and the Erlang concurrent programming paradigm. This is a fast track to specialized knowledge. The rest of the book gets into more advanced aspects of OTP. If you want to build a massive concurrent Erlang system then you should be using OTP. In summary this book is very highly recommended and the authors have to be commended for taking the time and care to craft a great book on a difficult subject.
6 of 7 people found the following review helpful
5.0 out of 5 stars A great addition to the growing collection of Erlang books 3 Dec 2010
By foamdino - Published on Amazon.com
Format:Paperback
When you've finished Joe's book, you'll know the syntax of Erlang, some interesting details and you'll know if the language is for you. Erlang and OTP in action takes you much further into Erlang the platform.

Great coverage of supervision hierarchies and Erlang's 'let it crash' philosophy for extreme reliability, and OTP behaviours (gen_server etc).

The case study that is built up throughout the book is interesting and a good fit to the key advantages of Erlang. The book also covers integration with Java through JInterface which some developers may find useful, although personally I'd rather just code in Erlang!

Buried in the appendicies is a small discussion on testing (eunit), and packaging and distribution (sinan and faxien).

Overall this book is the next logical step from Joe's book detailing the language.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Look for similar items by category


Feedback