Librería Portfolio

If you're new to Erlang, its functional style can seem difficult, but with help from this hands-on introduction, you'll scale the learning curve and discover how enjoyable, powerful, and fun this language can be.

In this updated second edition, author Simon St.Laurent shows you how to write simple Erlang programs by teaching you one skill at a time. You'll learn about pattern matching, recursion, message passing, process-oriented programming, and establishing pathways for data rather than telling it where to go. By the end of your journey, you'll understand why Erlang is ideal for concurrency and resilience.

Get cozy with Erlang's shell, its command line interface
Define functions, using the fun tool, to represent repeated calculations
Discover atoms, pattern matching, and guards: the foundations of your program structure
Delve into the heart of Erlang processing with recursion, strings, lists, and higher-order functions
Create processes, send messages among them, and apply pattern matching to incoming messages
Store and manipulate structured data with Erlang Term Storage and the Mnesia database
Learn about Open Telecom Platform, Erlang's open source libraries and tools



Chapter 1Getting Comfortable
Installation
Firing It Up
First Steps: The Shell
Doing Something
Calling Functions
Numbers in Erlang
Working with Variables in the Shell
Chapter 2Functions and Modules
Fun with fun
Defining Modules
Documenting Code
Chapter 3Atoms, Tuples, and Pattern Matching
Atoms
Pattern Matching with Atoms
Atomic Booleans
Guards
Underscoring That You Don't Care
Adding Structure: Tuples
Chapter 4Logic and Recursion
Logic Inside of Functions
The Gentlest Side Effect: io:format
Simple Recursion
Chapter 5Communicating with Humans
Strings
Asking Users for Information
Chapter 6Lists
List Basics
Splitting Lists into Heads and Tails
Processing List Content
Creating Lists with Heads and Tails
Mixing Lists and Tuples
Building a List of Lists
Chapter 7Higher-Order Functions and List Comprehensions
Simple Higher-Order Functions
Creating New Lists with Higher-Order Functions
Beyond List Comprehensions
Chapter 8Playing with Processes
The Shell Is a Process
Spawning Processes from Modules
Lightweight Processes
Registering a Process
When Processes Break
Processes Talking Amongst Themselves
Watching Your Processes
Breaking Things and Linking Processes
Chapter 9Exceptions, Errors, and Debugging
Flavors of Errors
Catching Runtime Errors as They Happen
Raising Exceptions with throw
Logging Progress and Failure
Debugging through a GUI
Tracing Messages
Watching Function Calls
Chapter 10Storing Structured Data
Mapping Your Data
From Tuples to Records
Storing Records in Erlang Term Storage
Storing Records in Mnesia
Chapter 11Getting Started with OTP
The Origins of OTP
Creating Services with gen_server
A Simple Supervisor
Packaging an Application
Chapter 12Next Steps Through Erlang
Moving Beyond the Erlang Shell
Distributed Computing
Processing Binary Data
Input and Output
Testing, Analyzing, and Refactoring
Networking and the Web
Data Storage
Extending Erlang
Languages Built on Erlang
Community
Sharing the Gospel of Erlang
Appendix An Erlang Parts Catalog
Shell Commands
Reserved Words
Operators
Guard Components
Common Functions
Strings and Formatting
Data Types for Documentation and Analysis
Appendix OTP Templates