Past Projects

WordPress (WP) PHP interference analysis

WP is one of the most popular if not the most popular Web content management software. To understand the goal, the why and where problems arise when using WP, let us go back to mid/end 2012 and consider a scenario in which a user decides to install and run a typical WP-based blog Web site which allows visitors to post and comment on pictures and picture galleries. Let us suppose the user decides to install the WP NextGEN plugin, release 1.9.3. NextGEN provides an easy-to-configure environment for managing slide shows and picture galleries. The installation task is done with a couple of mouse clicks, and the user may then create her first photo gallery by uploading a few images just to test the presentation and choose a nice page layout. Once done, she may also decide to install the WP Contact Form 7 feedback plugin and customize a feedback form. To test the form, the user may post a comment on a picture and then approve the comment. All is now ready, but before going live, she runs a scenario combining the two plugins, where she first uploads a set of different pictures into the already existing photo gallery and then mimics the behavior of a visitor commenting on pictures using the form.

Suddenly, she bumps into a strange problem: she cannot upload images any more. Unknown to her, she is experiencing a case of destructive interference between two (or more) plugins.

She remembers that before installing Contact Form 7 she was able to upload pictures. Indeed, if she removes the Contact Form 7 plugin, magically she is again able to upload pictures. However, the culprit is not actually Contact Form 7 — in fact, the problem is due to a wrong file inclusion order in the NextGEN plugin!

Unfortunately, this problem only appears if the Contact Form 7 plugin is installed and activated. For this reason, we argue, it was not immediately discovered by NextGEN developers, who might easily have attributed the problem to Contact Form 7 or other plugins with which the problem is manifested.

Here the problem is: there are about 800 include relations (excluding libraries!) in a way or the other involving the NextGen plugin. An excerpt of such include graph is shown as hierarchical graph above. Now the developer has to navigate such a graph to understand where problems arise! Alternatively, consider the organic graph view for the same plugin (left). There are a few disconnected or almost disconnected graphs thus one may wish to start eliminating those graphs. The problem is, those disconnected graphs are due to include relations dynamically defined at run-time via variables concatenation, pointers, functions and function pointers. Our goal is to provide easy means to limit the information that need to be managed and the effort to search and locate the problematic code section leading to a possible interference.

Textual information driven software quality improvement – linguistic anti-patterns

The research under this project has the long-term goal of promoting information consistency, therefore increasing software quality through the identification of textual ambiguities and inconsistencies, recommendation of improvements, and semi-automatic refactoring of textual information (including code comments and identifiers). In this program, we have developed approaches and methods to analyze linguistic information and detect inconsistencies. One of the most important results is the new family of linguistic anti-pattern. Linguistic anti-pattern are linguistic structure that impair program comprehension, and ultimately may result in more errors, higher software maintenance and evolution costs.

Error tolerant – approximated graph matching

It is difficult for developers to understand a source code of more than thousands lines of code (LOC). Moreover, it is difficult and error-prone for developers to compare two different releases of a system. Graph representations are frequently encountered in software engineering problems, for example, the relations between artifacts in a software system can be modeled as graphs. As the system evolves, its graph representations changes, nodes and edges are added, modified, or deleted. Comparing graph representations is an option but unfortunately available graph matching techniques cannot cope with large graphs. To overcome the limitations of available graph matching algorithm we developed fast, error tolerant, graph matching algorithms. Given a software system, it is represented as a family of diagrams; these in turn are mapped into graphs, costs are assigned to possible differences between two given graphs, and the goal is to retrieve the cheapest matching. We have developed MADMatch, a fast and scalable many-to-many approximate diagram matching approach based on a tabu search algorithm enhanced by the novel use of lexical and structural information. Through several case studies with different types of diagrams and tasks, we show that our generic approach obtains better results than dedicated state-of-the-art algorithms, such as AURA, PLTSDiff, or UMLDiff, on the exact same datasets used to introduce (and evaluate) these algorithms. This work was highly innovative, sonsequently, a number of papers were then published in prestigious software engineering conferences and journals, including the IEEE Transactions on Software Engineering, widely recognized as the best journal in the field, and Empirical Software Engineering Journal.

Feature location
Software evolution deals with the removal of bugs and the addition or improvement of existing features in existing software programs. In a program, a feature represents some functionality that is accessible by and visible to the developers and users. Bugs fixing can be considered the removal of unwanted features. Identifying the parts of the source code that correspond to a specific feature (or bug) is one of the most common activities undertaken by developers. We developed techniques based on the integration of static (e.g., identifiers and comments) and dynamic (e.g., trace execution) data sources to locate features (bugs) in large software systems (e.g., Eclipse). This research activity led to original and innovative feature location approaches; results have been published in prestigious software engineering conferences and journals.

Planning maintenance and changes in large software programs

This research focused on planning massive maintenance interventions in large software systems. In any maintenance project, managing the complex interactions between teams while dispatching work packages and optimizing the user’s perceived quality of service is an unsolved challenge. We initiated a research activity based on stochastic simulation, queuing networks, and genetic algorithms, to develop models and approaches to assist managers in the process of staffing and monitoring maintenance projects. This work was highly innovative, because no previous model of this kind existed, and only very partial empirical results were available in the literature. As a result, a number of papers have since been published in prestigious software engineering conferences and journals, including the IEEE Transactions on Software Engineering, and Software Practice and Experience

Traceability recovery
The IEEE glossary defines traceability as “the degree to which a relationship can be established between two or more products of the development process.” My main contributions to this research can be summarized as the original definition, development and assessment of methods to support traceability links recovery across different levels of abstraction. This work led to the publication of several papers in top conference, workshops, and also in highly rated journals. We published papers in the IEEE Transaction of Software Engineering — 770 citations, the Science of Computer Programming, Software Practice and Experience, the Empirical Software Engineering Journal and the Annals of Software Engineering. The published contributions have become a source of inspiration for other researchers.