Delightful and insightful ... with a ton of practical advice.
NEWER EDITION AVAILABLE IN MEAP
Elixir in Action, Second Edition is now available in the Manning Early Access Program. An eBook of this older edition is included at no additional cost when you buy the revised edition!
You may still purchase Elixir in Action (First Edition) using the Buy options on this page.
Elixir in Action teaches you to apply the new Elixir programming language to practical problems associated with scalability, concurrency, fault tolerance, and high availability.
preface
acknowledgments
about this book
about the cover illustration
Part 1 The language
1. First steps
1.1. About Erlang
1.1.1. High availability
1.1.2. Erlang concurrency
1.1.3. Server-side systems
1.1.4. The development platform
1.2. About Elixir
1.2.1. Code simplification
1.2.2. Composing functions
1.2.3. The big picture
1.3. Disadvantages
1.3.1. Speed
1.3.2. Ecosystem
1.4. Summary
2. Building blocks
2.1. The interactive shell
2.2. Working with variables
2.3. Organizing your code
2.3.1. Modules
2.3.2. Functions
2.3.3. Function arity
2.3.4. Function visibility
2.3.5. Imports and aliases
2.3.6. Module attributes
2.3.7. Comments
2.4. Understanding the type system
2.4.1. Numbers
2.4.2. Atoms
2.4.3. Tuples
2.4.4. Lists
2.4.5. Immutability
2.4.6. Maps
2.4.7. Binaries and bitstrings
2.4.8. Strings
2.4.9. First-class functions
2.4.10. Other built-in types
2.4.11. Higher-level types
2.4.12. IO lists
2.5. Operators
2.6. Macros
2.7. Understanding the runtime
2.7.1. Modules and functions in the runtime
2.7.2. Starting the runtime
2.8. Summary
3. Control flow
3.1. Pattern matching
3.1.1. The match operator
3.1.2. Matching tuples
3.1.3. Matching constants
3.1.4. Variables in patterns
3.1.5. Matching lists
3.1.6. Matching maps
3.1.7. Matching bitstrings and binaries
3.1.8. Compound matches
3.1.9. General behavior
3.2. Matching with functions
3.2.1. Multiclause functions
3.2.2. Guards
3.2.3. Multiclause lambdas
3.3. Conditionals
3.3.1. Branching with multiclause functions
3.3.2. Classical branching constructs
3.4. Loops and iterations
3.4.1. Iterating with recursion
3.4.2. Tail function calls
3.4.3. Higher-order functions
3.4.4. Comprehensions
3.4.5. Streams
3.5. Summary
4. Data abstractions
4.1. Abstracting with modules
4.1.1. Basic abstraction
4.1.2. Composing abstractions
4.1.3. Structuring data with maps
4.1.4. Abstracting with structs
4.1.5. Data transparency
4.2. Working with hierarchical data
4.2.1. Generating IDs
4.2.2. Updating entries
4.2.3. Immutable hierarchical updates
4.2.4. Iterative updates
4.2.5. Exercise: importing from a file
4.3. Polymorphism with protocols
4.3.1. Protocol basics
4.3.2. Implementing a protocol
4.3.3. Built-in protocols
4.4. Summary
Part 2 The platform
5. Concurrency primitives
5.1. Principles
5.2. Working with processes
5.2.1. Creating processes
5.2.2. Message passing
5.3. Stateful server processes
5.3.1. Server processes
5.3.2. Keeping a process state
5.3.3. Mutable state
5.3.4. Complex states
5.3.5. Registered processes
5.4. Runtime considerations
5.4.1. A process is a bottleneck
5.4.2. Unlimited process mailboxes
5.4.3. Shared nothing concurrency
5.4.4. Scheduler inner workings
5.5. Summary
6. Generic server processes
6.1. Building a generic server process
6.1.1. Plugging in with modules
6.1.2. Implementing the generic code
6.1.3. Using the generic abstraction
6.1.4. Supporting asynchronous requests
6.1.5. Exercise: refactoring the to-do server
6.2. Using gen_server
6.2.1. OTP behaviours
6.2.2. Plugging into gen_server
6.2.3. Handling requests
6.2.4. Handling plain messages
6.2.5. Other gen_server features
6.2.6. Process life cycle
6.2.7. OTP-compliant processes
6.2.8. Exercise: gen_server-powered to-do server
6.3. Summary
7. Building a concurrent system
7.1. Working with the mix project
7.2. Managing multiple to-do lists
7.2.1. Implementing a cache
7.2.2. Analyzing process dependencies
7.3. Persisting data
7.3.1. Encoding and persisting
7.3.2. Using the database
7.3.3. Analyzing the system
7.3.4. Addressing the process bottleneck
7.3.5. Exercise: pooling and synchronizing
7.4. Reasoning with processes
7.5. Summary
8. Fault-tolerance basics
8.1. Runtime errors
8.1.1. Error types
8.1.2. Handling errors
8.2. Errors in concurrent systems
8.2.1. Linking processes
8.2.2. Trapping exits
8.2.3. Monitors
8.3. Supervisors
8.3.1. Supervisor behaviour
8.3.2. Defining a supervisor
8.3.3. Starting a supervisor
8.3.4. Linking all processes
8.3.5. Restart frequency
8.4. Summary
9. Isolating error effects
9.1. Supervision trees
9.1.1. Separating loosely dependent parts
9.1.2. Rich process discovery
9.1.3. Supervising database workers
9.1.4. Removing the database process
9.1.5. Starting the system
9.1.6. Organizing the supervision tree
9.2. Starting workers dynamically
9.2.1. simple_one_for_one supervisors
9.2.2. Restart strategies
9.3. "Let it crash"
9.3.1. Error kernel
9.3.2. Handling expected errors
9.3.3. Preserving the state
9.4. Summary
10. Sharing state
10.1. Single-process bottleneck
10.2. ETS tables
10.2.1. Basic operations
10.2.2. ETS powered page cache
10.2.3. Other ETS operations
10.2.4. Other use cases for ETS
10.2.5. Beyond ETS
10.2.6. Exercise: ETS-powered process registry
10.3. Summary
Part 3 Production
11. Working with components
11.1. OTP applications
11.1.1. Describing an application
11.1.2. Creating applications with the mix tool
11.1.3. The application behaviour
11.1.4. Starting the application
11.1.5. Library applications
11.1.6. Creating a to-do application
11.1.7. The application folder structure
11.2. Working with dependencies
11.2.1. Specifying dependencies
11.2.2. Adapting the registry
11.3. Building a web server
11.3.1. Choosing dependencies
11.3.2. Starting the server
11.3.3. Handling requests
11.3.4. Reasoning about the system
11.4. Managing the application environment
11.5. Summary
12. Building a distributed system
12.1. Distribution primitives
12.1.1. Starting a cluster
12.1.2. Communicating between nodes
12.1.3. Process discovery
12.1.4. Links and monitors
12.1.5. Other distribution services
12.2. Building a fault-tolerant cluster
12.2.1. Cluster design
12.2.2. The distributed to-do cache
12.2.3. Implementing a replicated database
12.2.4. Testing the system
12.2.5. Dealing with partitions
12.2.6. Highly available systems
12.3. Network considerations
12.3.1. Node names
12.3.2. Cookies
12.3.3. Hidden nodes
12.3.4. Firewalls
12.4. Summary
13. Running the system
13.1. Running a system with the mix tool
13.1.1. Bypassing the shell
13.1.2. Running as a background process
13.1.3. Running scripts
13.1.4. Compiling for production
13.2. OTP releases
13.2.1. Building a release with exrm
13.2.2. Using a release
13.2.3. Release contents
13.3. Analyzing system behavior
13.3.1. Debugging
13.3.2. Logging
13.3.3. Interacting with the system
13.3.4. Tracing
13.4. Summary
index
About the Technology
Elixir is a modern programming language that takes advantage of BEAM, the Erlang virtual machine, without the burden of Erlang's complex syntax and conventions. Elixir gives you Ruby-like elegance with the power to develop bulletproof distributed server systems that can handle massive numbers of simultaneous clients and run with almost no downtime.
About the book
Elixir in Action teaches you how to solve practical problems of scalability, concurrency, fault tolerance, and high availability using Elixir. You'll start with the language, learning basic constructs and building blocks. Then, you'll learn to think about problems using Elixir's functional programming mindset. With that solid foundation, you'll confidently explore Elixir's seamless integration with BEAM and Erlang's powerful OTP framework of battle-tested abstractions you can use immediately. Finally, the book provides guidance on how to distribute a system over multiple machines and control it in production.
What's inside
- Practical introduction to the Elixir language
- Functional programming idioms
- Mastering the OTP framework
- Creating deployable releases
- customers also bought these items
- The Joy of Clojure, Second Edition
- Clojure in Action, Second Edition
- Reactive Design Patterns
- Erlang and OTP in Action
- Elm in Action
- Go in Action
FREE domestic shipping on three or more pBooks
Outstanding coverage of Elixir’s distributed computing capabilities, with a real-world point of view.
Read this book if you want to think and solve problems in the Elixir way!
Functional programming made easy.