Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20

Introducing Erlang

Getting Started in Functional Programming

Paperback Engels 2017 9781491973370
Verwachte levertijd ongeveer 8 werkdagen


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


Aantal pagina's:193
Hoofdrubriek:IT-management / ICT


Wees de eerste die een lezersrecensie schrijft!

Over Simon St. Laurent

Simon St. Laurent is a content manager at LinkedIn Learning, focusing primarily on front-end web projects. He has been co-chair of the Fluent conference and of OSCON. He has authored or co-authored books including Introducing Elixir, Introducing Erlang, Learning Rails 3, XML: A Primer, and Cookies. You can find more of his writing on technology, Quakerism, and the Town of Dryden at simonstl.com.

Andere boeken door Simon St. Laurent



1. Getting Comfortable
Firing It Up
First Steps: The Shell
Doing Something
Calling Functions
Numbers in Erlang
Working with Variables in the Shell

2. Functions and Modules
Fun with fun
Defining Modules
Documenting Code

3. Atoms, Tuples, and Pattern Matching
Pattern Matching with Atoms
Atomic Booleans
Underscoring That You Don’t Care
Adding Structure: Tuples

4. Logic and Recursion
Logic Inside of Functions
The Gentlest Side Effect: io:format
Simple Recursion

5. Communicating with Humans
Asking Users for Information

6. Lists
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

7. Higher-Order Functions and List Comprehensions
Simple Higher-Order Functions
Creating New Lists with Higher-Order Functions
Beyond List Comprehensions
8. Playing 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

9. Exceptions, 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

10. Storing Structured Data
Mapping Your Data
From Tuples to Records
Storing Records in Erlang Term Storage
Storing Records in Mnesia

11. Getting Started with OTP
The Origins of OTP
Creating Services with gen_server
A Simple Supervisor
Packaging an Application

12. Next 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
Sharing the Gospel of Erlang

Appendix A: An Erlang Parts Catalog
Appendix B: OTP Templates


Managementboek Top 100


Populaire producten



        Introducing Erlang