Index
A
- abcast() function, Going Global
- abnormal process termination
- ACID acronym, Share something
- add_handler() function, Adding Event Handlers
- add_patha() function, Starting an Application
- add_sup_handler() function, Handling Errors and Invalid Return Values, Wrapping It All Up
- administration state, Start Phases
- alarm handlers, The SASL Alarm Handler-The SASL Alarm Handler, Alarms
- alarming
- alarm_handler module, The SASL Alarm Handler, Summing Up
- Allen, Mark, Riak Core
- Alpern, Bowen, Share everything
- Amdahl's law, Horizontal and Vertical Scaling
- americano coffee, Asynchronous events
- amount (metrics), Metrics
- anonymous functions, Functional Influence-Fun with Anonymous Functions
- app files
- application controller, How Applications Run, Script files
- -Application flag, Arguments and Flags, Upgrading Environment Variables
- application master, How Applications Run
- application module
- application resource files (see app files)
- application:ensure_all_started() function, Starting an Application
- application:get_all_env() function, Environment Variables
- application:get_application() function, Environment Variables
- application:get_env() function, Application Resource Files, Environment Variables
- application:load() function, Starting and Stopping Applications, Script files
- application:set_env() function, Environment Variables
- application:start() function, The SASL Alarm Handler, Starting and Stopping Applications, Application Types and Termination Strategies, Distributed Applications
- application:start_boot() function, Script files
- application:stop() function, Starting and Stopping Applications, Application Types and Termination Strategies
- application:which_applications() function, Starting and Stopping Applications, Application Resource Files
- applications
- about, How Applications Run-How Applications Run
- callback module, The Callback Module-Starting and Stopping Applications
- combining with supervisors, Combining Supervisors and Applications
- distributed, Distributed Applications-Distributed Applications
- environment variables, Environment Variables-Environment Variables
- Erlang nodes and, Erlang Nodes
- included, Included Applications
- loading, Starting and Stopping Applications
- resource files, Application Resource Files-The Base Station Controller Application File
- SASL, The SASL Application-Supervisor Reports
- sources for, Applications
- standard releases and, Release Resource Files
- start phases, Start Phases-Start Phases
- starting, How Applications Run, Starting and Stopping Applications, Starting an Application-Starting an Application
- stopping, Starting and Stopping Applications-Starting and Stopping Applications
- structural overview, The Application Structure-The Application Structure
- termination strategies, Application Types and Termination Strategies
- tools supporting Erlang, Tools and Libraries-Tools and Libraries
- types of, How Applications Run
- upgrading, Upgrading the Emulator and Core Applications
- version considerations, Release Resource Files
- apply() function, Script files
- apply_after() function, Generic Server Timeouts
- apply_interval() function, Generic Server Timeouts
- appmon (application monitor), Starting an Application
- appup files
- -args_file flag, Arguments and Flags
- arguments, passing to runtime system, Arguments and Flags-Arguments and Flags
- Armstrong, Joe, Erlang, Finite State Machines
- ASN.1 program, Tools and Libraries
- asynchronous events
- asynchronous message passing, Distribution, Infrastructure, and Multicore, Processes and Message Passing, Asynchronous Message Passing
- -async_shell_start
flag, Arguments and Flags
- at least once approach, At most once, exactly once, and at least once, Tradeoffs Between Consistency and Availability
- at most once approach, At most once, exactly once, and at least once, Tradeoffs Between Consistency and Availability
- atomicity (ACID), Share something
- authentication, Node Types and Families, Interfaces
- availability (see high availability)
B
- back-end nodes, Node Types and Families, Node Types and Families, Interfaces
- back-off algorithms, Resilience
- backpressure, load regulation and, Load Regulation and Backpressure-Load Regulation and Backpressure
- Bailis, Peter, Share everything
- balancing systems, Capacity Planning, Balancing Your System-Balancing Your System
- base station controller example, The Base Station Controller Application File, Release Resource Files
- Basho website, Riak Core
- Basic Operating System (BOS), OTP
- basic target systems, System Principles
- +Bc emulator flag, Arguments and Flags
- +Bd emulator flag, Arguments and Flags
- beam files, The Application Structure, Application Resource Files, Wrapping Up
- BEAM virtual machine
- -behavior directive
- behavior module, Callback Modules-Callback Modules
- behaviors
- about, System Design Principles
- creating, Rules for Creating Behaviors
- design patterns and, Behaviors, Design Patterns-Callback Modules
- extracting generic, Extracting Generic Behaviors-Functions Internal to the Server
- generic FSM example, A Behavior Example-Termination
- generic server, The Generic Server-The Generic Server
- globally registered, Going Global
- hibernating, Hibernating Behaviors
- implementing, Your Own Behaviors-An Example Handling TCP Streams
- linking, Linking Behaviors
- message passing, Message Passing: Under the Hood-Message Passing: Under the Hood
- monitoring, Summing Up
- processes and, System Design Principles, Behaviors-Process Skeletons
- spawn options, Spawn Options-Timeouts
- sys module support, The sys Module-The sys Module Recap
- TCP stream example, An Example Handling TCP Streams-An Example Handling TCP Streams
- timeouts, Timeouts
- +Bi emulator flag, Arguments and Flags
- bidirectional links, Links
- BIFs (built-in functions), Tools and Libraries, Processes and Message Passing
- bin directory, Release Directory Structure, Start Scripts and Configuring on the Target
- BINDIR environment variable, Release Directory Structure
- boot file
- -boot flag, Arguments and Flags
- BOS (Basic Operating System), OTP
- bottlenecks
- Brewer, Eric, Share everything
- British Telecom, Availability
- built-in functions (BIFs), Tools and Libraries, Processes and Message Passing
C
- c:erlangrc() function, Script files
- call timeouts, Call Timeouts-Deadlocks
- call() function
- callback functions
- callback modules
- CAP theorem, Share everything
- capacity planning
- capacity testing, Capacity Testing-Generating load
- case expression, Recursion and Pattern Matching
- cast() function, Generic Servers, Asynchronous Message Passing
- catch-all clauses, Fail Safe!-Fail Safe!
- change_code() function, The Release Handler
- chaos monkey tool, Testing Your Supervision Strategy
- check_childspecs() function, The child specification
- check_install_release() function, The Release Handler
- chess board list comprehension, List Comprehensions: Generate and Test
- child processes
- child specification (supervisors)
- client API, The Client Functions-The Client Functions
- cloud computing environments, Networking
- cluster blueprints, System Blueprints
- code:add_patha() function, Starting an Application
- code:lib_dir() function, The Application Structure
- code:load_file() function, Upgrading Modules, Arguments and Flags, Software Upgrades
- code:purge() function, Upgrading Modules, Software Upgrades
- code:root_dir() function, System Principles
- code:soft_purge() function, Upgrading Modules
- code_change() callback function, Behavior Directives
- coffee machine FSM example
- common_test application, Tools and Libraries
- compile:file() function, Upgrading Modules
- -config flag, Arguments and Flags
- configuration files
- -connect_all flag, Arguments and Flags
- consensus protocols, Share something
- consistency
- consistent hashing system, Riak Core
- counters (metrics), Metrics
- count_children() function, The child specification
- CPU-bound nodes, Balancing Your System
- crash reports (SASL), Crash Reports
- create_RELEASES() function, The Release Handler
- CTRL-d, Start Scripts and Configuring on the Target
- CXC product-numbering scheme, Starting and Stopping Applications
- cyclic restarts, Supervision Trees
D
- Däcker, Bjarne, OTP
- data networks, Networking
- data sharing, Sharing Data-Share everything
- dbg debugger, Tools and Libraries, Release Resource Files
- deadlocks, Deadlocks-Deadlocks
- debugger tool, Tools and Libraries, Release Resource Files
- debug_options() function, Basic template for starting a special process, System Messages
- delete() function, Retrieving Data
- delete_child() function, Dynamic Children, Simple one for one, High-Level Instructions
- delete_handler() function, Deleting an Event Handler
- demilitarized zone (DMZ), Networking
- demonitor() function, Monitors, Message Passing: Under the Hood
- -detached flag, Arguments and Flags
- DETS tables, ETS: Erlang Term Storage
- Deutsch, Peter, Networking
- dialyzer tool, Tools and Libraries, Behavior Directives, Release Directory Structure
- diameter stack, Tools and Libraries
- directory structure
- disaster recovery guidelines, Reliability
- distributed application controller, Distributed Applications-Distributed Applications
- distributed applications, Distributed Applications-Distributed Applications
- distributed environments
- distributed Erlang
- distribution
- DMZ (demilitarized zone), Networking
- dotted version vectors (DVVs), Riak Core
- DTrace probe, Tools and Libraries
- duplicate requests, At most once, exactly once, and at least once
- durability (ACID), Share something
- DVVs (dotted version vectors), Riak Core
- dynamic children, Dynamic Children
- dynamic clusters, Distributed Erlang
- dynamic modules, Dynamic Modules and Hibernating
E
- +e emulator flag, Arguments and Flags
- ebin directory
- echo:go() function, Processes and Message Passing
- echo:loop() function, Processes and Message Passing
- ei program, Tools and Libraries
- elarm application, Tools and Libraries, Applications, Alarms
- elasticity, Horizontal and Vertical Scaling
- eldap application, Tools and Libraries
- element() function, Records
- emacs editor, Tools and Libraries
- embedded mode, What You’ll Learn in This Book, Script files, Arguments and Flags
- embedded target systems, Creating a Release Package, Arguments and Flags
- emulator flags, passing to runtime system, Arguments and Flags-Arguments and Flags
- emulator, upgrading, Upgrading the Emulator and Core Applications
- -emu_args flag, Arguments and Flags
- enif_schedule_nif() C API function, Horizontal and Vertical Scaling
- ensure_all_started() function, Starting an Application
- -env flag, Arguments and Flags, Heart
- environment variables
- epmd daemon, Release Directory Structure
- epp (Erlang preprocessor), Macros
- Ericsson Computer Science Laboratory, Introduction, OTP
- erl command
- erl file extension, Wrapping Up
- Erlang loader, The Erlang loader-The Erlang loader
- Erlang nodes
- Erlang preprocessor (epp), Macros
- Erlang programming language
- about, Erlang
- catch-all clauses, Fail Safe!-Fail Safe!
- defining the problem, Defining the Problem-Defining the Problem
- distribution, Distribution, Infrastructure, and Multicore-Distribution, Infrastructure, and Multicore, Distributed Erlang-Node Connections and Visibility
- ETS tables, ETS: Erlang Term Storage-ETS: Erlang Term Storage
- functional influence, Functional Influence-List Comprehensions: Generate and Test
- infrastructure, Distribution, Infrastructure, and Multicore
- links and monitors for supervision, Links and Monitors for Supervision-Monitors
- macro facility, Macros
- maps, Maps-Maps
- message passing, Processes and Message Passing-Processes and Message Passing
- multicore systems, Distribution, Infrastructure, and Multicore, Processes and Message Passing
- pattern matching, Recursion and Pattern Matching-Recursion and Pattern Matching
- processes, Processes and Message Passing-Processes and Message Passing
- records, Records-Records
- recursion, Recursion and Pattern Matching-Recursion and Pattern Matching
- upgrading modules, Upgrading Modules-Upgrading Modules
- Erlang Syntax Tools modules, Tools and Libraries
- Erlang/OTP (see OTP framework)
- Erlang: the Movie, Finite State Machines
- erlang:apply() function, Script files
- erlang:demonitor() function, Monitors, Message Passing: Under the Hood
- erlang:element() function, Records
- erlang:exit() function, Fail Safe!, Links
- erlang:link() function, Links, Naming and Communication
- erlang:make_ref() function, Monitors, Message Passing: Under the Hood
- erlang:map_size() function, Maps
- erlang:monitor() function, Monitors, Message Passing: Under the Hood
- erlang:monitor_node() function, Node Connections and Visibility
- erlang:node() function, Node Connections and Visibility
- erlang:nodes() function, Node Connections and Visibility
- erlang:process_flag() function, Links, Other Messages
- erlang:register() function, Going Global
- erlang:self() function, Processes and Message Passing, Basic template for starting a special process
- erlang:send_after() function, Generic Server Timeouts
- erlang:set_cookie() function, Node Connections and Visibility
- erlang:spawn() function, Processes and Message Passing, Naming and Communication
- erlang:spawn_link() function, Links, Naming and Communication
- erlang:spawn_opt() function, Spawn Options-Spawn Options to Avoid
- erlang:system_info() function, Release Resource Files, Arguments and Flags
- erlang:system_monitor() function, Sockets and SSL, Finding Bottlenecks
- erlang:unlink() function, Links
- erlangrc() function, Script files
- erlc program, Release Directory Structure
- erlexec binary, Release Directory Structure
- ERL_CRASH_DUMP_SECONDS environment
variable, Heart
- erl_interface, Tools and Libraries
- erl_prim_loader module, Script files, The Erlang loader
- erl_prim_loader:get_file() function, Script files
- error exception, Fail Safe!
- error reports (SASL), Error Reports
- error_logger module, Script files
- erts directory
- escript program, Release Directory Structure
- et (event tracer) tool, Tools and Libraries
- etop tool, Finding Bottlenecks
- ETS (Erlang Term Storage) tables, ETS: Erlang Term Storage-ETS: Erlang Term Storage, Retrieving Data, Simple one for one
- ets:delete() function, Retrieving Data
- ets:give_away() function, Simple one for one
- ets:match() function, ETS: Erlang Term Storage
- ets:new() function, ETS: Erlang Term Storage
- ets:update_counter() function, Metrics
- eunit tool, Tools and Libraries
- -eval flag, Arguments and Flags, Arguments and Flags
- event handlers
- about, System Design Principles, Events
- adding, Adding Event Handlers-Adding Event Handlers
- callback modules and, Generic Event Managers and Handlers
- deleting, Deleting an Event Handler
- event managers and, Generic Event Managers and Handlers
- generic, Generic Event Managers and Handlers-Wrapping It All Up
- gen_event module and, What You’ll Learn in This Book, Generic Event Managers and Handlers
- handling errors and invalid return values, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values
- retrieving data, Retrieving Data-Retrieving Data
- SASL alarm handler, The SASL Alarm Handler-The SASL Alarm Handler
- sending synchronous and asynchronous events, Sending Synchronous and Asynchronous Events-Sending Synchronous and Asynchronous Events
- swapping, Swapping Event Handlers-Swapping Event Handlers
- event managers
- about, System Design Principles, Events
- event handlers and, Generic Event Managers and Handlers
- generic, Generic Event Managers and Handlers-Wrapping It All Up
- gen_event module and, What You’ll Learn in This Book, Generic Event Managers and Handlers
- handling errors and invalid return values, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values
- SASL alarm handler, The SASL Alarm Handler-The SASL Alarm Handler
- sending synchronous and asynchronous events, Sending Synchronous and Asynchronous Events-Sending Synchronous and Asynchronous Events
- starting and stopping, Starting and Stopping Event Managers
- events
- about, Finite State Machines the Erlang Way, Events-Events
- asynchronous, The events-The remove state, Sending Events, Asynchronous events to all states, Sending Synchronous and Asynchronous Events-Sending Synchronous and Asynchronous Events
- logging, What You’ll Learn in This Book
- sending, Sending Events-Synchronous events
- synchronous, Sending Events, Synchronous events-Synchronous events, Sending Synchronous and Asynchronous Events-Sending Synchronous and Asynchronous Events
- system messages, System Messages
- eventual consistency, Share something
- exactly once approach, At most once, exactly once, and at least once, Tradeoffs Between Consistency and Availability
- exception handling
- exit exception, Fail Safe!
- exit signals, Links, Other Messages, Linking Behaviors, Preemptive Support
- exit() function, Fail Safe!, Links
- exometer application, Tools and Libraries, Applications, Metrics
- exponential back-off algorithms, Resilience
- -export directive, Starting the FSM
F
- factorials, computing for positive numbers, Recursion and Pattern Matching
- failovers, Distributed Applications
- false negatives, Alarms
- false positives, Alarms
- fault tolerance
- about, Defining the Problem, Systems That Never Stop, Summing Up
- availability and, Fault Tolerance-Fault Tolerance
- distribution and, Distribution, Infrastructure, and Multicore-Distribution, Infrastructure, and Multicore
- supervision trees and, Supervision Trees
- Fibonacci, Resilience
- FIFO queue strategy, Load Regulation and Backpressure
- file extensions, Wrapping Up
- file() function, Upgrading Modules
- filelib:wildcard() function, Records
- finite state machines (see FSMs)
- Fischer-Lynch-Paterson (FLP) Impossibility
result, Share everything
- flags, passing to runtime system, Arguments and Flags-Arguments and Flags
- FLP (Fischer-Lynch-Paterson) Impossibility
result, Share everything
- folsom application, Tools and Libraries, Applications, Metrics
- format() function, Synchronizing Clients, Your Own Trace Functions
- frequency allocator example
- front-end nodes, Node Types and Families, Node Types and Families, Interfaces
- FSMs (finite state machines), Finite State Machines
- (see also coffee machine FSM example)
- about, System Design Principles, What You’ll Learn in This Book, Finite State Machines-Finite State Machines the Erlang Way
- adding states, Adding a State-Adding a State
- behavior example, A Behavior Example-Termination
- defining states, Defining states-Defining states
- generic FSMs, Generic FSMs-Generic FSMs
- generic servers versus, Finite State Machines the Erlang Way
- mutex states and, The Mutex
- phone controllers example, Get Your Hands Dirty-Let’s Test It
- sending events, Sending Events-Synchronous events
- starting, Starting the FSM-Starting the FSM
- terminating, Termination-Termination
- full sweep garbage collection, Memory Management and Garbage Collection
- function_clause runtime error, Unhandled Messages
G
- garbage collection, Processes and Message Passing, Memory Management and Garbage Collection-Full sweep of the heap
- gauges (metrics), Metrics
- generic behaviors
- generic event handlers
- generic event managers
- generic FSMs
- generic servers
- about, System Design Principles, Generic Servers
- behavior directives, Behavior Directives
- call timeouts, Call Timeouts-Deadlocks
- deadlocks, Deadlocks-Deadlocks
- FSMs versus, Finite State Machines the Erlang Way
- globally registered processes, Going Global
- linking behaviors, Linking Behaviors
- message passing, Message Passing-Synchronizing Clients
- server module example, The Generic Server-The Generic Server
- starting a server, Starting a Server-Starting a Server
- terminating, Termination-Termination
- timeouts, Generic Server Timeouts-Hibernating Behaviors
- gen_event module
- gen_event:add_handler() function, Adding Event Handlers
- gen_event:add_sup_handler() function, Handling Errors and Invalid Return Values, Wrapping It All Up
- gen_event:call() function, Retrieving Data
- gen_event:delete_handler() function, Deleting an Event Handler
- gen_event:notify() function, Sending Synchronous and Asynchronous Events
- gen_event:start() function, Starting and Stopping Event Managers
- gen_event:start_link() function, Starting and Stopping Event Managers
- gen_event:stop() function, Starting and Stopping Event Managers, Deleting an Event Handler
- gen_event:swap_handler() function, Swapping Event Handlers
- gen_event:swap_sup_handler() function, Swapping Event Handlers
- gen_event:sync_event() function, Retrieving Data
- gen_event:sync_notify() function, Sending Synchronous and Asynchronous Events
- gen_fsm module
- gen_fsm:reply() function, Synchronous events
- gen_fsm:send_all_state_event() function, Asynchronous events to all states
- gen_fsm:send_event() function, Asynchronous events
- gen_fsm:start() function, Starting the FSM
- gen_fsm:start_link() function, Starting the FSM-Starting the FSM
- gen_fsm:sync_send_all_state_event() function, Synchronous events-Synchronous events
- gen_fsm:sync_send_event() function, Synchronous events-Termination
- gen_rpc application, Sockets and SSL
- gen_server module
- about, What You’ll Learn in This Book, Generic Servers
- behavior directives, Behavior Directives
- call timeouts, Call Timeouts-Deadlocks
- deadlocks, Deadlocks-Deadlocks
- generic server timeouts, Generic Server Timeouts-Hibernating Behaviors
- globally registered processes, Going Global
- linking behaviors, Linking Behaviors
- message passing, Message Passing-Synchronizing Clients
- starting a server, Starting a Server-Starting a Server
- system messages, System Messages
- terminating generic servers, Termination-Termination
- gen_server:abcast() function, Going Global
- gen_server:call() function, Generic Servers, Synchronous Message Passing-Synchronous Message Passing, Call Timeouts-Call Timeouts
- gen_server:cast() function, Generic Servers, Asynchronous Message Passing
- gen_server:multi_call() function, Going Global
- gen_server:reply() function, Synchronizing Clients, System Messages
- gen_server:start() function, Linking Behaviors
- gen_server:start_link() function, Generic Servers, Starting a Server-Starting a Server
- gen_tcp module, Sockets and SSL
- get flag (sys module), Tracing and Logging, The sys Module Recap
- gethostbyaddr() function, Records
- gethostbyname() function, Records
- get_all_env() function, Application Resource Files, Environment Variables
- get_application() function, Environment Variables
- get_argument() function, Arguments and Flags
- get_arguments() function, Arguments and Flags
- get_env() function, Environment Variables
- get_file() function, Script files
- get_plain_arguments() function, Arguments and Flags
- get_state() function, Statistics, Status, and State, The sys Module Recap
- get_status() function
- give_away() function, Simple one for one
- global module, Going Global, Starting the FSM
- global name server, Sockets and SSL
- global:register_name() function, Going Global, Scalable Distributed Erlang
- global:send() function, Going Global
- global:unregister_name() function, Going Global
- global:whereis_name() function, Going Global
- go() function, Processes and Message Passing
- gossip protocol, Riak Core
- gproc application, Service Orientation and Microservices
- Guerra, Mariano, Riak Core
H
- halt() shell command, Distributed Applications, Arguments and Flags
- handle_call() callback function
- handle_cast() callback function, Generic Servers, Asynchronous Message Passing
- handle_debug() function, Trace and Log Events, Putting It Together
- handle_event() callback function, Sending Synchronous and Asynchronous Events
- handle_info() callback function, Sending Synchronous and Asynchronous Events
- handle_sync_event() callback function, Synchronous events, Termination
- handle_system_message() function, System Messages
- handle_system_msg() function, Upgrading Special Processes
- -heart flag, Arguments and Flags
- heart module
- HEART_BEAT_TIMEOUT environment variable, Heart
- HEART_COMMAND environment variable, Heart
- Heriot-Watt University (Scotland), How Does This Compare?
- hibernate() function, Dynamic Modules and Hibernating
- hibernating
- -hidden flag, Node Connections and Visibility, Arguments and Flags
- high availability
- about, Defining the Problem, Availability
- fault tolerance and, Fault Tolerance
- in CAP theorem, Share everything
- reliability, Reliability-At most once, exactly once, and at least once
- resilience and, Resilience
- sharing data and, Sharing Data-Share everything
- strategies for, What You’ll Learn in This Book
- tradeoffs with consistency, Tradeoffs Between Consistency and Availability-Tradeoffs Between Consistency and Availability
- higher-order functions, Fun with Anonymous Functions
- hinted handoffs, Riak Core
- histograms, Metrics
- horizontal scaling, Horizontal and Vertical Scaling-Horizontal and Vertical Scaling
I
- i() shell command, Finding Bottlenecks
- I/O-bound nodes, Balancing Your System
- ic (IDL compiler), Tools and Libraries
- idempotence, At most once, exactly once, and at least once
- -include directive, The Application Structure
- include directory, The Application Structure, The Application Structure
- included_applications parameter, Included Applications-Start Phases in Included Applications
- inet module, The Erlang loader
- inet:gethostbyaddr() function, Records
- inet:gethostbyname() function, Records
- init module, Script files, The init Module
- init() callback function
- init:get_argument() function, Arguments and Flags
- init:get_arguments() function, Arguments and Flags
- init:get_plain_arguments() function, Arguments and Flags
- init:get_status() function, Script files, The init Module
- init:reboot() function, The init Module, The Release Handler
- init:restart() function, The init Module, The Release Handler
- init:stop() function, The init Module
- initializing processes, Process Skeletons
- init_ack() function, Basic template for starting a special process
- init_debug flag, Arguments and Flags
- -init_debug flag, Arguments and Flags
- init_request() callback function, An Example Handling TCP Streams
- install() function, Your Own Trace Functions, The sys Module Recap, Trace and Log Events
- install_release() function, High-Level Instructions, Low-Level Instructions, The Release Handler
- interactive mode, What You’ll Learn in This Book, Arguments and Flags
- interfaces, distributed environments and, Interfaces-Interfaces
- invalid return values, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values
- io:format() function, Synchronizing Clients, Your Own Trace Functions
- isolation (ACID), Share something
L
- lager application, Tools and Libraries, Applications, Logs
- Lamport, Leslie, Share everything
- last call optimization, Recursion and Pattern Matching
- latency, Capacity Planning, Capacity Testing, Balancing Your System
- LDAP (Lightweight Directory Access
Protocol), Tools and Libraries
- leex lexical analyzer generator, Tools and Libraries
- lib directory, The Application Structure, Release Directory Structure
- libraries and tools, Tools and Libraries-Tools and Libraries
- library applications, How Applications Run
- lib_dir() function, The Application Structure
- lifecycle of processes, Process Skeletons
- LIFO queue strategy, Load Regulation and Backpressure
- Lightweight Directory Access Protocol
(LDAP), Tools and Libraries
- link() function, Links, Naming and Communication
- linking
- list comprehensions, List Comprehensions: Generate and Test-List Comprehensions: Generate and Test
- lists
- Little's Law, Load Regulation and Backpressure
- load application type, Release Resource Files
- load regulation and backpressure, Load Regulation and Backpressure-Load Regulation and Backpressure
- load testing, Capacity Testing
- load() function, Starting and Stopping Applications, Script files
- load_file() function, Upgrading Modules, Arguments and Flags, Software Upgrades
- log directory, Start Scripts and Configuring on the Target
- log() function, Tracing and Logging, The sys Module Recap, Trace and Log Events
- logger callback module, Deleting an Event Handler
- logic nodes, Node Types and Families, Node Types and Families, Interfaces
- logrotate tool, Logs
- logs and logging
- log_to_file() function, Tracing and Logging, The sys Module Recap
- loop() function, Processes and Message Passing
- looping behavior, Recursion and Pattern Matching
- Lynch, Nancy, Share everything
M
- m(module) command, Starting and Stopping Applications
- macro facility, Macros
- make:files() function, Software Upgrades
- make_permanent() function, Installing an Upgrade, The Release Handler
- make_ref() function, Monitors, Message Passing: Under the Hood
- make_relup() function, Release Upgrade Files
- make_script() function, Creating the Boot File-Creating the Boot File, The make_script parameters, The Erlang loader, Release Upgrade Files
- make_tar() function, Creating a Release Package, Release Upgrade Files, The Release Handler
- map collection type, Maps-Maps
- map_size() function, Maps
- match() function, ETS: Erlang Term Storage
- md5 digest, Software Upgrades
- megaco stack, Tools and Libraries
- memory management, Memory Management and Garbage Collection-Full sweep of the heap, Sockets and SSL, Finding Bottlenecks
- memory-bound nodes, Balancing Your System
- message passing
- about, Erlang
- asynchronous, Distribution, Infrastructure, and Multicore, Processes and Message Passing, Asynchronous Message Passing
- behaviors and, Message Passing: Under the Hood-Message Passing: Under the Hood
- generic servers, Message Passing-Synchronizing Clients
- other messages, Other Messages
- processes and, Processes and Message Passing-Processes and Message Passing
- synchronous, Synchronizing Clients
- synchronous message, Synchronous Message Passing-Synchronous Message Passing
- system messages, System Messages, Sockets and SSL
- unhandled messages, Unhandled Messages-Unhandled Messages
- meters (metrics), Metrics
- metrics
- microservices, Service Orientation and Microservices
- Millroth, Håkan, What’s Next?
- Mnesia distributed database, Tools and Libraries, Synchronous Starts for Determinism, Share everything
- mnesia:transform_table() function, The Code to Upgrade
- -mode flag, Arguments and Flags
- -module directive, Starting the FSM
- modules, Callback Modules
- Modules element (child specification), The child specification
- module_info() callback function, Software Upgrades
- module_not_found error, Sending Synchronous and Asynchronous Events
- MongooseIM chat server, Applications
- monitor() function, Monitors, Message Passing: Under the Hood
- monitoring
- behaviors, Summing Up
- observer tool and, Starting an Application
- processes, Monitors-Monitors
- purpose of, Monitoring and Preemptive Support-Monitoring
- via alarms, Monitoring, Alarms-Alarms
- via logs and
logging, Monitoring, Logs-Logs
- via metrics, Monitoring, Metrics
- monitor_node() function, Node Connections and Visibility
- monotonic read model, Share something
- monotonic write model, Share something
- multicall() function, Sockets and SSL
- multicore systems
- multi_call() function, Going Global
- mutable variables, Recursion and Pattern Matching
- mutex (mutual exclusion)
N
- Name element (child specification), The child specification
- -name flag, Naming and Communication, Arguments and Flags, The Erlang loader
- namespaces, Scalable Distributed Erlang
- native implemented functions (NIFs), Horizontal and Vertical Scaling
- negative numbers, Fail Safe!
- net kernel process, Distributed Erlang, Sockets and SSL
- networking in distributed environments
- net_kernel module, Node Connections and Visibility
- new() function, ETS: Erlang Term Storage
- NIFs (native implemented functions), Horizontal and Vertical Scaling
- Nkcluster application, Riak Core
- Nkdist library, Riak Core
- node attributes, Scalable Distributed Erlang
- node families, Node Types and Families
- node() function, Node Connections and Visibility
- nodes (see Erlang nodes)
- nodes() function, Node Connections and Visibility
- none application type, Release Resource Files
- normal applications, How Applications Run
- normal process termination, Links, Process Skeletons, Testing Your Supervision Strategy
- -nostick flag, Arguments and Flags
- notify() function, Sending Synchronous and Asynchronous Events
- no_dot_erlang.boot file, The make_script parameters
O
- O&M networks, Networking
- OAM (Operation, Administration, and Maintenance), Monitoring
- Object Request Brokers, Tools and Libraries
- observer tool, Tools and Libraries, Starting an Application, Finding Bottlenecks
- observer:start() function, Starting an Application, Arguments and Flags
- odbc interface, Tools and Libraries
- one_for_all strategy, The restart specification
- one_for_one strategy, The restart specification
- Operation, Administration, and Maintenance (OAM), Monitoring
- orber broker, Tools and Libraries
- os_mon application, Tools and Libraries, Release Resource Files
- OTP behaviors (see behaviors)
- OTP framework, Erlang
- otp_mibs, Tools and Libraries
P
- +P emulator flag, Arguments and Flags
- p2p (peer-to-peer) architectures, Peer to Peer
- -pa flag, Arguments and Flags
- paritition tolerance (CAP theorem), Share everything
- parsetools application, Tools and Libraries
- path command (script file), Script files
- pattern matching and recursion, Recursion and Pattern Matching-Recursion and Pattern Matching
- Paxos protocol, Share something
- peer-to-peer (p2) architectures, Peer to Peer
- percept tool, Finding Bottlenecks
- perimeter networks, Networking
- permanent application type, Application Types and Termination Strategies, Release Resource Files
- phone controllers example, The Phone Controllers-Let’s Test It, Dynamic Children-Dynamic Children
- pids (process identifiers), Processes and Message Passing
- plain arguments, Arguments and Flags
- plain_fsm library, Asynchronous events to all states
- pman (process manager), Starting an Application
- point of failure, Reliability-Reliability, Horizontal and Vertical Scaling
- poolboy library, Networking, Sockets and SSL
- preemptive support automation, Monitoring and Preemptive Support, Preemptive Support-Preemptive Support
- preleases (release candidates), Release Resource Files
- preLoaded command (script file), Script files
- prep_stop() callback function, Included Applications
- primary-primary replication, Share everything
- primary-secondary replication, Share everything
- primLoad command (script file), Script files
- print flag, Tracing and Logging, The sys Module Recap
- printing list elements, Recursion and Pattern Matching
- priv directory, The Application Structure, The Application Structure, Release Resource Files
- proactive support automation, Preemptive Support
- process heap, Process heap
- process ID, Distributed Erlang
- process identifiers (pids), Processes and Message Passing
- processes
- application controller and, How Applications Run
- behaviors and, System Design Principles, Behaviors-Process Skeletons
- design patterns and, Behaviors, Design Patterns-Callback Modules
- events and, Events
- globally registered, Going Global
- initializing, Process Skeletons
- lifecycle of, Process Skeletons
- links and monitors for supervision, Links and Monitors for Supervision-Monitors
- memory and, Processes and Message Passing
- message passing and, Processes and Message Passing-Processes and Message Passing
- monitoring, Monitors-Monitors
- non-OTP-compliant, Non-OTP-Compliant Processes-Adding non-OTP-compliant processes
- restarting, Supervision Trees
- short-lived, Scalability and Short-Lived Processes-Scalability and Short-Lived Processes
- spawning, Processes and Message Passing, Process Skeletons, Spawn Options-Timeouts, Supervision Trees
- special, What You’ll Learn in This Book, Adding non-OTP-compliant processes, Special Processes and Your Own Behaviors-Dynamic Modules and Hibernating, Upgrading Special Processes
- terminating, Links, Process Skeletons, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values, Supervision Trees
- ProcessType element (child specification), The child specification
- process_flag() function, Links, Other Messages
- proc_lib module
- proc_lib:handle_system_msg() function, Upgrading Special Processes
- proc_lib:hibernate() function, Dynamic Modules and Hibernating
- proc_lib:init_ack() function, Basic template for starting a special process
- proc_lib:spawn() function, Starting Special Processes
- proc_lib:start() function, Starting Special Processes
- proc_lib:start_link() function, Basic template for starting a special process
- progress reports (SASL), Progress Reports
- PropEr tool, Supervisors
- public_key module, The Application Structure
- purge() function, Upgrading Modules, Software Upgrades
- -pz flag, Arguments and Flags
R
- +R emulator flag, Arguments and Flags
- RabbitMQ message broker, Applications
- race conditions, Heart
- Raft protocol, Share something
- ranch library, Networking
- random back-off algorithms, Resilience
- rb:start() function, Supervisor Reports
- read your own writes consistency level, Share something
- rebar3 tool
- reboot() function, The init Module, The Release Handler
- reboot_old_release() function, The Release Handler
- -record directive, Records
- records
- recursion and pattern matching, Recursion and Pattern Matching-Recursion and Pattern Matching
- reduction count, Processes and Message Passing
- register() function, Going Global
- register_name() function, Going Global, Scalable Distributed Erlang
- regs() shell command, Finding Bottlenecks
- regular expressions, special characters and, Application Upgrade Files
- rel files, Release Directory Structure, Release Resource Files, Wrapping Up
- RELDIR environment variable, Release Directory Structure
- release candidates (preleases), Release Resource Files
- release handling
- arguments and flags, Arguments and Flags-The Erlang loader
- configuring on target, Start Scripts and Configuring on the Target-Start Scripts and Configuring on the Target
- creating release packages, Creating a Release Package-Creating a Release Package
- creating release upgrades, Creating a Release Upgrade-Upgrading Environment Variables
- creating releases, Creating a Release
- init module, The init Module
- rebar3 tool and, Rebar3-Rebar3 Releases with Project Dependencies
- release and application versions, Release Resource Files
- release directory structure, Release Directory Structure-Release Directory Structure
- release resource files, Release Resource Files-Release Resource Files
- software upgrades, Software Upgrades-Adding a State
- start scripts, Start Scripts and Configuring on the Target-Start Scripts and Configuring on the Target
- upgrading modules, Upgrading Modules-Upgrading Modules
- RELEASE project, Node Types and Families, Scalable Distributed Erlang
- release upgrades
- releases directory, The make_script parameters, Installing an Upgrade, The Release Handler
- release_handler module, The Release Handler-The Release Handler
- release_handler:check_install_release() function, The Release Handler
- release_handler:create_RELEASES() function, The Release Handler
- release_handler:install_release() function, High-Level Instructions, Low-Level Instructions, The Release Handler
- release_handler:make_permanent() function, Installing an Upgrade, The Release Handler
- release_handler:reboot_old_release() function, The Release Handler
- release_handler:remove_release() function, Installing an Upgrade, The Release Handler
- release_handler:unpack_release() function, Installing an Upgrade, The Release Handler
- release_handler:which_releases() function, The Release Handler
- reliability, Distribution, Infrastructure, and Multicore, Reliability-At most once, exactly once, and at least once, Summing Up
- reltool (release management tool), Tools and Libraries, Creating a Release with Rebar3, Wrapping Up
- relup files, Wrapping Up, Creating a Release Upgrade, Release Upgrade Files-Release Upgrade Files
- relx tool, Creating a Release with Rebar3
- remove() function, Your Own Trace Functions, The sys Module Recap
- remove_release() function, Installing an Upgrade, The Release Handler
- -remsh flag, Arguments and Flags
- replace_state() function, Statistics, Status, and State, The sys Module Recap
- reply() function
- resilience, Resilience, Summing Up
- resource blueprints, System Blueprints
- resource files
- restart specification (supervisors), The restart specification-The restart specification
- restart() function, The init Module, The Release Handler
- RestartType element (child specification), The child specification
- restart_child() function, Simple one for one
- restart_new_emulator instruction, Upgrading the Emulator and Core Applications
- RESTful APIs, Networking
- rest_for_one strategy, Starting the Supervisor, The restart specification, High-Level Instructions
- resume() function, Statistics, Status, and State, The sys Module Recap
- return values, invalid, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values
- rex (RPC server), Distributed Erlang, Sockets and SSL
- RFC 6733, Tools and Libraries
- Riak Core framework
- ROOT environment variable, Script files
- ROOTDIR environment variable, Release Directory Structure
- root_dir() function, System Principles
- rpc:multicall() function, Sockets and SSL
- rr shell command, Records
- -run flag, Arguments and Flags
- runtime_tools application, Tools and Libraries, The Application Structure, Release Resource Files
- run_erl binary, Release Directory Structure
S
- -s flag, Arguments and Flags, Arguments and Flags
- Safetyvalve framework, Tools and Libraries, Load Regulation and Backpressure
- sasl application
- about, Tools and Libraries, What You’ll Learn in This Book, Starting and Stopping Applications
- alarm handler, The SASL Alarm Handler-The SASL Alarm Handler, Alarms
- alternative boot files, The make_script parameters
- crash reports, Crash Reports
- error reports, Error Reports
- progress reports, Progress Reports
- release resource files and, Release Resource Files
- services supported, The SASL Application-The SASL Application
- supervisor reports, Supervisor Reports
- sasl application resource file, Application Resource Files-Application Resource Files
- SASL logs, Supervisor Reports
- scalability
- about, Defining the Problem, Scaling Out
- capacity planning and, Capacity Planning-System Blueprints
- distributed Erlang and, Distributed Erlang
- distribution and, Distribution, Infrastructure, and Multicore
- horizontal and vertical, Horizontal and Vertical Scaling-Horizontal and Vertical Scaling
- load regulation and backpressure, Load Regulation and Backpressure-Load Regulation and Backpressure
- Riak Core and, Riak Core
- short-lived processes and, Scalability and Short-Lived Processes-Scalability and Short-Lived Processes
- strategies for, What You’ll Learn in This Book
- scaling out, Horizontal and Vertical Scaling
- scaling up, Horizontal and Vertical Scaling
- schedulers, Processes and Message Passing, Load Regulation and Backpressure
- Schneider, Fred B., Share everything
- script files, Script files-The make_script parameters, Wrapping Up
- script2boot() function, The make_script parameters
- SD (Scalable Distributed) Erlang framework
- secret cookies, Node Connections and Visibility
- selective receives, Asynchronous events to all states
- self() function, Processes and Message Passing, Basic template for starting a special process
- self-support automation, Preemptive Support
- semantic node types, Node Types and Families
- semi-explicit placement, Scalable Distributed Erlang
- send() function, Going Global
- send_after() function, Generic Server Timeouts
- send_all_state_event() function, Asynchronous events to all states
- send_event() function, Asynchronous events
- send_interval() function, Generic Server Timeouts
- server module example, The Generic Server-The Generic Server
- service metadata, Service Orientation and Microservices
- service nodes, Node Types and Families, Node Types and Families, Interfaces
- service-level agreements, Load Regulation and Backpressure
- service-oriented architecture (SOA), Distribution, Infrastructure, and Multicore, Service Orientation and Microservices
- session ID, Node Types and Families
- -setcookie flag, Node Connections and Visibility, Arguments and Flags
- set_cookie() function, Node Connections and Visibility
- set_env() function, Environment Variables
- share-everything architecture, Share everything-Share everything
- share-nothing architecture, Share nothing-Share nothing
- share-something architecture, Share something-Share something
- sharing data, Sharing Data-Share everything
- shell, exiting, Start Scripts and Configuring on the Target
- Short Message Service Center (SMSC), Logs
- ShutdownTime element (child
specification), The child specification
- -shutdown_time
flag, Arguments and Flags, The init Module
- signal event, The Mutex States
- simple target systems, System Principles
- simple_one_for_one strategy, The restart specification, Simple one for one-Simple one for one, Scalability and Short-Lived Processes
- single point of failure, Reliability-Reliability, Horizontal and Vertical Scaling
- site redundancy, Reliability
- sleep() function, Synchronizing Clients, Call Timeouts
- sloppy quorums, Riak Core
- SMP (symmetric multiprocessing), Distribution, Infrastructure, and Multicore
- SMSC (Short Message Service Center), Logs
- -sname flag, Arguments and Flags, The Erlang loader
- snmp agent, Tools and Libraries
- snmp client, Tools and Libraries
- SOA (service-oriented architecture), Distribution, Infrastructure, and Multicore, Service Orientation and Microservices
- soak testing, Capacity Testing
- soft real-time, Defining the Problem
- software upgrades
- soft_purge() function, Upgrading Modules
- spawn() function
- spawning processes
- spawn_link() function, Links, Naming and Communication
- spawn_opt() function, Spawn Options-Spawn Options to Avoid
- special processes
- about, What You’ll Learn in This Book, Special Processes and Your Own Behaviors
- asynchronously starting, Asynchronously starting a special process
- dynamic modules and hibernating, Dynamic Modules and Hibernating
- entire mutex example, Putting It Together-Putting It Together
- handling exits, Handling Exits-Handling Exits
- mutex states and, The Mutex States
- mutexes and, The Mutex-The Mutex
- proc_lib module and, Adding non-OTP-compliant processes
- starting, Starting Special Processes-Asynchronously starting a special process
- system messages, System Messages
- trace and log events, Trace and Log Events
- upgrading, Upgrading Special Processes
- spike testing, Capacity Testing
- spiral (metrics), Metrics
- src directory, The Application Structure, The Application Structure
- SSL, Distributed Erlang
- ssl module, Sockets and SSL-Sockets and SSL
- St. Laurent, Simon, What You’ll Learn in This Book
- stack overflow, Recursion and Pattern Matching
- start phases (applications)
- start script, Release Directory Structure, Creating a Release
- start() function
- application module, The SASL Alarm Handler, Starting and Stopping Applications, Application Types and Termination Strategies, Distributed Applications
- gen_event module, Starting and Stopping Event Managers
- gen_fsm module, Starting the FSM
- gen_server module, Linking Behaviors
- observer module, Starting an Application, Arguments and Flags
- proc_lib module, Starting Special Processes
- rb module, Supervisor Reports
- supervisor module, Starting the Supervisor
- start.boot file, The make_script parameters
- StartFunction element (child
specification), The child specification
- start_boot() function, Script files
- start_child() function, Dynamic Children, High-Level Instructions
- start_clean.boot file, The make_script parameters
- start_erl program, Release Directory Structure, Start Scripts and Configuring on the Target
- start_link() function
- start_sasl.boot file, The make_script parameters
- state-based alarms, Alarms
- states (see FSMs)
- static clusters, Distributed Erlang
- statistics() function, Statistics, Status, and State, The sys Module Recap
- stdlib application
- stop() function
- stress testing, Capacity Testing
- strict quorums, Riak Core
- supervision trees
- supervisor bridges, Supervisor bridges-Supervisor bridges
- supervisor module
- supervisor reports (SASL), Supervisor Reports
- supervisor specification
- supervisor:check_childspecs() function, The child specification
- supervisor:count_children() function, The child specification
- supervisor:delete_child() function, Dynamic Children, Simple one for one, High-Level Instructions
- supervisor:restart_child() function, Simple one for one
- supervisor:start() function, Starting the Supervisor
- supervisor:start_child() function, Dynamic Children, High-Level Instructions
- supervisor:start_link() function, Starting the Supervisor, Starting and Stopping Applications
- supervisor:terminate_child() function, Simple one for one, High-Level Instructions
- supervisor:which_children() function, The child specification, Dynamic Children
- supervisors
- about, System Design Principles, System Design Principles, Supervision Trees-OTP Supervisors
- application master and, How Applications Run
- combining with applications, Combining Supervisors and Applications
- dynamic children and, Dynamic Children-Gluing it all together
- handling errors, Handling Errors and Invalid Return Values-Handling Errors and Invalid Return Values
- links and monitors for, Links and Monitors for Supervision-Monitors
- scalability and short-lived processes, Scalability and Short-Lived Processes-Scalability and Short-Lived Processes
- starting, Supervision Trees, Starting the Supervisor-Starting the Supervisor
- supervisor specification, The Supervisor Specification-The child specification
- synchronous starts, Synchronous Starts for Determinism
- terminating, Supervision Trees
- supervisor_bridge:start_link() function, Supervisor bridges
- support automation, Preemptive Support-Preemptive Support
- suspend() function, Statistics, Status, and State, The sys Module Recap, High-Level Instructions
- swap_handler() function, Swapping Event Handlers
- swap_sup_handler() function, Swapping Event Handlers
- symmetric multiprocessing (SMP), Distribution, Infrastructure, and Multicore
- synchronous events
- synchronous message passing, Synchronous Message Passing-Synchronous Message Passing, Synchronizing Clients
- sync_event() function, Retrieving Data
- sync_nodes low-level instruction, Upgrading in Distributed Environments
- sync_notify() function, Sending Synchronous and Asynchronous Events
- sync_send_all_state_event() function, Synchronous events-Synchronous events
- sync_send_event() function, Synchronous events-Termination
- syntax_tools modules, Tools and Libraries
- sys module
- about, The sys Module
- debug options, Supervisor bridges
- handling system messages, System Messages
- implementing trace functions, Your Own Trace Functions-Your Own Trace Functions
- statistics, status, state, Statistics, Status, and State-Statistics, Status, and State
- system messages, System Messages
- tracing and logging, Tracing and Logging-Tracing and Logging
- user-defined behaviors and, Your Own Behaviors
- sys:change_code() function, The Release Handler
- sys:debug_options() function, Basic template for starting a special process, System Messages
- sys:get_state() function, Statistics, Status, and State, The sys Module Recap
- sys:get_status() function, Statistics, Status, and State, The sys Module Recap
- sys:handle_debug() function, Trace and Log Events, Putting It Together
- sys:handle_system_message() function, System Messages
- sys:install() function, Your Own Trace Functions, The sys Module Recap, Trace and Log Events
- sys:log() function, Tracing and Logging, The sys Module Recap, Trace and Log Events
- sys:log_to_file() function, Tracing and Logging, The sys Module Recap
- sys:remove() function, Your Own Trace Functions, The sys Module Recap
- sys:replace_state() function, Statistics, Status, and State, The sys Module Recap
- sys:resume() function, Statistics, Status, and State, The sys Module Recap
- sys:statistics() function, Statistics, Status, and State, The sys Module Recap
- sys:suspend() function, Statistics, Status, and State, The sys Module Recap, High-Level Instructions
- sys:trace() function, Tracing and Logging, The sys Module Recap, Trace and Log Events
- syslog tool, Logs
- System Application Support Libraries (see sasl application)
- system blueprints, Node Types and Families, System Blueprints
- system messages, System Messages, Sockets and SSL
- system principles
- SystemTap probe, Tools and Libraries
- system_continue() callback function, System Messages, Putting It Together
- system_info() function, Release Resource Files, Arguments and Flags
- system_information module, Release Resource Files
- system_monitor() function, Sockets and SSL, Finding Bottlenecks
- system_terminate() callback function, System Messages, Putting It Together
- systools module
- systools:make_relup() function, Release Upgrade Files
- systools:make_script() function, Creating the Boot File-Creating the Boot File, The make_script parameters, The Erlang loader, Release Upgrade Files
- systools:make_tar() function, Creating a Release Package, Release Upgrade Files, The Release Handler
- systools:script2boot() function, The make_script parameters
- s_groups, Scalable Distributed Erlang
T
- +t emulator flag, Arguments and Flags
- tail recursive functions, Recursion and Pattern Matching, Finite State Machines the Erlang Way
- takeovers, Distributed Applications
- target systems
- TCP stream example, An Example Handling TCP Streams-An Example Handling TCP Streams
- temporary application type, Application Types and Termination Strategies, Release Resource Files
- terminate() callback function
- gen_event and, Deleting an Event Handler, Sending Synchronous and Asynchronous Events
- gen_fsm and, Termination
- gen_server and, Generic Servers, Behavior Directives, Termination-Termination
- special processes and, Handling Exits
- supervisor and, The child specification, Gluing it all together
- supervisor_bridge and, Supervisor bridges
- terminate_child() function, Simple one for one, High-Level Instructions
- terminating
- Test Server framework, Tools and Libraries
- testing capacity, Capacity Testing-Generating load
- test_server application, Tools and Libraries
- text messages, Logs
- threshold-based alarms, Alarms
- throughput, Capacity Planning, Capacity Testing, Balancing Your System
- throw exception, Fail Safe!
- time (metrics), Metrics
- timeouts
- timer:apply_after() function, Generic Server Timeouts
- timer:apply_interval() function, Generic Server Timeouts
- timer:send_after() function, Generic Server Timeouts
- timer:send_interval() function, Generic Server Timeouts
- timer:sleep() function, Synchronizing Clients, Call Timeouts
- timestamps (metrics), Metrics
- tools and libraries, Tools and Libraries-Tools and Libraries
- tools application, Tools and Libraries
- to_erl command, Release Directory Structure, Start Scripts and Configuring on the Target
- trace() function, Tracing and Logging, The sys Module Recap, Trace and Log Events
- transform_table() function, The Code to Upgrade
- transient application type, Application Types and Termination Strategies, Release Resource Files
- trap_exit flag, Links, Process Skeletons, Basic template for starting a special process
- try-catch expression, Fail Safe!, Process Skeletons
- tv (table visualizer), Starting an Application
- two-module version limit, Software Upgrades
- typer application, Release Directory Structure
U
- Udon web server, Riak Core
- undef runtime error, Adding Event Handlers, The First Version of the Coffee FSM
- unhandled messages, Unhandled Messages-Unhandled Messages
- unique sequence numbers, At most once, exactly once, and at least once
- units of time, Metrics
- University of Glasgow, Scalable Distributed Erlang
- unlink() function, Links
- unpack_release() function, Installing an Upgrade, The Release Handler
- unregister_name() function, Going Global
- update_counter() function, Metrics
- upgrades
W
- wait event, The Mutex States
- werl program, Release Directory Structure
- whereis() function, The SASL Alarm Handler
- whereis_name() function, Going Global
- which_applications() function, Starting and Stopping Applications, Application Resource Files
- which_children() function, The child specification, Dynamic Children
- which_releases() function, The Release Handler
- Wiger, Ulf, Asynchronous events to all states, Service Orientation and Microservices, Load Regulation and Backpressure
- Wikström, Claes "Klacke", Heart
- wildcard() function, Records
- Williams, Mike, Finite State Machines
- worker processes, System Design Principles
- wx graphics package, Tools and Libraries
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.