Narrow Results

At present, the fault big data of open source software are opened as the open data set. In particular, the fault detection phenomenon depends on various situation of operation in OSS. Actually, various software reliability growth models have been actively proposed by several researchers in the past. This paper applies the deep learning approach to the OSS fault big data. Then, we propose several reliability assessment measures based on the deep learning. As an approach, the range of estimate expands by the Wiener process embedded for the data preprocessing. Furthermore, this paper proposes the performability as novel reliability assessment measure from the proposed deep learning model. In particular, we develop the prototype of 3D reliability assessment tool. Several illustration examples based on the developed prototype of 3D reliability assessment tool by using the actual fault big data sets are shown in this paper.

The OpenLB project aims at setting up an open source implementation of lattice Boltzmann methods in an object oriented framework. The code, which is written in C++, is intended to be used both by application programmers and by developers who may add their own particular dynamics. It supports advanced data structures that take into account complex geometries and parallel program executions. The programming concepts rely strongly on dynamic genericity through the use of object oriented interfaces as well as static genericity by means of templates. This design allows a straightforward and intuitive implementation of lattice Boltzmann models with almost no loss of efficiency. The aim of this paper is to introduce the OpenLB project and to depict the underlying structure leading to a powerful development tool for lattice Boltzmann methods.

This paper presents an empirical analysis of the Open Source development process from the point of view of the involvement of the developers in the production process. The study focuses on how developers contribute to projects in terms of involvement, size and kind of their contribution. Data have been collected from 53 Open Source projects and target application domains include different areas: web and application servers, databases, operating systems, and window managers. Collected data include the number of developers, patterns of code modifications, and evolution over the time of size and complexity.

The results of this study show evidence that there are recurrent patterns in Open Source software development and these patterns are common to all the projects considered even if there are no superimposed processes for development, application domains are different, and there are contributions from people spread across the world.

The causes of architecture changes can tell about why architecture changes, and this knowledge can be captured to prevent architecture knowledge vaporization and architecture degeneration. But the causes are not always known, especially in open source software (OSS) development. This makes it very hard to understand the underlying reasons for the architecture changes and design appropriate modifications. Architecture information is communicated in development mailing lists of OSS projects. To explore the possibility of identifying and understanding the causes of architecture changes, we conducted an empirical study to analyze architecture information (i.e. architectural threads) communicated in the development mailing lists of two popular OSS projects: Hibernate and ArgoUML, verified architecture changes with source code, and identified the causes of architecture changes from the communicated architecture information. The main findings of this study are: (1) architecture information communicated in OSS mailing lists does lead to architecture changes in code; (2) the major cause for architecture changes in both Hibernate and ArgoUML is preventative changes, and the causes of architecture changes are further classified to functional requirement, external quality requirement, and internal quality requirement using the coding techniques of grounded theory; (3) more than 45% of architecture changes in both projects happened before the first stable version was released.

Open Source Software (OSS) has become an important environment where developers can create, exchange, and improve reusable software assets by collaborating with other developers. Although developers may find useful software assets to reuse from OSS for their projects, they usually experience difficulties in solving problems that occur while integrating the assets to their own software. We investigated data from major open source environments such as Sourceforge.net and GitHub, and learned that there is a common pattern of solving reuse-related problems in OSS. To analyze the pattern in detail, we have developed an ontological model to formally represent the symptoms and causes of the reuse-related problems, and the correlations between them. Based on this model, we collected data from Sourceforge.net, and built a knowledge base for the most common problem type. We extracted the core types of symptoms and causes for the problem type and calculated the number of correlations between the types of symptoms and causes. We found that there exist correlations between the symptoms and causes that are extracted from the discussion threads for the problem type, and about 60% of them are statistically significant. We also conducted a study to understand the effective timing of recommending solutions to the developers by analyzing the recall rates of finding the causes of the problems in a timeline. We figured that most of the important causes of a problem are discussed at the beginning of the forum discussion. This leads us to the conclusion that recommending the causes of a problem early by using our knowledge framework may help developers spend less amount of time to solve the problem (around 50% less time than solving the problem without using our framework).

Open source software (OSS) projects and communities are becoming increasingly popular and influential recently. Communications and collaborations are essential for the success of projects. Usually, the most active and productive programmers are awarded with promotion to developers. To more effectively manage and progress the projects, it is important and beneficial to rank the programmers and thus, predict the developer candidates. In this work, we propose to combine machine learning techniques with existing complex network node ranking algorithms to improve the prediction results. Specifically, we have made the following contributions: (1), we have designed a novel machine learning-based classifier with significantly improved prediction performance; (2), we have constructed and tested various networks built based on the programmer email communication information; and (3), we have used real-world project data to compare different techniques and validate our methods. Experimental results demonstrate that our technique reduces the error rate by 25% compared with the second best. Moreover, we discover that the $\text{K}$ nearest neighbor (KNN)-based machine learning algorithm and non-directional temporal network with a time window of 1–3 months give the best prediction results.

Open Source Software (OSS) community has attracted a large number of distributed developers to work together, e.g. reporting and discussing issues as well as submitting and reviewing code. OSS developers create links among development units (e.g. issues and pull requests in GitHub), share their opinions and promote the resolution of development units. Although previous work has examined the role of links in recommending high-priority tasks and reducing resource waste, the understanding of the actual usage of links in practice is still limited. To address the research gap, we conduct an empirical study based on the 5W1H model and data mining from five popular OSS projects on GitHub. We find that links originating from a PR are more common than the other three types of links, and links are more frequently created in Documentation. We also find that average duration between development units’ create time in a link is half a year. We observed that link behaviors are very complex and the duration of link increases with the complexity of link structure. We also observe that the reasons of link are very different, especially in P–P and I–I. Finally, future works are discussed in conclusion.

From May 2019, GitHub launched sponsor mechanism indicating that GitHub is moving towards deeper integration of open source development and economic support. It will bring more comprehensive and diversified support to the open source community. However, the number of developers profiting from the sponsor mechanism follows a long tail distribution. Our study found that only 31% of developers who started the sponsor mechanism received rewards, and 39.3% of them only received a reward of one dollar.

Our work focuses on identifying what factors affect the availability of sponsorship for developers in open source community. We start by defining 45 features to characterize the developers in four dimensions i.e. Personality, Advertisement, Repository and Behavior. The results of statistical analysis indicate that most of the proposed features differ significantly between the ones who received rewards (short for MTs_Yes) from those that are not. After that, we build machine learning model based on the proposed features to predict MTs_Yes. Compared with the existing work, results show that our method outperforms baselines by 30% for AUC (Area Under the Curve). In addition, we investigated the relative contribution of features in detecting MTs_Yes and analyzed the important features by using an interpretable model SHAP. Finally, based on the experimental results, we put forward corresponding and practical suggestions for developers who want to receive rewards so as to make the community of open source projects develop more harmonious.

Software development environment has been changing into new development paradigms such as concurrent distributed development environment and the so-called open source project by using network computing technologies. Especially, an OSS (open source software) system which serves as key components of critical infrastructures in the society is still ever-expanding now. In case of considering the effect of the debugging process on an entire system in the development of a method of reliability assessment for the OSS, it is necessary to grasp the deeply-intertwined factors, such as programming path, size of each component, skill of fault reporter, and so on. In order to consider the effect of each software component on the reliability of an entire system, we propose a new approach to user-oriented software reliability assessment by creating a fusion of neural network and software reliability growth modeling. In this paper, we show application examples of component-oriented software reliability assessment based on neural network and software reliability growth modeling for the OSS. Also, we analyze actual software fault count data to show numerical examples of software reliability assessment for the OSS. Moreover, we develop the testing management tool for OSS.

Various open source software (OSS) projects are in action around the world. Many OSS are developed and maintained under these OSS projects. Considering the characteristics of OSS, the operation performance of OSS development will take an irregular fluctuation in the long term of operation, because several developers and many users are closely related to the maintenance of OSS.

This paper focuses on the irregular fluctuation of the operation performance of OSS. We apply the jump diffusion process model to the noisy cases in the operation of OSS. In particular, the maintenance effort is estimated by the stochastic differential equation model in terms of OSS project management. Moreover, we discuss the method of maintenance effort management based on jump diffusion process model considering the irregular fluctuation of performance for OSS projects. In particular, we propose the method of productivity assessment based on the proposed jump diffusion models. Thereby, it is helpful for the OSS development managers to understand the effort status of OSS from the standpoint of OSS project management. Also, we analyze actual data to show numerical examples of the proposed method considering the characteristics of OSS projects.

The operation of open source software (OSS) has a complex maintenance phase. This paper focuses on several irregular fluctuation in the operation performance of OSS. We apply a flexible jump diffusion process model to several noisy cases in the operation of OSS associated with version upgrade. In particular, we discuss a method of maintenance effort management based on the flexible jump diffusion process model considering the irregular fluctuation in version upgrade performance for OSS projects. Moreover, this paper proposes the optimal maintenance problems based on our flexible jump diffusion process models. Then, it will be useful for the OSS project managers to understand the effort status and the optimal maintenance times with version upgrade of OSS from the standpoint of OSS project management. Moreover, we analyze actual data to show numerical examples of our model and the proposed optimal maintenance problems considering the characteristics with version upgrade of OSS projects.

Recently, the computing service has been changing from the cloud computing to the edge one. The edge computing is very important to serve nearly the IoT devices. In particular, several IoT devices have no-large scale computer storage. Therefore, the edge servers will be able to solve the problems of small-scale computer storage. Also, the edge computing is structured by several open source software. Then, the open source software updates version-up day by day. The version-upgradation is the characteristic of open source software. This paper focuses on the keywords such as the edge computing, deep learning, reliability assessment, and open source software. We propose the method of reliability assessment based on deep learning.

It is important to carefully monitor the development status of an open source projects because of the large number of people involved in the projects. One of the methods for evaluating project stability is earned value management (EVM), applying EVM to projects requires time-series effort data. However, there are few researches on the calculation of time-series effort data for open source projects, because open source projects do not manage effort as a whole. In this research, we have examined the validity of the calculation method and results of the time-series effort data in the open source projects. In addition, we have verified similarity of proprietary software development projects to open source projects in terms of effort. In particular, the similarity between open source projects and proprietary software development projects is verified by applying the effort data of open source projects to the software reliability growth model (SRGM).

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.

This paper focuses on the sustainability based on the effort by using the fault big data of open source software (OSS). The fault detection phenomenon depends on the maintenance effort, because the number of software fault is influenced by the effort expenditure. Actually, the software reliability growth models with testing-effort have been proposed in the past. In this paper, we apply the deep learning approach to the OSS fault big data. Also, we propose the reliability assessment measure of sustainability. Then, we show several sustainability assessment measure based on the deep learning. Moreover, several numerical illustrations based on the proposed deep learning model are shown in this paper.

Software reliability growth model (SRGM) is used as one of the reliability assessment methods to assess the software reliability. In SRGM, the degree of reliability growth may fluctuate greatly according to change in the internal state of the software. It is called the change point (CP). Several researchers proposed the SRGM considering CP. In the open source software (OSS), there are many projects that continue development even after the software is released. Therefore, major updates with breaking changes may occur in it. The major updates can be a factor that causes a CP because it greatly changes the internal state of the OSS. This paper focuses on the relationship between CP and software updates. We collect OSS fault data from a bug tracking system. Moreover, we examine the behavior of SRGM before and after software updates. Furthermore, we discuss the applicability of SRGM for CP in OSS. Also, we compare the proposed model based on CP with the model without CP. As a result, we have confirmed that the SRGM can evaluate the reliability in the environment with major updates. Moreover, the proposed method performs better than without considering CP model. Especially, the exponential model’s mean value function is the suitable method to assess the OSS reliability for the proposed method.

In this paper, we apply concepts from Distributed Leadership, a theory suggesting that leadership is shared among members of an organization, to frame models of contribution that we uncover in five relatively successful open source software (OSS) projects hosted on GitHub. In this qualitative, comparative case study, we show how these projects make use of GitHub features such as pull requests (PRs). We find that projects in which member PRs are more frequently merged with the codebase experience more sustained participation. We also find that projects with higher success rates among contributors and higher contributor retention tend to have more distributed (non-centralized) practices for reviewing and processing PRs. The relationships between organizational form and GitHub practices are enabled and made visible as a result of GitHub's novel interface. Our results demonstrate specific dimensions along which these projects differ and explicate a framework that warrants testing in future studies of OSS, particularly GitHub.

In open source software (OSS) projects, participants initially communicate with others and then may become developers if they are deemed worthy by the community. Recent studies indicate that the abundance of established social links of a participant is the strongest predictor to his/her promotion. Having reliable rankings of the candidates is key to recruiting and maintaining a successful operation of an OSS project. This paper adopts degree-based, PageRank, and Hits ranking algorithms to rank developer candidates in OSS projects based on their social links. We construct several types of social networks based on the communications between the participants in Apache OSS projects, then train and test the ranking algorithms in these networks. We find that, for all the ranking algorithms under study, the rankings of emergent developers in temporal networks are higher than those in cumulative ones, indicating that the more recent communications of a developer in a project are more important to predict his/her first commit in the project. By comparison, the simple degree-based and the PageRank ranking algorithms in temporal undirected weighted networks behave better than the others in identifying emergent developers based on four performance indicators, and are thus recommended to be applied in the future.

We develop a model of innovation communities which allows us to address in a systematic way the influence of users and developers as well as communication between and within these groups. Based on this model, we derive a formal approach to quantify communication flows, community activity and community turnover. These measures are calculated using the data of 100 open source software projects. Our empirical analysis shows that: (i) Users play indeed a predominant role in communication, which points towards the vivid role of an active user community; (ii) communication is highly concentrated, which points towards the importance of active individuals and (iii) community turnover exhibits only little correlation with community segregation, which may allow to benefit from high turnover rates while keeping negative effects small. We argue that insight from this extensive analysis not only complements existing case studies, it also provides a reference frame to put these singular results into perspective when aiming at generalizations.

Established open source software (OSS) projects can grow in size if new developers join, but also the number of OSS projects can grow if developers choose to found new projects. We discuss to what extent an established model for firm growth can be applied to the dynamics of OSS projects. Our analysis is based on a large-scale data set from SourceForge (SF) consisting of monthly data for 10 years, for up to 360,000 OSS projects and up to 340,000 developers. Over this time period, we find an exponential growth both in the number of projects and developers, with a remarkable increase of single-developer projects after 2009. We analyze the monthly entry and exit rates for both projects and developers, the growth rate of established projects and the monthly project size distribution. To derive a prediction for the latter, we use modeling assumptions of how newly entering developers choose to either found a new project or to join existing ones. Our model applies only to collaborative projects that are deemed to grow in size by attracting new developers. We verify, by a thorough statistical analysis, that the Yule–Simon distribution is a valid candidate for the size distribution of collaborative projects except for certain time periods where the modeling assumptions no longer hold. We detect and empirically test the reason for this limitation, i.e., the fact that an increasing number of established developers found additional new projects after 2009.