Abstract Software process improvement requires significant effort related not only to the identification of relevant issues and providing an adequate response to them, but also to the implementation and adoption of the changes. Best practices provide recommendations to software teams on how to address identified objectives in practice, based on aggregated experience and knowledge. In the paper, we present the GÉANT SPI framework based on best practices, together with the collected experience from the process of adopting the best practices.

The assessment of software quality is one of the most multifaceted (eg, structural, product, and process quality) and subjective aspects of software engineering, as in most cases, it is substantially based on expert judgement. Such assessments can be performed at almost all phases of software development (from project inception to maintenance) and at different levels of granularity (from source code to architecture). However, human judgement is (1) inherently biased by implicit, subjective criteria applied in the evaluation process, and (2) its economical effectiveness is limited compared to automated or semi­automated approaches. For these reasons, the research community is still looking for new, more effective methods of assessing various qualitative characteristics of software systems and the related processes. In recent years, we observed a rising interest in adopting various approaches to exploiting machine learning (ML) and automated decision­making processes in several areas of software engineering. These models and algorithms help to reduce effort and risk related to human judgment in favor of automated systems, which are able to make informed decisions based on available data and evaluated with objective criteria. Thus, the adoption of machine learning techniques seems to be one of the most promising ways to improve software quality evaluation. This special issue aims at providing researchers with the possibility to spread novel ideas and methods to make machine learning actionable for the assessment of software quality artifacts and processes. The call for papers was originally published in SE­WORLD, the journal webpage, and other forums relevant to the software engineering community. We particularly encouraged the authors of papers accepted at the 2nd International Workshop on Machine Learning for Software Quality Evaluation (MaLTeSQuE 20181) to submit a revised, extended version of the workshop papers. All submitted papers went through a rigorous review process, which involved up to three internationally recognized experts of the field. This ensured rigor, novelty, and the scientific contribution expected by the Journal of Software: Evolution and Process. As a result, out of the six submitted papers, four of them were recommended for publication. It is our hope that the papers presented in this special issue will further foster the research community toward the intersection between machine learning and software quality assessment. We would like to thank the Editor­in­Chief of the Journal of Software: Evolution and Process, Professor Gerardo Canfora, for allowing us to present this special issue. We are very grateful to all our reviewers for their efforts in evaluating the submitted papers as well as for their timely and constructive reviews that have helped the authors to substantially improve the quality of their works. Finally, we would like to thank the authors who have submitted and revised their papers according to the reviewers' feedback and who have made this special issue possible.

Abstract In the paper, we present a measurement framework for evaluating quality in software products developed within the research and innovation framework project GÉANT. The proposed framework is based on the quality models by Boehm and McCall, but also addresses the presence and point of view of a third stakeholder: an external funding agency (EU), which has started and is temporally financing the project, but aims at making it self‐financing in the future. We also provide results of evaluation of 2 projects from the GÉANT ecosystem and one open‐source system with this framework.

Hierarchical software quality models usually rely on a number of metrics, which, once aggregated, provide an overview of selected perspectives of a system's quality. Missing values of some metrics, that usually result from data unavailability, can seriously affect the final score. In the paper we empirically validate a few imputation methods in context of a custom Géant-QM framework, used for evaluation of several open source systems. Early results indicate imputing a missing value based on its close neighbors as data donors introduces less noise that using a wider set of donors.

Hierarchical software quality models define different levels, at which various criteria or characteristics are evaluated. In order to combine the data from lower levels, we need an effective method of aggregation. In this paper we report observations and conclusions from applying several approaches to metric aggregation, based on data acquired from two software systems.

Anti-patterns and code smells are archetypes used for describing software design shortcomings that can negatively affect software quality, in particular maintainability. Tools, metrics and methodologies have been developed to identify these archetypes, based on the assumption that they can point at problematic code. However, recent empirical studies have shown that some of these archetypes are ubiquitous in real world programs, and many of them are found not to be as detrimental to quality as previously conjectured. We are therefore interested in revisiting common anti-patterns and code smells, and building a catalogue of cases that constitute candidates for "false positives". We propose a preliminary classification of such false positives with the aim of facilitating a better understanding of the effects of anti-patterns and code smells in practice. We hope that the development and further refinement of such a classification can support researchers and tool vendors in their endeavour to develop more pragmatic, context-relevant detection and analysis tools for anti-patterns and code smells.

The presence of anti-patterns and code smells can affect adversely software evolution and quality. Recent work has shown that code smells that appear together in the same file (i.e., collocated smells) can interact with each other, leading to various types of maintenance issues and/or to the intensification of negative effects. It has also been found that code smell interactions can occur across coupled files (i.e., coupled smells), with comparable negative effects as the interaction of same-file (collocated) smells. Different inter-smell relations have been described in previous work, yet only few studies have evaluated them empirically. This study attempts to replicate the findings from previous work on inter-smell relations by analyzing larger systems, and by including both industrial and open source ones. We also include the analysis of coupled smells in addition to collocated smells, to achieve a more complete picture of inter-smell relations. Our results suggest that if coupled smells are not considered, one may risk increasing the number of false negatives when analysing inter-smells. A major finding is that patterns of inter-smell relations vary between open source and industrial systems, suggesting that contextual variables should be considered in further studies on code smells.

There are various activities that support software maintenance. Program comprehension and detection of design anomalies and their symptoms, like code smells and anti patterns, are particularly relevant for improving the quality and facilitating evolution of a system. In this paper we describe an empirical study on the detection of code smells, aiming at identifying the most frequent smells in systems of different domains and hence the domains characterized by more smells. Moreover, we study possible correlations existing among smells and the values of a set of software quality metrics using Spearman's rank correlation and Principal Component Analysis.

Extreme programming (XP) is an agile (lightweight) software development methodology and it becomes more and more popular. XP proposes many interesting practices, but it also has some weaknesses. From the software engineering point of view the most important issues are: maintenance problems resulting from very limited documentation (XP relies on code and test cases only), and lack of wider perspective of a system to be built. Moreover, XP assumes that there is only one customer representative. In many cases there are several representatives (each one with his own view of the system and different priorities) and then some XP practices should be modified. In the paper we assess XP from two points of view: the capability maturity model and the Sommerville-Sawyer model (1997). We also propose how to introduce documented requirements to XP, how to modify the planning game to allow many customer representatives and how to get a wider perspective of a system to be built at the beginning of the project lifecycle.