并发编程利器：Programming Erlang.pdf解读

需积分: 2 156 浏览量更新于2024-08-02 1 收藏 3.98MB PDF 举报

"Programming Erlang.pdf" 是一本由 Joe Armstrong 撰写的关于 Erlang 编程语言的书籍，旨在帮助读者理解和掌握并发世界的软件开发。这本书由 The Pragmatic Bookshelf 出版，特别为 Kwonjin Jeong 准备。 Erlang 是一种面向并发的编程语言，它的设计目标是支持大规模的并行处理和高容错性。在并发编程领域，Erlang 以其独特的轻量级进程、消息传递以及分布式计算能力而著称。Joe Armstrong 在书中强调，如果我们想要编写的行为类似于现实世界中其他对象的程序，那么这些程序应该具有并发结构。使用像 Erlang 这样专为并发应用设计的语言，可以使开发过程变得更加简单和高效。书中会详细介绍 Erlang 的核心特性，包括其函数式编程范式、过程（processes）的概念、错误处理机制、模式匹配以及并发模型。Erlang 的轻量级进程使得创建和管理大量并发执行的任务成为可能，而其消息传递机制保证了进程之间的通信安全和解耦。此外，Erlang 的强类型系统和静态类型检查也有助于减少错误和提高代码质量。 Erlang 还以其在分布式系统中的应用而闻名，它支持构建能够跨多台机器扩展的系统，这使得 Erlang 成为了电信、物联网(IoT)和现代Web服务等领域的重要工具。书中可能会涵盖如何利用 Erlang 构建可扩展和容错的系统，以及如何处理分布式系统中的常见挑战。在学习 Erlang 时，读者可以期待掌握如何编写高效、可靠且易于维护的并发代码。书中的实例和练习将帮助读者理解 Erlang 的设计理念，并将其应用到实际项目中。同时，由于并发编程的复杂性，作者可能还会讨论调试并发程序的技巧，以及如何利用 Erlang 的监控和日志功能来诊断和解决问题。虽然这本书在编写时已尽可能地确保准确性，但出版商仍然提醒读者，由于技术的快速发展，书中某些信息可能已经过时，建议读者结合最新的技术文档和社区资源进行学习。 "Programming Erlang" 是一本深入探讨 Erlang 语言及其并发编程实践的宝贵资源，对于想要提升并发编程技能或对 Erlang 感兴趣的开发者来说，是一本不可多得的参考书籍。通过阅读这本书，读者不仅可以了解并发编程的基本概念，还能掌握构建高效并发软件的实际技术。

BEGIN AGAIN 16

• Appendix E, on page 419, looks at techniques for analyz ing, 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 libraries.

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. It 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 more 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 locks 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 interact 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.

Report erratum

this copy is (P1.1 printing, July, 2007)

Prepared exclusively for Kwonjin Jeong

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 has been teaching me to write

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

Why that? When I started the book, Dave said my w riting 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 h ad a litt l e committee of language experts at my back. They

helped me decide what to leave out. They also helped me clarify some

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

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

Lundin, Richard Carlsson, and Ulf Wiger.

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

to Rickard Green on SMP Erlang, and to Hans Nilsson for the stemming

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 active 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. What’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 h elped 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 you and praised you. When the ﬁrst beta w ent 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 r esulted 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 material concerned. Thanks for

your help, everybody.

Joe Armstrong

May 2007

Report erratum

this copy is (P1.1 printing, July, 2007)

Prepared exclusively for Kwonjin Jeong

OVERVIEW 19

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

interest i ng topics:

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

lot more t han 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 th e libraries (called modules in Erlang). Most

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

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

thr oughout 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 lots of time. After all, why

reinvent the wheel if someone has already wri tten the functional-

ity you need? We’ll learn the 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 progr ams and for programming modern multi-

core and SMP

computers. Most Erlang programs will just run faster

when run on a multicore or SMP machine.

Erlang programming involves using a programming paradigm that I call

concurrency-oriented programming (COP).

1. Open Telecom Platform.

2. Symmetric multiprocessing.

Report erratum

this copy is (P1.1 printing, July, 2007)

Prepared exclusively for Kwonjin Jeong

剩余525页未读，继续阅读

不悲不喜

粉丝: 103
资源: 16

并发编程利器：Programming Erlang.pdf解读

Programming Erlang 2nd.pdf

Pragmatic.Programming.Erlang.2nd.Edition

《Programming Erlang》

rabbitmq .erlang.cookie文件疑惑

cookie文件（.erlang.cookie）到mq1、mq2、mq3：

RabbitMQ:Erlang distribution failed

erlang 21.3.rpm

WARNING: Default (insecure) Erlang cookie is in use.

centos8 erlang安装

linux 安装erlang

最新资源