Programming Erlang, Second Edition

527 Pages·2013·4.87 MB·English

by  Joe Armstrong

Prepared exclusively for John Chukwuma
Under Construction: The book you’re reading is still under
development. As part of our Beta book program, we’re releasing
ß this copy well before a normal book would be released. That
way you’re able to get this content a couple of months before
it’s available in finished form, and we’ll get feedback to make
the book even better. The idea is that everyone wins!
Be warned: The book has not had a full technical edit, so it will contain errors.
It has not been copyedited, so it will be full of typos, spelling mistakes, and the
occasional creative piece of grammar. And there’s been no effort spent doing
layout, so you’ll find bad page breaks, over-long code lines, incorrect hyphen-
ation, and all the other ugly things that you wouldn’t expect to see in a finished
book. It also doesn't have an index. We can’t be held liable if you use this book
to try to create a spiffy application and you somehow end up with a strangely
shaped farm implement instead. Despite all this, we think you’ll enjoy it!
Download Updates: Throughout this process you’ll be able to get updated
ebooks from your account at pragprog.com/my_account. When the book is com-
plete, you’ll get the final version (and subsequent updates) from the same ad-
dress.
Send us your feedback: In the meantime, we’d appreciate you sending us your
feedback on this book at pragprog.com/titles/jaerlang2/errata, or by using the links
at the bottom of each page.
Thank you for being part of the Pragmatic community!
Dave & Andy
Prepared exclusively for John Chukwuma
Programming Erlang,
Second Edition
Software for a Concurrent World
Joe Armstrong
The Pragmatic Bookshelf
Dallas, Texas • Raleigh, North Carolina
Prepared exclusively for John Chukwuma
Many of the designations used by manufacturers and sellers to distinguish their products
are claimed as trademarks. Where those designations appear in this book, and The Pragmatic
Programmers, LLC was aware of a trademark claim, the designations have been printed in
initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer,
Pragmatic Programming, Pragmatic Bookshelf, PragProg and the linking g device are trade-
marks of The Pragmatic Programmers, LLC.
Every precaution was taken in the preparation of this book. However, the publisher assumes
no responsibility for errors or omissions, or for damages that may result from the use of
information (including program listings) contained herein.
Our Pragmatic courses, workshops, and other products can help you and your team create
better software and have more fun. For more information, as well as the latest Pragmatic
titles, please visit us at http://pragprog.com.
Copyright © 2013 Pragmatic Programmers, LLC.
All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or
transmitted, in any form, or by any means, electronic, mechanical, photocopying,
recording, or otherwise, without the prior consent of the publisher.
Printed in the United States of America.
ISBN-13: 978-1-937785-53-6
Encoded using the finest acid-free high-entropy binary digits.
Book version: B6.0—July 26, 2013
Prepared exclusively for John Chukwuma
Contents
Changes in the Beta Releases . . . . . . . . xi
Introduction . . . . . . . . . . . . xiii
Part I — Why Erlang?
1. Introducing Concurrency . . . . . . . . . . 3
1.1 Modeling Concurrency 3
1.2 Benefits of Concurrency 6
1.3 Concurrent Programs and Parallel Computers 8
1.4 Sequential vs. Concurrent Programming Languages 9
2. A Whirlwind Tour of Erlang . . . . . . . . . 11
2.1 The Shell 11
2.2 Processes, Modules, and Compilation 13
2.3 Hello, Concurrency 15
Part II — Sequential Programming
3. Basic Concepts . . . . . . . . . . . . 23
3.1 Starting and Stopping the Erlang Shell 23
3.2 Simple Integer Arithmetic 26
3.3 Variables 26
3.4 Floating-Point Numbers 30
3.5 Atoms 31
3.6 Tuples 32
3.7 Lists 35
3.8 Strings 37
3.9 Pattern Matching Again 39
Prepared exclusively for John Chukwuma
Contents • iv
4. Modules and Functions . . . . . . . . . . 41
4.1 Modules Are Where We Store Code 41
4.2 Back to Shopping 48
4.3 Funs: The Basic Unit of Abstraction 50
4.4 Simple List Processing 55
4.5 List Comprehensions 57
4.6 BIFs 61
4.7 Guards 62
4.8 case and if Expressions 65
4.9 Building Lists in Natural Order 68
4.10 Accumulators 69
5. Records and Maps . . . . . . . . . . . 73
5.1 When to Use Maps or Records 73
5.2 Naming Tuple Items with Records 74
5.3 Maps: Associative Key-Value Stores 77
6. Error Handling in Sequential Programs . . . . . . 85
6.1 Handling Errors in Sequential Code 86
6.2 Trapping an Exception with try…catch 87
6.3 Trapping an Exception with catch 90
6.4 Programming Style with Exceptions 91
6.5 Stack Traces 93
6.6 Fail Fast and Noisily, Fail Politely 94
7. Binaries and the Bit Syntax . . . . . . . . . 97
7.1 Binaries 97
7.2 The Bit Syntax 99
7.3 Bitstrings: Processing Bit-Level Data 108
8. The Rest of Sequential Erlang . . . . . . . . 111
8.1 apply 112
8.2 Arithmetic Expressions 113
8.3 Arity 113
8.4 Attributes 114
8.5 Block Expressions 117
8.6 Booleans 118
8.7 Boolean Expressions 118
8.8 Character Set 119
8.9 Comments 119
8.10 Dynamic Code Loading 119
Prepared exclusively for John Chukwuma
Contents • v
8.11 Erlang Preprocessor 123
8.12 Escape Sequences 123
8.13 Expressions and Expression Sequences 124
8.14 Function References 125
8.15 Include Files 125
8.16 List Operations ++ and - - 126
8.17 Macros 127
8.18 Match Operator in Patterns 129
8.19 Numbers 129
8.20 Operator Precedence 130
8.21 The Process Dictionary 131
8.22 References 132
8.23 Short-Circuit Boolean Expressions 133
8.24 Term Comparisons 133
8.25 Tuple Modules 134
8.26 Underscore Variables 135
9. Types . . . . . . . . . . . . . . 137
9.1 Specifying Data and Function Types 137
9.2 Erlang Type Notation 139
9.3 A Session with the Dialyzer 144
9.4 Type Inference and Success Typing 148
9.5 Limitations of the Type System 151
10. Compiling and Running Your Program . . . . . . 155
10.1 Modifying the Development Environment 155
10.2 Different Ways to Run Your Program 157
10.3 Automating Compilation with Makefiles 162
10.4 When Things Go Wrong 165
10.5 Getting Help 168
10.6 Tweaking the Environment 169
Part III — Concurrent and Distributed Programs
11. Real-World Concurrency . . . . . . . . . 173
12. Concurrent Programming . . . . . . . . . 177
12.1 The Concurrency Primitives 178
12.2 Introducing Client-Server 180
12.3 Processes Are Cheap 185
12.4 Receive with a Timeout 187
Prepared exclusively for John Chukwuma
Contents • vi
12.5 Selective Receive 190
12.6 Registered Processes 191
12.7 A Word About Tail Recursion 193
12.8 Spawning with MFAs or Funs 194
13. Errors in Concurrent Programs . . . . . . . . 197
13.1 Error Handling Philosophy 197
13.2 Error Handling Semantics 200
13.3 Creating Links 202
13.4 Groups of Processes That All Die Together 202
13.5 Setting Up a Firewall 203
13.6 Monitors 204
13.7 Error Handling Primitives 204
13.8 Programming for Fault Tolerance 205
14. Distributed Programming . . . . . . . . . 211
14.1 Two Models for Distribution 212
14.2 Writing a Distributed Program 213
14.3 Building the Name Server 213
14.4 Libraries and BIFS for Distributed Programming 219
14.5 The Cookie Protection System 223
14.6 Socket-Based Distribution 224
Part IV — Programming Libraries and Frameworks
15. Interfacing Techniques . . . . . . . . . . 231
15.1 How Erlang Communicates with External Programs 232
15.2 Interfacing an External C Program with a Port 234
15.3 Calling a Shell Script from Erlang 240
15.4 Advanced Interfacing Techniques 241
16. Programming with Files . . . . . . . . . 243
16.1 Modules for Manipulating Files 243
16.2 Ways to Read a File 245
16.3 Ways to Write a File 251
16.4 Directory and File Operations 255
16.5 Bits and Pieces 258
16.6 A Find Utility 258
Prepared exclusively for John Chukwuma
Contents • vii
17. Programming with Sockets . . . . . . . . . 263
17.1 Using TCP 263
17.2 Active and Passive Sockets 273
17.3 Error Handling with Sockets 275
17.4 UDP 277
17.5 Broadcasting to Multiple Machines 280
17.6 A SHOUTcast Server 281
18. Browsing with Websockets and Erlang . . . . . . 287
18.1 Creating a Digital Clock 288
18.2 Basic Interaction 291
18.3 An Erlang Shell in the Browser 292
18.4 Creating a Chat Widget 294
18.5 IRC Lite 296
18.6 Graphics in the Browser 300
18.7 The Browser Server Protocol 302
19. Storing Data with ETS and DETS . . . . . . . 305
19.1 Types of Table 306
19.2 ETS Table Efficiency Considerations 308
19.3 Creating an ETS Table 309
19.4 Example Programs with ETS 310
19.5 Storing Tuples on Disk 315
19.6 What Haven’t We Talked About? 318
20. Mnesia: The Erlang Database . . . . . . . . 321
20.1 Creating the Initial Database 321
20.2 Database Queries 322
20.3 Adding and Removing Data in the Database 326
20.4 Mnesia Transactions 328
20.5 Storing Complex Data in Tables 332
20.6 Table Types and Location 333
20.7 The Table Viewer 337
20.8 Digging Deeper 337
21. Profiling, Debugging, and Tracing . . . . . . . 341
21.1 Tools for Profiling Erlang Code 342
21.2 Testing Code Coverage 343
21.3 Generating Cross-References 344
21.4 Compiler Diagnostics 345
21.5 Runtime Diagnostics 348
Prepared exclusively for John Chukwuma
Contents • viii
21.6 Debugging Techniques 349
21.7 The Erlang Debugger 352
21.8 Tracing Messages and Process Execution 354
21.9 Frameworks for Testing Erlang Code 358
22. Introducing OTP . . . . . . . . . . . 361
22.1 The Road to the Generic Server 362
22.2 Getting Started with gen_server 371
22.3 The gen_server Callback Structure 375
22.4 Filling in the gen_server Template 378
22.5 Digging Deeper 380
23. Making a System with OTP . . . . . . . . . 383
23.1 Generic Event Handling 384
23.2 The Error Logger 387
23.3 Alarm Management 394
23.4 The Application Servers 396
23.5 The Supervision Tree 398
23.6 Starting the System 402
23.7 The Application 405
23.8 File System Organization 407
23.9 The Application Monitor 408
23.10 How Did We Make That Prime? 409
23.11 Digging Deeper 412
Part V — Building Applications
24. Programming Idioms . . . . . . . . . . 417
24.1 Maintaining the Erlang View of the World 417
24.2 A Multipurpose Server 420
24.3 Stateful Modules 422
24.4 Adapter Patterns 423
24.5 Intentional Programming 426
25. Third-Party Programs . . . . . . . . . . 429
25.1 Making a Shareable Archive and Managing Your Code with
Rebar 429
25.2 Integrating External Programs with Our Code 432
25.3 Making a Local Copy of the Dependencies 434
25.4 Building Embedded Web Servers with Cowboy 435
Prepared exclusively for John Chukwuma