Erlang and OTP in Action

Front cover......Page 1
brief contents......Page 8
contents......Page 10
foreword......Page 18
preface......Page 21
acknowledgments......Page 23
Roadmap......Page 24
Author Online......Page 26
About the authors......Page 27
About the cover illustration......Page 28
introduction......Page 29
Stockholm, mid-1980s: an Englishman gets a license to poke around......Page 30
Erlang comes to life......Page 31
The in-between years......Page 32
Getting dressed for success......Page 33
Part 1 – Getting past pure Erlang: the OTP basics......Page 34
The Erlang/OTP platform......Page 36
1.1.1 Understanding concurrency......Page 38
1.1.2 Erlang’s process model......Page 39
1.1.3 Four process communication paradigms......Page 41
1.1.4 Programming with processes in Erlang......Page 44
1.2.1 How process links work......Page 46
1.2.2 Supervision and trapping of exit signals......Page 47
1.2.3 Layering processes for fault tolerance......Page 48
1.3 Distributed Erlang......Page 49
1.4 The Erlang runtime system and virtual machine......Page 50
1.4.1 The scheduler......Page 51
1.4.3 Process isolation and the garbage collector......Page 52
1.5 Functional programming: Erlang’s face to the world......Page 53
1.6 Summary......Page 54
Erlang language essentials......Page 55
2.1 The Erlang shell......Page 56
2.1.2 Entering expressions......Page 57
2.1.4 Escaping from the shell......Page 59
2.1.5 Job-control basics......Page 60
2.2.1 Numbers and arithmetic......Page 62
2.2.2 Binaries and bitstrings......Page 63
2.2.3 Atoms......Page 64
2.2.4 Tuples......Page 65
2.2.5 Lists......Page 66
2.2.6 Strings......Page 67
2.2.7 Pids, ports, and references......Page 68
2.2.9 Comparing terms......Page 69
2.2.10 Understanding lists......Page 71
2.3 Modules and functions......Page 72
2.3.2 Functions of different arity......Page 73
2.3.3 Built-in functions and standard library modules......Page 74
2.3.4 Creating modules......Page 75
2.3.5 Compiling and loading modules......Page 76
2.3.6 The stand-alone compiler, erlc......Page 77
2.3.7 Compiled modules versus evaluation in the shell......Page 78
2.4.1 Variable syntax......Page 79
2.4.2 Single assignment......Page 80
2.4.3 Pattern matching: assignment on steroids......Page 82
2.4.4 More about patterns......Page 83
2.5.1 A function with side effects: printing text......Page 85
2.5.2 Multiple clauses and pattern matching for choice......Page 87
2.5.3 Guards......Page 88
2.6 Case and if expressions......Page 89
2.6.1 Boolean if-then-else switches in Erlang......Page 90
2.7.1 Funs as aliases for existing functions......Page 91
2.7.2 Anonymous funs......Page 92
2.8 Exceptions, try, and catch......Page 94
2.8.2 Using try...catch......Page 95
2.8.3 try...of...catch......Page 96
2.8.6 Rethrowing......Page 97
2.9 List comprehensions......Page 98
2.9.2 Mapping, filtering, and pattern matching......Page 99
2.10.1 Building a bitstring......Page 100
2.10.2 Pattern matching with bit syntax......Page 101
2.11 Record syntax......Page 102
2.11.3 Record fields and pattern matching......Page 103
2.11.5 Where to put the record declarations......Page 104
2.12.1 Defining and using macros......Page 105
2.12.2 Include files......Page 106
2.13 Processes......Page 107
2.13.1 Operating on processes......Page 108
2.13.2 Receiving messages, selective receive......Page 109
2.13.3 Registered processes......Page 110
2.13.4 Delivery of messages and signals......Page 111
2.14.1 Why ETS tables work like they do......Page 112
2.14.2 Basics of using ETS tables......Page 113
2.15.1 From iteration to recursion......Page 114
2.15.2 Understanding tail recursion......Page 117
2.15.4 Some words on efficiency......Page 118
2.15.5 Tips for writing recursive functions......Page 119
2.17 Summary......Page 125
Writing a TCP-based RPC service......Page 127
3.1 What you’re creating......Page 128
3.1.1 A reminder of the fundamentals......Page 129
3.1.2 Behaviour basics......Page 130
3.2.1 Canonical module layout for a behaviour implementation......Page 133
3.2.2 The module header......Page 134
3.2.3 The API section......Page 136
3.2.4 The callback function section......Page 142
3.3 Running the RPC server......Page 149
3.4 A few words on testing......Page 150
3.5 Summary......Page 151
OTP applications and supervision......Page 152
4.1.1 The organization of an OTP application......Page 153
4.1.2 Adding the application metadata......Page 155
4.1.3 The application behaviour......Page 156
4.2 Adding fault tolerance with supervisors......Page 158
4.2.1 Implementing a supervisor......Page 159
4.2.2 The supervisor restart strategy......Page 160
4.2.3 Writing the child specification......Page 161
4.3 Starting the application......Page 162
4.4 Generating documentation with EDoc......Page 163
4.5 Summary......Page 164
5.1 Appmon......Page 165
5.1.1 The Appmon GUI......Page 166
5.1.2 The WebTool version of Appmon......Page 169
5.2 Pman......Page 170
5.3 Debugger......Page 173
5.4 TV, the Table Viewer......Page 177
5.6 Summary......Page 179
Part 2 – Building a production system......Page 180
6.1 The background story......Page 182
6.2 The design of your cache......Page 184
6.3.1 Laying out the application directory structure......Page 186
6.3.3 Implementing the application behaviour......Page 187
6.3.4 Implementing the supervisor......Page 188
6.4.1 Coding the sc_element processes......Page 190
6.4.2 Implementing the sc_store module......Page 195
6.4.3 Rounding off with the application-level API module......Page 200
6.5 Summary......Page 202
Logging and event handling the Erlang/OTP way......Page 203
7.1.1 Logging in general......Page 204
7.1.2 Erlang/OTP built-in logging facilities......Page 205
7.1.3 The standard logging functions......Page 206
7.1.4 SASL and crash reports......Page 208
7.2.1 Introducing the gen_event behaviour......Page 212
7.2.2 Event handler example......Page 213
7.2.3 Acting on error events......Page 214
7.3 Adding a custom event stream to the Simple Cache......Page 216
7.3.1 The event stream API......Page 217
7.3.2 Integrating the handler with Simple Cache......Page 218
7.3.3 Subscribing to a custom event stream......Page 221
7.4 Summary......Page 222
8.1 The fundamentals of Erlang distribution......Page 223
8.1.1 Process communication by copying......Page 224
8.1.2 Location transparency......Page 225
8.2 Nodes and clustering......Page 226
8.2.1 Starting a node......Page 227
8.2.2 Connecting nodes......Page 228
8.2.3 How Erlang nodes find each other and communicate......Page 230
8.2.4 The magic cookie security system......Page 231
8.2.5 Sending messages between connected nodes......Page 232
8.2.6 Working with remote shells......Page 234
8.3.1 Terminology and taxonomy......Page 237
8.3.2 The algorithm......Page 238
8.3.3 Implementing the resource discovery application......Page 239
8.4 Summary......Page 245
Adding distribution to the cache with Mnesia......Page 246
9.1.1 Choosing a communication strategy......Page 247
9.1.2 Synchronous versus asynchronous cache......Page 249
9.2 Distributed data storage with Mnesia......Page 252
9.2.1 Creating a project database......Page 253
9.2.2 Initializing the database......Page 254
9.2.3 Creating the tables......Page 256
9.2.4 Populating the tables......Page 259
9.2.5 Do some basic queries on your data......Page 261
9.3.1 Switching from ETS to Mnesia......Page 263
9.3.2 Making the cache aware of other nodes......Page 266
9.3.3 Integrating resource discovery to find other cache instances......Page 269
9.3.4 Bringing the Mnesia tables into dynamic replication......Page 271
9.4 Summary......Page 274
Packaging, services, and deployment......Page 275
10.1.2 Metadata......Page 276
10.1.3 How the system manages running applications......Page 277
10.2 Making a release......Page 278
10.2.1 Releases......Page 279
10.2.3 The release metadata file......Page 280
10.2.4 The script and boot files......Page 282
10.2.5 System configuration......Page 283
10.2.6 Starting a target system......Page 284
10.3.1 Creating a release package......Page 286
10.3.2 Release package contents......Page 287
10.3.3 Customizing a release package......Page 288
10.4 Installing a release......Page 289
10.5 Summary......Page 291
Part 3 – Integrating and refining......Page 292
Adding an HTTP interface to the cache......Page 294
11.1.1 A pattern for efficient TCP servers......Page 295
11.1.2 Sketching the tcp_interface application......Page 296
11.1.3 Fleshing out the TCP server......Page 297
11.1.4 The simple text-based protocol......Page 300
11.1.5 Text interface implementation......Page 301
11.2 Building a web service from the ground up......Page 303
11.2.1 A quick-and-dirty introduction to HTTP......Page 304
11.2.2 Implementing a generic web server behaviour......Page 307
11.2.3 Getting REST......Page 319
11.2.4 Implementing the RESTful protocol with gen_web_server......Page 320
11.3 Summary......Page 323
Integrating with foreign code using ports and NIFs......Page 324
12.1 Ports and NIFs......Page 325
12.1.1 Plain ports......Page 327
12.1.3 Natively implemented functions (NIFs)......Page 328
12.2 Integrating with the parser through a port......Page 329
12.2.1 The Erlang side of the port......Page 330
12.2.2 The C side of the port......Page 333
12.2.3 Compiling and running the code......Page 345
12.3.1 Understanding linked-in drivers......Page 346
12.3.2 The C side of the driver......Page 348
12.3.3 Compiling the driver code......Page 353
12.3.4 The Erlang side of the driver......Page 354
12.4.1 The Erlang side of the NIF......Page 355
12.4.2 The C side of the NIF......Page 356
12.4.3 Compiling and running the code......Page 363
12.5 Summary......Page 364
Communication between Erlang and Java via Jinterface......Page 365
13.1.2 The OtpMbox class......Page 367
13.1.3 Mapping Erlang data structures onto Java......Page 368
13.1.4 Message-handling example in Java......Page 370
13.1.5 Talking to the Java node from Erlang......Page 372
13.2.1 Downloading and installing......Page 373
13.2.2 Configuring HBase......Page 374
13.3.1 The Erlang side: sc_hbase.erl......Page 375
13.3.2 The HBaseConnector class......Page 377
13.3.3 Java message handling......Page 379
13.3.4 The HBaseTask class......Page 382
13.4 Integrating HBase with Simple Cache......Page 384
13.4.2 Insert......Page 385
13.5 Running the integrated system......Page 386
13.6 Summary......Page 389
Optimization and performance......Page 390
14.1.1 Determining your performance goals......Page 391
14.1.3 Profiling the system......Page 392
14.2 Profiling Erlang code......Page 393
14.2.1 Counting calls with cprof......Page 394
14.2.2 Profiling execution time with fprof......Page 396
14.3 Erlang programming language caveats......Page 401
14.3.1 Performance aspects of the primitive data types......Page 402
14.3.2 Performance of built-in functions and operators......Page 406
14.3.3 Functions......Page 407
14.3.4 Processes......Page 409
14.4 Summary......Page 411
A.2.1 Compiling from source......Page 412
A.2.2 Resolving configuration problems......Page 413
B.2 Advantages of referential transparency......Page 414
B.3 What it has to do with lists......Page 415
A......Page 416
C......Page 417
E......Page 419
H......Page 421
I......Page 422
L......Page 423
M......Page 424
P......Page 425
S......Page 427
T......Page 429
Y......Page 430
Back cover......Page 431