aboutsummaryrefslogtreecommitdiffstats
path: root/system
diff options
context:
space:
mode:
Diffstat (limited to 'system')
-rw-r--r--system/doc/design_principles/statem.xml776
1 files changed, 354 insertions, 422 deletions
diff --git a/system/doc/design_principles/statem.xml b/system/doc/design_principles/statem.xml
index ca0fce55e2..585b1a35f5 100644
--- a/system/doc/design_principles/statem.xml
+++ b/system/doc/design_principles/statem.xml
@@ -5,7 +5,7 @@
<header>
<copyright>
<year>2016</year>
- <holder>Ericsson AB. All Rights Reserved.</holder>
+ <holder>Ericsson AB. All Rights Reserved.</holder>
</copyright>
<legalnotice>
Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,7 +22,7 @@
</legalnotice>
- <title>gen_statem Behaviour</title>
+ <title>gen_statem Behavior</title>
<prepared></prepared>
<docno></docno>
<date></date>
@@ -33,63 +33,61 @@
<p>
This section is to be read with the
<seealso marker="stdlib:gen_statem"><c>gen_statem(3)</c></seealso>
- manual page in STDLIB, where all interface functions and callback
+ manual page in <c>STDLIB</c>, where all interface functions and callback
functions are described in detail.
</p>
- <p>
- This is a new behaviour in OTP-19.0.
- It has been thoroughly reviewed, is stable enough
- to be used by at least two heavy OTP applications, and is here to stay.
- But depending on user feedback, we do not expect
- but might find it necessary to make minor
- not backwards compatible changes into OTP-20.0,
- so its state can be designated as "not quite experimental"...
- </p>
+ <note>
+ <p>
+ This is a new behavior in Erlang/OTP 19.0.
+ It has been thoroughly reviewed, is stable enough
+ to be used by at least two heavy OTP applications, and is here to stay.
+ Depending on user feedback, we do not expect
+ but can find it necessary to make minor
+ not backward compatible changes into Erlang/OTP 20.0.
+ </p>
+ </note>
<!-- =================================================================== -->
<section>
- <title>Event Driven State Machines</title>
+ <title>Event-Driven State Machines</title>
<p>
Established Automata theory does not deal much with
how a state transition is triggered,
- but in general assumes that the output is a function
+ but assumes that the output is a function
of the input (and the state) and that they are
some kind of values.
</p>
<p>
- For an Event Driven State Machine the input is an event
+ For an Event-Driven State Machine, the input is an event
that triggers a state transition and the output
is actions executed during the state transition.
It can analogously to the mathematical model of a
- Finite State Machine be described as
- a set of relations of the form:
+ Finite-State Machine be described as
+ a set of relations of the following form:
</p>
<pre>
State(S) x Event(E) -> Actions(A), State(S')</pre>
- <p>These relations are interpreted as meaning:</p>
- <p>
- If we are in state <c>S</c> and event <c>E</c> occurs, we
+ <p>These relations are interpreted as follows:
+ if we are in state <c>S</c> and event <c>E</c> occurs, we
are to perform actions <c>A</c> and make a transition to
- state <c>S'</c>.
- </p>
- <p>
- Note that <c>S'</c> may be equal to <c>S</c>.
+ state <c>S'</c>. Notice that <c>S'</c> can be equal to <c>S</c>.
</p>
<p>
- Since <c>A</c> and <c>S'</c> depend only on
- <c>S</c> and <c>E</c> the kind of state machine described
- here is a Mealy Machine.
- (See for example the corresponding Wikipedia article)
+ As <c>A</c> and <c>S'</c> depend only on
+ <c>S</c> and <c>E</c>, the kind of state machine described
+ here is a Mealy Machine
+ (see, for example, the corresponding Wikipedia article).
</p>
<p>
- Like most <c>gen_</c> behaviours, <c>gen_statem</c> keeps
- a server <c>Data</c> besides the state. This and the fact that
+ Like most <c>gen_</c> behaviors, <c>gen_statem</c> keeps
+ a server <c>Data</c> besides the state. Because of this, and as
there is no restriction on the number of states
- (assuming enough virtual machine memory)
- or on the number of distinct input events actually makes
- a state machine implemented with this behaviour Turing complete.
- But it feels mostly like an Event Driven Mealy Machine.
+ (assuming that there is enough virtual machine memory)
+ or on the number of distinct input events,
+ a state machine implemented with this behavior
+ is in fact Turing complete.
+ But it feels mostly like an Event-Driven Mealy Machine.
</p>
</section>
@@ -99,38 +97,39 @@ State(S) x Event(E) -> Actions(A), State(S')</pre>
<marker id="callback_modes" />
<title>Callback Modes</title>
<p>
- The <c>gen_statem</c> behaviour supports two different callback modes.
- In the mode
- <seealso marker="stdlib:gen_statem#type-callback_mode">
- <c>state_functions</c>,
- </seealso>
- the state transition rules are written as a number of Erlang
- functions, which conform to the following convention:
+ The <c>gen_statem</c> behavior supports two callback modes:
</p>
- <pre>
+ <list type="bulleted">
+ <item>
+ <p>
+ In mode
+ <seealso marker="stdlib:gen_statem#type-callback_mode"><c>state_functions</c></seealso>,
+ the state transition rules are written as some Erlang
+ functions, which conform to the following convention:
+ </p>
+ <pre>
StateName(EventType, EventContent, Data) ->
.. code for actions here ...
{next_state, NewStateName, NewData}.</pre>
- <p>
- In the mode
- <seealso marker="stdlib:gen_statem#type-callback_mode">
- <c>handle_event_function</c>
- </seealso>
- there is only one
- Erlang function that implements all state transition rules:
- </p>
- <pre>
+ </item>
+ <item>
+ <p>
+ In mode
+ <seealso marker="stdlib:gen_statem#type-callback_mode"><c>handle_event_function</c></seealso>,
+ only one Erlang function provides all state transition rules:
+ </p>
+ <pre>
handle_event(EventType, EventContent, State, Data) ->
.. code for actions here ...
- {next_state, State', Data'}</pre>
- <p>
- Both these modes allow other return tuples
- that you can find in the
- <seealso marker="stdlib:gen_statem#Module:StateName/3">
- reference manual.
- </seealso>
- These other return tuples can for example stop the machine,
- execute state transition actions on the machine engine itself
+ {next_state, NewState, NewData}</pre>
+ </item>
+ </list>
+ <p>
+ Both these modes allow other return tuples; see
+ <seealso marker="stdlib:gen_statem#Module:StateName/3"><c>Module:StateName/3</c></seealso>
+ in the <c>gen_statem</c> manual page.
+ These other return tuples can, for example, stop the machine,
+ execute state transition actions on the machine engine itself,
and send replies.
</p>
@@ -139,54 +138,54 @@ handle_event(EventType, EventContent, State, Data) ->
<p>
The two
<seealso marker="#callback_modes">callback modes</seealso>
- gives different possibilities
+ give different possibilities
and restrictions, but one goal remains:
you want to handle all possible combinations of
events and states.
</p>
<p>
- You can for example do this by focusing on one state at the time
- and for every state ensure that all events are handled,
- or the other way around focus on one event at the time
- and ensure that it is handled in every state,
- or mix these strategies.
+ This can be done, for example, by focusing on one state at the time
+ and for every state ensure that all events are handled.
+ Alternatively, you can focus on one event at the time
+ and ensure that it is handled in every state.
+ You can also use a mix of these strategies.
</p>
<p>
- With <c>state_functions</c> you are restricted to use
- atom only states, and the <c>gen_statem</c> engine dispatches
- on state name for you. This encourages the callback module
+ With <c>state_functions</c>, you are restricted to use
+ atom-only states, and the <c>gen_statem</c> engine dispatches
+ on state name for you. This encourages the callback module
to gather the implementation of all event actions particular
- to one state in the same place in the code
+ to one state in the same place in the code,
hence to focus on one state at the time.
</p>
<p>
- This mode fits well when you have a regular state diagram
- like the ones in this chapter that describes all events and actions
+ This mode fits well when you have a regular state diagram,
+ like the ones in this chapter, which describes all events and actions
belonging to a state visually around that state,
and each state has its unique name.
</p>
<p>
- With <c>handle_event_function</c> you are free to mix strategies
- as you like because all events and states
- are handled in the the same callback function.
+ With <c>handle_event_function</c>, you are free to mix strategies,
+ as all events and states are handled in the same callback function.
</p>
<p>
This mode works equally well when you want to focus on
- one event at the time or when you want to focus on
- one state at the time, but the <c>handle_event/4</c> function
+ one event at the time or on
+ one state at the time, but function
+ <seealso marker="stdlib:gen_statem#Module:handle_event/4"><c>Module:handle_event/4</c></seealso>
quickly grows too large to handle without introducing dispatching.
</p>
<p>
- The mode enables the use of non-atom states for example
- complex states or even hiearchical states.
+ The mode enables the use of non-atom states, for example,
+ complex states or even hierarchical states.
If, for example, a state diagram is largely alike
- for the client and for the server side of a protocol;
- then you can have a state <c>{StateName,server}</c> or
- <c>{StateName,client}</c> and since you do the dispatching
- yourself you make <c>StateName</c> decide where in the code
+ for the client side and the server side of a protocol,
+ you can have a state <c>{StateName,server}</c> or
+ <c>{StateName,client}</c>. Also, as you do the dispatching
+ yourself, you make <c>StateName</c> decide where in the code
to handle most events in the state.
- The second element of the tuple is then used to select
- whether to handle special client side or server side events.
+ The second element of the tuple is then used to select
+ whether to handle special client-side or server-side events.
</p>
</section>
</section>
@@ -196,31 +195,28 @@ handle_event(EventType, EventContent, State, Data) ->
<section>
<title>Example</title>
<p>
- This is an example starting off as equivalent to the the example in the
- <seealso marker="fsm"><c>gen_fsm</c> behaviour</seealso>
- description. In later chapters additions and tweaks are made
+ This example starts off as equivalent to the example in section
+ <seealso marker="fsm"><c>gen_fsm</c> Behavior</seealso>.
+ In later sections, additions and tweaks are made
using features in <c>gen_statem</c> that <c>gen_fsm</c> does not have.
- At the end of this section you can find the example again
+ The end of this chapter provides the example again
with all the added features.
</p>
<p>
- A door with a code lock can be viewed as a state machine.
- Initially, the door is locked. Anytime someone presses a button,
- this generates an event.
+ A door with a code lock can be seen as a state machine.
+ Initially, the door is locked. When someone presses a button,
+ an event is generated.
Depending on what buttons have been pressed before,
the sequence so far can be correct, incomplete, or wrong.
- </p>
- <p>
- If it is correct, the door is unlocked for 10 seconds (10000 ms).
- If it is incomplete, we wait for another button to be pressed. If
- it is is wrong, we start all over,
- waiting for a new button sequence.
+ If correct, the door is unlocked for 10 seconds (10,000 milliseconds).
+ If incomplete, we wait for another button to be pressed. If
+ wrong, we start all over, waiting for a new button sequence.
</p>
<image file="../design_principles/code_lock.png">
- <icaption>Code lock state diagram</icaption>
+ <icaption>Code Lock State Diagram</icaption>
</image>
<p>
- We can implement such a code lock state machine using
+ This code lock state machine can be implemented using
<c>gen_statem</c> with the following callback module:
</p>
<marker id="ex"></marker>
@@ -241,7 +237,6 @@ start_link(Code) ->
button(Digit) ->
gen_statem:cast(?NAME, {button,Digit}).
-
init(Code) ->
do_lock(),
Data = #{code => Code, remaining => Code},
@@ -286,7 +281,7 @@ code_change(_Vsn, State, Data, _Extra) ->
<section>
<title>Starting gen_statem</title>
<p>
- In the example in the previous section, the <c>gen_statem</c> is
+ In the example in the previous section, <c>gen_statem</c> is
started by calling <c>code_lock:start_link(Code)</c>:
</p>
<code type="erl"><![CDATA[
@@ -294,80 +289,71 @@ start_link(Code) ->
gen_statem:start_link({local,?NAME}, ?MODULE, Code, []).
]]></code>
<p>
- <c>start_link</c> calls the function
- <seealso marker="stdlib:gen_statem#start_link/4">
- <c>gen_statem:start_link/4</c>
- </seealso>
- which spawns and links to a new process; a <c>gen_statem</c>.
+ <c>start_link</c> calls function
+ <seealso marker="stdlib:gen_statem#start_link/4"><c>gen_statem:start_link/4</c></seealso>,
+ which spawns and links to a new process, a <c>gen_statem</c>.
</p>
<list type="bulleted">
<item>
<p>
- The first argument, <c>{local,?NAME}</c>, specifies
- the name. In this case, the <c>gen_statem</c> is locally
- registered as <c>code_lock</c> through the macro <c>?NAME</c>.
- </p>
+ The first argument, <c>{local,?NAME}</c>, specifies
+ the name. In this case, the <c>gen_statem</c> is locally
+ registered as <c>code_lock</c> through the macro <c>?NAME</c>.
+ </p>
<p>
- If the name is omitted, the <c>gen_statem</c> is not registered.
- Instead its pid must be used. The name can also be given
- as <c>{global,Name}</c>, in which case the <c>gen_statem</c> is
- registered using
- <seealso marker="kernel:global#register_name/2">
- <c>global:register_name/2</c>.
- </seealso>
- </p>
+ If the name is omitted, the <c>gen_statem</c> is not registered.
+ Instead its pid must be used. The name can also be specified
+ as <c>{global,Name}</c>, then the <c>gen_statem</c> is
+ registered using
+ <seealso marker="kernel:global#register_name/2"><c>global:register_name/2</c></seealso>
+ in <c>Kernel</c>.
+ </p>
</item>
<item>
<p>
- The second argument, <c>?MODULE</c>, is the name of
- the callback module, that is; the module where the callback
+ The second argument, <c>?MODULE</c>, is the name of
+ the callback module, that is, the module where the callback
functions are located, which is this module.
- </p>
+ </p>
<p>
- The interface functions (<c>start_link/1</c> and <c>button/1</c>)
- are located in the same module as the callback functions
- (<c>init/1</c>, <c>locked/3</c>, and <c>open/3</c>).
- It is normally good programming practice to have the client
- side and the server side code contained in one module.
- </p>
+ The interface functions (<c>start_link/1</c> and <c>button/1</c>)
+ are located in the same module as the callback functions
+ (<c>init/1</c>, <c>locked/3</c>, and <c>open/3</c>).
+ It is normally good programming practice to have the client-side
+ code and the server-side code contained in one module.
+ </p>
</item>
<item>
<p>
- The third argument, <c>Code</c>, is a list of digits that
- is the correct unlock code which is passsed
- to the callback function <c>init/1</c>.
+ The third argument, <c>Code</c>, is a list of digits, which
+ is the correct unlock code that is passed
+ to callback function <c>init/1</c>.
</p>
</item>
<item>
<p>
- The fourth argument, <c>[]</c>, is a list of options. See the
- <seealso marker="stdlib:gen_statem#start_link/3">
- <c>gen_statem:start_link/3</c>
- </seealso>
- manual page for available options.
+ The fourth argument, <c>[]</c>, is a list of options.
+ For the available options, see
+ <seealso marker="stdlib:gen_statem#start_link/3"><c>gen_statem:start_link/3</c></seealso>.
</p>
</item>
</list>
<p>
If name registration succeeds, the new <c>gen_statem</c> process
- calls the callback function <c>code_lock:init(Code)</c>.
+ calls callback function <c>code_lock:init(Code)</c>.
This function is expected to return <c>{CallbackMode,State,Data}</c>,
where
- <seealso marker="#callback_modes">
- <c>CallbackMode</c>
- </seealso>
+ <seealso marker="#callback_modes"><c>CallbackMode</c></seealso>
selects callback module state function mode, in this case
- <seealso marker="stdlib:gen_statem#type-callback_mode">
- <c>state_functions</c>
- </seealso>
- through the macro <c>?CALLBACK_MODE</c> that is; each state
+ <seealso marker="stdlib:gen_statem#type-callback_mode"><c>state_functions</c></seealso>
+ through macro <c>?CALLBACK_MODE</c>. That is, each state
has got its own handler function.
<c>State</c> is the initial state of the <c>gen_statem</c>,
- in this case <c>locked</c>; assuming the door is locked to begin with.
- <c>Data</c> is the internal server data of the <c>gen_statem</c>.
+ in this case <c>locked</c>; assuming that the door is locked to begin
+ with. <c>Data</c> is the internal server data of the <c>gen_statem</c>.
Here the server data is a <seealso marker="stdlib:maps">map</seealso>
- with the key <c>code</c> that stores
- the correct button sequence and the key <c>remaining</c>
+ with key <c>code</c> that stores
+ the correct button sequence, and key <c>remaining</c>
that stores the remaining correct button sequence
(the same as the <c>code</c> to begin with).
</p>
@@ -377,24 +363,19 @@ init(Code) ->
Data = #{code => Code, remaining => Code},
{?CALLBACK_MODE,locked,Data}.
]]></code>
- <p>
- <seealso marker="stdlib:gen_statem#start_link/3">
- <c>gen_statem:start_link</c>
- </seealso>
- is synchronous. It does not return until the <c>gen_statem</c>
- has been initialized and is ready to receive events.
+ <p>Function
+ <seealso marker="stdlib:gen_statem#start_link/3"><c>gen_statem:start_link</c></seealso>
+ is synchronous. It does not return until the <c>gen_statem</c>
+ is initialized and is ready to receive events.
</p>
<p>
- <seealso marker="stdlib:gen_statem#start_link/3">
- <c>gen_statem:start_link</c>
- </seealso>
+ Function
+ <seealso marker="stdlib:gen_statem#start_link/3"><c>gen_statem:start_link</c></seealso>
must be used if the <c>gen_statem</c>
- is part of a supervision tree, that is; started by a supervisor.
- There is another function;
- <seealso marker="stdlib:gen_statem#start/3">
- <c>gen_statem:start</c>
- </seealso>
- to start a standalone <c>gen_statem</c>, that is;
+ is part of a supervision tree, that is, started by a supervisor.
+ Another function,
+ <seealso marker="stdlib:gen_statem#start/3"><c>gen_statem:start</c></seealso>
+ can be used to start a standalone <c>gen_statem</c>, that is,
a <c>gen_statem</c> that is not part of a supervision tree.
</p>
</section>
@@ -402,12 +383,10 @@ init(Code) ->
<!-- =================================================================== -->
<section>
- <title>Events and Handling them</title>
+ <title>Handling Events</title>
<p>The function notifying the code lock about a button event is
implemented using
- <seealso marker="stdlib:gen_statem#cast/2">
- <c>gen_statem:cast/2</c>:
- </seealso>
+ <seealso marker="stdlib:gen_statem#cast/2"><c>gen_statem:cast/2</c></seealso>:
</p>
<code type="erl"><![CDATA[
button(Digit) ->
@@ -415,9 +394,9 @@ button(Digit) ->
]]></code>
<p>
The first argument is the name of the <c>gen_statem</c> and must
- agree with the name used to start it so therefore we use the
+ agree with the name used to start it. So, we use the
same macro <c>?NAME</c> as when starting.
- <c>{button,Digit}</c> is the actual event content.
+ <c>{button,Digit}</c> is the event content.
</p>
<p>
The event is made into a message and sent to the <c>gen_statem</c>.
@@ -452,19 +431,19 @@ open(cast, {button,_}, Data) ->
]]></code>
<p>
If the door is locked and a button is pressed, the pressed
- button is compared with the next correct button and,
- depending on the result, the door is either unlocked
+ button is compared with the next correct button.
+ Depending on the result, the door is either unlocked
and the <c>gen_statem</c> goes to state <c>open</c>,
or the door remains in state <c>locked</c>.
</p>
<p>
- If the pressed button is incorrect the server data
+ If the pressed button is incorrect, the server data
restarts from the start of the code sequence.
</p>
<p>
- In state <c>open</c> any button locks the door since
- any event cancels the event timer so we will not get
- a timeout event after a button event.
+ In state <c>open</c>, any button locks the door, as
+ any event cancels the event timer, so no
+ time-out event occurs after a button event.
</p>
</section>
@@ -478,11 +457,11 @@ open(cast, {button,_}, Data) ->
{next_state,open,Data#{remaining := Code},10000};
]]></code>
<p>
- 10000 is a time-out value in milliseconds.
- After this time, that is; 10 seconds, a time-out occurs.
+ 10,000 is a time-out value in milliseconds.
+ After this time (10 seconds), a time-out occurs.
Then, <c>StateName(timeout, 10000, Data)</c> is called.
The time-out occurs when the door has been in state <c>open</c>
- for 10 seconds. After that the door is locked again:
+ for 10 seconds. After that the door is locked again:
</p>
<code type="erl"><![CDATA[
open(timeout, _, Data) ->
@@ -496,16 +475,16 @@ open(timeout, _, Data) ->
<section>
<title>All State Events</title>
<p>
- Sometimes an event can arrive in any state of the <c>gen_statem</c>.
+ Sometimes events can arrive in any state of the <c>gen_statem</c>.
It is convenient to handle these in a common state handler function
that all state functions call for events not specific to the state.
</p>
<p>
- Let's introduce a <c>code_length/0</c> function that returns
+ Consider a <c>code_length/0</c> function that returns
the length of the correct code
- (that should not be sensitive to reveal...).
- We'll dispatch all events that are not state specific
- to the common function <c>handle_event/3</c>.
+ (that should not be sensitive to reveal).
+ We dispatch all events that are not state-specific
+ to the common function <c>handle_event/3</c>:
</p>
<code type="erl"><![CDATA[
...
@@ -530,9 +509,7 @@ handle_event({call,From}, code_length, #{code := Code} = Data) ->
]]></code>
<p>
This example uses
- <seealso marker="stdlib:gen_statem#call/2">
- <c>gen_statem:call/2</c>
- </seealso>
+ <seealso marker="stdlib:gen_statem#call/2"><c>gen_statem:call/2</c></seealso>,
which waits for a reply from the server.
The reply is sent with a <c>{reply,From,Reply}</c> tuple
in an action list in the <c>{keep_state,...}</c> tuple
@@ -545,14 +522,15 @@ handle_event({call,From}, code_length, #{code := Code} = Data) ->
<section>
<title>One Event Handler</title>
<p>
- If you use the mode <c>handle_event_function</c>
- all events are handled in <c>handle_event/4</c> and we
- may (but do not have to) use an event-centered approach
+ If mode <c>handle_event_function</c> is used,
+ all events are handled in
+ <seealso marker="stdlib:gen_statem#Module:handle_event/4"><c>Module:handle_event/4</c></seealso>
+ and we can (but do not have to) use an event-centered approach
where we dispatch on event first and then state:
</p>
<code type="erl"><![CDATA[
...
--define(CALLBACK_MODE, state_functions).
+-define(CALLBACK_MODE, handle_event_function).
...
-export([handle_event/4]).
@@ -596,19 +574,14 @@ handle_event(timeout, _, open, Data) ->
The <c>gen_statem</c> is automatically terminated by its supervisor.
Exactly how this is done is defined by a
<seealso marker="sup_princ#shutdown">shutdown strategy</seealso>
- set in the supervisor.
+ set in the supervisor.
</p>
<p>
If it is necessary to clean up before termination, the shutdown
- strategy must be a time-out value and the <c>gen_statem</c> must
- in the <c>init/1</c> function set itself to trap exit signals
+ strategy must be a time-out value and the <c>gen_statem</c> must
+ in function <c>init/1</c> set itself to trap exit signals
by calling
- <seealso marker="erts:erlang#process_flag/2">
- <c>process_flag(trap_exit, true)</c>.
- </seealso>
- When ordered to shutdown, the <c>gen_statem</c> then calls
- the callback function
- <c>terminate(shutdown, State, Data)</c>:
+ <seealso marker="erts:erlang#process_flag/2"><c>process_flag(trap_exit, true)</c></seealso>:
</p>
<code type="erl"><![CDATA[
init(Args) ->
@@ -617,9 +590,13 @@ init(Args) ->
...
]]></code>
<p>
- In this example we let the <c>terminate/3</c> function
- lock the door if it is open so we do not accidentally leave the door
- open when the supervision tree terminates.
+ When ordered to shut down, the <c>gen_statem</c> then calls
+ callback function <c>terminate(shutdown, State, Data)</c>.
+ </p>
+ <p>
+ In the following example, function <c>terminate/3</c>
+ locks the door if it is open, so we do not accidentally leave the door
+ open when the supervision tree terminates:
</p>
<code type="erl"><![CDATA[
terminate(_Reason, State, _Data) ->
@@ -633,9 +610,7 @@ terminate(_Reason, State, _Data) ->
<p>
If the <c>gen_statem</c> is not part of a supervision tree,
it can be stopped using
- <seealso marker="stdlib:gen_statem#stop/1">
- <c>gen_statem:stop</c>,
- </seealso>
+ <seealso marker="stdlib:gen_statem#stop/1"><c>gen_statem:stop</c></seealso>,
preferably through an API function:
</p>
<code type="erl"><![CDATA[
@@ -647,8 +622,8 @@ stop() ->
gen_statem:stop(?NAME).
]]></code>
<p>
- This makes the <c>gen_statem</c> call the <c>terminate/3</c>
- callback function just like for a supervised server
+ This makes the <c>gen_statem</c> call callback function
+ <c>terminate/3</c> just like for a supervised server
and waits for the process to terminate.
</p>
</section>
@@ -659,48 +634,41 @@ stop() ->
<section>
<title>Actions</title>
<p>
- In the first chapters we mentioned actions as a part of
- the general state machine model, and these actions
- are implemented with the code the <c>gen_statem</c>
- callback module executes in an event handling
+ In the first sections actions were mentioned as a part of
+ the general state machine model. These general actions
+ are implemented with the code that callback module
+ <c>gen_statem</c> executes in an event-handling
callback function before returning
to the <c>gen_statem</c> engine.
</p>
<p>
- There are more specific state transition actions
+ There are more specific state-transition actions
that a callback function can order the <c>gen_statem</c>
engine to do after the callback function return.
These are ordered by returning a list of
- <seealso marker="stdlib:gen_statem#type-action">
- actions
- </seealso>
+ <seealso marker="stdlib:gen_statem#type-action">actions</seealso>
in the
- <seealso marker="stdlib:gen_statem#type-state_function_result">
- return tuple
- </seealso>
+ <seealso marker="stdlib:gen_statem#type-state_function_result">return tuple</seealso>
from the
- <seealso marker="stdlib:gen_statem#Module:StateName/3">
- callback function.
- </seealso>
+ <seealso marker="stdlib:gen_statem#Module:StateName/3">callback function</seealso>.
These state transition actions affect the <c>gen_statem</c>
- engine itself. They can:
+ engine itself and can do the following:
</p>
<list type="bulleted">
- <item>Postpone the current event.</item>
- <item>Hibernate the <c>gen_statem</c>.</item>
- <item>Start an event timeout.</item>
- <item>Reply to a caller.</item>
- <item>Generate the next event to handle.</item>
+ <item>Postpone the current event</item>
+ <item>Hibernate the <c>gen_statem</c></item>
+ <item>Start an event time-out</item>
+ <item>Reply to a caller</item>
+ <item>Generate the next event to handle</item>
</list>
<p>
- We have mentioned the event timeout
- and replying to a caller in the example above.
- An example of event postponing comes in later in this chapter.
- See the
- <seealso marker="stdlib:gen_statem#type-action">
- reference manual
- </seealso>
- for details. You can for example actually reply to several callers
+ In the example earlier was mentioned the event time-out
+ and replying to a caller.
+ An example of event postponing is included later in this chapter.
+ For details, see the
+ <seealso marker="stdlib:gen_statem#type-action"><c>gen_statem(3)</c></seealso>
+ manual page.
+ You can, for example, reply to many callers
and generate multiple next events to handle.
</p>
</section>
@@ -710,38 +678,30 @@ stop() ->
<section>
<title>Event Types</title>
<p>
- So far we have mentioned a few
- <seealso marker="stdlib:gen_statem#type-event_type">
- event types.
- </seealso>
+ The previous sections mentioned a few
+ <seealso marker="stdlib:gen_statem#type-event_type">event types</seealso>.
Events of all types are handled in the same callback function,
for a given state, and the function gets
<c>EventType</c> and <c>EventContent</c> as arguments.
</p>
<p>
- Here is the complete list of event types and where
+ The following is a complete list of event types and where
they come from:
</p>
<taglist>
<tag><c>cast</c></tag>
<item>
Generated by
- <seealso marker="stdlib:gen_statem#cast/2">
- <c>gen_statem:cast</c>.
- </seealso>
+ <seealso marker="stdlib:gen_statem#cast/2"><c>gen_statem:cast</c></seealso>.
</item>
<tag><c>{call,From}</c></tag>
<item>
Generated by
- <seealso marker="stdlib:gen_statem#call/2">
- <c>gen_statem:call</c>
- </seealso>
+ <seealso marker="stdlib:gen_statem#call/2"><c>gen_statem:call</c></seealso>,
where <c>From</c> is the reply address to use
when replying either through the state transition action
<c>{reply,From,Msg}</c> or by calling
- <seealso marker="stdlib:gen_statem#reply/1">
- <c>gen_statem:reply</c>.
- </seealso>
+ <seealso marker="stdlib:gen_statem#reply/1"><c>gen_statem:reply</c></seealso>.
</item>
<tag><c>info</c></tag>
<item>
@@ -750,15 +710,15 @@ stop() ->
</item>
<tag><c>timeout</c></tag>
<item>
- Generated by the state transition action
+ Generated by state transition action
<c>{timeout,Time,EventContent}</c> (or its short form <c>Time</c>)
timer timing out.
</item>
<tag><c>internal</c></tag>
<item>
- Generated by the state transition action
+ Generated by state transition action
<c>{next_event,internal,EventContent}</c>.
- In fact all event types above can be generated using
+ All event types above can also be generated using
<c>{next_event,EventType,EventContent}</c>.
</item>
</taglist>
@@ -767,34 +727,32 @@ stop() ->
<!-- =================================================================== -->
<section>
- <title>State Timeouts</title>
+ <title>State Time-Outs</title>
<p>
- The timeout event generated by the state transition action
- <c>{timeout,Time,EventContent}</c> is an event timeout,
- that is; if an event arrives the timer is cancelled.
- You get either an event or a timeout but not both.
+ The time-out event generated by state transition action
+ <c>{timeout,Time,EventContent}</c> is an event time-out,
+ that is, if an event arrives the timer is cancelled.
+ You get either an event or a time-out, but not both.
</p>
<p>
- Often you want a timer to not be cancelled by any event
+ Often you want a timer not to be cancelled by any event
or you want to start a timer in one state and respond
- to the timeout in another. This can be accomplished
- with a regular erlang timer:
- <seealso marker="erts:erlang#start_timer/4">
- <c>erlang:start_timer</c>.
- </seealso>
+ to the time-out in another. This can be accomplished
+ with a regular Erlang timer:
+ <seealso marker="erts:erlang#start_timer/4"><c>erlang:start_timer</c></seealso>.
</p>
<p>
- Looking at the example in this chapter so far; using the
+ For the example so far in this chapter: using the
<c>gen_statem</c> event timer has the consequence that
if a button event is generated while in the <c>open</c> state,
- the timeout is cancelled and the button event is delivered.
- Therefore we chose to lock the door if this happended.
+ the time-out is cancelled and the button event is delivered.
+ So, we choose to lock the door if this occurred.
</p>
<p>
- Suppose we do not want a button to lock the door,
+ Suppose that we do not want a button to lock the door,
instead we want to ignore button events in the <c>open</c> state.
Then we start a timer when entering the <c>open</c> state
- and wait for it to expire while ignoring button events:
+ and waits for it to expire while ignoring button events:
</p>
<code type="erl"><![CDATA[
...
@@ -816,17 +774,15 @@ open(cast, {button,_}, Data) ->
...
]]></code>
<p>
- If you need to cancel a timer due to some other event you can use
- <seealso marker="erts:erlang#cancel_timer/2">
- <c>erlang:cancel_timer(Tref)</c>.
- </seealso>
- Note that a timeout message can not arrive after this,
+ If you need to cancel a timer because of some other event, you can use
+ <seealso marker="erts:erlang#cancel_timer/2"><c>erlang:cancel_timer(Tref)</c></seealso>.
+ Notice that a time-out message cannot arrive after this,
unless you have postponed it (see the next section) before,
- so make sure you do not accidentally postpone such messages.
+ so ensure that you do not accidentally postpone such messages.
</p>
<p>
- Another way to cancel a timer is to not cancel it,
- but instead to ignore it if it arrives in a state
+ Another way to cancel a timer is not to cancel it,
+ but to ignore it if it arrives in a state
where it is known to be late.
</p>
</section>
@@ -839,19 +795,17 @@ open(cast, {button,_}, Data) ->
If you want to ignore a particular event in the current state
and handle it in a future state, you can postpone the event.
A postponed event is retried after the state has
- changed i.e <c>OldState =/= NewState</c>.
+ changed, that is, <c>OldState =/= NewState</c>.
</p>
<p>
Postponing is ordered by the state transition
- <seealso marker="stdlib:gen_statem#type-action">
- action
- </seealso>
+ <seealso marker="stdlib:gen_statem#type-action">action</seealso>
<c>postpone</c>.
</p>
<p>
In this example, instead of ignoring button events
- while in the <c>open</c> state we can postpone them
- and they will be queued and later handled in the <c>locked</c> state:
+ while in the <c>open</c> state, we can postpone them
+ and they are queued and later handled in the <c>locked</c> state:
</p>
<code type="erl"><![CDATA[
...
@@ -861,16 +815,16 @@ open(cast, {button,_}, Data) ->
]]></code>
<p>
The fact that a postponed event is only retried after a state change
- translates into a requirement on the event and state space:
- if you have a choice between storing a state data item
- in the <c>State</c> or in the <c>Data</c>;
- should a change in the item value affect which events that
- are handled, then this item ought to be part of the state.
+ translates into a requirement on the event and state space.
+ If you have a choice between storing a state data item
+ in the <c>State</c> or in the <c>Data</c>:
+ if a change in the item value affects which events that
+ are handled, then this item is to be part of the state.
</p>
<p>
- What you want to avoid is that you maybe much later decide
- to postpone an event in one state and by misfortune it is never retried
- because the code only changes the <c>Data</c> but not the <c>State</c>.
+ You want to avoid that you maybe much later decide
+ to postpone an event in one state and by misfortune it is never retried,
+ as the code only changes the <c>Data</c> but not the <c>State</c>.
</p>
<section>
@@ -883,7 +837,7 @@ open(cast, {button,_}, Data) ->
or from the context.
</p>
<p>
- Possible actions may be; ignore as in drop the event
+ Possible actions: ignore as in drop the event
(maybe log it) or deal with the event in some other state
as in postpone it.
</p>
@@ -892,10 +846,10 @@ open(cast, {button,_}, Data) ->
<section>
<title>Selective Receive</title>
<p>
- Erlang's selective receive statement is often used to
- describe simple state machine examples in straightforward
- Erlang code. Here is a possible implementation of
- the first example:
+ Erlang's selective receive statement is often used to
+ describe simple state machine examples in straightforward
+ Erlang code. The following is a possible implementation of
+ the first example:
</p>
<code type="erl"><![CDATA[
-module(code_lock).
@@ -937,33 +891,31 @@ do_unlock() ->
io:format("Open~n", []).
]]></code>
<p>
- The selective receive in this case causes <c>open</c>
- to implicitly postpone any events to the <c>locked</c> state.
+ The selective receive in this case causes implicitly <c>open</c>
+ to postpone any events to the <c>locked</c> state.
</p>
<p>
- A selective receive can not be used from a <c>gen_statem</c>
- behaviour just as for any <c>gen_*</c> behavior
- since the receive statement is within the <c>gen_*</c> engine itself.
- It has to be there because all
+ A selective receive cannot be used from a <c>gen_statem</c>
+ behavior as for any <c>gen_*</c> behavior,
+ as the receive statement is within the <c>gen_*</c> engine itself.
+ It must be there because all
<seealso marker="stdlib:sys"><c>sys</c></seealso>
- compatible behaviours must respond to system messages and therefore
+ compatible behaviors must respond to system messages and therefore
do that in their engine receive loop,
passing non-system messages to the callback module.
</p>
<p>
The state transition
- <seealso marker="stdlib:gen_statem#type-action">
- action
- </seealso>
- <c>postpone</c> is designed to be able to model
- selective receives. A selective receive implicitly postpones
+ <seealso marker="stdlib:gen_statem#type-action">action</seealso>
+ <c>postpone</c> is designed to model
+ selective receives. A selective receive implicitly postpones
any not received events, but the <c>postpone</c>
state transition action explicitly postpones one received event.
</p>
<p>
- Other than that both mechanisms have got the same theoretical
+ Both mechanisms have the same theoretical
time and memory complexity, while the selective receive
- language construct has got smaller constant factors.
+ language construct has smaller constant factors.
</p>
</section>
</section>
@@ -971,43 +923,39 @@ do_unlock() ->
<!-- =================================================================== -->
<section>
- <title>Self Generated Events</title>
+ <title>Self-Generated Events</title>
<p>
- It may be beneficial in some cases to be able to generate events
+ It can sometimes be beneficial to be able to generate events
to your own state machine.
This can be done with the state transition
- <seealso marker="stdlib:gen_statem#type-action">
- action
- </seealso>
+ <seealso marker="stdlib:gen_statem#type-action">action</seealso>
<c>{next_event,EventType,EventContent}</c>.
</p>
<p>
You can generate events of any existing
- <seealso marker="stdlib:gen_statem#type-action">
- type,
- </seealso>
- but the <c>internal</c> type can only be generated through the
- <c>next_event</c> action and hence can not come from an external source,
+ <seealso marker="stdlib:gen_statem#type-action">type</seealso>,
+ but the <c>internal</c> type can only be generated through action
+ <c>next_event</c>. Hence, it cannot come from an external source,
so you can be certain that an <c>internal</c> event is an event
from your state machine to itself.
</p>
<p>
- One example of using self generated events may be when you have
+ One example of using self-generated events can be when you have
a state machine specification that uses state entry actions.
- That you could code using a dedicated function
- to do the state transition. But if you want that code to be
- visible besides the other state logic you can insert
+ You can code that using a dedicated function
+ to do the state transition. But if you want that code to be
+ visible besides the other state logic, you can insert
an <c>internal</c> event that does the entry actions.
This has the same unfortunate consequence as using
- state transition functions that everywhere you go to
- the state in question you will have to explicitly
+ state transition functions: everywhere you go to
+ the state, you must explicitly
insert the <c>internal</c> event
- or use state transition function.
+ or use a state transition function.
</p>
<p>
- Here is an implementation of entry actions
+ The following is an implementation of entry actions
using <c>internal</c> events with content <c>enter</c>
- utilizing a helper function <c>enter/3</c> for state entry:
+ using a helper function <c>enter/3</c> for state entry:
</p>
<code type="erl"><![CDATA[
...
@@ -1051,20 +999,20 @@ enter(Tag, State, Data) ->
<section>
<title>Example Revisited</title>
<p>
- Here is the example after all mentioned modifications
- and some more utilizing the entry actions,
+ This section includes the example after all mentioned modifications
+ and some more using the entry actions,
which deserves a new state diagram:
</p>
<image file="../design_principles/code_lock_2.png">
- <icaption>Code lock state diagram revisited</icaption>
+ <icaption>Code Lock State Diagram Revisited</icaption>
</image>
<p>
- Note that this state diagram does not specify how to handle
- a button event in the state <c>open</c>, so you will have to
- read some other place that is here that unspecified events
- shall be ignored as in not consumed but handled in some other state.
- Nor does it show that the <c>code_length/0</c> call shall be
- handled in every state.
+ Notice that this state diagram does not specify how to handle
+ a button event in the state <c>open</c>. So, you need to
+ read somewhere else that unspecified events
+ must be ignored as in not consumed but handled in some other state.
+ Also, the state diagram does not show that the <c>code_length/0</c>
+ call must be handled in every state.
</p>
<section>
@@ -1147,10 +1095,11 @@ code_change(_Vsn, State, Data, _Extra) ->
<section>
<title>Callback Mode: handle_event_function</title>
<p>
- What to change to use one <c>handle_event/4</c> function.
- Here a clean first-dispatch-on-event approach
- does not work that well due to the generated
- entry actions:
+ This section describes what to change in the example
+ to use one <c>handle_event/4</c> function.
+ The previously used clean first-dispatch-on-event approach
+ does not work that well here because of the generated
+ entry actions so this example dispatches on state first:
</p>
<code type="erl"><![CDATA[
...
@@ -1195,7 +1144,7 @@ handle_event({call,From}, code_length, _State, #{code := Code}) ->
]]></code>
</section>
<p>
- Note that postponing buttons from the <c>locked</c> state
+ Notice that postponing buttons from the <c>locked</c> state
to the <c>open</c> state feels like the wrong thing to do
for a code lock, but it at least illustrates event postponing.
</p>
@@ -1206,33 +1155,29 @@ handle_event({call,From}, code_length, _State, #{code := Code}) ->
<section>
<title>Filter the State</title>
<p>
- The example servers so far in this chapter will for example
- when killed by an exit signal or due to an internal error
- print out the full internal state in the error log.
+ The example servers so far in this chapter
+ print the full internal state in the error log, for example,
+ when killed by an exit signal or because of an internal error.
This state contains both the code lock code
- and which digits that remains to unlock.
+ and which digits that remain to unlock.
</p>
<p>
This state data can be regarded as sensitive,
and maybe not what you want in the error log
- because of something unpredictable happening.
+ because of some unpredictable event.
</p>
<p>
Another reason to filter the state can be
- that the state is too big to print out since it fills
+ that the state is too large to print, as it fills
the error log with uninteresting details.
</p>
<p>
- To avoid this you can format the internal state
+ To avoid this, you can format the internal state
that gets in the error log and gets returned from
- <seealso marker="stdlib:sys#get_status/1">
- <c>sys:get_status/1,2</c>
- </seealso>
- by implementing the
- <seealso marker="stdlib:gen_statem#Module:format_status/2">
- <c>Module:format_status/2</c>
- </seealso>
- function, for example like this:
+ <seealso marker="stdlib:sys#get_status/1"><c>sys:get_status/1,2</c></seealso>
+ by implementing function
+ <seealso marker="stdlib:gen_statem#Module:format_status/2"><c>Module:format_status/2</c></seealso>,
+ for example like this:
</p>
<code type="erl"><![CDATA[
...
@@ -1257,12 +1202,10 @@ format_status(Opt, [_PDict,State,Data]) ->
]]></code>
<p>
It is not mandatory to implement a
- <seealso marker="stdlib:gen_statem#Module:format_status/2">
- <c>Module:format_status/2</c>
- </seealso>
- function. If you do not a default implementation is used that
+ <seealso marker="stdlib:gen_statem#Module:format_status/2"><c>Module:format_status/2</c></seealso>
+ function. If you do not, a default implementation is used that
does the same as this example function without filtering
- the <c>Data</c> term that is: <c>StateData = {State,Data}</c>.
+ the <c>Data</c> term, that is, <c>StateData = {State,Data}</c>.
</p>
</section>
@@ -1272,57 +1215,54 @@ format_status(Opt, [_PDict,State,Data]) ->
<title>Complex State</title>
<p>
The callback mode
- <seealso marker="stdlib:gen_statem#type-callback_mode">
- <c>handle_event_function</c>
- </seealso>
- enables using a non-atom state as described in
- <seealso marker="#callback_modes">
- Callback Modes,
- </seealso>
- for example a complex state term like a tuple.
+ <seealso marker="stdlib:gen_statem#type-callback_mode"><c>handle_event_function</c></seealso>
+ enables using a non-atom state as described in section
+ <seealso marker="#callback_modes">Callback Modes</seealso>,
+ for example, a complex state term like a tuple.
</p>
<p>
One reason to use this is when you have
- a state item that affects the event handling
- in particular when combining that with postponing events.
- Let us complicate the previous example
+ a state item that affects the event handling,
+ in particular in combination with postponing events.
+ We complicate the previous example
by introducing a configurable lock button
- (this is the state item in question)
- that in the <c>open</c> state immediately locks the door,
+ (this is the state item in question),
+ which in the <c>open</c> state immediately locks the door,
and an API function <c>set_lock_button/1</c> to set the lock button.
</p>
<p>
Suppose now that we call <c>set_lock_button</c>
while the door is open,
and have already postponed a button event
- that up until now was not the lock button;
- the sensible thing might be to say that
- the button was pressed too early so it should
- not be recognized as the lock button,
- but then it might be surprising that a button event
+ that until now was not the lock button.
+ The sensible thing can be to say that
+ the button was pressed too early so it is
+ not to be recognized as the lock button.
+ However, then it can be surprising that a button event
that now is the lock button event arrives (as retried postponed)
immediately after the state transits to <c>locked</c>.
</p>
<p>
- So let us make the <c>button/1</c> function synchronous
- by using <c>gen_statem:call</c>,
+ So we make the <c>button/1</c> function synchronous
+ by using
+ <seealso marker="stdlib:gen_statem#call/2"><c>gen_statem:call</c></seealso>
and still postpone its events in the <c>open</c> state.
Then a call to <c>button/1</c> during the <c>open</c>
- state will not return until the state transits to <c>locked</c>
- since it is there the event is handled and the reply is sent.
+ state does not return until the state transits to <c>locked</c>,
+ as it is there the event is handled and the reply is sent.
</p>
<p>
- If now one process calls <c>set_lock_button/1</c>
- to change the lock button while some other process
- hangs in <c>button/1</c> with the new lock button
- it could be expected that the hanging lock button call
+ If a process now calls <c>set_lock_button/1</c>
+ to change the lock button while another process
+ hangs in <c>button/1</c> with the new lock button,
+ it can be expected that the hanging lock button call
immediately takes effect and locks the lock.
- Therefore we make the current lock button a part of the state
- so when we change the lock button the state will change
- and all postponed events will be retried.
+ Therefore, we make the current lock button a part of the state,
+ so that when we change the lock button, the state changes
+ and all postponed events are retried.
</p>
<p>
- We define the state as <c>{StateName,LockButton}</c>
+ We define the state as <c>{StateName,LockButton}</c>,
where <c>StateName</c> is as before
and <c>LockButton</c> is the current lock button:
</p>
@@ -1441,10 +1381,9 @@ format_status(Opt, [_PDict,State,Data]) ->
end.
]]></code>
<p>
- It may be an ill-fitting model for a physical code lock
- that the <c>button/1</c> call might hang until the lock
- is locked. But for an API in general it is really not
- that strange.
+ It can be an ill-fitting model for a physical code lock
+ that the <c>button/1</c> call can hang until the lock
+ is locked. But for an API in general it is not that strange.
</p>
</section>
@@ -1457,26 +1396,21 @@ format_status(Opt, [_PDict,State,Data]) ->
and they have some state(s) in their lifetime in which
the servers can be expected to idle for a while,
and the amount of heap memory all these servers need
- is a problem; then it is possible to minimize
- the memory footprint of a server by hibernating it through
- <seealso marker="stdlib:proc_lib#hibernate/3">
- <c>proc_lib:hibernate/3</c>.
- </seealso>
+ is a problem, then the memory footprint of a server
+ can be mimimized by hibernating it through
+ <seealso marker="stdlib:proc_lib#hibernate/3"><c>proc_lib:hibernate/3</c></seealso>.
</p>
<note>
<p>
- To hibernate a process is rather costly. See
- <seealso marker="erts:erlang#hibernate/3">
- <c>erlang:hibernate/3</c>.
- </seealso>
- It is in general not something you want to do
- after every event.
+ It is rather costly to hibernate a process; see
+ <seealso marker="erts:erlang#hibernate/3"><c>erlang:hibernate/3</c></seealso>.
+ It is not something you want to do after every event.
</p>
</note>
<p>
- We can in this example hibernate in the <c>{open,_}</c> state
- since what normally happens in that state is that
- the state timeout after a while
+ We can in this example hibernate in the <c>{open,_}</c> state,
+ because what normally occurs in that state is that
+ the state time-out after a while
triggers a transition to <c>{locked,_}</c>:
</p>
<code type="erl"><![CDATA[
@@ -1493,29 +1427,27 @@ handle_event(
]]></code>
<p>
The
- <seealso marker="stdlib:gen_statem#type-hibernate">
- <c>[hibernate]</c>
- </seealso>
+ <seealso marker="stdlib:gen_statem#type-hibernate"><c>[hibernate]</c></seealso>
action list on the last line
when entering the <c>{open,_}</c> state is the only change.
- If any event arrives in the <c>{open,_},</c> state we
- do not bother to re-hibernate, so the server stays
+ If any event arrives in the <c>{open,_},</c> state, we
+ do not bother to rehibernate, so the server stays
awake after any event.
</p>
<p>
To change that we would need to insert
- the <c>hibernate</c> action in more places,
- for example for the state independent <c>set_lock_button</c>
+ action <c>hibernate</c> in more places.
+ For example, for the state-independent <c>set_lock_button</c>
and <c>code_length</c> operations that then would have to
be aware of using <c>hibernate</c> while in the
- <c>{open,_}</c> state which would clutter the code.
+ <c>{open,_}</c> state, which would clutter the code.
</p>
<p>
- This server probably does not use an amount of
+ This server probably does not use
heap memory worth hibernating for.
- To gain anything from hibernation your server would
- have to actually produce some garbage during callback execution,
- for which this example server may serve as a bad example.
+ To gain anything from hibernation, your server would
+ have to produce some garbage during callback execution,
+ for which this example server can serve as a bad example.
</p>
</section>