Journée sur les Architectures Logicielles pour la Robotique Autonome, les Systèmes Cyber-Physiques et les Systèmes Auto-Adaptables sur le thème Modèles à l’exécution (model@runtime) pour la vérification, la simulation et l’auto-adaptabilité dynamiques organisée par le Laboratoire LIP6, soutenue par l’action transversale ALROB entre les GDR GPL et Robotique du CNRS LIP6/Université Pierre et Marie Curie, 7 décembre 2015

Date limite des propositions : vendredi 13 novembre 2015

Types : présentations et posters (travaux nouveaux ou dejà publiés)

Depuis une vingtaine d’années, la robotique autonome fait face à une croissance rapide dans
la complexité des besoins et des exigences pour des robots chargés de missions multiples, capables
de se coordonner, et fournissant des garanties de sûreté et de sécurité puissent être vérifiées et
certifiées en vue d’une utilisation dans un environnement humain. En parallèle, une évolution
similaire dans le domaine des systèmes temps-réel embarqués répartis a justifié l’émergence du
domaine des systèmes « cyber-physiques » reflétant une montée similaire en complexité. D’autres
domaines sont également apparus, comme l’informatique autonomique, partageant les mêmes objectifs
scientifiques dans la conception et la mise en oeuvre de leurs architectures logicielles.
Ces architectures logicielles visent toutes, globalement, à intégrer un système informatisé de
contrôle avec d’autres traitements d’informations de plus en plus lourds (cartographie, planification,
analyse de données, apprentissage, etc.), et ce dans un contexte en prise constante avec
le monde réel. L’expérience de ces vingt dernières années en robotique autonome montre que la
réalisation d’architectures logicielles correctes et sûres, facilement réutilisables et évolutives reste
un défi formidable car il est très difficile d’obtenir un bon découplage entre capteurs, contrôle,
algorithmes et actionneurs. La prise en compte du temps et des contraintes diverses a mené à des
systèmes très couplés, où les caractéristiques des capteurs et des actionneurs de même que le cahier
des charges des fonctionnalités attendues finissent par dicter des solutions spécifiques en termes
d’algorithmes, d’architectures, de configurations des intergiciels et du système, etc., solutions qui
sont coûteuses à développer et ensuite difficiles à valider, à vérifier et à faire évoluer.

Après le succès des Première et Seconde Journées organisées le 1er décembre 2014 au LIP6 à
Paris et les 29-30 juin 2015 au CITI à Lyon, cette troisième journée souhaite poursuivre l’animation de la
communauté par des échanges et des collaborations sur les défis scientifiques communs au génie
logiciel et au développement de ces architectures de contrôle, autonomiques et cyber-physiques.
Pour cette troisième édition, la thématique centrale est « Modèles à l’exécution » (model@
runtime). L’utilisation de modèles d’architecture logicielle (UML, …) ou de comportement
(automates, systèmes hybrides, …) est une pratique centrale et courante en génie logiciel depuis
plusieurs années déjà. Plus récemment, l’idée d’embarquer au sein du système une représentation
de ses modèles manipulable à l’exécution se développe de plus en plus. Ces modèles embarqués
peuvent alors servir de base à la vérification dynamique, à l’apprentissage, à la simulation et plus
généralement à l’auto-adaptation dynamiques des architectures logicielles. Des contributions sur
les approches utilisant les modèles à l’exécution développées dans les domaines des architectures de
contrôle de robots, de l’automatique, des systèmes autonomiques et des systèmes cyber-physiques
en général sont particulièrement attendues.

Des contributions peuvent également être soumises sur les thématiques générales suivantes
(toujours comprises dans l’optique des architectures logicielles pour la robotique autonome, les
systèmes cyber-physiques et les systèmes auto-adaptables) :
— définition d’architectures logicielles
— langages de programmation, abstractions de programmation, et patrons de conception
— spécification, modélisation et validation, en particulier en fonction de leur impact et contraintes
sur les architectures logicielles
— les aspects du génie logiciel directement liés aux architectures logicielles : conception, développement,
tests, validation, gestion du cycle de vie, etc.
— composition, coordination, inter-connexion de ces systèmes

Types de propositions
L’objectif de ces journées est d’abord l’animation de la communauté de recherche dans le domaine.
La présentation de travaux nouveaux non-publiés n’est pas une condition de participation.
Les propositions faites sur la base de travaux préalablement publiés sont parfaitement acceptables.
Deux types de propositions sont possibles :
— propositions de présentations orales requérant l’envoi d’un article, ou
— propositions de posters requérant l’envoi d’un article court.

La sélection des travaux présentés oralement sera faite en fonction de leur intérêt le plus large
pour la communauté et leur pertinence par rapport aux thèmes de la journée. Les propositions de
présentations orales non-retenues pourront se voir offrir la possibilité de présenter un poster.

Pour éviter les problèmes de droits de publication, il ne sera pas fait d’actes formels de ces
journées ; la présentation (orale ou poster) de travaux déjà publiés, en cours de soumission ailleurs
ou à soumettre plus tard est donc tout à fait possible. Pour les auteurs qui le souhaiteront, les
supports et les textes pourront cependant être mis sur le site de la journée.

Modalités de proposition
— la date limite des propositions est le vendredi 13 novembre 2015 ;
— les propositions sont envoyées directement par courrier électronique à l’un ou l’autre des
membres du comité scientifique ;
— les résultats et invitations seront donnés au plus tard le vendredi 20 novembre 2015.

Comité scientifique
David Andreu LIRMM andreu/at/lirmm.fr
Noury Bouraqadi EMDouai noury.bouraqadi/at/mines-douai.fr
Jacques Malenfant LIP6 jacques.malenfant/at/lip6.fr
Roger Pissard-Gibolet INRIA Grenoble roger.pissard/at/inria.fr
Romain Rouvoy LIFL-CRiSTAL romain.rouvoy/at/univ-lille1.fr
Éric Rutten INRIA Grenoble eric.rutten/at/inria.fr
Olivier Simonin CITI-Inria olivier.simonin/at/insa-lyon.fr
Serge Stinckwich UMMISCO serge.stinckwich/at/gmail.com

CONTACT
Prof. Noury Bouraqadi, noury.bouraqadi AT mines-douai.fr
Dr. Luc Fabresse, luc.fabresse AT mines-douai.fr
Dr. Guillaume Lozengez, guillaume.lozenguez AT mines-douai.fr

DESCRIPTION
Robotic exploration and mapping is basic to many robotic applications and more specifically to search and rescue operations. It relies on robots to build a map of the environment as a first step to further mission specific tasks (eg. extracting trapped victims). In scenarios where time is critical such in the aftermath of an earthquake, the use of multiple robots allows to speed up the exploration and to take advantage of distributed sensor to increase the mapping process. Each robot explores a different but connected area. The global map is built by merging local maps built by individual robots.

To build a map of an unknown environment, a robot has to perform Simultaneous Localization and Mapping (SLAM). Based on different perceived data (typically odometery and laser scans), metric SLAM algorithms localize the robot while building an occupancy grid. The occupancy grid models the environment as a matrix where each cell denotes the probability of occupancy of a small area.

Best metric SLAM algorithms produce precise maps that allow localization with typically centimetric precision. However, an occupancy grid map is materialized as a large matrix. Beside the memory consumption, such a map leads to high CPU consumption for path planning. CPU consumption is also a concern in multi-robot exploration. Indeed, merging metric maps produced by different robots is computationally intensive.

The above drawbacks of metrics maps can be mitigated by the use of topological maps. However, topological maps do not allow precise obstacle delimitations needed for autonomous robots exploration. The goal of this PhD is to contribute to our ongoing effort, and propose a solution that gathers the best of both worlds.

The expected outcome is a SLAM algorithm that builds a topological map that embeds metric information. The target algorithm should be implemented on top of the ROS middleware and validated both in simulation and on actual robots. It should also be supported by a set of automated tests that can safely run on an actual robot.

BIBLIOGRAPHY
- Robotic Mapping and Exploration. C. Stachniss. Springer 2009.
- An evaluation of 2D SLAM techniques available in Robot Operating System. J. M. Santos, D. Portugal, and R. Rocha. SSRR 2013.
- A Methodology for Testing Mobile Autonomous Robots. Jannik Laval, Luc Fabresse and Noury Bouraqadi. IROS 2013.
- Towards Test-Driven Development for Mobile Robots. Luc Fabresse, Jannik Laval and Noury Bouraqadi. ICRA 2013 eigth workshop on Software Development and Integration in Robotics (SDIR VIII).
- Team Size Optimization for Multi-robot Exploration, Zhi Yan, Luc Fabresse, Jannik Laval, and Noury Bouraqadi, SIMPAR 2014.
- Metrics for Performance Benchmarking of Multi-robot Exploration. Zhi Yan, Luc Fabresse, Jannik Laval, and Noury Bouraqadi. IROS 2015.
- Punctual versus continuous auction coordination for multi-robot and multi-task topological navigation, Guillaume Lozenguez, Lounis Adouane, Aurélie Beynier, Abdel-Illah Mouaddib, Philippe Martinet, Autonomous Robot 2015.

CONTACT
Prof. S. Ducasse, stephane.ducasse AT inria.fr, INRIA, France
Prof. N. Bouraqadi, noury.bouraqadi AT mines-douai.fr, Mines Douai, France
Dr. M. Denker, marcus.denker AT inria.fr, INRIA, France
Dr. L. Fabresse, luc.fabresse AT mines-douai.fr, Mines Douai, France

CONTEXT
Building next generation systems that can not be stopped in deployment is an interesting challenge for industry.
Indeed, when we need to replace current software for an upgrade or a bug fix, it is mandatory to stop
the old running version, make the change and then restart the new version.
However, there are situations where a such process is either impossible or at least undesirable because
of the costs resulting from a shutdown (e.g production line, robot on mars, …).

We believe that software built with from the beginning the property to work indefinitely, will be by
construction more robust to change, intrinsically capable of evolution and more agile than traditional software.

Dynamic languages such as CLOS, Ruby, Python, Smalltalk and Pharo provide a support for updates that involve code change.
Even if they are more advanced compared to other languages, their solutions are mainly ad hoc and deserve being rethought.
We believe it is important to have a mechanism and an infrastructure that allow adaptive and safe software updates.

By “safe” we mean that this solution should support different conditions, such as a series of updates performed in the wrong sequence.
In such situations, instances of changed classes should migrate in a satisfactory fashion.
Safety also means verifying loaded changes. Changes should be checked and possibly rejected if they make the system
unstable or if they introduce errors.

SCIENTIFIC GOALS
The questions we would like to target in this PhD are the following:

- What is a good infrastructure to support reliable dynamic code update? Do we need to analyse changes?

- Is an infrastructure based on isolated environments enough to ensure update safety? What level of atomicity is required?

- What kind of meta-object protocol is required to migrate objets?

- Would it be interesting to have different versions of a given class or package active at the same time for the same software?

BIBLIOGRAPHY

. D. Duggan. Type-based hot swapping of running modules. In Intl. Conf. on Functional Programming, pages 62–73, 2001.
. M. Denker, T. Gîrba, A. Lienhard, O. Nierstrasz, L. Renggli, and P. Zumkehr. Encapsulating and exploiting change with Changeboxes. In Proc. Int. Conference on Dynamic Languages, pages 25–49. ACM Digital Lib., 2007.
. M. Dmitriev. Safe Class and Data Evolution in Large and Long-Lived Java Applications. PhD thesis, University of Glasgow, 2001.
. M. Hicks and S. Nettles. Dynamic software updating. ACM Transactions on Programming Languages and Systems, 27(6):1049–1096, nov 2005.
. J. Kephart. Research challenges of autonomic computing. In ICSE 2005, pages 15–22, may 2005.
. G. Kniesel. Type-safe delegation for run-time component adaptation. In R. Guerraoui, editor, Proceedings ECOOP ’99, volume 1628 of LNCS, pages 351–366, Lisbon, Portugal, June 1999. Springer-Verlag.
. I. Neamtiu, M. W. Hicks, G. Stoyle, and M. Oriol. Practical dynamic software updating for c. In PLDI, pages 72–83, 2006.
. G Polito, Stéphane Ducasse, N Bouraqadi, L Fabresse, M Mattone. Virtualization Support for Dynamic Core Library Update. Onward!, Oct 2015, Pittsburg, USA.
. X. Ren, F. Shah, F. Tip, B. Ryder, and O. Chesley. Chianti: A tool for change impact analysis of Java programs. In Proceedings of OOPSLA 2004), pages 432–448, 2004.

Our paper presented at the International Workshop on Smalltalk Technology 2015, Brescia Italy, as part of the PhD of LE Xuan Sang received the 1st prize, offered by the Lam Research Corporation.

A Meta Model Supporting Both Hardware and Smalltalk-based Execution of Fpga Circuits
High level synthesis (HLS) refers to an automated process that creates a digital hardware from an algorithmic description of some computation. From the perspective of Smalltalk, this process consists in converting a code from the OO level to the register transfer level (RTL), that supports direct compilation to the hardware level. In this paper, we present first steps to achieve this process. We introduce a Smalltalk-based meta-model that allows to express descriptions (i.e. models) of digital circuits. These descriptions materialize as Smalltalk code. A such circuit description can be run on top of the Smalltalk VM, simulating the parallelism intrinsic to hardware. Alternatively, it can be compiled into a binary representation directly transferable to FPGA chips, which can run and exchange data with Smalltalk objects.

We are glad to announce PharoJS, which is an infrastructure to run Pharo code on top of JavaScript. The goal of PharoJS is to allow developers benefit from the power of Pharo while targeting platforms that support JavaScript.

For example, PharoJS can be used to develop client side web applications. It can also be used to support cross-platform mobile apps based on Phone Gap.

PharoJS is freely available under MIT License. It can be dowloaded from SmalltalkHub.