Designing for scalability with Erlang/OTP
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 o...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Beijing, [China] :
O'Reilly
2016.
|
| Edición: | First edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630276106719 |
Tabla de Contenidos:
- 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 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 Collection
- Spawn 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 Data
- Handling 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
- Starting and Stopping Applications
