Customer Reviews

ERLANG Programming

5 star:		(16)
4 star:		(3)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

What is most attractive about the Erlang programming language is that from the beginning it was designed to solve real and difficult problems, and to do it in an elegant and powerful way. It is also a small language, which makes writing tools for it much more practical than for larger language such as Java or C++.

This book is written for experienced programmers, but not necessarily those that have any prior exposure to Erlang or even functional programming languages in general. The book consists of two parts. The first should be read sequentially, like a textbook. The second part, however, can be read in any order as you need the informaton. The following is a listing of the chapters and a brief description of what you'll find in each.

The first part of the book consists of the first eleven chapters, and describes the core parts of the Erlang language.

1. Introduction - Gives a high-level overview of the characteristics and features that have made Erlang so successful, provides insight into the context in which the language was designed, and describes how this influenced its current shape. Case studies show how Erlang is actually used, comparing it with other languages and highlighting its strengths.

2. Erlang Basics - Covers the basics of Erlang. Some of this will be elementary for experienced programmers, and some will not, such as the fact that you can assign to each variable only once. The chapter starts with defining the basic Erlang data types, and concludes by showing how to define Erlang functions and place them into modules to create programs.

3. Sequential Erlang - An important topic here is recursion, which is perhaps the most useful and powerful of all techniques usually found in a functional language. It allows a programmer to traverse a data structure via successive calls to the same function. Also exception-handling mechanisms are covered here as is the debugger.

4. Concurrent Programming - Concurrency is when different functions execute in parallel without affecting each other unless explicitly programmed to do so. The ability of the runtime system to scale concurrency to levels such that there can be thousands of processes running in parallel with a small memory footprint differentiates Erlang from other concurrent programming languages. This chapter discusses all of these matters.

5. Process Design Patterns - Many Erlang processes will fall into one of three categories - client/servers, finite state machines, and event handlers. This chapter looks at examples of process design patterns, explaining how they can be used to program each of these three types of processes. The OTP framewor is also part of this topic, but OTP doesn't get discussed until chapter 12.

6. Process Error Handling - Erlang has simple but powerful constructs built into the language's concurrency model. These constructs allow processes to monitor each other's behavior and to recover from software faults, and are discussed here.

7. Records and Macros - In the first part of this chapter you will learn about records, which make code evolution easier to achieve. The key to this is the fact that records provide data abstraction. Macros, the other topic in this chapter, allow you to write abbreviations that are expanded by the Erlang preprocessor. Macros can be used to make programs more readable, to extend the language, and to write debugging code. The chapter concludes by describing the include directive, by which header files containing macro and record definitions are used in Erlang projects.

8. Software Upgrade - The software upgrade mechanism relies on a set of simple but powerful constructs upon which more powerful tools are built. These upgrade tools are used in pretty much every Erlang-based system where downtime has to be reduced to a minimum. These topics are explored here.

9. More data types and high-level constructs - The various language features covered in this chapter, many of them derived from functional programming languages, are tools that will improve the productivity of a working Erlang programmer. The topics are: funs and higher-order functions, list comprehensions, binaries, and serialization.

10. ETS and Dets Tables - To handle fast searches, Erlang provides two mechanisms. This chapter introduces Erlang Term Storage (ETS) and Disk Erlang Term Storage (Dets), two mechanisms for memory and disk-efficient storage and retrieval of large groups of data. Erlang also provides a full database application, Mnesia, which is covered in chapter 13.

11. Distributed Programming in Erlang - This chapter explores the theory behind distributed systems and shows how it is applied to Erlang-based systems. Erlang distribution is built into the language, and can be completely transparent to the user.

The rest of the book can be read in any order as needed:

12. OTP Behaviors - OTP behaviors provide library modules that implement the most common concurrent design patterns. Behind the scenes the library modules insure that errors and special cases are handled in a consistent way. As a result, OTP behaviors provide a set of standardized building blocks. This subject is a large one and this chapter is only an introduction.

13. Introducing Mnesia - Mnesia is a powerful database that is part of the standard Erlang distribution. It merges the efficiency and simplicity of ETS and Dets tables with the Erlang distribution and adds a transaction layer on top. Again, this is a large subject and this chapter acts only as an introduction.

14. GUI Programming with Erlang - GUIs are not one of Erlang's strengths, but it does have a cross-platform GUI programming system, wxErlang, which is a binding of the wxWidgets system. This chapter introduces wxWidgets and explains its Erlang binding. After describing the event-handling mechanism in wxErlang, a scaled-down blog example is presented using it. This chapter concludes with a number of pointers for learning more about wxWidgets and wxErlang, and a series of exercises to improve and extend the running example.

15. Socket Programming - Sockets allow programs written in any language to exchange data on different computers by exchanging byte streams transmitted using the protocols of the Internet Protocol. Sometimes even Erlang programs must rely on such a lower-level mechanism for communication.

16. Interfacing Erlang with Other Programming Languages - Discusses how to link Erlang with a C program, Java program, or the Unix shell.

17. Trace BIFs, the dbg Tracer, and Match Specifications - Explains in depth how all aspects of Erlang systems can be traced without degrading their performance.

18. Types and Documentation - This chapter shows how you can write down the types of functions as a part of their formal documentation in Erlang, using the EDoc documentation framework. In addition, what you write down as the type of a function can be checked for consistency against the function definition using the TypEr tool, which is also discussed here.

19. EUnit and Test-Driven Development - In this chapter, the EUnit tool, which gives you a framework for unit testing in Erlang, is discussed. It is shown in action and there is a discussion on how it supports test-driven development.

20. Styles and Efficiency - Summarizes design guidelines and programming strategies to use when developing Erlang systems. The chapter also covers common mistakes and inefficiencies and looks at memory handling and profiling.

Appendix A - Using Erlang- Recommends tools to help you in Erlang softare development and also lists resources for programmers such as websites and books.

I've spent some considerable time with both Haskell and Erlang, two very good functional languages. When it comes to high concurrency and networking applications, Erlang is probably the best choice. However, I still like Haskell because I've found it easier to handle when writing multimedia applications, which is often my focus. You could take a long time to come to your own conclusions, but I found this book and the recently published book on Haskell, Real World Haskell, to cut that time down extensively by explaining the features of both languages so well. I therefore highly recommend this book to people trying to make up their minds about Erlang and those that have made up their minds and now need a clear book on the subject.

What a great book! I have been gobbling up everything that I can related to Erlang in the last several months (forums, books by Joe Armstrong (4 stars), Martin Logan (4 stars) and now, the best of all ... Francesco and Simon's 'Erlang Programming'. It presents a broad view of much that Erlang has to offer in a way that is very accessible to newcomers. They systematically present what you need to get started in the first three chapters, then explain the concurrency model and the three process design patterns in the next two chapters. The next few chapters of the book dive into the details of various features of the language: records, specialized data types, persistence options. Then you are ready for OTP: the Open Telecom Platform. This is where Erlang really shines and they describe it clearly and concisely. The latter chapters cover various language libraries and features: sockets, the Mnesia database, interfacing with C and Java (elegant!), and the finer points of debugging, tracing, testing, documenting and deploying your application.

By all means, get all three books: 'Programming Erlang' (Pragmatic) by Joe Armstrong, 'Erlang and OTP in Action' (Manning) by Martin Logan et. al., and this book by Francesco and Simon. But if you choose to buy only one, I do not hesitate to recommend this one. But do yourself a favor and get all three. Each one offers a different perspective.

Having already read the very good Erlang book by Joe Armstrong entitled "Programming Erlang: Software for a Concurrent World", I was very excited to get this new Erlang book the moment it became available.

I am fairly new to Erlang and unfortunately do not use it in my daily job (SAP technical consultant by day) so I can only give a "beginners viewpoint". Not taking anything away from Joe Armstrongs book at all...it is also superb, but from a beginners point of view I have found that "Erlang Programming" is an easier read and I'm doing more "oh, is that how it works" now ;-) I especially enjoy the little diagrams scattered around the book to help illustrate how the processes communicate etc.

The chapters I have found most useful to me are:

- Process Design Patterns (I enjoyed reading on the "Finite State Machine etc")
- Process Error Handling
- Distributed Programming in Erlang

Overall I am VERY impressed with this book and would happily recommend it to anyone like me who is trying to get up to speed with Erlang very quickly.

BTW: The 2 books combined definetly compliment each other very nicely!

Thankyou Simon and Francesco for an OUTSTANDING book!!

I'm a newbie to the Erlang world and I'm glad I picked this book.

The authors have done a good job of motivating the reader in the first couple of chapters.

These are followed by a few more that lay out the foundations of the language in a crisp and concise manner.

The next set of chapters on processes and their design patterns are informative and interesting.

The last chapters concentrate on describing the libraries provided by the OTP platform including one on the battle-tested Mnesia database.

Overall, I'd say it's a well organized and easy read.

Erlang has been on my "learn something about it" list for ages. A little reading time opened up, so I grabbed this book. (Despite a few clunkers, I still trust the O'Reilly 'animal' books). The first half the the book went pleasantly enough. It's a functional language, something I've come to appreciate without being a drink-the-Koolade convert. It features pattern matching as an alternative to most flow control - even X = y is a pattern match. Pattern matching is almost always a good idea, despite XSLT, but this doesn't go anywhere near Prolog's unification. In this age of 100-core processors (Tilera comes to mind), preparedness for million-thread apps is decidedly a good idea, and Erlang offers uber-lightweight processes. Still, its string processing makes Fortran look sophisticated. It lacks object-ness and its type system so far defies formal analysis, so it fell off most the the 1990s and early-2000s bandwagons, but somehow lingered on. Looking just at that, I'd have to say the language seems "cute."

It lingered for reasons, lots of them. This little language grew up in the harsh world of telecomm, where only 100,000 of anything means you're not ready to swim in the deep end. I know of no other language with hot-swap of software components built in. Fault tolerance (or fast recovery, at least) lives in its core design patterns. Maybe it lacks in general-purpose file IO, but its persistent tables offer Relational as only one possible endpoint for their usage. It also grew up in the era when "only one language" meant you hadn't finished your undergrad yet, so provides shims to pretty much whatever you'd want to approach. (Face it: you'd rather write your drivers in C and your graphics in almost anything else.) On top of all that, whoever wrote the debugger spent a long time programming triggers for logic analyzers. EEs have been debugging wildly parallel systems for years; 'dbg' has a design center somewhere near a crash dump, which doesn't even have one thread running. Which do you want when you're deploying a distributed system to handle 1M text messages per minute?

Odd, as have been so many of the other Scandanavian languages, but likeable (as the others have been). It has its annoyances, like the authors' insistence on 80-char source lines. Cripes, I grew out of 80-col ASR33 TTYs and punch cards in the 1970s. I thought I saw the last of 80-columnism in the 1980s, Fortran excepted. Still, there's a lot of good in this language. It grew up working hard, not polishing the ivory in an ivory tower. That heritage explains both Erlang's magnificent strengths and pathetic weakenesses. Despite a somewhat sycophantic tone, this book provides a gently paced intro to as much as you can reasonably expect from just one book.

-- wiredwierd

Programming Erlang is both an excellent introduction to the Erlang language and OTP platform, and a great book on programming generally. Meant for experienced programmers seeking to learn Erlang, the book is extraordinarily well-written. In fact, I'd say that Cesarini's command of the English language contributes immensely to the book's ability to teach Erlang. The writing is clear, focused and leads the reader to a firm understanding of each Erlang concept, as well as each concept's proper place and usage within the platform as a whole. The book deserves a full five stars, and should have a prominent place on every Erlang programmer's bookshelf, dog-eared and thoroughly absorbed. In addition, the book should serve as a premiere example to other authors on how to write a great technical book.

First off, this is an o'rielly book and they always have coupons you can google for, as much as 40% off.

I was reading joe's pragmatic programming book and after the first 150 pages I got kind of flustered and decided to read this one. This book adds quite a few small details not mentioned in joe's book. Joe starts you off faster with a small shopping list example that seems to never die. Then just breezes through funs, guards, list comprehension, and try/catch statements with only very short examples. Since this book was written and released much later I bet it got to evaluate and improve upon some of the shortcomings people complain about in joe's book. I wouldn't say it's necessarily better but it definitely helped clarify many points I had issues with in joe's book. I can't really compare it to joe's book without the bias of having read his first when I didn't know anything about erlang.

Summary: This is a great Erlang starter and maybe the only book you'll need. It is not an academic text but is very practical and applied.

I've only just started with Erlang and am enjoying it quite a bit - other than wondering if this is another one of those flash-in-the-pan languages. Even if Erlang is not long lived, I think that something like Erlang is where computing is destined to go. The reason being that even our supercomputers seem to have moved away from big iron and into the cluster world. Erlang fits onto clusters more naturally than anything I've yet experienced and that includes MPI and PVM. The reason is that Erlang provides the infrastructure for running an awe inspiring number of "processes" in a multi-machine environment. Or on one machine if that's your preference. Process is in quote marks above because each process runs in an erlang VM instead of as a process/thread in the operating system.

The thing that really amazes me about Erlang is how easy it is to design and build stuff that is fault tolerant and that scales unbelievably. It really is beautiful. I'm kinda wondering if Erlang is the destined to be the "glue language" for clusters.

As for direct usefulness of the book... I've read chapters: 1 Intro; 2 Erlang Basics; 3 Sequential Erlang; 4 Concurrent Programming; and 11 Distributed Programming. In that order. It was a few hours of reading and fiddling around and now I'm somewhat dangerously able to use the language for what I want. Gotta read those other chapters though.

So, why read the chapters? It's because the writing is honest and applicable. Kind of like the bit in Chapter 2 (I think) where the author says you should mess around with something error prone in the shell now because the next time it'll be buried deep in some module and be difficult to isolate. Now that's practical. I bet that OTP chapter will keep me from reinventing some wheels too.

I've started study Erlang after 4 years of Java and Object Oriented Programming. I choose Erlang because of its great features that day by day are matching the real world needs, and I think it could be a great investment on my career.
Erlang is different, and without a good source of information about, it could be very hard to understand; this is why I choose "Erlang Programming". In fact this book is born from 2 persons that well know the argument, and are familiar with its explanation.
Francesco Cesarini uses it from about 1994 when he was studying at Uppsala University, and he is the founder of the leading company about Erlang in the world today and most of all, he is very very active in the Erlang Community.
Simon Thompson is a professor at Kent University and he has taught Logic and Computation for about twenty years, writing some other books, and leading his team in the developement of Wrangler, a refactoring tool for Erlang.
Erlang Programming will guide you in every Erlang aspects, giving you some good advices on how to design systems in the right way so that you will be able to use Erlang's key features to get the best from them.

There are too few books in Erlang development, and I am happy that with the release of this book (in addition to Joe's) that that is starting to change. Not only is this book good for the beginner in Erlang development, it is also helpful for the more experienced developer. Covers a wide range of areas that are often overlooked including edoc, debugging, efficiency and correct coding style. A must buy for the Erlang developer, manager or anyone considering a move to Erlang development.