Other Past Projects

Constraints Decoupling

This work takes place in the context of research towards intelligent tools that could assist developers in the design and deployment of applications. I wrote a Prolog program that takes the UML diagram of a program, some constraints required by designers expressed as predicates, and checks if the program complies to the constraints, and if not where the violations are. This work got integrated within the Stratego software.


C Code Inliner

The input code is written in C but with some slightly different rules and some restrictions which led to call the input language "textual C".
The program takes several input code files and combines them into one single output file. This final file contains procedure code where the input files contained procedure calls.

The idea of this work was to introduce in the C language the possibilities of a special inlining. This inlining is different from the inlining found in C++ as it imposes some constraints but also allows new possibilities on the structure of the input code. It is possible for a user to write a modular code not usable for compilation with a C compiler but outputting a correct and efficient inlined code.
For example let's assume the existence of some variables in a parent code file for which we know the exact name. A parent code is some code that will call a function within the file we are writing. We know when writing our module that these variables will be properly declared in the final output code as the code will be moved to the parent code where the variables are declared. Therefore we can use in our module some declarations, locally unknown, but which will be known at the end of the process.
This is just a basic example among others but this work proved that according to some rules a lot of new code optimisations are possible. The user can write a clear modular program, as usual, and the tool is in charge of optimising the code outputted into one file without any loss of efficiency.

When I stopped working on this, more optimisations remained possible. The tool was a first prototype aiming at demonstrating the potential of the method with a proof-of-concept.

This project was proposed by the CAPS project of the IRISA-INRIA (National Institute for Research in Computer Science and Control, Rennes, France) and both supported by the IRISA and and Texas Instrument. For copyright reasons I cannot put it online.



This work was achieved in the context of the Design for Trustability approach, project directed by the IRISA-INRIA (National Institute for Research in Computer Science and Control, Rennes, France), and the VALORIA computer science laroratory (Vannes, France).

The JMutator tool was designed to test Java classes with the mutation method. This method consists in injecting errors inside a Java program, using mutants of some of its classes, and then analysing the program's behaviour at runtime when undergoing a set of tests. If the program crashes because of a no respect of a contract then the program is able to detect an internal exception. If the program does not crash it is then likely to be running with an internal error, in which case either no test case is testing the mutated code or the contracts failed to locate the error.

For a presentation of the project you can check out http://www-valoria.univ-ubs.fr/aglae/seminaires/2001/FEIT.html.
Typing "jmutator" in Google should also give a couple of pages about the tool and the mutation test method.

JMutator image

This program belongs to the IRISA and VALORIA labs. Therefore I cannot put it online.