
Designing for Scalability with Erlang/OTP
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
If you need to build a scalable, fault tolerant system with requirements for high availability, discover why the Erlang/OTP platform stands out for the breadth, depth, and consistency of its features. This hands-on guide demonstrates how to use the Erlang programming language and its OTP framework of reusable libraries, tools, and design principles to develop complex commercial-grade systems that simply cannot fail.
In the first part of the book, you'll learn how to design and implement process behaviors and supervision trees with Erlang/OTP, and bundle them into standalone nodes. The second part addresses reliability, scalability, and high availability in your overall system design. If you're familiar with Erlang, this book will help you understand the design choices and trade-offs necessary to keep your system running.
- Explore OTP's building blocks: the Erlang language, tools and libraries collection, and its abstract principles and design rules
- Dive into the fundamentals of OTP reusable frameworks: the Erlang process structures OTP uses for behaviors
- Understand how OTP behaviors support client-server structures, finite state machine patterns, event handling, and runtime/code integration
- Write your own behaviors and special processes
- Use OTP's tools, techniques, and architectures to handle deployment, monitoring, and operations
More details
Other editions
Additional editions

Content
- Intro
- Copyright
- Table of Contents
- Preface
- Francesco: Why This Book?
- Steve: Why This Book?
- Who Should Read This Book
- How To Read This Book
- Acknowledgments
- Conventions Used in This Book
- Using Code Examples
- Safari® Books Online
- How to Contact Us
- Chapter 1. Introduction
- Defining the Problem
- OTP
- Erlang
- Tools and Libraries
- System Design Principles
- Erlang Nodes
- Distribution, Infrastructure, and Multicore
- Summing Up
- What You'll Learn in This Book
- Chapter 2. Introducing Erlang
- Recursion and Pattern Matching
- Functional Influence
- Fun with Anonymous Functions
- List Comprehensions: Generate and Test
- Processes and Message Passing
- Fail Safe!
- Links and Monitors for Supervision
- Links
- Monitors
- Records
- Maps
- Macros
- Upgrading Modules
- ETS: Erlang Term Storage
- Distributed Erlang
- Naming and Communication
- Node Connections and Visibility
- Summing Up
- What's Next?
- Chapter 3. Behaviors
- Process Skeletons
- Design Patterns
- Callback Modules
- Extracting Generic Behaviors
- Starting the Server
- The Client Functions
- The Server Loop
- Functions Internal to the Server
- The Generic Server
- Message Passing: Under the Hood
- Summing Up
- What's Next?
- Chapter 4. Generic Servers
- Generic Servers
- Behavior Directives
- Starting a Server
- Message Passing
- Synchronous Message Passing
- Asynchronous Message Passing
- Other Messages
- Unhandled Messages
- Synchronizing Clients
- Termination
- Call Timeouts
- Deadlocks
- Generic Server Timeouts
- Hibernating Behaviors
- Going Global
- Linking Behaviors
- Summing Up
- What's Next?
- Chapter 5. Controlling OTP Behaviors
- The sys Module
- Tracing and Logging
- System Messages
- Your Own Trace Functions
- Statistics, Status, and State
- The sys Module Recap
- Spawn Options
- Memory Management and Garbage Collection
- Spawn Options to Avoid
- Timeouts
- Summing Up
- What's Next?
- Chapter 6. Finite State Machines
- Finite State Machines the Erlang Way
- Coffee FSM
- The Hardware Stub
- The Erlang Coffee Machine
- Generic FSMs
- A Behavior Example
- Starting the FSM
- Sending Events
- Termination
- Summing Up
- Get Your Hands Dirty
- The Phone Controllers
- Let's Test It
- What's Next?
- Chapter 7. Event Handlers
- Events
- Generic Event Managers and Handlers
- Starting and Stopping Event Managers
- Adding Event Handlers
- Deleting an Event Handler
- Sending Synchronous and Asynchronous Events
- Retrieving Data
- Handling Errors and Invalid Return Values
- Swapping Event Handlers
- Wrapping It All Up
- The SASL Alarm Handler
- Summing Up
- What's Next?
- Chapter 8. Supervisors
- Supervision Trees
- OTP Supervisors
- The Supervisor Behavior
- Starting the Supervisor
- The Supervisor Specification
- Dynamic Children
- Non-OTP-Compliant Processes
- Scalability and Short-Lived Processes
- Synchronous Starts for Determinism
- Testing Your Supervision Strategy
- How Does This Compare?
- Summing Up
- What's Next?
- Chapter 9. Applications
- How Applications Run
- The Application Structure
- The Callback Module
- Starting and Stopping Applications
- Application Resource Files
- The Base Station Controller Application File
- Starting an Application
- Environment Variables
- Application Types and Termination Strategies
- Distributed Applications
- Start Phases
- Included Applications
- Start Phases in Included Applications
- Combining Supervisors and Applications
- The SASL Application
- Progress Reports
- Error Reports
- Crash Reports
- Supervisor Reports
- Summing Up
- What's Next?
- Chapter 10. Special Processes and Your Own Behaviors
- Special Processes
- The Mutex
- Starting Special Processes
- The Mutex States
- Handling Exits
- System Messages
- Trace and Log Events
- Putting It Together
- Dynamic Modules and Hibernating
- Your Own Behaviors
- Rules for Creating Behaviors
- An Example Handling TCP Streams
- Summing Up
- What's Next?
- Chapter 11. System Principles and Release Handling
- System Principles
- Release Directory Structure
- Release Resource Files
- Creating a Release
- Creating the Boot File
- Creating a Release Package
- Start Scripts and Configuring on the Target
- Arguments and Flags
- The init Module
- Rebar3
- Generating a Rebar3 Release Project
- Creating a Release with Rebar3
- Rebar3 Releases with Project Dependencies
- Wrapping Up
- What's Next?
- Chapter 12. Release Upgrades
- Software Upgrades
- The First Version of the Coffee FSM
- Adding a State
- Creating a Release Upgrade
- The Code to Upgrade
- Application Upgrade Files
- High-Level Instructions
- Release Upgrade Files
- Low-Level Instructions
- Installing an Upgrade
- The Release Handler
- Upgrading Environment Variables
- Upgrading Special Processes
- Upgrading in Distributed Environments
- Upgrading the Emulator and Core Applications
- Upgrades with Rebar3
- Summing Up
- What's Next?
- Chapter 13. Distributed Architectures
- Node Types and Families
- Networking
- Distributed Erlang
- Sockets and SSL
- Service Orientation and Microservices
- Peer to Peer
- Interfaces
- Summing Up
- What's Next?
- Chapter 14. Systems That Never Stop
- Availability
- Fault Tolerance
- Resilience
- Reliability
- Sharing Data
- Tradeoffs Between Consistency and Availability
- Summing Up
- What's Next?
- Chapter 15. Scaling Out
- Horizontal and Vertical Scaling
- Capacity Planning
- Capacity Testing
- Balancing Your System
- Finding Bottlenecks
- System Blueprints
- Load Regulation and Backpressure
- Summing Up
- What's Next?
- Chapter 16. Monitoring and Preemptive Support
- Monitoring
- Logs
- Metrics
- Alarms
- Preemptive Support
- Summing Up
- What's Next?
- Index
- About the Authors
- Colophon
System requirements
File format: PDF
Copy-Protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our eBook Help page.