Elixir in Action
Saša Jurić
  • May 2015
  • ISBN 9781617292019
  • 376 pages
  • printed in black & white

Delightful and insightful ... with a ton of practical advice.

Ved Antani, Electronic Arts

Elixir in Action teaches you to apply the new Elixir programming language to practical problems associated with scalability, concurrency, fault tolerance, and high availability.

Table of Contents show full

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

About the reader

Requires no previous experience with Elixir, Erlang, or the OTP. Written for readers who are familiar with another programming language like Ruby, JavaScript, or C#.

About the author

Saša Jurić is a developer with extensive experience using Elixir and Erlang in high-volume, concurrent server-side systems.


combo $44.99 pBook + eBook
eBook $35.99 pdf + ePub + kindle

FREE domestic shipping on three or more pBooks

Outstanding coverage of Elixir’s distributed computing capabilities, with a real-world point of view.

Christopher Bailey, HotelTonight

Read this book if you want to think and solve problems in the Elixir way!

Kosmas Chatzimichalis, Mach 7x

Functional programming made easy.

Mohsen Mostafa Jokar, Hamshahri