The Little Elixir & OTP Guidebook video edition

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

"Move seamlessly from learning the basics of Elixir to mastering the key concepts of OTP."
Roberto Infante, Devqf Ltd.

The Little Elixir & OTP Guidebook gets you started programming applications with Elixir and OTP. You begin with a quick overview of the Elixir language syntax, along with just enough functional programming to use it effectively. Then, you'll dive straight into OTP and learn how it helps you build scalable, fault-tolerant and distributed applications through several fun examples.

Elixir is an elegant programming language that combines the expressiveness of Ruby with the concurrency and fault-tolerance of Erlang. It makes full use of Erlang's BEAM VM and OTP library, so you get two decades' worth of maturity and reliability right out of the gate. Elixir's support for functional programming makes it perfect for modern event-driven applications.

  • Covers Elixir 1.2 and 1.3
  • Introduction to functional concurrency with actors
  • Experience the awesome power of Erlang and OTP
Made for programmers comfortable with a standard programming language like Ruby, Java, or Python. FP experience is helpful but not required.

Benjamin Tan Wei Hao is a software engineer at Pivotal Labs, Singapore. He is also an author, a speaker, and an early adopter of Elixir.

Engaging. Practical. Informative. Thumbs up!
Dane Balia, Hetzner

If you’ve never touched Elixir or Erlang before, this book will open the door to a new universe for you.
Thomas Peklak, Emakina CEE

Offers techniques and insights difficult or impossible to find anywhere else.
Kosmas Chatzimichalis, Mach7x

Table of contents

  1. Chapter 1. Introduction
  2. Chapter 1. How is Elixir different from Erlang?
  3. Chapter 1. Why Elixir and not X?
  4. Chapter 1. The road ahead
  5. Chapter 2. A whirlwind tour
  6. Chapter 2. Data types
  7. Chapter 2. Guards
  8. Chapter 2. Lists
  9. Chapter 2. Meet |>, the pipe operator
  10. Chapter 2. Exercises
  11. Chapter 3. Processes 101
  12. Chapter 3. The worker
  13. Chapter 3. Creating processes for concurrency
  14. Chapter 3. Collecting and manipulating results with another actor
  15. Chapter 3. Exercises
  16. Chapter 4. Writing server applications with GenServer
  17. Chapter 4. OTP behaviors
  18. Chapter 4. Hands-on OTP: revisiting Metex
  19. Chapter 4. Callbacks 1st part
  20. Chapter 4. Callbacks 2nd part
  21. Chapter 4. Reflecting on chapter 3’s Metex
  22. Chapter 4. Exercise
  23. Chapter 5. Concurrent error-handling and fault tolerance with links, monitors, and processes
  24. Chapter 5. Setting up the ring
  25. Chapter 5. Linking a terminated/nonexistent process
  26. Chapter 5. Monitors
  27. Chapter 5. Implementing a supervisor
  28. Chapter 5. Handling crashes
  29. Chapter 6. Fault tolerance with Supervisors
  30. Chapter 6. A sample run of Pooly
  31. Chapter 6. Implementing the worker Supervisor
  32. Chapter 6. max_restarts and max_seconds
  33. Chapter 6. Implementing the server: the brains of the operation
  34. Chapter 6. Prepopulating the worker Supervisor with workers
  35. Chapter 6. Checking out a worker
  36. Chapter 6. Implementing the top-level Supervisor
  37. Chapter 6. Exercises
  38. Chapter 7. Completing the worker-pool application
  39. Chapter 7. Adding the top-level Supervisor
  40. Chapter 7. Adding the brains for the pool
  41. Chapter 7. Version 4: implementing overflowing and queuing
  42. Chapter 7. Queuing worker processes
  43. Chapter 7. Exercises
  44. Chapter 8. Supervising Tasks with Tasks.Supervisor
  45. Chapter 8. Distribution and load balancing
  46. Chapter 8. Distribution for load balancing
  47. Chapter 8. Introducing Tasks
  48. Chapter 8. Onward to distribution!
  49. Chapter 8. Remotely executing functions
  50. Chapter 8. Making Blitzy distributed
  51. Chapter 9. Distribution and fault tolerance
  52. Chapter 9. An overview of failover and takeover in Chucky
  53. Chapter 9. Failover and takeover in action
  54. Chapter 9. Connecting nodes in a LAN, cookies, and security
  55. Chapter 10. Dialyzer and type specifications
  56. Chapter 10. Success typings
  57. Chapter 10. Getting started with Dialyzer
  58. Chapter 10. Software discrepancies that Dialyzer can detect
  59. Chapter 10. Type specifications
  60. Chapter 10. Writing your own types
  61. Chapter 11. Property-based and concurrency testing
  62. Chapter 11. Patterns for designing properties
  63. Chapter 11. Generators
  64. Chapter 11. Creating custom generators
  65. Chapter 11. Recursive generators
  66. Chapter 11. Concurrency testing with Concuerror
  67. Chapter 11. Reading Concuerror’s output
  68. Chapter 11. Resources

Product information

  • Title: The Little Elixir & OTP Guidebook video edition
  • Author(s): Benjamin Tan Wei Hao
  • Release date: September 2016
  • Publisher(s): Manning Publications
  • ISBN: None