In the previous article, we addressed what is one of the most important topics in robotics
these days: the fundamental role played by software engineering (SE for short) in designing
and implementing efficient, reliable, and robust robotic systems. First, we defined the
fundamental requirements that must be met when building robots for real-world scenarios:
The on-board software must be concurrent, distributed, embedded, real-time, and
data-intensive. Second, we discussed the problems related to the actual code written for
implementing software control architectures, and the underlying relevant guidelines to be
strictly followed by programmers, such as maintainability, interoperability, and reusability.
Finally, we introduced a simple reference scenario of service robots (or automated guided
vehicles; AGV for short) in warehouses or similar static environments where the robot
workspace can be defined in advance with great precision, and every detail can be represented
by the system since it will not vary at run-time.

In such a setting, we showed how software engineering reduces to a domain-engineering
process that is basically unidirectional design flow starting from domain analysis (a study
about the fundamental requirements imposed by the operating environment), continuing with
domain design (an actual design phase where the non-technical requirements imposed by the
previous analysis are formalized in order to be implemented), and concluding with domain
implementation (a phase when the robotic system is finally implemented and deployed).

Summarizing, the key idea of the previous article was
that every aspect of a real-world robotic system ultimately
depends on the characteristics of the robot operating
environment. From mechanics to control laws, from HW to
SW layers, up to artificial intelligence techniques possibly
implemented as actual code, each part of the whole
architecture depends on the operating environment.

The scenario that we assumed in the previous article is
fairly simple from the perspective of robotics engineering.
Since every detail of the environment where the robot
usually operates is known or can be easily determined
beforehand, it is not difficult — at least in principle — to
provide the robot with the necessary knowledge to operate
at its best in each possible situation (and this is indeed a

60 SERVO 10.2009

very hot topic of active research these days). At the
software level, this assumption is particularly useful. In
fact, we noticed that in these cases object oriented
programming (OOP) is particularly intriguing.

OOP allows robotics engineers to design the complete
system starting from a well-defined conceptual model of
the operating environment that — as we just noticed — is
literally available. When each relevant object in the operating
environment is modelled (as long as it is relevant for robot
operations), the implementation of the final system is
straightforward. As a matter of fact, in the previous article
we showed that the overall system can be reduced to three
main subsystems: Human-Computer Interface;
Communication; and Robot Control software. This is