Large-scale Open Source Software Research Articles

Don’t forget to change these functions! recommending co-changed functions in modern code review

Context:Code review is effective and widely used, yet still time-consuming. Especially, in large-scale software systems, developers may forget to change other related functions that must be changed together (aka. co-changes). This may increase the number of review iterations and reviewing time, thus delaying the code review process. Based on our analysis of 66 projects from five open-source systems, we find that there are 16%–33% of code reviews where at least one function must be co-changed, but was not initially changed. Objectives:This study aims to propose an approach to recommend co-changed functions in the context of modern code review, which could reduce reviewing time and iterations and help developers identify functions that need to be changed together. Methods:We propose CoChangeFinder, a novel method that employs a Graph Neural Network (GNN) to recommend co-changed functions for newly submitted code changes. Then, we conduct a quantitative and qualitative evaluation of CoChangeFinder with 66 studied large-scale open-source software projects. Results:Our evaluation results show that our CoChangeFinder outperforms the state-of-the-art approach, achieving 3.44% to 40.45% for top-k accuracy, 2.00% to 26.07% for Recall@k, and 0.04 to 0.21 for mean average precision better than the baseline approach. In addition, our CoChangeFinder demonstrates the capacity to pinpoint the functions related to logic changes. Conclusion:Our CoChangeFinder outperforms the baseline approach (i.e., TARMAQ) in recommending co-changed functions during the code review process. Based on our findings, CoChangeFinder could help developers save their time and effort, reduce review iterations, and enhance the efficiency of the code review process.

A Method of OSS Reliability Assessment Based on Public Repository Analysis

Open Source Software (OSS) is developed by various developers. Moreover, OSS user is increasing all over the world. There are various methods to maintain the software. Large-scale OSS projects mainly use bug tracking system (BTS) for bug management. Recently, OSS project uses public software repository to publish software such as GitHub. Public software repository has a function to report software issue. In the past, several researchers have proposed reliability assessment method using BTS. In this research, we propose a reliability assessment method based on deep learning using software repository analysis.

A Cross-Level Requirement Trace Link Update Model Based on Bidirectional Encoder Representations from Transformers

Cross-level requirement trace links (i.e., links between high-level requirements (HLRs) and low-level requirements (LLRs)) record the top-down decomposition process of requirements and support various development and management activities (e.g., requirement validation). Undoubtedly, updating trace links synchronously with requirement changes is critical for their constant availability. However, large-scale open-source software that is rapidly iterative and continually released has numerous requirements that are dynamic. These requirements render timely update of trace links challenging. To address these problems, in this study, a novel deep-learning-based method, deep requirement trace analyzer fusing heterogeneous features (DRAFT), was proposed for updating trace links between various levels of requirements. Considering both the semantic information of requirement text descriptions and the process features based on metadata, trace link data accumulated in the early stage are comprehensively used to train the trace link identification model. Particularly, first, we performed second-phase pre-training for the bidirectional encoder representations from transformers (BERT) language model based on the project document corpus to realize project-related knowledge transfer, which yields superior text embedding. Second, we designed 11 heuristic features based on the requirement metadata in the open-source system. Based on these features and semantic similarity between HLRs and LLRs, we designed a cross-level requirement tracing model for new requirements. The superiority of DRAFT was verified based on the requirement datasets of eight open-source projects. The average F1 and F2 scores of DRAFT were 69.3% and 76.9%, respectively, which were 16.5% and 22.3% higher than baselines. An ablation experiment proved the positive role of two key steps in trace link construction.

Commercial Participation in OpenStack: Two Sides of a Coin

This article provides a landscape of commercial participation in OpenStack, a large-scale open source software (OSS) ecosystem. We discuss how to achieve a balance between maximizing business profit and ensuring the long-term sustainability of OSS ecosystems.

A study of quality prediction for large-scale open source software projects

Open source software (OSS) has seen remarkable progress in recent years. Moreover, OSS usage in corporate information systems has been increasing steadily; consequently, the overall impact of OSS on the society is increasing as well. While product quality of enterprise software is assured by the provider, the deliverables of an OSS are developed by the OSS developer community; therefore, their quality is not guaranteed. Thus, the objective of this study is to build an artificial-intelligence-based quality prediction model that corporate businesses could use for decision-making to determine whether a desired OSS should be adopted. We define the quality of an OSS as “the resolution rate of issues processed by OSS developers as well as the promptness and continuity of doing so.” We selected 44 large-scale OSS projects from GitHub for our quality analysis. First, we investigated the monthly changes in the status of issue creation and resolution for each project. It was found that there are three different patterns in the increase of issue creation, and three patterns in the relationship between the increase in issue creation and that of resolution. It was confirmed that there are multiple cases of each pattern that affect the final resolution rate. Next, we investigated the correlation between the final resolution rate and that for a relevant number of months after issue creation. We deduced that the correlation coefficient even between the resolution rate in the first month and the final rate exceeded 0.5. Based on these analysis results, we conclude that the issue resolution rate in the first month once an issue is created is applicable as knowledge for knowledge-based AI systems that can be used to assist in decision-making regarding OSS adoption in business projects.

On the fulfillment of coordination requirements in open-source software projects: An exploratory study

In large-scale open-source software projects, where developers are often distributed across the entire planet, coordination among developers is crucial. To estimate whether a state of socio-technical congruence is achieved, which is associated with software quality and project success, we assess the alignment of collaboration and communication in such software projects in terms of coordination requirements. By means of an empirical study on a substantial set of large-scale open-source software projects—the development histories of all projects sum up to over 180 years—we aim at shedding light on this issue. To this end, to take a more semantic view on this phenomenon in comparison to previous work, we do not only identify coordination requirements arising from files and functions only, but also those arising from features. We found that open-source developers fulfill coordination requirements intentionally, but mostly those coordination requirements that arise from coupled source-code artifacts, while they resolve simpler ones independently. Furthermore, neither of the considered abstraction levels of source-code artifacts (files, functions, features) is more suitable to construct coordination requirements with respect to their fulfillment. This finding strongly indicates that features do not play an as important role in the development process as expected and commonly believed by the research community in the area of feature-oriented and feature-driven development. Finally, we identified notable evolutionary trends in the fulfillment of coordination requirements and showed that far-reaching social events (such as organizational issues) have a huge impact on their fulfillment, both negatively and positively. The key findings of our empirical study are that socio-technical relations are important to understand open-source development communities and that the incorporation of different abstraction levels for developer collaboration does yield important insights to further improve the evolution in open-source software projects.

A Study of Quality Indicator Model of Large-Scale Open Source Software Projects for Adoption Decision-making

Abstract Open source software (OSS) usage in information systems has been essential. As OSSs are deliverables of the developer community, their quality is not guaranteed. The corporate user adopting the OSS is responsible for its quality. Thus, it is desirable to have information that the corporate could use for quantitatively assessing whether an OSS should be adopted before discussing its detailed contents thoroughly. The objective of this study is to propose an OSS quality indicator model and assessment method by monitoring the status of member raised created and closed issue sessions in the community. The proposed method is based on two axes. First, the trends are summarized in three categories, “Linear,” “Logarithmic curve,” and “Cubic curve,” with thresholds. Next, the deviation timing between the number of created and closed cases is summarized in three stages, “Early,” “Middle,” and “Late.” We attempt to improve the understanding by examining 39 large-scale OSS projects from GitHub. We derived the “T-model” as a quality indicator for OSS adoption decision-making. Assessing only these quantitative evaluations, we can see that the projects in the “Late” horizontal axis and the “Logarithm” vertical axis maintain adequate quality that can be sufficiently used for system development. Based on these results, we conclude that the T-model has shown the possibility of a quick evaluation of whether to adopt the desired OSS for corporate information system.

Open collaborative writing with Manubot.

Open, collaborative research is a powerful paradigm that can immensely strengthen the scientific process by integrating broad and diverse expertise. However, traditional research and multi-author writing processes break down at scale. We present new software named Manubot, available at https://manubot.org, to address the challenges of open scholarly writing. Manubot adopts the contribution workflow used by many large-scale open source software projects to enable collaborative authoring of scholarly manuscripts. With Manubot, manuscripts are written in Markdown and stored in a Git repository to precisely track changes over time. By hosting manuscript repositories publicly, such as on GitHub, multiple authors can simultaneously propose and review changes. A cloud service automatically evaluates proposed changes to catch errors. Publication with Manubot is continuous: When a manuscript’s source changes, the rendered outputs are rebuilt and republished to a web page. Manubot automates bibliographic tasks by implementing citation by identifier, where users cite persistent identifiers (e.g. DOIs, PubMed IDs, ISBNs, URLs), whose metadata is then retrieved and converted to a user-specified style. Manubot modernizes publishing to align with the ideals of open science by making it transparent, reproducible, immediate, versioned, collaborative, and free of charge.

Extracting and studying the Logging-Code-Issue- Introducing changes in Java-based large-scale open source software systems

Execution logs, which are generated by logging code, are widely used in modern software projects for tasks like monitoring, debugging, and remote issue resolution. Ineffective logging would cause confusion, lack of information during problem diagnosis, or even system crash. However, it is challenging to develop and maintain logging code, as it inter-mixes with the feature code. Furthermore, unlike feature code, it is very challenging to verify the correctness of logging code. Currently developers usually rely on their intuition when performing their logging activities. There are no well established logging guidelines in research and practice. In this paper, we intend to derive such guidelines through mining the historical logging code changes. In particular, we have extracted and studied the Logging-Code-Issue-Introducing (LCII) changes in six popular large-scale Java-based open source software systems. Preliminary studies on this dataset show that: (1) both co-changed and independently changed logging code changes can contain fixes to the LCII changes; (2) the complexity of fixes to LCII changes are similar to regular logging code updates; (3) it takes longer for developers to fix logging code issues than regular bugs; and (4) the state-of-the-art logging code issue detection tools can only detect a small fraction (3%) of the LCII changes. This highlights the urgent need for this area of research and the importance of such a dataset.

A Study of Measurement for Development Efficiency in Large Scale Open Source Software Projects

A Study of Measurement for Development Efficiency in Large Scale Open Source Software Projects

Taming of ‘Openness' in Software Innovation Systems

In large-scale open source software (OSS) innovation ecosystems that incorporate firms, a variety of measures are taken to tame the potentially chaotic activities and align the contributions of various participants with the strategic priorities of major stakeholders. Such taming rests on the dual desires of this emergent community of firms to unleash the innovation potential of OSS and to drive it to a certain direction, and it emerges in the form of various organizational activities. By drawing on a sample of large-scale OSS ecosystems, the authors discuss that methods employed for taming are isomorphic, and overview the emerging strategic pattern for establishing systems of innovation. This pattern involves a related set of practices to balance virtues of OSS community while introducing corporate discipline. In contrast to approaches such as open innovation, which favor isolated reasoning, they present a systemic and historical perspective to explain the continuum in emergence and establishment of strategic patterns.

Leveraging topic modeling and part-of-speech tagging to support combinational creativity in requirements engineering

Requirements engineering (RE), framed as a creative problem solving process, plays a key role in innovating more useful and novel requirements and improving a software system's sustainability. Existing approaches, such as creativity workshops and feature mining from web services, facilitate creativity by exploring a search space of partial and complete possibilities of requirements . To further advance the literature, we study creativity from a combinational perspective, i.e., making unfamiliar connections between familiar possibilities of requirements. In particular, we propose a novel framework that extracts familiar ideas from the requirements and stakeholders' comments using topic modeling, and automatically generates requirements by obtaining unfamiliar idea combinations by means of flipping the part-of-speech of identified topics. We apply our framework on two large-scale open-source software systems (Firefox and Mylyn) and report two studies to assess the viability of combinational creativity in RE. The results show that the creativity merit of requirements generated by our framework judged by human experts is comparable to that of requirements created manually. Meanwhile, the cost of our framework is significantly less than manual work, measured by time spent generating requirements. Our work illuminates a possible improvement toward interactive generation of creative requirements using mechanism's outputs .

SMPLearner: learning to predict software maintainability

Accurate and practical software maintainability prediction enables organizations to effectively manage their maintenance resources and guide maintenance-related decision making. This paper presents SMPLearner, an automated learning-based approach to train maintainability predictors by harvesting the actual average maintenance effort computed from the code change history as well as employing a much richer set of 44 four-level hierarchical code metrics collected by static code analysis tools. We systematically evaluated SMPLearner on 150 observations partitioned from releases of eight large scale open source software systems. Our evaluation showed that SMPLearner not only outperformed the traditional 4-metric MI model but also the recent learning-based maintainability predictors constructed based on single Class-level metrics, demonstrating that single Class-level metrics were not sufficient for maintainability prediction.

Tag recommendation for open source software

Nowadays open source software becomes highly popular and is of great importance for most software engineering activities. To facilitate software organization and retrieval, tagging is extensively used in open source communities. However, finding the desired software through tags in these communities such as Freecode and ohloh is still challenging because of tag insufficiency. In this paper, we propose TRG (tag recommendation based on semantic graph), a novel approach to discovering and enriching tags of open source software. Firstly, we propose a semantic graph to model the semantic correlations between tags and the words in software descriptions. Then based on the graph, we design an effective algorithm to recommend tags for software. With comprehensive experiments on large-scale open source software datasets by comparing with several typical related works, we demonstrate the effectiveness and efficiency of our method in recommending proper tags.

Calculation and optimization of thresholds for sets of software metrics

In this article, we present a novel algorithmic method for the calculation of thresholds for a metric set. To this aim, machine learning and data mining techniques are utilized. We define a data-driven methodology that can be used for efficiency optimization of existing metric sets, for the simplification of complex classification models, and for the calculation of thresholds for a metric set in an environment where no metric set yet exists. The methodology is independent of the metric set and therefore also independent of any language, paradigm or abstraction level. In four case studies performed on large-scale open-source software metric sets for C functions, C+ +, C# methods and Java classes are optimized and the methodology is validated.

Use of a multidimensional approach to study the evolution of software complexity

The ability of a software system to survive is not only dependent on a good architectural design, but also the effective management of architectural changes as the system evolves over time. With the emergence of incremental and evolutionary development approaches, this evolution is no longer restricted to the maintenance phase of development, but now manifests itself during system elaboration and construction. Structural complexity is often inadvertently introduced as the number of interdependencies between parts of the system grows and design goals are violated. Such increasing complexity may paradoxically impede its survivability. Software architects must, therefore, learn to track, manage, and mitigate software complexity since, left unchecked, it can lead to systems that are difficult to maintain and evolve. There are two key aspects of software systems that must be monitored in order to effectively manage the inherent complexity that is systematically introduced in evolving systems: the stability of intermediate forms must be preserved, and structural complexity must be monitored to prevent incidental (excessive) complexity from being introduced. While these key aspects of software architecture are often monitored independently in evolving systems, an integrative metric-based approach would provide a more comprehensive means of assessing the impact that architectural changes have on overall system quality. In this study, an integrative, multidimensional approach was used to examine the evolutionary changes that occurred in the architectural stability and structural complexity over 21 releases of Hibernate, a large-scale open source software system.

TEMPORAL SOFTWARE CHANGE PREDICTION USING NEURAL NETWORKS

Predicting changes in software entities (e.g. source files) that are more likely to change can help in the efficient allocation of the project resources. A powerful change prediction tool can improve maintenance and evolution tasks in software projects in terms of cost and time factors. The vast majority of research works have focused on determining "where" the most change-prone entities are, and "how" the change will be propagated through a system. This article suggests that knowing "when" changes are likely to happen can also provide another consideration for managers and developers to plan their maintenance activities more efficiently. To address this issue, a Neural Network-based Temporal Change Prediction (NNTCP) framework is proposed. This novel framework indicates "where" the changes are likely to happen (i.e. hot spots), and then adds the time dimension to predict "when" it may occur. In proving this concept, the NNTCP framework is applied in two large-scale open source software projects, Mozilla and Eclipse. The results obtained indicate NNTCP can predict the occurrence of several future revisions with reasonable performance.

Investigating quality in large-scale Open Source Software

Open Source Software (OSS) development and use has increased significantly over recent years. Therefore, there is a need to analyze and understand these projects. Software quality is an important characteristic effecting overall system lifecycle cost, performance and useful life. The existing models for software quality are based on empirical analysis of propriety source software (PSS), and need to be verified in OSS. Research on PSS has revealed that software quality declines, as it ages. Part of this decline is associated with the lifecycle maintenance activities that introduce change in the size and complexity of the system, while introducing software errors into modified system. Lifecycle maintenance activities in OSS systems are processed under a very different paradigm. We are interested in investigating the effects of maintenance activities on OSS project outcomes. Linux is one of the most popular and complex OSS project available. In our research, we investigate the characteristics of Linux source code. In this position paper we present some preliminary results of the effects of various types of maintenance activities on quality of Linux software.