Jean-Rémy Falleri

Efficient retrieval and ranking of undesired package cycles in large software systems

Many design guidelines state that a software system architecture should avoid cycles between its packages. Yet such cycles appear again and again in many programs. We believe that the existing approaches for cycle detection are too coarse to assist the developers to remove cycles from their programs. In this paper, we describe an efficient algorithm that performs a fine-grained analysis of the cycles among the packages of an application. In addition, we define a metric to rank cycles by their level of undesirability, prioritizing the cycles that seems the more undesired by the developers. Our approach is validated on two large and mature software systems in Java and Smalltalk.

Impact of developer turnover on quality in open-source software

Turnover is the phenomenon of continuous influx and retreat of human resources in a team. Despite being well-studied in many settings, turnover has not been characterized for open-source software projects. We study the source code repositories of five open-source projects to characterize patterns of turnover and to determine the effects of turnover on software quality. We define the base concepts of both external and internal turnover, which are the mobility of developers in and out of a project, and the mobility of developers inside a project, respectively. We provide a qualitative analysis of turnover patterns. We also found, in a quantitative analysis, that the activity of external newcomers negatively impact software quality.

Code ownership in open-source software

Context: Ownership metrics measure how the workload of software modules is shared among their developers. They have been shown to be accurate indicators of software quality. Objective: Since ownership metrics studies were done only on industrial software projects, we replicated such a study on Java free/libre and open source software (FLOSS) projects. Our goal was to generalize an ownership law that stated that minor developers should be avoided. Method: We explored the relationship between ownership metrics and fault-proneness on seven FLOSS projects, using publicly available corpora to retrieve the fault-related information. Results: In our corpus, the relationship between ownership metrics and module faults is weak. At best, less than half of projects exhibit a significant correlation, and at worst, no projects at all. Moreover, fault-proneness seems to be much more influenced by module size than by ownership. Conclusion: The results of ownership studies done on closed-source projects do not generalize to FLOSS projects. To understand the reasons for that, we performed an in-depth analysis and found that the lack of correlation between ownership metrics and module faults is due to the distributions of contributions among developers and the presence of heroes in FLOSS projects.

Computing contextual metric thresholds

Software metrics have been developed to measure the quality of software systems. A proper use of metrics requires thresholds to determine whether the value of a metric is acceptable or not. Many approaches propose to define thresholds based on large analyses of software systems. However it has been shown that thresholds depend greatly on the context of the project. Thus there is a need for an approach that computes thresholds by taking into account this context. In this paper we propose such approach with the objective to reach a trade-off between representativeness of the threshold and computation cost. Our approach is based on an unbiased selection of software entities and makes no assumptions on the statistical properties of the software metrics values. It can therefore be used by anyone, ranging from developer to manager, for computing a representative metric threshold tailored to their context.

Easing model transformation learning with automatically aligned examples

Model Based Transformation Example (MTBE) is a recent track of research aiming at learning a transformation from examples. In most MTBE processes, a transformation example is given in the form of a source model, a transformed model and links between source elements and the corresponding transformed elements. Building the links is done manually, which is a tedious task, while in many cases, they can be deduced from the examination of the source and transformed models, by using relevant attributes, like names or identifiers. We exploit this characteristic by proposing a semi-automatic matching operation, suitable for discovering matches between the source model and the transformed model. Our technique is inspired by and extends the Anchor-Prompt approach, and is based on the automatic discovery of pairs of anchors (pairs of elements for which there is a strong assumption of matching) to support the whole matching discovery. An implementation of the approach is provided for validation on a case study.

Efficient Retrieval and Ranking of Undesired Package Cycles in Large Software Systems

Many design guidelines state that a software system architecture should avoid cycles between its packages. Yet such cycles appear again and again in many programs. We believe that the existing approaches for cycle detection are too coarse to assist developers to remove cycles from their programs. In this paper, we describe an efficient algorithm that performs a fine-grained analysis of cycles among application packages. In addition, we define multiple metrics to rank cycles by their level of undesirability, prioritizing cycles that are the more undesired by developers. We compare these multiple ranking metrics on four large and mature software systems in Java and Smalltalk.

Circular dependencies and change-proneness: An empirical study

Advice that circular dependencies between programming artefacts should be avoided goes back to the earliest work on software design, and is well-established and rarely questioned. However, empirical studies have shown that real-world (Java) programs are riddled with circular dependencies between artefacts on different levels of abstraction and aggregation. It has been suggested that additional heuristics could be used to distinguish between bad and harmless cycles, for instances by relating them to the hierarchical structure of the packages within a program, or to violations of additional design principles. In this study, we try to explore this question further by analysing the relationship between different kinds of circular dependencies between Java classes, and their change frequency. We find that (1) the presence of cycles can have a significant impact on the change proneness of the classes near these cycles and (2) neither subtype knowledge nor the location of the cycle within the package containment tree are suitable criteria to distinguish between critical and harmless cycles.

An empirical assessment of Bellon's clone benchmark

Context: Clone benchmarks are essential to the assessment and improvement of clone detection tools and algorithms. Among existing benchmarks, Bellons benchmark is widely used by the research community. However, a serious threat to the validity of this benchmark is that reference clones it contains have been manually validated by Bellon alone. Other persons may disagree with Bellons judgment. Objective: In this paper, we perform an empirical assessment of Bellons benchmark. Method: We seek the opinion of eighteen participants on a subset of Bellons benchmark to determine if researchers should trust the reference clones it contains. Results: Our experiment shows that a significant amount of the reference clones are debatable, and this phenomenon can introduce noise in results obtained using this benchmark.

Typhoon: a middleware for epidemic propagation of software updates

Applications for mobiles devices are subject to very frequent updates for fixing security vulnerabilities, ensuring compatibility with new hardware and APIs or enhancing functionalities. Getting the new version of an application involves the download of a significant amount of data, which is not practical through low-bandwidth/high-cost links. As a consequence, mobile device users often fail to update their applications.n This paper introduces a collaborative and epidemic updating scheme to improve software updates distribution. In our approach, updates are distributed by the surrounding devices, eliminating the need for costly resources. Moreover, the packaging of these updates, which consists in delivering binary patches of the difference with a previous version, dramatically reduces the amount of data to download.n Preliminary experimental results based on real contact traces show that our approach offers an efficient selection and recovery of patches, ensuring a fast update for each participating device.

Automated Generation of REST API Specification from Plain HTML Documentation

REST is nowadays highly popular and widely adopted by Web services providers. However, most of the Web services providers only provide the documentation of their REST API in plain HTML pages, even if many specification formats exist such as WADL or OpenAPI for example. This prevents the Web Services users to benefit from all the advantages of having a machine-readable specification, such as generating client or server code, generating web services composition, checking formal properties, testing, etc. To face this issue, we provide a fully automated approach that builds a REST API specification from its corresponding plain HTML documentation. By given the root URL of the plain HTML API documentation, our approach automatically extracts the four mandatory parts that compose a specification: the base URL, the path templates, the HTTP verbs and the associated formal parameters. Our approach has been validated with topmost commercial REST based Web Services, and the validation shows that our approach achieves good precision and recall for popular Web Services.