User's Guide
PDF
Top

OTP Design Principles
User's Guide
Version 5.8.5

Expand All
Contract All

Chapters

# 1 Overview

The OTP Design Principles is a set of principles for how to structure Erlang code in terms of processes, modules and directories.

### 1.1 Supervision Trees

A basic concept in Erlang/OTP is the supervision tree. This is a process structuring model based on the idea of workers and supervisors.

- Workers are processes which perform computations, that is, they do the actual work.
- Supervisors are processes which monitor the behaviour of workers. A supervisor can restart a worker if something goes wrong.
- The supervision tree is a hierarchical arrangement of code into supervisors and workers, making it possible to design and program fault-tolerant software.

Figure 1.1: Supervision Tree

In the figure above, square boxes represents supervisors and circles represent workers.

### 1.2 Behaviours

In a supervision tree, many of the processes have similar structures, they follow similar patterns. For example, the supervisors are very similar in structure. The only difference between them is which child processes they supervise. Also, many of the workers are servers in a server-client relation, finite state machines, or event handlers such as error loggers.

Behaviours are formalizations of these common patterns. The idea is to divide the code for a process in a generic part (a behaviour module) and a specific part (a callback module).

The behaviour module is part of Erlang/OTP. To implement a process such as a supervisor, the user only has to implement the callback module which should export a pre-defined set of functions, the callback functions.

An example to illustrate how code can be divided into a generic and a specific part: Consider the following code (written in plain Erlang) for a simple server, which keeps track of a number of "channels". Other processes can allocate and free the channels by calling the functions alloc/0 and free/1, respectively.

    -module(ch1).
    -export([start/0]).
    -export([alloc/0, free/1]).
    -export([init/0]).

    start() ->
        spawn(ch1, init, []).

    alloc() ->
        ch1 ! {self(), alloc},
        receive
            {ch1, Res} ->
                Res
        end.

    free(Ch) ->
        ch1 ! {free, Ch},
        ok.

    init() ->
        register(ch1, self()),
        Chs = channels(),
        loop(Chs).

    loop(Chs) ->
        receive
            {From, alloc} ->
                {Ch, Chs2} = alloc(Chs),
                From ! {ch1, Ch},
                loop(Chs2);
            {free, Ch} ->
                Chs2 = free(Ch, Chs),
                loop(Chs2)
        end.

The code for the server can be rewritten into a generic part server.erl:

    -module(server).
    -export([start/1]).
    -export([call/2, cast/2]).
    -export([init/1]).

    start(Mod) ->
        spawn(server, init, [Mod]).

    call(Name, Req) ->
        Name ! {call, self(), Req},
        receive
            {Name, Res} ->
                Res
        end.

    cast(Name, Req) ->
        Name ! {cast, Req},
        ok.

    init(Mod) ->
        register(Mod, self()),
        State = Mod:init(),
        loop(Mod, State).

    loop(Mod, State) ->
        receive
            {call, From, Req} ->
                {Res, State2} = Mod:handle_call(Req, State),
                From ! {Mod, Res},
                loop(Mod, State2);
            {cast, Req} ->
                State2 = Mod:handle_cast(Req, State),
                loop(Mod, State2)
        end.

and a callback module ch2.erl:

    -module(ch2).
    -export([start/0]).
    -export([alloc/0, free/1]).
    -export([init/0, handle_call/2, handle_cast/2]).

    start() ->
        server:start(ch2).

    alloc() ->
        server:call(ch2, alloc).

    free(Ch) ->
        server:cast(ch2, {free, Ch}).

    init() ->
        channels().

    handle_call(alloc, Chs) ->
        alloc(Chs). % => {Ch,Chs2}

    handle_cast({free, Ch}, Chs) ->
        free(Ch, Chs). % => Chs2

Note the following:

- The code in server can be re-used to build many different servers.
- The name of the server, in this example the atom ch2, is hidden from the users of the client functions. This means the name can be changed without affecting them.
- The protcol (messages sent to and received from the server) is hidden as well. This is good programming practice and allows us to change the protocol without making changes to code using the interface functions.
- We can extend the functionality of server, without having to change ch2 or any other callback module.

(In ch1.erl and ch2.erl above, the implementation of channels/0, alloc/1 and free/2 has been intentionally left out, as it is not relevant to the example. For completeness, one way to write these functions are given below. Note that this is an example only, a realistic implementation must be able to handle situations like running out of channels to allocate etc.)

    channels() ->
       {_Allocated = [], _Free = lists:seq(1,100)}.

    alloc({Allocated, [H|T] = _Free}) ->
       {H, {[H|Allocated], T}}.

    free(Ch, {Alloc, Free} = Channels) ->
       case lists:member(Ch, Alloc) of
          true ->
             {lists:delete(Ch, Alloc), [Ch|Free]};
          false ->
             Channels
       end.

Code written without making use of behaviours may be more efficient, but the increased efficiency will be at the expense of generality. The ability to manage all applications in the system in a consistent manner is very important.

Using behaviours also makes it easier to read and understand code written by other programmers. Ad hoc programming structures, while possibly more efficient, are always more difficult to understand.

The module server corresponds, greatly simplified, to the Erlang/OTP behaviour gen_server.

The standard Erlang/OTP behaviours are:

gen_server
  For implementing the server of a client-server relation.
gen_fsm
  For implementing finite state machines.
gen_event
  For implementing event handling functionality.
supervisor
  For implementing a supervisor in a supervision tree.

The compiler understands the module attribute -behaviour(Behaviour) and issues warnings about missing callback functions. Example:

    -module(chs3).
    -behaviour(gen_server).
    ...

    3> c(chs3).
    ./chs3.erl:10: Warning: undefined call-back function handle_call/3
    {ok,chs3}

### 1.3 Applications

Erlang/OTP comes with a number of components, each implementing some specific functionality. Components are with Erlang/OTP terminology called applications. Examples of Erlang/OTP applications are Mnesia, which has everything needed for programming database services, and Debugger which is used to debug Erlang programs. The minimal system based on Erlang/OTP consists of the applications Kernel and STDLIB.

The application concept applies both to program structure (processes) and directory structure (modules).

The simplest kind of application does not have any processes, but consists of a collection of functional modules. Such an application is called a library application. An example of a library application is STDLIB.

An application with processes is easiest implemented as a supervision tree using the standard behaviours.

How to program applications is described in Applications.

### 1.4 Releases

A release is a complete system made out from a subset of the Erlang/OTP applications and a set of user-specific applications.

How to program releases is described in Releases.

How to install a release in a target environment is described in the chapter about Target Systems in System Principles.

### 1.5 Release Handling

Release handling is upgrading and downgrading between different versions of a release, in a (possibly) running system. How to do this is described in Release Handling.