Programming Erlang, 2nd Edition

Book description

A multi-user game, web site, cloud application, or networked database can have thousands of users all interacting at the same time. You need a powerful, industrial-strength tool to handle the really hard problems inherent in parallel, concurrent environments. You need Erlang. In this second edition of the bestselling Programming Erlang, you'll learn how to write parallel programs that scale effortlessly on multicore systems.

Using Erlang, you'll be surprised at how easy it becomes to deal with parallel problems, and how much faster and more efficiently your programs run. That's because Erlang uses sets of parallel processes-not a single sequential process, as found in most programming languages.

Joe Armstrong, creator of Erlang, introduces this powerful language in small steps, giving you a complete overview of Erlang and how to use it in common scenarios. You'll start with sequential programming, move to parallel programming and handling errors in parallel programs, and learn to work confidently with distributed programming and the standard Erlang/Open Telecom Platform (OTP) frameworks.

You need no previous knowledge of functional or parallel programming. The chapters are packed with hands-on, real-world tutorial examples and insider tips and advice, and finish with exercises for both beginning and advanced users.

The second edition has been extensively rewritten. New to this edition are seven chapters covering the latest Erlang features: maps, the type system and the Dialyzer, WebSockets, programming idioms, and a new stand-alone execution environment. You'll write programs that dynamically detect and correct errors, and that can be upgraded without stopping the system. There's also coverage of rebar (the de facto Erlang build system), and information on how to share and use Erlang projects on github, illustrated with examples from cowboy and bitcask.

Erlang will change your view of the world, and of how you program.

Table of contents

  1. Programming Erlang, Second Edition
    1. Copyright
    2. For the Best Reading Experience...
    3. Table of Contents
    4. Early Praise for Programming Erlang, Second Edition
    5. Introduction
      1. What’s This Book About?
      2. Who Is This Book For?
      3. New in This Edition
      4. Road Map
      5. The Code in This Book
      6. Help! It Doesn’t Work
      7. Acknowledgments
    6. Part 1: Why Erlang?
      1. Chapter 1: Introducing Concurrency
        1. Modeling Concurrency
        2. Benefits of Concurrency
        3. Concurrent Programs and Parallel Computers
        4. Sequential vs. Concurrent Programming Languages
      2. Chapter 2: A Whirlwind Tour of Erlang
        1. The Shell
        2. Processes, Modules, and Compilation
        3. Hello, Concurrency
    7. Part 2: Sequential Programming
      1. Chapter 3: Basic Concepts
        1. Starting and Stopping the Erlang Shell
        2. Simple Integer Arithmetic
        3. Variables
        4. Floating-Point Numbers
        5. Atoms
        6. Tuples
        7. Lists
        8. Strings
        9. Pattern Matching Again
      2. Chapter 4: Modules and Functions
        1. Modules Are Where We Store Code
        2. Back to Shopping
        3. Funs: The Basic Unit of Abstraction
        4. Simple List Processing
        5. List Comprehensions
        6. BIFs
        7. Guards
        8. case and if Expressions
        9. Building Lists in Natural Order
        10. Accumulators
      3. Chapter 5: Records and Maps
        1. When to Use Maps or Records
        2. Naming Tuple Items with Records
        3. Maps: Associative Key-Value Stores
      4. Chapter 6: Error Handling in Sequential Programs
        1. Handling Errors in Sequential Code
        2. Trapping an Exception with try…catch
        3. Trapping an Exception with catch
        4. Programming Style with Exceptions
        5. Stack Traces
        6. Fail Fast and Noisily, Fail Politely
      5. Chapter 7: Binaries and the Bit Syntax
        1. Binaries
        2. The Bit Syntax
        3. Bitstrings: Processing Bit-Level Data
      6. Chapter 8: The Rest of Sequential Erlang
        1. apply
        2. Arithmetic Expressions
        3. Arity
        4. Attributes
        5. Block Expressions
        6. Booleans
        7. Boolean Expressions
        8. Character Set
        10. Dynamic Code Loading
        11. Erlang Preprocessor
        12. Escape Sequences
        13. Expressions and Expression Sequences
        14. Function References
        15. Include Files
        16. List Operations ++ and - -
        17. Macros
        18. Match Operator in Patterns
        19. Numbers
        20. Operator Precedence
        21. The Process Dictionary
        22. References
        23. Short-Circuit Boolean Expressions
        24. Term Comparisons
        25. Tuple Modules
        26. Underscore Variables
      7. Chapter 9: Types
        1. Specifying Data and Function Types
        2. Erlang Type Notation
        3. A Session with the Dialyzer
        4. Type Inference and Success Typing
        5. Limitations of the Type System
      8. Chapter 10: Compiling and Running Your Program
        1. Modifying the Development Environment
        2. Different Ways to Run Your Program
        3. Automating Compilation with Makefiles
        4. When Things Go Wrong
        5. Getting Help
        6. Tweaking the Environment
    8. Part 3: Concurrent and Distributed Programs
      1. Chapter 11: Real-World Concurrency
      2. Chapter 12: Concurrent Programming
        1. The Concurrency Primitives
        2. Introducing Client-Server
        3. Processes Are Cheap
        4. Receive with a Timeout
        5. Selective Receive
        6. Registered Processes
        7. A Word About Tail Recursion
        8. Spawning with MFAs or Funs
      3. Chapter 13: Errors in Concurrent Programs
        1. Error Handling Philosophy
        2. Error Handling Semantics
        3. Creating Links
        4. Groups of Processes That All Die Together
        5. Setting Up a Firewall
        6. Monitors
        7. Error Handling Primitives
        8. Programming for Fault Tolerance
      4. Chapter 14: Distributed Programming
        1. Two Models for Distribution
        2. Writing a Distributed Program
        3. Building the Name Server
        4. Libraries and BIFS for Distributed Programming
        5. The Cookie Protection System
        6. Socket-Based Distribution
    9. Part 4: Programming Libraries and Frameworks
      1. Chapter 15: Interfacing Techniques
        1. How Erlang Communicates with External Programs
        2. Interfacing an External C Program with a Port
        3. Calling a Shell Script from Erlang
        4. Advanced Interfacing Techniques
      2. Chapter 16: Programming with Files
        1. Modules for Manipulating Files
        2. Ways to Read a File
        3. Ways to Write a File
        4. Directory and File Operations
        5. Bits and Pieces
        6. A Find Utility
      3. Chapter 17: Programming with Sockets
        1. Using TCP
        2. Active and Passive Sockets
        3. Error Handling with Sockets
        4. UDP
        5. Broadcasting to Multiple Machines
        6. A SHOUTcast Server
      4. Chapter 18: Browsing with Websockets and Erlang
        1. Creating a Digital Clock
        2. Basic Interaction
        3. An Erlang Shell in the Browser
        4. Creating a Chat Widget
        5. IRC Lite
        6. Graphics in the Browser
        7. The Browser Server Protocol
      5. Chapter 19: Storing Data with ETS and DETS
        1. Types of Table
        2. ETS Table Efficiency Considerations
        3. Creating an ETS Table
        4. Example Programs with ETS
        5. Storing Tuples on Disk
        6. What Haven’t We Talked About?
      6. Chapter 20: Mnesia: The Erlang Database
        1. Creating the Initial Database
        2. Database Queries
        3. Adding and Removing Data in the Database
        4. Mnesia Transactions
        5. Storing Complex Data in Tables
        6. Table Types and Location
        7. The Table Viewer
        8. Digging Deeper
      7. Chapter 21: Profiling, Debugging, and Tracing
        1. Tools for Profiling Erlang Code
        2. Testing Code Coverage
        3. Generating Cross-References
        4. Compiler Diagnostics
        5. Runtime Diagnostics
        6. Debugging Techniques
        7. The Erlang Debugger
        8. Tracing Messages and Process Execution
        9. Frameworks for Testing Erlang Code
      8. Chapter 22: Introducing OTP
        1. The Road to the Generic Server
        2. Getting Started with gen_server
        3. The gen_server Callback Structure
        4. Filling in the gen_server Template
        5. Digging Deeper
      9. Chapter 23: Making a System with OTP
        1. Generic Event Handling
        2. The Error Logger
        3. Alarm Management
        4. The Application Servers
        5. The Supervision Tree
        6. Starting the System
        7. The Application
        8. File System Organization
        9. The Application Monitor
        10. How Did We Make That Prime?
        11. Digging Deeper
    10. Part 5: Building Applications
      1. Chapter 24: Programming Idioms
        1. Maintaining the Erlang View of the World
        2. A Multipurpose Server
        3. Stateful Modules
        4. Adapter Patterns
        5. Intentional Programming
      2. Chapter 25: Third-Party Programs
        1. Making a Shareable Archive and Managing Your Code with Rebar
        2. Integrating External Programs with Our Code
        3. Making a Local Copy of the Dependencies
        4. Building Embedded Web Servers with Cowboy
      3. Chapter 26: Programming Multicore CPUs
        1. Good News for Erlang Programmers
        2. How to Make Programs Run Efficiently on a Multicore CPU
        3. Parallelizing Sequential Code
        4. Small Messages, Big Computations
        5. Parallelizing Computations with mapreduce
      4. Chapter 27: Sherlock’s Last Case
        1. Finding Similarities in Data
        2. A Session with Sherlock
        3. The Importance of Partitioning the Data
        4. Adding Keywords to the Postings
        5. Overview of the Implementation
        6. Exercises
        7. Wrapping Up
    11. Appendix 1: OTP Templates
      1. The Generic Server Template
      2. The Supervisor Template
      3. The Application Template
    12. Appendix 2: A Socket Application
      1. An Example
      2. How lib_chan Works
      3. The lib_chan Code
    13. Appendix 3: A Simple Execution Environment
      1. How Erlang Starts
      2. Running Some Test Programs in SEE
      3. The SEE API
      4. SEE Implementation Details
      5. How Code Gets Loaded in Erlang
      6. You May Be Interested In…

Product information

  • Title: Programming Erlang, 2nd Edition
  • Author(s): Joe Armstrong
  • Release date: September 2013
  • Publisher(s): Pragmatic Bookshelf
  • ISBN: 9781937785536