Subobject-oriented programming: diamonds are forever

Who: Marko van Dooren
When: Tuesday the 16th, 14h.
Where: B31.
What: Subobject-oriented programming: diamonds are forever

Classes are fundamental elements in object-oriented programming, but they cannot easily be assembled from other classes. As a result, many code patterns such as associations, graph structures, and so forth are duplicated over and over again. Subobject-oriented programming overcomes this problem by augmenting object-oriented programming with subobjects. Subobjects can be used as buildings blocks to configure and compose classes without suffering from name conflicts. By relieving the subclassing relation from its duty as a pure code reuse mechanism, subobjects solve the diamond problem that has plagued object-oriented programming for decades.

Subobject-oriented programming has previously been implemented as a language extension to Java with Eclipse support and as a library in Python. Currently, we are moving away from using Java as the host language and instead using more ideas from Eiffel and Smalltalk.

In this talk, I will give an introduction to subobject-oriented programming and present the latest developments and the roadmap for the future. In particular, we want to remove fields from the language turn individual methods into subobjects. Combined with a mechanism similar to family polymorphism, this should e.g. allow any subobject-oriented program to be turned into a distributed program with little to no modifications to the original source code.


Marko van Dooren is a guest professor at the department of Applied Mathematics, Informatics, and Statistics at the University of Ghent. He leads the programming language research group and teaches courses on object-oriented programming, basic logic, type systems, and leads the final software development project of the bachelor in Informatics. Marko obtained his PhD at KU Leuven in 2007. His research mainly focuses on object-oriented programming languages and more in particular the subobject-oriented programming paradigm. To simplify experimentation with new language concepts he developed the Chameleon framework for modelling software languages and language independent programming tools.

Software Engineering Day 2015

Who: The Software Engineering research theme from the CRIStAL laboratory
When: Thursday 28 May 2015
Where: Polytech Lille, Amphi Appert

09:00 – 09:15 Intro (Lionel Seinturier)
09:15 – 10:00 Template Based MDE – Matthieu Allon (Caramel)
10:00 – 10:45 Présentation Carbon – Jean-Claude Tarby, Cédric Dumoulin (Carbon)

11:00 – 11:45 Software Product Lines for Automatic Multi-Cloud Configuration – Gustavo Sousa (Spirals)
11:45 – 12:30 An Experimental Protocol for Analyzing the Accuracy of Software Error Impact Analysis – Vincenzo Musco (Spirals)

14:00 – 14:45 Secure Reflection – Camille Teruel (Rmod)
14:45 – 15:15 Supporting Software Integration Activities with Fine-grained Code Changes – Martin Dias (Rmod)

15:30 – 16:15 Systematic Source Code Transformations – Gustavo Santos (Rmod)

Pharo tools for cross-platform development and building GUIs

Who: Alain Plantec & Glenn Cavarle
When: Tuesday 2nd June, 13h30
Where: B11

Dali is a framework prototype for cross-platform development implemented in Pharo. It is based on Software Product Line and Model Driven Engineering to design, simulate and product softwares for several target platforms. This presentation shows the current state of Dali and the progress of experiments conducted in the domains of models execution and of the GUI simulation.

Bloc is a redesign of the Morphic graphics system. It’s the new building bloc of all Pharo’s future tools

Extracting functional features from legacy Java code by Hafedh Mili (UQAM)

Thursday at 10h30 Hafedh Mili from the Université du Quèbec à Montreal (UQAM) will give a talk on extracting functional features from Java legacy code. The talk will be held in B31 at the Inria Lille.

Summary: Typical OO applications implement several functional features that are interwoven into the same class hiererachies. In the absence of aspect-oriented techniques to develop and compose functionalities, developers resort to object-oriented design and programming idioms. Given a legacy OO application, it pays to identify existing functional features to help understand the structure of the application and potentially to extract those featues into separate software modules that can be maintained and reused individually. We are interested in the extraction and repackaging of functional features. We first characterize what we mean by functional feature, and then explore the properties that such features are likely to exhibit in a legacy application that integrates many of them. Next, we present algorithms for extracting such features, and the preliminary results we obtained. We conclude by discussing directions for future research.

All things I don’t know about model-driven engineering (and Software Engineering!)

Title: All things I don’t know about model-driven engineering (and Software Engineering!)
Who: Jordi Cabot, Ecole des Mines de Nantes –
When: Friday March 27th 2015, 03:00 PM
Where: Board Room, Extension-M3, LIFL

Abstract: In this talk I’ll give an overview of the research lines we’re working on in my team ranging from “Research in MDE” topics like formal model verification , scalable model persistence, distributed transformations, collaborative DSLs,… to “Research by MDE” (using MDE techniques to attack SE problems) such as security network analysis, mining of OSS projects or bringing politics into software development. In each of them I’ll try to focus on the things that we don’t know. Who knows? Maybe you can help me answer them!

Memory and test visualization

What: Memory and test visualization
Who: Alexandre Bergel, full-time Assistant Professor at the University of Chile, co-founder of Object Profile
When: Tuesday, 16th of December, 14:30
Where: Inria, Lille B31

This talk will present the latest advances by the Object Profile company and Pleiad laboratory, from the University of Chile, in the field of memory and test visualization.
Three different but complementary topics will be addressed.

1 – memory profiling
Memory blueprint visually reports the memory consumption of a program execution. A number of simple visual cues are provided to identify direct and indirect object production sites, key ingredients to efficiently address memory issues. Scalability is addressed by restricting the scope of interest both in the call graph and the considered classes.

2 – test coverage
By relating execution and complexity metrics, we have identified five essential patterns to characterize the test coverage of a group of methods. Each pattern has an associated action to increase the test coverage, and these actions differ in their effectiveness. We empirically determined the optimal sequence of actions to obtain the highest coverage with a minimum number of tests. We present test blueprint, a visual tool to help practitioners assess and increase test coverage by graphically relating execution and complexity metrics.

3 – agile data visualization
Roassal is an agile visualization engine. Roassal graphically renders objects using short and expressive Smalltalk expressions. A large set of interaction facilities are provided for a better user experience. Painting, brushing, interconnecting, zooming, drag and dropping will just make you more intimate with any arbitrary object model. Roassal is used in dozen of commercial or open source projects.

Behavioral interpretation of resilience for systems and ambients

Who: Vincenzo De Florio, University of Antwerpen –
When: Friday November 14th 2014, 11:00 AM
Where: Meeting room B31, Building B (3rd floor), Inria Lille

Abstract: Vincenzo will discuss resilience as the behavior resulting from the coupling of a system and its environment(s). Depending on the interactions between these two “ends” and on the quality of the individual behaviors that they may exercise, different strategies may be chosen: elasticity (change masking); entelechism (change tolerance); and antifragility (adapting to & learning from change). When the environment is very simple and only capable of so-called “random behavior”, often the only effective strategy towards resilience is off-line dimensioning of redundancy as a result of a worst-case assessment of disturbances and/or threats. Much more complex and variegated is the case when both systems and environments are “intelligent” — or at least able to exercise complex teleological and extrapolatory behaviors. In this case both system and ambient may choose among a variety of strategies in what could be regarded as a complex evolutionary game theory setting.

Specification and Detection of SOA Antipatterns

Who: Francis Palma, PhD student @ UQAM (Canada) –

When: Wednesday 29th October 2014, 10:00 AM

Where: Meeting room B31, Building B (3rd floor), Inria

Title: Specification and Detection of SOA Antipatterns

Abstract: Service-based systems (SBSs), like any other complex systems, are subject to change. Changes can be functional (i.e., user requirements) or non-functional (i.e., network protocol, organisations data security and business policy, and service-level agreements) and can be at different levels (i.e., design or implementation) that take place during the software evolution and maintenance phases. These changes may cause degradation of design and quality of service (QoS) when they involve poor solutions, commonly known as antipatterns, in opposition to design patterns, which are good solutions to recurring design problems. Antipatterns in SBSs are commonly referred to as SOA (Service Oriented Architecture) antipatterns. The presence of SOA antipatterns in SBSs may (i) result in poor design and QoS and (ii) impact future maintenance and evolution. Therefore, detecting SOA antipatterns deserves attention for assessing the design and QoS of SBSs. Also, this detection may facilitate the future evolution and maintenance of an SBS. Yet, despite of their importance, there are no dedicated methods and techniques for specifying and detecting SOA antipatterns. Our aims are: (1) to propose a novel approach for the specification and detection of SOA antipatterns, (2) an empirical study showing the impact of SOA antipatterns in SBSs, and (3) a dedicated framework supporting specification and detection of SOA anti patterns.

Assessing and Improving Rules to Support Software Evolution

What: PhD defense
Who: André Cavalcante Hora
When: Tuesday, 4th November 2014, 10h00
Where: Amphi de l’IRCICA

Software systems evolve by adding new features, fixing bugs or refactoring existing source code. During this process, some problems may occur (e.g., backward-incompatibility, missing or unclear method deprecation) causing evolving systems and their clients to be inconsistent or to fail, decreasing code quality. As nowadays software systems are frequently part of bigger ecosystems, such problems are even harder to handle because the impact may be large and unknown.
One solution to deal with such maintainability problems is the usage of rules to ensure consistency. These rules may be created by experts or extracted from source code repositories, which are commonly evaluated in small-scale case studies. We argue that existing approaches lack of: (i) a deep understanding of the benefits provided by expert-based rules, (ii) a better use of source code repositories to extract history-based rules, and (iii) a large-scale analysis of the impact of source code evolution on the actual clients.
In this thesis we propose to analyze and improve rules to better support developers keeping track of source code evolution. We cover three aspects:
• The benefits provided by expert-based rules: we report on an investigation of rules created based on expert opinion to understand whether they are worthwhile to be adopted given the cost to produce them.
• The improvement of history-based rules: we propose two solutions to extract better rules from source code history.
• The impact of source code evolution on a software ecosystem: we undergo an investigation, in a large-scale ecosystem, on the awareness of the client systems about source code evolution.
We evaluated the proposed approaches qualitatively and quantitatively in real-world case studies, and, in many cases, with the help of experts on the system under analysis. The results we obtained demonstrate the usefulness of our approaches.

Learning to Combine Multiple Ranking Metrics for Fault Localization

Talk: Learning to Combine Multiple Ranking Metrics for Fault Localization
Who: Jifeng Xuan, postdoc Inria Lille, équipe Spirals
When: September 26th, 2014, 11:00
Where: Inria Lille, B11,

Abstract: Fault localization is an inevitable step in software debugging. Spectrum-based fault localization consists in computing a ranking metric on execution traces to identify faulty source code. Existing empirical studies on fault localization show that there is no optimal ranking metric for all faults in practice. In this paper, we propose Multric, a learning-based approach to combining multiple ranking metrics for effective fault localization. In Multric, a suspiciousness score of a program entity is a combination of existing ranking metrics. Multric consists two major phases: learning and ranking. Based on training faults, Multric builds a ranking model by learning from pairs of faulty and non-faulty source code elements. When a new fault appears, Multric computes the final ranking with the learned model. Experiments are conducted on 5386 seeded faults in ten open-source Java programs. We empirically compare Multric against four widely-studied metrics and three recently-proposed one. Our experimental results show that Multric localizes faults more effectively than state-of-art metrics, such as Tarantula, Ochiai, and Ample.