East Baton Rouge Parish Library

Designing for scalability with Erlang/OTP, Francesco Cesarini and Steve Vinoski

eng

illustrations

index present

non fiction

Designing for scalability with Erlang/OTP

dictionaries

1950572436

Francesco Cesarini and Steve Vinoski

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

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 FunctionsList Comprehensions: Generate and TestProcesses 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 ServersGeneric 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 CollectionSpawn Options to AvoidTimeouts; 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 DataHandling Errors and Invalid Return ValuesSwapping 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

Designing for scalability with Erlang/Open Telecom Platform