(Français) Les définitions inductives, les programmes récursives, les continuations, et l’évaluation partielle

Sorry, this entry is only available in French.

Tips and Tricks for Communication in Computer Science: Reviews, Papers and Talks

When: Friday, 21st June: 14h -> 15h
Where: Salle Pleniere, Inria Building A
Who: Olivier Danvy


This lecture is mainly for PhD students who wants to think about their
communication skills.

Research results in computer science are peer-reviewed, read, and listened to.
To communicate our results, we thus need to write them down, submit
what we wrote to peer review, and present them orally.
These lectures are dedicated to
(a) criticism: how to receive and to offer reviews;
(b) the written word: how to read and to write papers; and
(c) the spoken word: how to attend and to give talks.

Suman Saha: Improving the Quality of Error-Handling Code

What: Improving the Quality of Error-Handling Code in Systems Software using Function-Local Information
Who: Suman Saha, PhD in the Inria REGAL group
When: March 12th, 11am
Where: Inria B31



Adequate error-handling code is essential to the reliability of any systems software. On an error, such code is responsible for releasing acquired resources to restore the system to a viable state. Omitting such operations leads not only to memory leaks, but also to system crashes and deadlocks.

The C language does not provide any abstractions for exception handling or other forms of error handling, leaving programmers to devise their own conventions for detecting and handling errors. The Linux coding style guidelines suggest placing error handling code at the end of each function, where it can be reached by gotos whenever an error is detected. This coding style has the advantage of putting all of the error-handling code in one place, which eases understanding and maintenance, and reduces code duplication. Nevertheless, this coding style is not always applied. In the first part of the thesis, we propose an automatic program transformation that transforms error-handling code into this style. We have implemented this algorithm as a tool and have applied this tool to five directories (drivers, fs, net, arch, and sound) in Linux 3.6 kernel source code as well as to five widely used open-source systems software projects: PostgreSQL, Apache, Wine, Python, and PHP. This tool successfully converts 22% of the conditionals containing state-restoring error-handling code that have the scope to merge code into one, from the basic strategy to the goto-based strategy.

Even when error handling code is structured according to the Linux coding style guidelines, the management of the releasing of allocated resources remains a continual problem in ensuring the robustness of systems software. Finding such faults is very challenging due to the difficulty of systematically reproducing system errors and the diversity of system resources and their associated resource release operations. To address these issues, over 10 years of research has focused on macroscopic approaches that globally scan a code base for common resource-release operations. Such approaches are notorious for their high rates of false positives, while at the same time, in practice, they leave many faults undetected.

In the second part of the thesis, we propose a novel microscopic approach to finding resource- release faults in systems software, taking into account such software’s diversity of resource types and resource-release operations. Rather than generalizing from the results of a complete scan of the source code, our approach achieves precision and scalability by focusing on the error-handling code of each function. Using a tool, Hector, that we have developed based on this approach, we have found 485 faults in 19 different C systems software projects, including Linux, Python, and Apache, with a false positive rate of 23%, well below the 30% that has been reported to be acceptable to developers. Some of these faults are exploitable by an unprivileged malicious user, making it possible to crash the entire system.

PRIME – Yet another middleware for pervasive computing

On Friday 1 March 2013, 11:00-11:45 INRIA Lille room B31 (new building), Mauro Caporuscio will give a talk on “PRIME – Yet another middleware for pervasive computing”



Computing facilities are an essential part of the fabric of our society, and an ever-increasing number of computing devices is deployed within the environment in which we live. The vision of pervasive computing is becoming real. However, to effectively exploit the opportunities offered by pervasiveness, we need to meet new requirements: (i) pervasive applications should be able to dynamically configure themselves, also benefiting from third-party functionalities discovered at run time and, (ii) pervasive applications should be aware of, and resilient to, environmental changes. To this end, the PRIME middleware leverages on REST principles to facilitate both the development and the run-time adaptation of pervasive applications. Furthermore, to deal with the high degree of dynamics inherent to pervasive environments, PRIME promotes the exploitation of Emergent Semantics as enabling technique for achieving resource discovery.

Michele Lanza: Software Visualization

What: Software Visualization: Principles, Practice, Myths, Perils, Promises, Evaluation, and all the rest
Who: Michele Lanza, Professor at the University of Lugano
When: Friday 15th February, 11h
Where: Inria B21


The title says it all: In this talk I will introduce the principles that govern software visualization, and show through a series of examples how they can be applied in practice. Furthermore I will reflect on how such research can be evaluated.


Michele Lanza is associate professor of the faculty of informatics, which he co-founded in 2004. His doctoral dissertation, completed in 2003 at the University of Bern,received the prestigious European Ernst Denert award for best thesis in software engineering of 2003. Prof. Lanza received the Credit Suisse Award for best teaching in 2007 and 2009.

At the University of Lugano Prof. Lanza leads the REVEAL research group, working in the areas of software visualization, evolution,and reverse engineering. He authored more than peer-reviewed 100 technical papers and the book “Object-Oriented Metrics in Practice”.

Prof. Lanza is involved in a number of scientific communities,and has served on more than 80 program committees. He is president of CHOOSE (the Swiss Object-Oriented Software Engineering society). He was program co-chair of ICSM (the IEEE International Conference on Software Maintenance) in 2010, of MSR (the Working Conference on Mining Software Repositories) in 2007 and 2008, of VISSOFT (the IEEE Workshop on Visualizing Software) in 2009, of IWPSE (the International Workshop on Principles of Software Evolution) in 2007. He is steering committee member of ICSM, MSR, VISSOFT, Softvis, and IWPSE. He was keynote speaker at MSR 2010 and CBSOFT 2011.

Workshop Cloud SlapOS

What: Journée Cloud SlapOS
Who: Christophe Cérin et Alain Takoudjou (Université de Paris 13, LIPN), Cédric de Saint Martin (Nexedi)
When: 11 fevrier 2013, all day (9:00-17:00)
Where: Inria Lille room B31 (new building)


Le matin (9:30 – 12:30)

>>>>> 1- Grilles de PC : histoire et projets actuels qui visent à 1) offrir un service de calcul à la demande 2) utiliser tout type de dispositif matériel (Smartphones, Tablets…) 3) déploiement et configuration sans l’aide d’un administrateur système et réseau (automatisation des tâches). Les Grilles de PC sont un fil conducteur, une étude de cas qui permet d’illustrer comment des problèmes académiques de calcul scientifique à base de volontaires peuvent être captés par SlapOS.

>>>>> 2- La vision SlapOS du cloud computing est inspirée des Grilles de PC. Principes très généraux de SlapOS. Etude de cas : intégration des principaux intergiciels de grilles de PC (Boinc, Condor, BonjourGrid). Démonstration d’un déploiement d’un projet BOINC, Condor.

L’après midi (14:00 – 17:00)

>>>>> 3- SlapOS internals : retour sur les principes de SlapOS mais avec un focus sur les applications Web en lieu et place du déploiement d’un service de calcul à la demande. Mise en oeuvre de déploiement de services KVM, WordPress…Edutes de recettes. Veuillez vous munir d’un ordinateur portable et d’une connexion Internet.

The Challenges of Cross-Language Interoperability

What: Talk on “The Challenges of Cross-Language Interoperability”
Who: David Chisnall (a Research Associate in the University of Cambridge Computer Lab)
When: Monday 4 February 2013, 14:00-15:30
Where: Inria Lille room B31 (new building)


As software becomes more complex, it becomes increasingly clear that no single language is an ideal solution for all parts of a program. The extremes range from CPU-specific assembly routines for micro-optimised hot paths to very high-level domain-specific languages for cleaner expression of application-specific ideas. At the same time, code reuse becomes increasingly important: modern applications are often over 90% shared libraries and completely implementing even comparatively simple systems without reusing any existing code is rarely economically feasible.

ArchLint: A Lightweight Approach for Architecture Conformance Based on a Combination of Static and Historical Source Code Analysis

On Friday 18 January 2013, 11:00-12:00 Inria Lille room B21 (new building), Cristiano Maffort (PhD student at Federal University of Minas Gerais, Belo Horizonte, Brazil) will give a talk on “ArchLint: A Lightweight Approach for Architecture Conformance Based on a Combination of Static and Historical Source Code Analysis”


Software architecture conformance is a key software quality control activity that aims to reveal the progressive gap normally observed between concrete and planned software architectures. Therefore, we presents ArchLint, an lightweight approach for architecture conformance based on a combination of static and historical software analysis. For this purpose, ArchLint relies on four heuristics for detecting both absences and divergences in source code based architectures. We have applied ArchLint in an industrial-strength system and as a result we have detected 119 architectural violations, with an overall precision of 46.7% and a recall of 96.2%, for divergences. We also compare ArchLint with reflexion models, a well-known model-based approach for architecture conformance. We show that ArchLint can detect more violations than reflexion models, particularly absences, using a simple high-level model that does not require successive refinements.

Few issues in the development of service oriented architectures

On Monday 28 January 2013, 11:00-11:45 INRIA Lille room B31 (new building), Franscesco Lelli (researcher at the European Research Institute in Service Science (ERISS) and adjunct professor at the University of Tilburg) will give a talk on “Few issues in the development of service oriented architectures”



This talk presents an overview of a few different aspects of today’s service development using use cases coming from high-energy physics (CMS and AGaTA), Power Grid and Smart Devices. We then focus on “interactivity” as an example of an issue that this class of use cases presents and we will advocate that we can guarantee a certain level of interactivity over unreliable medias like the Web. The talk conclude by introducing a blueprinting technique for describing cloud-based services that can serve for integrating heterogeneous applications in cloud infrastructures. Given the time, the talk introduces some socio-technical concerns regarding the development of a software artifact and advocating that the creation of a community can actively contribute to the development, thus improving the quality of the software.

Understanding Code Changes With AST Differencing

On Wednesday 12 December 2012, 9:00-9:30 INRIA Lille room B31 (new building), Jean-Rémy Falleri (Associate Professor @ ENSEIRB-MATMECA) will give a talk on “Understanding Code Changes With AST Differencing”


Finding the differences between two versions of a source code file is
a very common operation in software development. It is used in various
tasks such as performing a code review or understanding a bug fix.
Many automated tools have been introduced over the years to assist the
developers in this tedious task. For instance, \texttt{diff} is very
famous among the developers. This tool consider source code files as a
sequence of text lines and find a minimal cost edition sequence that
transform a sequence into another. The actions are: insert a line,
delete a line and update a line.

diff is very useful: it works without any adaptation on any
textual programming language. Nevertheless, its limitation is very
obvious: a source code is not really a sequence of lines, it always
has a tree structure, usually called abstract syntax tree (AST). Many
approaches have adapted the idea of textual differencing to trees.
These approaches find an minimal cost edition sequence between two
trees. The editing actions on a tree are: insert a node, delete a node
and update the label of a node.

Unfortunately, the best known algorithms to find such a sequence have
a $O(n^3)$ time complexity (n beeing the number of nodes), which is
expensive for real world ASTs that contain more than tens of thousands
nodes. More importantly, these approaches do not take into account a
very frequent edit action used in software development: moving a node.
If this action is taken into account, the problem of finding an
minimal cost edition sequence is NP-hard. AST differencing including
moves requires therefore good heuristics to be used in practice.

AST differencing including move actions has not been investigated a
lot. The main approaches in the literature are either language
specifics and/or does not work on raw ASTs and/or have not been
empirically validated. We propose a novel algorithm that computes an
edition sequence between two ASTs including move actions. This
algorithm is very fast and works on raw ASTs with almost no