SEKE 2012 Proceedings - Knowledge Systems Institute

Engineering Graphical Domain Specific Languages to
Develop Embedded Robot Applications
Daniel B. F. Conrado and Valter V. de Camargo
Computing Department – Federal University of São Carlos (UFSCar)
São Carlos, Brazil
{daniel_conrado,valter}@dc.ufscar.br
Abstract—Over the last years, little attention has been paid in
software engineering techniques for improving the productivity
of embedded robot application development. The complexity of
these applications has been continuously growing and they are
presenting challenges that are uncommon to information systems'
development. Therefore, any technique that can support their
development is a great contribution. Domain specific languages
(DSLs) are one technique that aims at improving productivity by
reusing concepts and abstractions from a specific domain. In this
paper we present a DSL engineering process for embedded robot
applications. The aim is to make the activity of creating DSLs to
this domain more systematic and controlled. As a result, one can
build embedded robot applications in a more productive way. An
important characteristic of our process is that it asks for just one
application to reach a first version of a running DSL. We also
present a generic language model that may serve as a foundation
for future DSLs. In order to validate our process, we have
applied it to the development of a DSL from an aisle monitoring
robot application.
Keywords-component; Domain-Specific Languages; Mobile
Robots; DSL Engineering
I. INTRODUCTION
Domain-specific languages (DSLs) are small programming
languages which targets a specific domain. This domain may
be vertical, i.e. application domains like healthcare,
engineering, home security, etc. or horizontal, that is, technical
domains that provide structures to build applications, like
persistence, signal processing, security, among others [1].
One of the main advantages of DSLs is the possibility of
writing applications using domain expressions instead of
programming languages’ constructs. It raises the abstraction
level and also improves code reuse. DSLs can be differentiated
by their appearance (textual or graphical) and their origin
(internal or external). The difference between external and
internal DSLs is that the latter are embedded into another
general purpose language (GPL) called the host language, and
that’s why such DSLs are often called embedded languages.
In general, DSLs increases expressiveness significantly
when compared to a GPL [3]. It allows the developers to write
applications with fewer instructions that are easier to
comprehend. DSLs are also used in the context of Model-
Driven Development (MDD) by specifying high-level models
that are transformed into source code artifacts (Model-to-Code
transformation) or detailed models (Model-to-Model
transformation) [1,4].
Robots are electromechanical machines that perform
repetitive and/or dangerous tasks in an environment. They
extract environment’s information using sensors; calculate
actions based on that information by means of processing units
and perform those actions with end effectors (devices like
gripper and arm). In short, robots are composed by sensors,
actuators and processing units. The latter generally are a
platform-specific software embedded into one or more
microcontrollers [6,7,8].
In this context, one may note that the way the robot wheels
are configured, its sensors, microcontrollers, physical structure
and even its environment influences its programming.
Furthermore, there are a lot of non-functional properties that
must be considered such as power consumption, response time,
safety, among others. As we said, most of these issues are
uncommon to or quite different from information systems.
Although there are some processes to build DSLs
[3,9,10,11], we didn’t find one that takes into consideration
specific characteristics of mobile robots. With this lack, these
processes may yield poorly designed DSLs which compromises
the quality of generated applications. Using DSLs in the
context of robot applications may enhance their overall
development, since robotics is a complex domain and highlevel
representations combined with model/code generation
would contribute for better understanding and code reuse.
In this paper we present a process for building DSLs which
target to the r obot application domain. Moreover, although
domain engineering is generally performed by analyzing at
least three applications of a certain domain, there may be
situations where there is an interest in building DSLs even
though such applications don’t exist yet. In this context, our
aim is to c ontribute to robotic software development with an
alternative process that provides guidelines for building initial
DSLs based on a single application. The main idea is that such
initial DSLs may eventually be evolved to the extent that new
applications are developed and new abstractions are identified.
As a proof of concept, we developed a DSL based on security
applications implemented with a LEGO Mindstorms kit and the
LeJOS API [5].
This paper is organized as follows: section II presents our
process; section III presents our proof of concept; section IV
presents related works, and section V concludes the paper.
495