Programming Erlang: Software for a Concurrent World | 
 enlarge | Author: Joe Armstrong
Publisher: Pragmatic Bookshelf
Category: Book
List Price: $36.95
Buy New: $20.24
You Save: $16.71 (45%)
New (35) Used (9) from $20.24
Avg. Customer Rating:  28 reviews
Sales Rank: 38166
Format: Illustrated
Media: Paperback
Edition: 1
Number Of Items: 1
Pages: 536
Shipping Weight (lbs): 1.9
Dimensions (in): 8.8 x 7.6 x 1
ISBN: 193435600X
Dewey Decimal Number: 005.133
EAN: 9781934356005
ASIN: 193435600X
Publication Date: July 11, 2007
Availability: Usually ships in 1-2 business days
Condition: All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST.
|
| Similar Items:
|
| Editorial Reviews:
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: A SHOUTcast server which you can use to stream music to every computer in your house, and a full-text indexing and search engine that can index gigabytes of data. Learn how to write programs that run on dozens or even hundreds of local and remote processors. See how to write robust applications that run even in the face of network and hardware failure, using the Erlang programming language.
|
| Customer Reviews: Read 23 more reviews...
 Mediocre; Erlangers should expect more January 2, 2009
0 out of 1 found this review helpful
In my opinion, Programming Erlang has been bought and used primarily because it is first book on Erlang, not because it will stand the test of time. Alpha-geeks want to learn Erlang and there just aren't many options available yet. Unfortunately, this is not a well-done book. I expect more from The Programmatic Programmers (the publishers).
I used this book as part of a study group to learn Erlang. Most of us had Ruby experience but not all of us had functional programming experience. The group, as a whole, was not pleased with the book. I admit that Erlang is a different way of programming than many Rubyists would expect -- this makes writing such a book challenging.
To summarize, the book just doesn't feel put together right. The intended audience, organization, and writing style don't work together.
Perhaps the book is trying to do too much: introduce the Erlang language, explain how programming in Erlang requires a different approach, and give good examples. Perhaps the book should be more cleanly organized into parts (e.g. quick introduction, language reference, language best practices, examples) so that a reader knows what to expect.
Don't expect "Programming Erlang" to be similar to "Programming Ruby" by The Pragmatic Programmers. The latter is well organized, comprehensive, detailed, and teaches the Ruby language well. "Programming Erlang" is none of these. It probably should have a different title, hopefully indicating that is trying to teach the language and intermix useful examples. I emphasize "try." This book doesn't satisfy in terms of teaching the Erlang language nor as a cookbook.
Here are some specific criticisms:
1. I would think that any book about Erlang would want to discuss functional programming to some degree. It would also be helpful to refer the reader to other resources if the author expects a certain level of understanding. As it stands, functional programming seems to be the elephant in the room of this book. It is mentioned on page 1, but never again according to the index. This book is neither a good introduction to functional programming nor good at tying in concepts of functional programming as they are used in the book.
2. I expected the book to lay out the syntax and basic constructs of the language in a coherent, organized way. It does not. The language is introduced in a piecemeal fashion and never covered in a satisfying way.
3. The organization of the book needs improvement. Take section 5.4, "Miscellaneous Short Topics," for example. It is a scattershot of topics that should have been organized in a better fashion. It is dry, probably because the reader doesn't know why the topics are relevant.
4. As my fellow user group attendees pointed out, some of Erlang is inspired by several other languages, including LISP. I think the book would serve its readers well by offering more footnotes and referrals to other texts to help explain why parts of Erlang seem strange to Ruby programmers.
On the positive side, some parts are humorous. Sometimes (but not consistently) the explanations are insightful, too. Some kudos are:
1. I like how the author (Armstrong) introduces, emphasizes, and even defends single assignment variables and pattern matching right from the beginning. These core concepts are strange to a new Erlanger and should not be breezed over.
2. The introduction to concurrency (Chapter 7) is a humorous and enlightening metaphor. "If somebody dies, other people will notice" uses not-too dark humor to explain error detection.
At least one reviewer here said that this book is going to be the "classic" Erlang text. Not in its current form -- the Erlang community can do better. Let's encourage Mr. Armstrong to iterate on his book. Concurrently, I encourage other authors (especially those who do a lot of teaching) to write a book that does Erlang justice.
 The K&R of the Erlang world November 6, 2008
0 out of 1 found this review helpful
I found this to be a pretty easy read overall, but of course had to re-read some sections as I was coming across new concepts.
It reminded me a lot of reading Kernighan and Ritchie way back when I was learning C. I don't say that because the author is the "father" of the language, but because it covers the bare essentials, just enough for you to start really learning to use it.
So if you want to start learning Erlang then this is essential reading and will give you a good start. If you want advance then you'll either have read the online documentation (and there's lots of it) or wait for a book that covers things in more depth.
Highly recommended.
Great overview on Erlang and OTP September 25, 2008
1 out of 1 found this review helpful
With a very amenable writing, Joe Armstrong presents a clear overview on the Erlang Language and basics of the OTP. The book presents the basic topics, with simple and yet powerful examples, and points the directions on how to find more informations.
Definitely a great book.
Very good intro to Erlang September 8, 2008
1 out of 2 found this review helpful
This book was well worth the money even if you don't intend to program in Erlang. It gives a very good over view of an alternative model of parallel programming that is currently not heavily used. The model emphasizes reliability by not having any shared state. I went on to use this model in C++ projects.
Good book technically; a bit confusing organizationally. August 5, 2008
0 out of 2 found this review helpful
Overall, I liked this book. When I read this, I was looking at doing some Erlang work; I didn't end up using Erlang, but the book was still enjoyable, and gave me a good overview of the language.
Some things were a bit odd: the organization was not clear, and the order of chapters was confusing. The authors choice of material was seemed unusual to me: he covered a streaming MP3 server, and mentions ID3 tags; he does not, however, describe what they are or describe in detail how his code processes them. Still, the important details of Erlang itself are covered, and perhaps that's the most important part.
Take it easy,
Dave
|
|
|
