In this paper, we conduct an empirical study aiming at investigating how personality traits can affect the productivity of software developers in the context of the distributed development of multi-platform apps within a software project stored in GitHub. Participants were 31 master’s students in Computer Science grouped in 13 teams. Data were gathered from the compilation of the IPIP-NEO-120 questionnaire, a largely adopted tool to estimate personality traits, and from the software projects. We analyzed the correlation between personality traits (and their facets) and the productivity metrics. The results of this preliminary study seem to reveal that the most productive participants are those with the highest scores for the personality traits of Agreeableness and Conscientiousness.

GitHub currently hosts more than 100 million public repositories. This has made it very popular to conduct Mining Software Repositories (MSR) studies. Researchers have been exploiting the information stored in GitHub (e.g., commits, pull requests, or issues) to investigate both developer- and project-related aspects. GitHub provides the REST API to make queries without cloning repositories. In this tool-demo paper, we highlight some issues we noticed when conducting an MSR study on GitHub by using the REST API and present G-Repo: a tool developed to support researchers when tackling these issues able to ease the creation of datasets for MSR studies. Also, we provide a manually-annotated dataset with information about the kind and the (spoken) languages of 1,500 repositories hosted on GitHub. A video showing the functioning of G-Repo is available at: https://youtu.be/mb9CIALBFZk.

Researchers in the field of Software Fault Prediction (SFP) make use of software metrics to build predictive models, for example, by means of machine learning and statistical techniques. The number of metrics used for SFP has increased dramatically in the last few decades. Therefore, a taxonomy of metrics for SFP could be useful to standardize the lexicon, to simplify the communication among researchers/practitioners, and to organize and classify such metrics. In this research, we built a taxonomy of metrics for SFP with the aim of making it as comprehensive as possible. We exploited and extended two Systematic Literature Reviews (SLRs) to collect and classify a total of 512 metrics for SFP and then to build our taxonomy. We also provide information on the metrics in this taxonomy in terms of: acronym(s), extended name, description, granularity of the prediction, category, and research papers in which they were used. To allow the taxonomy to be constantly updated over time, we provide external contributors the possibility to ask for changes via pull-requests on GitHub.

Knowledge transfer is one of the main goals of modern code review, as shown by several studies that surveyed and interviewed developers. While knowledge transfer is a clear expectation of the code review process, there are no analytical studies using data mined from software repositories to assess the effectiveness of code review in "training" developers and improve their skills over time. We present a mining-based study investigating how and whether the code review process helps developers to improve their contributions to open source projects over time. We analyze 32,062 peer-reviewed pull requests (PRs) made across 4,981 GitHub repositories by 728 developers who created their GitHub account in 2015. We assume that PRs performed in the past by a developer D that have been subject to a code review process have "transferred knowledge" to D. Then, we verify if over time (i.e., when more and more reviewed PRs are made by D), the quality of the contributions made by D to open source projects increases (as assessed by proxies we defined, such as the acceptance of PRs, or the polarity of the sentiment in the review comments left for the submitted PRs). With the above measures, we were unable to capture the positive impact played by the code review process on the quality of developers' contributions. This might be due to several factors, including the choices we made in our experimental design.Additional investigations are needed to confirm or contradict such a negative result.

When committing source code in a Version Control System (VCS) as a consequence of a bug fixing task, a good practice should consist in writing a message that shortly explains how the bug has been fixed. In this paper, we empirically assess a heuristic based on the presence of keywords in developers' commit messages, while uploading their changes to source code classes on GitHub. A class is fault-prone if it is involved in a commit, whose message contains keywords that are related to bug-fixing tasks. After having analyzed all the commits between two consecutive releases of a software project, a class is labeled with the number of how many bug-fixing commits in which it was involved. We assessed whether our heuristic can be used to support the human annotating activity, by comparing the number of bugs provided by the popularity dataset of the PROMISE research repository with the one estimated through such heuristic. We considered the identification of (i) faulty source code classes (i.e., a class is faulty if it contains at least one fault) and (ii) the number of faults in source code classes. The average accuracy (i.e., the number of classes correctly identified as either faulty or not over the total number of classes) of our approach is 71%. As for the number of faults in source code classes, the concordance (i.e., the number of classes on which the heuristic correctly identifies the number of faults over the total number of classes) is 62% on average. Our proposal might support, but not replace, annotating activities when building datasets for fault prediction.

In the field of Software Fault Prediction (SFP), researchers exploit software metrics to build predictive models using machine learning and/or statistical techniques. SFP has existed for several decades and the number of metrics used has increased dramatically. Thus, the need for a taxonomy of metrics for SFP arises firstly to standardize the lexicon used in this field so that the communication among researchers is simplified and then to organize and systematically classify the used metrics. In this doctoral symposium paper, I present my ongoing work which aims not only to build such a taxonomy as comprehensive as possible, but also to provide a global understanding of the metrics for SFP in terms of detailed information: acronym(s), extended name, univocal description, granularity of the fault prediction (e.g., method and class), category, and research papers in which they were used.

We present a new metaphor that takes advantages of concepts such as archipelagos, atolls, and palms. Each package of a software system is represented as an atoll that maintainers can navigate and interact with. Atolls that form an archipelago represent the entire system. Maintainers can pass from an atoll to another one, so understanding how the entire software and its packages are related with one another. Palms on an atoll graphically depict salient information of the classes contained in the package associated to that atoll. The metaphor has been implemented as a 3D interactive environment tool to allow a fine- and large-grained understanding of a subject software system implemented in Java. Finally, we have used our 3D environment on a number of open-source object-oriented software systems and the obtained results are preliminarily presented in this paper.