并发世界中的编程Erlang：构建并行软件

需积分: 20 80 浏览量更新于2024-07-27 收藏 2.65MB PDF 举报

"Programming Erlang: Software for a Concurrent World" 是一本经典的Erlang编程教材，由Erlang的创始人之一Joe Armstrong撰写，并被Erlang官方网站推荐。这本书深入介绍了如何使用Erlang语言来构建并发应用程序。在当今的计算环境中，并发已经成为了一个核心概念。由于世界本身是并行的，我们的软件也需要模拟这种并行性，以便更有效地处理多任务和高并发场景。Erlang就是一种专为编写并发应用设计的语言，它提供了独特的机制来简化并发编程的复杂性。 Erlang的设计哲学强调的是简单、容错和高可用性，这些特性使得它在分布式系统、实时系统和大规模并发环境中有广泛应用，尤其是在电信和互联网服务等领域。在Erlang中，进程是轻量级的，它们之间的通信通过消息传递来实现，这种模型鼓励程序员以一种与现实世界交互方式相匹配的方式来思考问题。本书内容涵盖了Erlang语言的基础，包括语法、数据类型、模式匹配、函数式编程思想、进程通信以及错误处理策略。作者Joe Armstrong通过实例和实践指导读者如何利用Erlang的并发特性来构建可扩展、健壮的系统。他还探讨了Erlang的模块化设计，以及如何利用OTP（Open Telecom Platform）框架来提高代码的复用性和可靠性。此外，书中还讨论了Erlang在容错和故障恢复方面的强大能力，如心跳检测、状态复制和分布式系统的构建。这使得Erlang在需要处理大量并发连接或高容错需求的场景下表现出色，如构建分布式数据库、实时通信系统和大规模网络服务。 "Programming Erlang: Software for a Concurrent World" 不仅仅是一本语言教程，更是理解并发编程思维方式的宝贵资源。通过学习这本书，读者将能够掌握Erlang的核心概念和最佳实践，从而更好地适应和驾驭并发世界的挑战。

BEGIN AGAIN 16

• Appendix E, on page 419, looks at techniques for analyz i ng, pro-

ﬁling, debugging, and tracing your code.

• Appendix

F, on page 439, has one-line summaries of the most

used modules in the Erlang standard librari es.

1.2 Begin Again

Once upon a time a programmer came across a book describing a funny

programming language. It had an unfamiliar syntax, equal didn’t mean

equals, and variables weren’t allowed to vary. Worse, it wasn’t even

object-oriented. The programs were, well, different....

Not only were the programs different, but the whole approach to pro-

gramming was different. The author kept on and on about concurrency

and distribution and fault tolerance and about a method of programming

called concurrency-oriented programming—whatever that might mean.

But some of the examples looked like fun. That evening the programmer

looked at the example chat program. I t was pretty small and easy to

understand, even if the syntax was a bit strange. Surely it couldn’t be

that easy.

The basic program was simple, and with a few mo re lines of code, ﬁle

sharing and encrypted conversations became possible. The programmer

started typing....

What’s This All About?

It’s about concurrency. It’s about distribution. It’s about fault toler-

ance. It’s about functional programming. It ’s about programming a dis-

tributed concurrent system without l ocks and mutexes but using only

pure message passing. It ’s about speeding up your programs on multi-

core CPUs. It’s about writing distributed applications that allow people

to in teract with each other. It’s about design methods and behaviors

for writing fault-tolerant and distributed systems. It’s about modeling

concurrency and mapping those models onto computer programs, a

process I call concurrency-oriented programming.

I had fun writing this book. I hope you have fun reading it.

Now go read the book, write some code, and have fun.

ACKNOWLEDGMENTS 17

1.3 Acknowledgments

Many people have helped in the preparation of this book, and I’d like to

thank them all here.

First, Dave Thomas, my editor: Dave h as been teaching me to write

and subjecting me to a barr age of never-ending questions. Why this?

Why that? When I star ted the book, Dave said my writing style was like

“standing on a rock preaching.” He said, “I want you to talk to people,

not preach.” The book is better for it. Thanks, Dave.

Next, I’ve had a little committee of language experts at my back. They

helped me decide what to leave out. They also helped me clarif y some

of the bits that are difﬁcult to explain. Thanks here (in no particular

order) to Björn Gustavsson, Robert Virding, Kostis Sagonas, Kenneth

Lundin, Richard Carlsson, and Ulf Wiger.

Thanks also to Claes Vikström who pr ovided valuable advice on Mnesia,

to Rickard Green on SMP Erlang, and to Hans Nilsson for the ste mmi ng

algorithm used in the text-indexing program.

Sean Hinde and Ulf Wiger helped me understand how to use various

OTP internals, and Serge Aleynikov explained acti ve sockets to me so

that I could understand.

Helen Taylor (my wife) has proofread several chapters and provided

hundreds of cups of tea at appropriate moments. Wh at’s more, she put

up with my rather obsessive behavior for the last seven months. Thanks

also to Thomas and Claire; and thanks t o Bach and Handel, Zorro and

Daisy, and Doris, who have helped me stay sane, have purred when

stroked, and have gotten me to the right addresses.

Finally, to all the readers of the beta book who ﬁlled in errata requests:

I have cursed y ou and praised you. When the ﬁrst beta went out, I was

unprepared for the entire book to be read in two days and for you to

shred every page with your comments. But the process has resulted in

a much better book than I had imagined. When (as happened several

times) dozens of people said, “I don’t understand this page,” then I was

forced to think again and rewrite the mater i al concerned. Thanks for

your help, everybody.

Joe Armstrong

May 2007

OVERVIEW 19

At this stage you’ll be familiar with Erlang, so we’ll move on to more

interesti ng topics:

• You’ll pick up more advanced uses of the shell. The shell can do a

lot more th an we let on when you were ﬁrst learning it. ( For exam-

ple, you can recall and edit previous expressions. This is covered

in Section

6.5, Command Editing in the Erlang Shell, on page 130.)

• You’ll start learning the libraries (called modules in Erlang). Most

of the programs I write can be w ritten using ﬁve modules: lists, io,

ﬁle, dict, and gen_tcp; therefore, we’ll be using these modules a lot

throughout the book.

• As your programs get bigger, you’ll need to learn how to automate

compiling and running them. The tool of choice for this is make.

We’ll see how to control the process by writing a makeﬁle. This is

covered in Section

6.4, Automating Compilation with Makeﬁles, on

page 127.

• The bigger world of Erlang programming uses an extensive library

collection called OTP.

As you gain experience with Erlang, you’ll

ﬁnd that knowing OTP will save you l ots of time. After all, wh y

reinvent the wheel if someone has already written the functional-

ity you need? We’ll learn th e major OTP behaviors, in particular

gen_server. This is covered in Section

16.2, Getting Started with

gen_server, on page

301.

• One of the main uses of Erlang is writing distributed programs,

so now is the time to start experimenting. You can start with the

examples in Chapter 10, Distributed Programming, on page 175,

and you can extend them in any way you want.

Stage 2.5: I May Learn Some Optional Stuff

You don’t have to read every chapter in this book the ﬁrst time through.

Unlike most of the languages you have probably met before, Erlang is

a concurrent programming language—this makes it particularly suited

for writing distributed programs and for programming modern mult i -

core and SMP

computers. Most Erlang programs will just run faster

when run on a multicore or SMP machine.

Erlang programming in volves using a programming paradigm that I call

concurrency-oriented programming (COP).

1. Open Telecom Platform.

2. Symmetric multiprocessing.

剩余518页未读，继续阅读

green_island521

粉丝: 0
资源: 1

并发世界中的编程Erlang：构建并行软件

programming-erlang-software-for-a-concurrent-world

erlang 开发

erlang 设计指南

erlang 语言程序设计

erlang的学习pdf

Erlang and OTP in Action

并发世界的Erlang编程

并发编程利器：Erlang

并发编程：Erlang实战指南

并发世界中的编程Erlang

最新资源