Erlang编程 英文版PDF电子书下载

1．Introduction 1

Why Should I Use Erlang? 1

The History of Erlang 3

Erlang's Characteristics 4

High-Level Constructs 4

Concurrent Processes and Message Passing 5

Scalable,Safe,and Efficient Concurrency 6

Soft Real-Time Properties 6

Robustness 6

Distributed Computation 7

Integration and Openness 8

Erlang and Multicore 9

Case Studies 10

The AXD301 ATM Switch 10

CouchDB 11

Comparing Erlang to C++ 12

How Should I Use Erlang? 14

2．Basic Erlang 15

Integers 15

The Erlang Shell 16

Floats 17

Mathematical Operators 17

Atoms 19

Booleans 20

Tuples 21

Lists 22

Characters and Strings 22

Atoms and Strings 23

Building and Processing Lists 24

List Functions and Operations 25

Term Comparison 28

Variables 30

Complex Data Structures 32

Pattern Matching 33

Functions 38

Modules 40

Compilation and the Erlang Virtual Machine 40

Module Directives 41

Exercises 43

3．Sequential Erlang 45

Conditional Evaluations 46

The case Construct 46

Variable Scope 48

The if Construct 49

Guards 50

Built-in Functions 53

Object Access and Examination 53

Type Conversion 54

Process Dictionary 55

Meta Programming 55

Process,Port,Distribution,and System Information 56

Input and Output 57

Recursion 59

Tail-Recursive Functions 63

Tail-Call Recursion Optimization 66

Iterations Versus Recursive Functions 67

Runtime Errors 68

Handling Errors 70

Using try... catch 70

Using catch 74

Library Modules 77

Documentation 77

Useful Modules 79

The Debugger 80

Exercises 82

4．Concurrent Programming 89

Creating Processes 90

Message Passing 92

Receiving Messages 94

Selective and Nonselective Receives 97

An Echo Example 100

Registered Processes 102

Timeouts 104

Benchmarking 106

Process Skeletons 107

Tail Recursion and Memory Leaks 108

A Case Study on Concurrency-Oriented Programming 110

Race Conditions,Deadlocks,and Process Starvation 112

The Process Manager 114

Exercises 115

5．Process Design Patterns 117

Client/Server Models 118

A Client/Server Example 119

A Process Pattern Example 125

Finite State Machines 126

An FSM Example 127

A Mutex Semaphore 129

Event Managers and Handlers 131

A Generic Event Manager Example 132

Event Handlers 135

Exercises 137

6．Process Error Handling 139

Process Links and Exit Signals 139

Trapping Exits 142

The monitor BIFs 144

The exit BIFs 145

BIFs and Terminology 146

Propagation Semantics 148

Robust Systems 148

Monitoring Clients 150

A Supervisor Example 152

Exercises 154

7．Recordsand Macros 157

Records 158

Introducing Records 158

Working with Records 159

Functions and Pattern Matching over Records 160

Records in the Shell 161

Record Implementation 162

Record BIFs 164

Macros 165

Simple Macros 165

Parameterized Macros 166

Debugging and Macros 166

Include Files 168

Exercises 168

8．Software Upgrade 173

Upgrading Modules 173

Behind the Scenes 176

Loading Code 179

The Code Server 180

Purging Modules 182

Upgrading Processes 182

The .erlang File 186

Exercise 186

9．More Data Types and High-Level Constructs 189

Functional Programming for Real 189

Funs and Higher-Order Functions 190

Functions As Arguments 190

Writing Down Functions:fun Expressions 192

Functions As Results 193

Using Already Defined Functions 194

Functions and Variables 195

Predefined,Higher-Order Functions 195

Lazy Evaluation and Lists 197

List Comprehensions 198

A First Example 198

General List Comprehensions 198

Multiple Generators 200

Standard Functions 200

Binaries and Serialization 201

Binaries 202

The Bit Syntax 203

Pattern-Matching Bits 205

Bitstring Comprehensions 206

Bit Syntax Example:Decoding TCP Segments 206

Bitwise Operators 208

Serialization 208

References 210

Exercises 211

10．ETSand DetsTables 213

ETS Tables 213

Implementations and Trade-offs 214

Creating Tables 216

Handling Table Elements 217

Example:Building an Index,Act Ⅰ 218

Traversing Tables 220

Example:Building an Index,Act Ⅱ 222

Extracting Table Information:match 223

Extracting Table Information:select 225

Other Operations on Tables 226

Records and ETS Tables 226

Visualizing Tables 228

Dets Tables 229

A Mobile Subscriber Database Example 231

The Database Backend Operations 232

The Database Server 237

Exercises 242

11．Distributed Programming in Erlang 245

Distributed Systems in Erlang 245

Distributed Computing in Erlang:The Basics 247

Node Names and Visibility 249

Communication and Security 250

Communication and Messages 252

Node Connections 253

Remote Procedure Calls 256

The rpc Module 258

Essential Distributed Programming Modules 258

The epmd Process 260

Distributed Erlang Behind Firewalls 261

Exercises 261

12．OTP Behaviors 263

Introduction to OTP Behaviors 263

Generic Servers 266

Starting Your Server 266

Passing Messages 268

Stopping the Server 270

The Example in Full 271

Running gen_server 273

Supervisors 276

Supervisor Specifications 277

Child Specifications 278

Supervisor Example 279

Dynamic Children 280

Applications 281

Directory Structure 282

The Application Resource File 283

Starting and Stopping Applications 284

The Application Monitor 287

Release Handling 287

Other Behaviors and Further Reading 290

Exercises 291

13．Introducing Mnesia 293

When to Use Mnesia 293

Configuring Mnesia 295

Setting Up the Schema 295

Starting Mnesia 296

Mnesia Tables 296

Transactions 299

Writing 299

Reading and Deleting 300

Indexing 301

Dirty Operations 302

Partitioned Networks 304

Further Reading 305

Exercises 306

14．GUI Programming with wxErlang 309

wxWidgets 309

wxErlang:An Erlang Binding for wxWidgets 310

Objects and Types 311

Event Handling,Object Identifiers,and Event Types 312

Putting It All Together 313

A First Example:MicroBlog 314

The MiniBlog Example 317

Obtaining and Running wxErlang 321

Exercises 321

15．Socket Programming 323

User Datagram Protocol 323

Transmission Control Protocol 327

A TCP Example 328

The inet Module 331

Further Reading 333

Exercises 334

16．Interfacing Erlang with Other Programming Languages 335

An Overview of Interworking 336

Interworking with Java 337

Nodes and Mailboxes 337

Representing Erlang Types 338

Communication 338

Putting It Together:RPC Revisited 339

Interaction 340

The Small Print 341

Taking It Further 342

C Nodes 342

Going Further 345

Erlang from the Unix Shell:erl_call 346

Port Programs 346

Erlang Port Commands 347

Communicating Data to and from a Port 349

Library Support for Communication 350

Working in Ruby:erlectricity 351

Linked-in Drivers and the FFI 352

Exercises 353

17．Trace BIFs,the dbg Tracer,and Match Specifications 355

Introduction 355

The Trace BIFs 357

Process Trace Flags 358

Inheritance Flags 360

Garbage Collection and Timestamps 361

Tracing Calls with the trace_pattern BIF 362

The dbg Tracer 365

Getting Started with dbg 366

Tracing and Profiling Functions 369

Tracing Local and Global Function Calls 369

Distributed Environments 371

Redirecting the Output 371

Match Specifications:The fun Syntax 374

Generating Specifications Using fun2ms 375

Difference Between ets and dbg Match Specifications 382

Match Specifications:The Nuts and Bolts 383

The Head 383

Conditions 384

The Specification Body 387

Saving Match Specifications 390

Further Reading 391

Exercises 392

18．Types and Documentation 395

Types in Erlang 395

An Example:Records with Typed Fields 395

Erlang Type Notation 396

TypEr:Success Types and Type Inference 399

Dialyzer:A DIscrepancy AnaLYZer for ERlang Programs 401

Documentation with EDoc 402

Documenting usr_db.erl 403

Running EDoc 405

Types in EDoc 407

Going Further with EDoc 408

Exercises 410

19．EUnit and Test-Driven Development 411

Test-Driven Development 411

EUnit 412

How to Use EUnit 413

Functional Testing,an Example:Tree Serialization 413

The EUnit Infrastructure 416

Assert Macros 416

Test-Generating Functions 416

EUnit Test Representation 417

Testing State-Based Systems 418

Fixtures:Setup and Cleanup 418

Testing Concurrent Programs in Erlang 419

Exercises 420

20．Style and Efficiency 421

Applications and Modules 421

Libraries 422

Dirty Code 423

Interfaces 423

Return Values 424

Internal Data Structures 425

Processes and Concurrency 426

Stylistic Conventions 430

Coding Strategies 435

Efficiency 437

Sequential Programming 437

Lists 439

Tail Recursion and Non-tail Recursion 440

Concurrency 440

And Finally... 442

Appendix:Using Erlang 445

Index 451