Cargando…

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...

Descripción completa

Detalles Bibliográficos
Clasificación:Libro Electrónico
Autores principales: Cesarini, Francesco (Autor), Vinoski, Steve (Autor)
Formato: Electrónico eBook
Idioma:Inglés
Publicado: Sebastopol, CA : O'Reilly Media, 2016.
Edición:First edition.
Temas:
Acceso en línea:Texto completo (Requiere registro previo con correo institucional)

MARC

LEADER 00000cam a2200000Ii 4500
001 OR_ocn950572436
003 OCoLC
005 20231017213018.0
006 m o d
007 cr unu||||||||
008 160526s2016 caua o 001 0 eng d
040 |a UMI  |b eng  |e rda  |e pn  |c UMI  |d TEFOD  |d N$T  |d YDXCP  |d OCLCO  |d EBLCP  |d OCLCO  |d OCLCF  |d OCLCO  |d COO  |d IUP  |d DEBBG  |d FEM  |d DEBSZ  |d QCL  |d VT2  |d REB  |d CEF  |d NTG  |d OCLCQ  |d UAB  |d OCLCQ  |d OCLCO  |d OCLCQ 
019 |a 949930453  |a 950055291  |a 951833122  |a 951977540  |a 968095367  |a 969072072 
020 |a 9781449361570  |q (electronic bk.) 
020 |a 1449361579  |q (electronic bk.) 
020 |a 9781449361563  |q (electronic bk.) 
020 |a 1449361560  |q (electronic bk.) 
020 |a 9781449361556 
020 |a 1449361552 
020 |a 1449320732 
020 |a 9781449320737 
020 |z 9781449320737 
029 1 |a AU@  |b 000059224334 
029 1 |a DEBBG  |b BV043969201 
029 1 |a DEBSZ  |b 485797151 
029 1 |a GBVCP  |b 882849417 
029 1 |a AU@  |b 000057621691 
035 |a (OCoLC)950572436  |z (OCoLC)949930453  |z (OCoLC)950055291  |z (OCoLC)951833122  |z (OCoLC)951977540  |z (OCoLC)968095367  |z (OCoLC)969072072 
037 |a CL0500000744  |b Safari Books Online 
037 |a 60E0D968-5EB3-4964-A448-DF0B19967D7A  |b OverDrive, Inc.  |n http://www.overdrive.com 
050 4 |a TK5103 
072 7 |a TEC  |x 009070  |2 bisacsh 
082 0 4 |a 621.382  |2 23 
049 |a UAMI 
100 1 |a Cesarini, Francesco,  |e author. 
245 1 0 |a Designing for scalability with Erlang/OTP /  |c Francesco Cesarini and Steve Vinoski. 
246 3 |a Designing for scalability with Erlang/Open Telecom Platform 
250 |a First edition. 
264 1 |a Sebastopol, CA :  |b O'Reilly Media,  |c 2016. 
300 |a 1 online resource (1 volume) :  |b illustrations 
336 |a text  |b txt  |2 rdacontent 
337 |a computer  |b c  |2 rdamedia 
338 |a online resource  |b cr  |2 rdacarrier 
347 |a text file  |2 rda 
588 0 |a Online resource; title from title page (Safari, viewed May 23, 2016). 
500 |a Includes index. 
505 0 |a 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. 
505 8 |a 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? 
505 8 |a 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. 
505 8 |a 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. 
505 8 |a 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. 
520 |a 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. 
590 |a O'Reilly  |b O'Reilly Online Learning: Academic/Public Library Edition 
650 0 |a Telecommunication systems  |x Design and construction. 
650 0 |a Wireless communication systems  |x Design and construction. 
650 0 |a ERLANG (Computer program language) 
650 6 |a ERLANG (Langage de programmation) 
650 7 |a TECHNOLOGY & ENGINEERING  |x Mechanical.  |2 bisacsh 
650 7 |a ERLANG (Computer program language)  |2 fast  |0 (OCoLC)fst00900472 
650 7 |a Telecommunication systems  |x Design and construction.  |2 fast  |0 (OCoLC)fst01146047 
650 7 |a Wireless communication systems  |x Design and construction.  |2 fast  |0 (OCoLC)fst01176210 
700 1 |a Vinoski, Steve,  |e author. 
776 0 8 |i Print version:  |a Cesarini, Francesco.  |t Designing for Scalability with Erlang/OTP : Implement Robust, Fault-Tolerant Systems.  |d Sebastopol : O'Reilly Media, ©2013  |z 9781449320737 
856 4 0 |u https://learning.oreilly.com/library/view/~/9781449361556/?ar  |z Texto completo (Requiere registro previo con correo institucional) 
938 |a EBL - Ebook Library  |b EBLB  |n EBL4543851 
938 |a EBSCOhost  |b EBSC  |n 1238909 
938 |a YBP Library Services  |b YANK  |n 12996204 
994 |a 92  |b IZTAP