Programming ERLANG: Software for a Concurrent World / Edition 1

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 94%)
Other sellers (Paperback)
  • All (16) from $1.99   
  • New (2) from $58.77   
  • Used (14) from $1.99   
Sort by
Page 1 of 1
Showing 1 – 1 of 2
Note: Marketplace items are not eligible for any coupons and promotions
Seller since 2008

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.


Ships from: Chicago, IL

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing 1 – 1 of 2
Sort by


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.

Read More Show Less

Product Details

  • ISBN-13: 9781934356005
  • Publisher: Pragmatic Programmers, LLC, The
  • Publication date: 7/28/2007
  • Series: Pragmatic Programmers Series
  • Edition description: Older Edition
  • Edition number: 1
  • Pages: 526
  • Product dimensions: 7.60 (w) x 8.90 (h) x 0.99 (d)

Table of Contents

Begin     1
Road Map     2
Begin Again     5
Acknowledgments     6
Getting Started     7
Overview     7
Installing Erlang     10
The Code in This Book     12
Starting the Shell     13
Simple Integer Arithmetic     14
Variables     16
Floating-Point Numbers     21
Atoms     22
Tuples     24
Lists     27
Strings     29
Pattern Matching Again     30
Sequential Programming     33
Modules     33
Back to Shopping     39
Functions with the Same Name and Different Arity     42
Funs     42
Simple List Processing     48
List Comprehensions     51
Arithmetic Expressions     54
Guards     55
Records     59
Case and if Expressions     62
Building Lists in Natural Order     63
Accumulators     64
Exceptions     67
Exceptions     67
Raising an Exception     68
Try...catch     69
Catch     72
Improving Error Messages     73
Programming Style with try...catch     73
Catching Every Possible Exception     74
Old- and New-Style Exception Handling     75
Stack Traces     75
Advanced Sequential Programming     77
BIFs     78
Binaries     78
The Bit Syntax     80
Miscellaneous Short Topics     89
Compiling and Running Your Program     109
Starting and Stopping the Erlang Shell     109
Modifying the Development Environment     110
Different Ways to Run Your Program     113
Automating Compilation with Makefiles     118
Command Editing in the Erlang Shell     121
Getting Out of Trouble     122
When Things Go Wrong     122
Getting Help     125
Tweaking the Environment     126
The Crash Dump     127
Concurrency     129
Concurrent Programming     133
The Concurrency Primitives     134
A Simple Example     135
Client-Server-An Introduction     136
How Long Does It Take to Create a Process?     140
Receive with a Timeout     142
Selective Receive     145
Registered Processes     146
How Do We Write a Concurrent Program?     148
A Word About Tail Recursion     148
Spawning with MFAs     149
Problems     150
Errors in Concurrent Programs     151
Linking Processes     151
An on_exit Handler     152
Remote Handling of Errors     154
The Details of Error Handling     154
Error Handling Primitives     162
Sets of Linked Processes     164
Monitors     164
A Keep-Alive Process     165
Distributed Programming     167
The Name Server     169
The Distribution Primitives     174
Libraries for Distributed Programming     177
The Cookie Protection System     178
Socket-Based Distribution     179
IRC Lite     183
Message Sequence Diagrams     185
The User Interface     186
Client-Side Software     187
Server-Side Software     191
Running the Application     195
The Chat Program Source Code     196
Exercises      203
Interfacing Techniques     205
Ports     206
Interfacing an External C Program     207
Open_port     213
Linked-in Drivers     214
Notes     218
Programming with Files     219
Organization of the Libraries     219
The Different Ways of Reading a File     220
The Different Ways of Writing to a File     228
Directory Operations     232
Finding Information About a File     233
Copying and Deleting Files     234
Bits and Pieces     234
A Find Utility     235
Programming with Sockets     239
Using TCP     240
Control Issues     249
Where Did That Connection Come From?     252
Error Handling with Sockets     253
UDP     254
Broadcasting to Multiple Machines     257
A SHOUTcast Server     259
Digging Deeper     266
ETS and DETS: Large Data Storage Mechanisms     267
Basic Operations on Tables     268
Types of Table     269
ETS Table Efficiency Considerations     270
Creating an ETS Table      271
Example Programs with ETS     273
DETS     278
What Haven't We Talked About?     281
Code Listings     282
OTP Introduction     285
The Road to the Generic Server     286
Getting Started with gen_server     295
The gen_server Callback Structure     299
Code and Templates     303
Digging Deeper     306
Mnesia: The Erlang Database     307
Database Queries     307
Adding and Removing Data in the Database     311
Mnesia Transactions     313
Storing Complex Data in Tables     317
Table Types and Location     319
Creating the Initial Database     322
The Table Viewer     323
Digging Deeper     323
Listings     325
Making a System with OTP     329
Generic Event Handling     330
The Error Logger     333
Alarm Management     340
The Application Servers     342
The Supervision Tree     345
Starting the System     348
The Application     352
File System Organization     354
The Application Monitor     355
Digging Deeper     355
How Did We Make That Prime?     357
Multicore Prelude     359
Programming Multicore CPUs     361
How to Make Programs Run Efficiently on a Multicore CPU     362
Parallelizing Sequential Code     366
Small Messages, Big Computations     369
Mapreduce and Indexing Our Disk     373
Growing Into the Future     383
Documenting Out Program     385
Erlang Type Notation     386
Tools That Use Types     389
Erlang on Microsoft Windows     391
Erlang     391
Fetch and Install MinGW     391
Fetch and Install MSYS     392
Install the MSYS Developer Toolkit (Optional)     392
Emacs     392
Resources     395
Online Documentation     395
Books and Theses     396
Link Collections     396
Blogs     396
Forums, Online Communities, and Social Sites     397
Conferences     397
Projects     397
Bibliography     398
A Socket Application     399
An Example      399
How lib_chan Works     402
The lib_chan Code     405
Miscellaneous     415
Analysis and Profiling Tools     415
Debugging     418
Tracing     427
Dynamic Code Loading     431
Module and Function Reference     435
Module: application     435
Module: base64     436
Module: beam_lib     437
Module: c     437
Module: calendar     439
Module: code     440
Module: dets     441
Module: dict     444
Module: digraph     445
Module: digraph_utils     446
Module: disk_log     447
Module: epp     448
Module: erl_eval     449
Module: erl_parse     449
Module: erl_pp     450
Module: erl_scan     450
Module: erl_tar     450
Module: erlang     451
Module: error_handler     460
Module: error_logger     460
Module: ets     461
Module: file     464
Module: file_sorter     466
Module: filelib     467
Module: filename      467
Module: gb_sets     468
Module: gb_trees     470
Module: gen_event     471
Module: gen_fsm     472
Module: gen_sctp     473
Module: gen_server     474
Module: gen_tcp     474
Module: gen_udp     475
Module: global     475
Module: inet     476
Module: init     477
Module: io     477
Module: io_lib     478
Module: lib     479
Module: lists     479
Module: math     483
Module: ms_transform     483
Module: net_adm     483
Module: net_kernel     484
Module: os     484
Module: proc_lib     485
Module: qlc     485
Module: queue     486
Module: random     487
Module: regexp     488
Module: rpc     488
Module: seq_trace     490
Module: sets     490
Module: shell     491
Module: slave     491
Module: sofs     492
Module: string     496
Module: supervisor     497
Module: sys     497
Module: timer     498
Module: win32reg     499
Module: zip     500
Module: zlib     500
Index     503
Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Anonymous

    Posted October 2, 2009

    No text was provided for this review.

Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)