Table Of ContentProgrammer Passport: OTP
by Bruce Tate
Version: P1.0 (June 2022)
Copyright © 2022 The Pragmatic Programmers, LLC. This book is licensed to the individual who
purchased it. We don't copy-protect it because that would limit your ability to use it for your own
purposes. Please don't break this trust—you can use this across all of your devices but please do not
share this copy with other members of your team, with friends, or via file sharing services. Thanks.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was
aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals.
The Pragmatic Starter Kit, The Pragmatic Programmer, Pragmatic Programming, Pragmatic Bookshelf
and the linking g device are trademarks of The Pragmatic Programmers, LLC.
Every precaution was taken in the preparation of this book. However, the publisher assumes no
responsibility for errors or omissions, or for damages that may result from the use of information
(including program listings) contained herein.
About the Pragmatic Bookshelf
The Pragmatic Bookshelf is an agile publishing company. We’re here because we want to improve the
lives of developers. We do this by creating timely, practical titles, written by programmers for
programmers.
Our Pragmatic courses, workshops, and other products can help you and your team create better
software and have more fun. For more information, as well as the latest Pragmatic titles, please visit us
at http://pragprog.com.
Our ebooks do not contain any Digital Restrictions Management, and have always been DRM-free. We
pioneered the beta book concept, where you can purchase and read a book while it’s still being written,
and provide feedback to the author to help make a better book for everyone. Free resources for all
purchasers include source code downloads (if applicable), errata and discussion forums, all available on
the book's home page at pragprog.com. We’re here to make your life easier.
New Book Announcements
Want to keep up on our latest titles and announcements, and occasional special offers? Just create an
account on pragprog.com (an email address and a password is all it takes) and select the checkbox to
receive newsletters. You can also follow us on twitter as @pragprog.
About Ebook Formats
If you buy directly from pragprog.com, you get ebooks in all available formats for one price. You can
synch your ebooks amongst all your devices (including iPhone/iPad, Android, laptops, etc.) via
Dropbox. You get free updates for the life of the edition. And, of course, you can always come back and
re-download your books when needed. Ebooks bought from the Amazon Kindle store are subject to
Amazon's polices. Limitations in Amazon's file format may cause ebooks to display differently on
different devices. For more information, please see our FAQ at pragprog.com/#about-ebooks. To learn
more about this book and access the free resources, go to https://pragprog.com/book/passotp, the book's
homepage.
Thanks for your continued support,
Andy Hunt
The Pragmatic Programmers
The team that produced this book includes: Dave Rankin (CEO), Janet Furlow (COO),
Tammy Coron (Managing Editor), Jacquelyn Carter (Development Editor),
Vanya Wong (Copy Editor), Andy Hunt and Dave Thomas (Founders)
For customer support, please contact [email protected].
For international rights, please contact [email protected].
Table of Contents
Preface
1. A Basic Handmade Server
Build a Server with a Process
Build the Boundary Layer
Build an OTP Server, with Mix
Your Turn
2. Communication Between Servers
Anatomy of a GenServer
handle_info Processes Nonstandard Messages
Schedule an Alarm with handle_cast
Implement a Status Message with handle_call
Your Turn
3. The Lifecycle and Supervision
The Primitive Mechanisms
OTP Supervisors Manage GenServer Lifecycles
Add Some Children
Lifecycle Policy
Your Turn
4. The Power of a Name
Add Dynamic Characters to SuperDuper
Dynamic Children
Dynamic Supervisors
The Process Registry: The Power of a Name
Your Turn
Bibliography
Copyright © 2022, The Pragmatic Bookshelf.
Preface
OTP is one of the most consequential inventions in the entire Erlang and
Elixir ecosystems. The library provides a common framework for reliably
starting, stopping, and running concurrent workers. OTP is the reason many
developers learn Erlang or Elixir. Elixir’s wonderful management
characteristics and seamless concurrency flow out of OTP. If you’re looking
to take the step from beginner to intermediate Elixir developer, OTP would
be a great place to start.
With so much attention on OTP, you might wonder if the world needs yet
another OTP book. The wonderful Designing Elixir Systems with
OTP [IT19] I wrote with James E Gray II and the brilliant Elixir in
Action [Jur15] by Saša Jurić provide excellent insight into how to design
Elixir with OTP. If you’re using OTP in conjunction with Phoenix, Lance
Halvorsen’s treatment in Functional Web Development with Elixir, OTP,
and Phoenix [Hal18] might be just the ticket.
Still, this short book fills a nice niche. OTP is a behaviour, a program
written by someone else. The only way to understand OTP is to know what
the behaviour is doing under the surface. After teaching OTP for four years,
I’ve learned that many developers don’t understand the underlying
behaviour, so they need more than the documentation. At the same time,
they don’t always have the time or attention for a longer text. This small
companion to Groxio’s OTP course[1] presents a no-frills treatment for those
needing more than stock documentation or blog posts, without reading a
more expansive OTP treatment.
If you find yourself in this niche, I’d love to join you in the journey. If you
like what you see, who knows? You might decide to join us on Groxio for
some video demonstrations of OTP and other Elixir concepts!
Footnotes
[1] https://grox.io
Copyright © 2022, The Pragmatic Bookshelf.
Chapter 1
A Basic Handmade Server
For dozens of years, the Erlang language has achieved extraordinary
reliability. Now, Elixir programmers expect the same. Elixir and Erlang
systems can support applications with even hundreds of thousands of
processes without skipping a beat. The actor-based message passing
architecture is now common across many programming languages. Perhaps
the most important feature in either of these languages is OTP.
OTP is a set of libraries and APIs that enable applications with
extraordinary reliability and scalability through concurrency. In the four
OTP chapters that follow, we’ll cover the main two main abstractions for
OTP, the boundary and lifecycle layers.
The boundary layers allow Elixir to share state across processes with a
combination of concurrency, message passing, and recursion called
GenServers, short for generic servers. They also allow processes to
communicate and control the impact of failures. All of this may seem like a
mystery at first, but don’t worry. We’ll walk you through a good example.
The lifecycle layers are responsible for starting and stopping processes with
supervisors. These supervisors can detect when a process crashes and
execute a policy for responding to failure, perhaps by starting a new
process.
This combination of GenServers and supervisors has brilliantly withstood
the tests of time. Failures in any part of the system are transient because any
but the most catastrophic failures are quickly remedied with a restart.
This book is not designed to replace Designing Elixir Systems with
OTP [IT19] by James Edward Gray II and myself. That book focuses on
design philosophies and considerations for complex Elixir systems, which
often include OTP. Instead, it’s a companion. Instead of focusing on a single
OTP application using Elixir, this one will focus on the basic understanding
of the OTP API. Instead of working with one primary project, we’ll solve
several smaller problems. Since we won’t have to handle deep design
questions throughout the release, we’ll be able to spend more time on those
aspects of OTP that are not as commonly approached. Hopefully, when
we’re done, you’ll have a better understanding of the various knobs and
levers that GenServer provides, and where you might use them.
In this first chapter, we’re going to build a calculator application without
OTP. Along the way, we’ll teach you the OTP terminology for the features
we’re building. We’ll use native processes and message passing rather than
the OTP library. Then we’ll wrap the application in an API, and show how
we might implement that API using OTP instead.
At its basic level, a GenServer is a running process that sends and receives
messages. It has several standardized functions called callbacks that
communicate with your application so you can customize the process with
your own code. Since OTP programs implement only these callbacks,
beginners sometimes have a tough time understanding what a whole
GenServer looks like. We’re going to remedy that problem first by building
an app without using the GenServer API. Then, we’ll make a few tiny
tweaks to replace our process machinery with a GenServer.
Rather than walk through a lot of theory, let’s write a few dozen lines of
simple code that describe how you might build a server—a process that
sends and receives messages—without OTP. That will give you a good
sense of how an OTP service is built. Then, we’ll convert that service to use
OTP.
Let’s get started!
