Learn You Some Erlang Great for Good! A beginner's Guide 129

Erlang is the language of choice for programmers who want to write robust, concurrent applications, but its strange syntax and functional design can intimidate the uninitiated. Luckily, there's a new weapon in the battle against Erlang-phobia: Learn You Some Erlang Great for Good! Erlang maestro Fred Hebert starts slow and eases you into the basics: you'll learn about Erlang's unorthodox syntax, its data structures, its type system (or lack thereof!), and basic functional programming techniques. Once you've wrapped your head around the simple stuff, you'll tackle the real meat-and-potatoes of the language: concurrency, distributed computing, hot code loading, and all the other dark magic that makes Erlang such a hot topic among today's savvy developers. As you dive into Erlang's functional fantasy world, you'll learn about: Testing your applications with EUnit and Common Test Building and releasing your applications with the OTP framework Passing messages, raising errors, and starting/stopping processes over many nodes Storing and retrieving data using Mnesia and ETS Network programming with TCP, UDP, and the module inet The simple joys and potential pitfalls of writing distributed, concurrent applications Packed with lighthearted illustrations and just the right mix of незвичний and practical example programs, Learn You Some Erlang Great for Good! is the perfect entry point into the sometimes-crazy, always-thrilling world of Erlang.

Chapter 1 : Starting Out
Using the Erlang Shell
Some Erlang Basics
Working with Binary Data
Chapter 2 : Modules
What Are Modules?
Creating Modules
Compiling Code
Defining Macros
More About Modules
Chapter 3 : Syntax Functions in
Pattern Matching
Guards, Guards!
What the If ?!
In case ... of
Which Should We Use?
Chapter 4 : Types (or Lack Thereof)
Dynamite-Strong Typing
Type Conversions
To Guard a Data Type
For Type Junkies
Chapter 5 : Hello Recursion!
How Recursion Works
More Recursive Functions
More Than Lists
Thinking Recursively
Chapter 6 : Higher-Order Functions
let's Get Functional
Anonymous Functions
Maps, Filters, Folds, and More
Chapter 7 : Errors and Exceptions
A Compilation of Errors
Raising Exceptions
Dealing with Exceptions
Try a try in a Tree
Chapter 8 : Functionally Solving Problems
Reverse Polish Notation Calculator
to London Heathrow
Chapter 9 : A Short Visit to Common Data Structures
Records
Key/Value Stores
A Set of Sets
Directed Graphs
Queues
End of the Short Visit
Chapter 10 : The hitchhiker's Guide to Concurrency
don't Panic
Concurrency Concepts
Not Entirely Unlike Linear Scaling
So Long and Thanks for All the Fish!
Chapter 11 : More on Multiprocessing
State Your State
We Love Messages, But We Keep Them Secret
Time Out
Selective Receives
Chapter 12 : Errors and Processes
Links
Monitors
Naming Processes
Chapter 13 : Designing a Concurrent Application
Understanding the Problem
Defining the Protocol
Lay Them Foundations
An Event Module
The Event Server
A Test Drive
Adding Supervision
Namespaces (or Lack Thereof)
Chapter 14 : An Introduction to OTP
The Common Process, Abstracted
The Basic Server
Specific vs. Generic
Callback to the Future
.BEAM Me Up, Scotty!
Chapter 15 : Rage Against the Finite State Machines
What Is a Finite State Machine?
Generic Finite State Machines
A Trading System Specification
Game Trading Between Two Players
That Was Really Something
Fit for the Real World?
Chapter 16 : Event Handlers
Handle This! *pumps shotgun*
Generic Event Handlers
it's Curling Time!
Chapter 17 : Who Supervises the Supervisors?
Supervisor Concepts
Using Supervisors
Band Practice
Dynamic Supervision
Chapter 18 : Building an Application
A Pool of Processes
Implementing the Supervisors
Working on the Workers
Writing a Worker
Run Pool Run
Cleaning the Pool
Chapter 19 : Building Applications the OTP Way
My Other Car Is a Pool
The Application Resource File
Converting the Pool
The Application Behavior
From Chaos to Application
Library Applications
Chapter 20 : The Count of Applications
From OTP Application to Real Application
Run App Run
Included Applications
Complex Terminations
Глава 21 : Release Is the Word
Fixing the Leaky Pipes
Releases with systools
Releases with Reltool
Reltool Recipes
Released from Releases
Chapter 22 : Leveling Up in the Process Quest
The Hiccups of Appups and Relups
The Ninth Circle of Erl
Process Quest
Making Process Quest Better
Relup Review
Chapter 23 : Buckets of Sockets
IO Lists
UDP and TCP: Bro-tocols
More Control with Inet
Sockserv, Revisited
Where to Go from Here?
Chapter 24 : EUnited Nations Council
EUnit—what's an EUnit?
Test Generators
Fixtures
Testing Regis
He Who Knits EUnits
Chapter 25 : Bears, ETS, Beets: In-Memory NoSQL for Free!
Why ETS
The Concepts of ETS
ETS Home Phone
Meeting Match Your
You Have Been Selected
DETS
A Little Less Conversation, a Little More Action, Please
Chapter 26 : Distribunomicon
This Is My Boomstick
Помилок of Distributed Computing
Dead or Dead-Alive
My Other Cap Is a Theorem
Setting Up an Erlang Cluster
Cookies
Remote Shells
Hidden Nodes
The Walls Are Made of Fire and the Goggles Do Nothing
The Calls from Beyond
Burying the Distribunomicon
Chapter 27 : Distributed OTP Applications
Adding More to OTP
Taking and Failing Over
The Magic 8 Ball
Chapter 28 : Common Test for Uncommon Tests
What Is Common Test?
Common Test Structure
Creating a Simple Test Suite
Testing with State
Test Groups
Test Suites Redux
Test Specifications
Large-Scale Testing
Integrating EUnit Within Common Test
There Is More?
Chapter 29 : Mnesia and the Art of Remembering
what's Mnesia?
What Should the Store Store?
From Record to Table
Of Mnesia Schemas and Tables
Creating Tables
Access and Context
Reads, Writes, and More
Implementing the First Requests
Meet the Boss
Deleting Stuff, Demonstrated
Query List Comprehensions
Remember Mnesia
Chapter 30 : Type Specifications and Dialyzer
PLTs Are the Best Sandwiches
Success Typing
Type Inference and Discrepancies
Typing About Types of Types
Typing Functions
Typing Practice
Exporting Types
Typed Behaviors
Polymorphic Types
You're My Type
that's All, Folks
Appendix : Afterword
Other Erlang Applications
Community Libraries
Your Ideas Are Інтригуючою to Me and I Wish to Subscribe to Your Newsletter
Is That It?
Appendix : On Erlang's Syntax
The Template
The English Sentence
And, Or, Done.
In Conclusion
Colophon
Appendix : Updates