Librería Portfolio Librería Portfolio

Búsqueda avanzada

TIENE EN SU CESTA DE LA COMPRA

0 productos

en total 0,00 €

DESIGNING FOR SCALABILITY WITH ERLANG/OTP. IMPLEMENT ROBUST, FAULT-TOLERANT SYSTEMS
Título:
DESIGNING FOR SCALABILITY WITH ERLANG/OTP. IMPLEMENT ROBUST, FAULT-TOLERANT SYSTEMS
Subtítulo:
Autor:
CESARINI, F
Editorial:
O´REILLY
Año de edición:
2016
ISBN:
978-1-4493-2073-7
Páginas:
482
48,95 € -10,0% 44,06 €

 

Sinopsis

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



Chapter 1Introduction
Defining the Problem
OTP
Distribution, Infrastructure, and Multicore
Summing Up
What You'll Learn in This Book
Chapter 2Introducing Erlang
Recursion and Pattern Matching
Functional Influence
Processes and Message Passing
Fail Safe!
Links and Monitors for Supervision
Records
Maps
Macros
Upgrading Modules
ETS: Erlang Term Storage
Distributed Erlang
Summing Up
What's Next?
Chapter 3Behaviors
Process Skeletons
Design Patterns
Extracting Generic Behaviors
The Generic Server
Message Passing: Under the Hood
Summing Up
What's Next?
Chapter 4Generic Servers
Generic Servers
Behavior Directives
Starting a Server
Message Passing
Termination
Call Timeouts
Generic Server Timeouts
Going Global
Linking Behaviors
Summing Up
What's Next?
Chapter 5Controlling OTP Behaviors
The sys Module
Spawn Options
Summing Up
What's Next?
Chapter 6Finite State Machines
Finite State Machines the Erlang Way
Coffee FSM
Generic FSMs
A Behavior Example
Summing Up
Get Your Hands Dirty
What's Next?
Chapter 7Event Handlers
Events
Generic Event Managers and Handlers
The SASL Alarm Handler
Summing Up
What's Next?
Chapter 8Supervisors
Supervision Trees
OTP Supervisors
How Does This Compare?
Summing Up
What's Next?
Chapter 9Applications
How Applications Run
The Application Structure
The Callback Module
Application Resource Files
Starting an Application
Environment Variables
Application Types and Termination Strategies
Distributed Applications
Start Phases
Included Applications
Combining Supervisors and Applications
The SASL Application
Summing Up
What's Next?
Chapter 10Special Processes and Your Own Behaviors
Special Processes
Your Own Behaviors
Summing Up
What's Next?
Chapter 11System Principles and Release Handling
System Principles
Rebar3
Wrapping Up
What's Next?
Chapter 12Release Upgrades
Software Upgrades
Creating a Release Upgrade
Upgrading Special Processes
Upgrading in Distributed Environments
Upgrading the Emulator and Core Applications
Upgrades with Rebar3
Summing Up
What's Next?
Chapter 13Distributed Architectures
Node Types and Families
Networking
Interfaces
Summing Up
What's Next?
Chapter 14Systems That Never Stop
Availability
Summing Up
What's Next?
Chapter 15Scaling Out
Horizontal and Vertical Scaling
Capacity Planning
Load Regulation and Backpressure
Summing Up
What's Next?
Chapter 16Monitoring and Preemptive Support
Monitoring
Preemptive Support
Summing Up
What's Next?