Erlang编程精髓：弗朗西斯科·切萨里尼与西蒙·汤普森指南

5星 · 超过95%的资源需积分: 41 87 浏览量更新于2024-07-26 收藏 5.08MB PDF 举报

"Erlang Programming - 由Francesco Cesarini和Simon Thompson编写的书籍，涵盖了Erlang编程语言的各个方面。本书是指导学习Erlang编程的专业指南，适用于初学者和有一定经验的开发者。" 在深入探讨Erlang编程的知识点之前，我们先了解一下Erlang本身。Erlang是一种面向并发、动态类型、函数式编程语言，由爱立信（Ericsson）在1986年开发，主要用于构建分布式、容错、实时系统。Erlang以其强大的错误恢复能力和高效处理大量并发连接的能力而闻名。在Francesco Cesarini和Simon Thompson的《Erlang Programming》一书中，读者可以期待以下关键知识点： 1. **函数式编程基础**：Erlang是一种函数式语言，书中会介绍函数式编程的基本概念，如纯函数、不可变数据结构、高阶函数等。 2. **并发与并行**：Erlang的设计非常适合处理并发问题，书中有详尽的讲解如何利用轻量级进程（processes）实现并发，并讨论如何管理和通信这些进程。 3. **错误处理和容错**：Erlang的哲学是“让软件失败快速且优雅”，书中将讲述如何通过模式匹配和异常处理来设计健壮的系统。 4. **分布式编程**：Erlang具有内置的分布式特性，使得编写跨节点的分布式应用程序变得简单。书中会讲解如何设置和管理分布式Erlang集群。 5. ** OTP（Open Telecom Platform）框架**：OTP是Erlang的标准库，提供了大量用于构建可伸缩、可靠和容错系统的模块。书中会详细解释OTP的设计原则和组件，如GenServer、GenEvent和Supervisor等行为。 6. **模式和最佳实践**：书中包含了许多Erlang编程的最佳实践，如如何编写可读性高的代码、测试策略以及性能优化技巧。 7. **Erlang虚拟机（BEAM）**：BEAM是Erlang运行时环境，书中会介绍其工作原理和特性，如垃圾回收机制、内存管理等。 8. **案例研究**：通过实际案例，读者可以了解Erlang在现实世界中的应用，例如电信、Web开发和大规模数据处理等场景。 9. **工具和开发环境**：书中会介绍Erlang的开发工具，如REPL（Read-Eval-Print Loop）、ERTS（Erlang Run-Time System）以及常用的调试和分析工具。 10. **调试和测试**：学习如何有效地调试Erlang代码，以及使用Eunit和CT（Common Test）进行单元测试和集成测试的方法。《Erlang Programming》是一本全面介绍Erlang编程语言及其应用的权威指南，无论你是对Erlang感兴趣，还是计划使用Erlang构建复杂系统，这本书都能提供宝贵的知识和实践经验。

Preface

What made us start writing this book in the first place is the enthusiasm we share for

Erlang.

We wanted to help get the word out, giving back a little of what the community

has given to us. Although we both got into Erlang for very different reasons, the end

result was the same: lots of fun hours doing lots of fun stuff at a fraction of the effort

it would have taken with other languages. And best of all, it is not a tool we use for

hobby projects, but one we use on a daily basis in our real jobs!

Francesco: Why Erlang?

The year was 1994. While studying computer science at Uppsala University, one of the

courses I took was on parallel programming. The lecturer held up the first edition of

Concurrent Programming in Erlang (Prentice Hall) and said, “Read it.” He then held

up a handout and added, “These are the exercises, do them,” after which Erlang barely

got a mention; it was quickly overshadowed with the theory of threads, shared memory,

semaphores, and deadlocks.

As the main exercise for this course, we had to implement a simulated world inhabited

by carrots, rabbits, and wolves. Rabbits would roam this world eating carrots that grew

in random patches. When they had eaten enough carrots, the rabbits would get fat and

split in two. Wolves ran around eating up the rabbits; if they managed to catch and eat

enough rabbits, they would also get fat and split. Rabbits and wolves within a certain

distance of each other would broadcast information on food and predators. If a rabbit

found a carrot patch, other rabbits would quickly join him. If a wolf found a rabbit,

the pack would start chasing it.

The final result was amusingly fun to watch. The odd rabbit would run straight into a

group of wolves, while others would run in other directions, sometimes stopping to

grab a carrot en route. Every carrot patch, rabbit, and wolf was represented as an Erlang

process communicating through message passing.

The exercise took me about 40 hours to solve. Although I enjoyed using Erlang and

was positively surprised at the simplicity of its concurrency model and lack of OS

threads for every process, I did not think that much of it right there and then. After all,

it was one of the dozen or so languages I had to learn for my degree. Having used ML

in my functional programming courses and ADA in my real-time programming courses,

for me Erlang was just another language in the crowd. That changed a few months later

when I started studying object-oriented programming.

In the object-oriented (OO) programming course, we were given the same simulated

world lab but had to solve it with Eiffel, an OO language our new lecturer insisted was

ideal for simulations. Although I had already solved the same problem and was able to

reuse a good part of the algorithms, it took me and a fellow student 120 man-hours to

solve.

This was the eye-opener that led me to believe the declarative and concurrent features

in Erlang had to be the direction in which software development was heading. At the

time, I was not sure whether the language that would lead the way in this paradigm

shift was going to be Erlang, but I was certain that whatever language it was, it would

be heavily influenced by Erlang and its ancestors. I picked up the phone and called Joe

Armstrong, one of the inventors of Erlang. A week later, I visited the Ericsson Computer

Science Lab for an interview, and I have never looked back.

Simon: Why Erlang?

I have worked in functional programming since the early 1980s, and have known about

Erlang ever since it was first defined about 20 years ago. What I find most attractive

about Erlang is that it’s a language that was designed from the start to solve real and

difficult problems, and to do it in an elegant and powerful way. That’s why we’ve seen

Erlang used in more and more systems in recent years.

It’s also a small language, which makes writing tools for it much more practical than

for a language such as Java, C++, or even Haskell. This, and the quality of the libraries

we’ve been able to build on in our work, has helped the functional programming group

at Kent to be very productive in implementing the Wrangler refactoring tool for Erlang.

Who Should Read This Book?

We have written this book to introduce you to programming in Erlang. We don’t expect

that you have programmed in Erlang before, nor do we assume that you are familiar

with functional programming in other languages.

We do expect you to have programmed in Java, C, Ruby, or another mainstream lan-

guage, and we’ve made sure that we point out to you where Erlang differs from what

you’re used to.

xvi | Preface

How to Read This Book

We wrote this book in two parts, the first to be read sequentially and the second can

be read concurrently (or sequentially in whatever order you like), as the chapters are

independent of each other.

The first 11 chapters of the book cover the core parts of Erlang:

• Chapter 1 gives a high-level introduction to the language, covering its key features

for building high-availability, robust concurrent systems. In doing this, we also

describe how Erlang came to be the way it is, and point out some of its high-profile

success stories, which explain why you may want to adopt Erlang in one of your

projects.

• The basics of sequential programming in Erlang are the subject of Chapters 2 and

3. In these chapters, we cover the central role of recursion in writing Erlang pro-

grams, as well as how single assignment in Erlang is quite different from the way

variables are handled in other languages, such as C and Java.

• While covering sequential programming, we also introduce the basic data types of

Erlang—numbers, atoms, strings, lists, and tuples—comparing them with similar

types in other languages. Other types are covered later: records in Chapter 7, and

function types and binaries in Chapter 9. Large-scale storage in ETS tables is the

topic of Chapter 10.

• Erlang’s distinctiveness comes to the fore in Chapters 4–6, which together cover

the concurrent aspects of Erlang, embodied in message passing communication

between concurrently executing processes running in separate memory spaces.

• It is possible to “hot-swap” code in a system, supporting software upgrades in run-

ning systems: this is the topic of Chapter 8.

• To conclude this part of the book, we cover distributed programming in Chap-

ter 11. This allows different Erlang runtime systems (or nodes), which might be

running on the same or different machines, to work together and interact as a

distributed system.

In the remaining chapters, we cover a variety of different topics largely independent of

each other. These include the following:

• The Open Telecom Platform (OTP) gives a set of libraries and design principles

supporting the construction of robust, scalable systems in Erlang; this is the subject

of Chapter 12.

• The Erlang distribution contains some standard computing applications: we cover

the Mnesia database in Chapter 13 and the wxErlang GUI programming library in

Chapter 14.

Preface | xvii

• Erlang distribution gives one mechanism for linking Erlang systems to each other.

Chapter 15 shows how Erlang supports programming across the Internet using

sockets, and Chapter 16 covers the various ways in which Erlang can interwork

with systems written in C, Java, and Ruby, as well as many other languages.

• The standard Erlang distribution comes with a number of very useful tools, and

we cover some of these next. Chapter 17 explains in depth how all aspects of Erlang

systems can be traced without degrading their performance, and Chapter 18 covers

tools for checking the correctness of programs, and for constructing documenta-

tion for Erlang systems. Unit testing, and how it is supported by EUnit, is the

subject of Chapter 19.

• The last chapter, Chapter 20, looks at how to write programs that are elegant,

readable, and efficient, and pulls together into one place much of the accumulated

experience of the Erlang community.

The Appendix covers how to get started with Erlang, how to use the Erlang shell,

popular tools for Erlang, and how to find out more about Erlang.

Each chapter is accompanied by a set of exercises, and you can download all the code

in this book from its website:

http://www.erlangprogramming.org

The website also has references to further reading as well as links to the major sites

supporting the Erlang community.

wrote this book to be compatible with Erlang Release 13 (R13-B). Most of the

features we describe will work with earlier releases; known incompatibilities with more

recent earlier releases are detailed on our website.

Conventions Used in This Book

The following typographical conventions are used in this book:

Italic

Indicates new terms, URLs, filenames, file extensions, and occasionally, emphasis

and keyword phrases.

Constant width

Indicates computer coding in a broad sense. This includes commands, options,

variables, attributes, keys, requests, functions, methods, types, classes, modules,

properties, parameters, values, objects, events, event handlers, XML and XHTML

tags, macros, and keywords.

Constant width bold

Indicates commands or other text that the user should type literally.

xviii | Preface

剩余495页未读，继续阅读

yujianchi

粉丝: 0
资源: 3

Erlang编程精髓：弗朗西斯科·切萨里尼与西蒙·汤普森指南

Pragmatic.Programming.Erlang.2nd.Edition

Programming Erlang.pdf

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

Programming Erlang 2nd.pdf

Erlang Programming 导读.pdf

erlang programming

Erlang Programming

Erlang编程语言The Erlang Programming Language

Programming Erlang

Erlang - Structured Programming Using Processes

最新资源