IEEE Robotics & Automation Magazine - September 2018 - 50

A limitation of such behavior graphs is their inflexibility.
Typically, the structure of the graph is fixed. Therefore, runtime changes in the robot's behavior can occur only through
changes in the states of the nodes. This results in increased
node-code complexity. Consequently, the robotic behavior is
no longer expressed solely by the structure of the graph, i.e., a
profound knowledge of the code embedded with the nodes is
required to relate the graph to the behavior displayed by the
robot. As the size of the graph grows and the complexity of
the nodes increases, this relationship becomes intractable.
Because the code encapsulated by the nodes does not necessarily refer exclusively to a functionality reusable across
behaviors, but may also include logic related to the specifics of
the target behavior, there is a direct negative impact on code
reusability. And because the logic of the behavior is shared
between the structure of the graph and the code encapsulated
by the nodes, the efforts required to modify or extend the
existing graphs is considerable.
Playful enables the encoding of robotic behavior via
behavior trees that support runtime structural modifications, such as 1) changes in the activation status of nodes,
2) online creation of branches, and 3) online setup of
information flows between nodes. A first consequence of
these runtime structural modifications is that these trees
may express reactive behaviors. For example, Playful is
suitable for implementing the sensory-motor couplings
required to grasp a moving object while looking at it. The
second consequence is that the logic of the robotic
behaviors designed via Playful no longer needs to be partially delegated to nodes; it may be fully expressed by the
tree. As exemplified in the "Complex Behaviors" section,
this has a positive effect in terms of code reuse and
behavior refactoring.
When using Playful, developers design reactive trees
whose structure will change during runtime. To simplify the
definition of such behavior trees, Playful supports, as a front
end for developers, a novel dedicated scripting language
based on the reactive programming paradigm. We chose
this paradigm because it allows for specifying logic via
expressive statements relatively close to natural language. At
startup, the script provided by the user is interpreted, the
corresponding behavior tree is created, and Playful's underlying engine ensures that the specified logic is applied and
the sensory-motor couplings are suitably coordinated.
Reactive programming, while popular for creating graphical
interfaces, is rarely used for robotics (see the "Related Work"
section). To our knowledge, the Playful scripting language is
the first application of such programming to the definition
of behavior trees.
This article shows that applying reactive programming to
the design of dynamic trees amounts to a high-level scripting
language that allows the design of reactive behavior trees
using descriptive statements. In the "Complex Behaviors" section, we show that Playful supports the creation of complex
dynamic behaviors via the association of reusable components of modest size. We also show how these behaviors can
50

IEEE ROBOTICS & AUTOMATION MAGAZINE

september 2018

be significantly extended via the addition of only a few lines of
script. This work focuses on Playful as a convenient tool for
creating first-order reactive and lively behaviors; interfacing
with higher-order planning and reasoning software has not
yet been validated. In the "Future Work" section, we discuss
how such interfacing could be done and report on related
early results.
A dedicated website for download and tutorials is available
[15]. A support video [16] for this article as well as an overview video [17] can be found online.
Related Work
Reactive programming is an asynchronous programming
paradigm concerned with data streams and the propagation
of change. Elliot and Hudak first formulated it [1], and it has
been used mostly for the development of graphical user interfaces. The researchers in [2] and [3] proposed its use for robot
control in the form of languages embedded in Haskell. These
languages handle both streams of continuous values and discrete events without regard for their rates, allowing the creation of commands at higher levels of abstraction. While the
latter languages focus on lower-level control, Playful applies
reactive programming to another domain of robotics: that of
orchestrating behavior trees. Our software platform monitors
the activation of higher-level modules communicating with a
middleware-e.g., the Robot Operating System (ROS). In this
context, a combination of streams is solved by the middleware, as with the use of publishers and subscribers. Playful
operates with different concepts (e.g., it does not use monades
and signals) and provides complementary constructs more
suitable for describing overall behavior (e.g., online activation
and modification of behavior trees).
Three-layer architectures, and notably modern hybrid
architectures, are robotic software creations supporting the
integration of deliberation and reactive execution. Executive control often refers to the middle component of threelayer architectures, for which the concept of task is central
[4]. A task refers to the execution of a potentially complex
action characterized by a start and an end. Typically, a task's
performance can be monitored, and its success or failure
evaluated on completion. While both approaches have been
designed for supporting reactive execution, they differ
drastically, as the notion of task does not exist in Playful.
The latter's behaviors are encoded in tree structures defining mappings between the state of the world and module
activation patterns. Thus, Playful and three-layer architectures are suitable for different application domains. Executive control, as implemented in three-layer architectures, is
suitable for applying sequences of actions generated online
by planners. In this article, on the other hand, we present
Playful only for rapid prototyping of reactive behaviors and
its possible interfacing with other higher-level decisionmaking systems not yet tested and only briefly discussed in
the "Future Work" section.
Following Target-Drive-Means (TDM), a software product
for declarative specification of high-level robotic behavior

IEEE Robotics & Automation Magazine - September 2018

Table of Contents for the Digital Edition of IEEE Robotics & Automation Magazine - September 2018