Renaud Rioboo

Invariants for the FoCaL language

In this paper we present a FoCaL formalization for quotient structures which are common in mathematics. We first present a framework for stating invariant properties of the data manipulated by running programs. A notion of equivalence relation is then encoded for the FoCaL library. It is implemented through projections functions, this enables us to provide canonical representations which are commonly used in Computer Algebra but seldom formally described. We further provide a FoCaL formalization for the code used inside the library for modular arithmetic through the certification of quotient groups and quotient rings which are involved in the model. We finally instantiate our framework to provide a trusted replacement of the existing FoCaL library.

Programming Robots with Events

We introduce how to use event-based style to program robots through the INI programming language. INI features both built-in and user-defined events, a mechanism to handle various kinds of changes happening in the environment. Event handlers run in parallel either synchronously or asynchronously, and events can be reconfigured at runtime to modify their behavior when needed. We apply INI to the humanoid robot called Nao, for which we develop an object tracking program.

Using Event-Based Style for Developing M2M Applications

In this paper, we introduce how to write M2M applications by using INI, a programming language specified and implemented by ourselves that supports event-based style. With event-based programming, all M2M communication can be handled and scheduled. Programmers may use existing built-in events or define their own events. We apply our approach in a real M2M gateway, which allows gathering and exchanging information between sensors and machines in the network. The results shows that our work proposes a concise and elegant alternative and complement to industrial state-of-the-art languages such as Java or C/C++.

Development of secured systems by mixing programs, specifications and proofs in an object-oriented programming environment: a case study within the FoCaLiZe environment

FoCaLiZe is an object-oriented programming environment that combines specifications, programs and proofs in the same language. This paper describes how its features can be used to formally express specifications and to develop by stepwise refinement the design and implementation of secured systems, while proving that the implementation meets its specification or design requirements. We thus obtain a modular implementation of a generic framework for the definition of security policies together with certified enforcement mechanism for these policies.

Modeling UML Template Classes with FoCaLiZe

UML is the defacto standard language to graphically describe systems in an object oriented way. Once an application has been specified, Model Driven Architecture (MDA) techniques can be applied to generate code from such specifications. Because UML lacks formal basis to analyze and check model consistency, it is pertinent to choose a formal target language (in the MDA process) to enable proofs and verification techniques. To achieve this goal, we have associated to UML the FoCaLiZe language, an object-oriented development environment using a proof-based formal approach. This paper focuses on a subset of UML constructors, the template classes. These latter allow developers to create generic models that can be instantiated for actual models through a binding relationship. Specifically, we propose a formal transformation of UML template classes annotated with OCL constraints into FoCaLiZe specification. The proposed mapping directly supports most of UML template features.

Verified Functional Iterators Using the FoCaLiZe Environment

Collections and iterators are widely used in the Object community since they are standards of the Java language. We present a certified functional implementation of collections and iterators addressing the Specification And Verification of Component Based Systems 2006 challenge. More precisely we describe a FoCaLiZe implementation providing these functionalities. Our approach uses inheritance and parameterization to describe functional iterators. Our code can be run in Ocaml and is certified using Coq. We provide general specifications for collections, iterators and removable iterators together with complete implementation for collections using lists as representation and iterators over those.