Open Source Projects Research Articles

An Open-Source Software Reliability Model Considering Learning Factors and Stochastically Introduced Faults

In recent years, software development models have undergone changes. In order to meet user needs and functional changes, open-source software continuously improves its software quality through successive releases. Due to the iterative development process of open-source software, open-source software testing also requires continuous learning to understand the changes in the software. Therefore, the fault detection process of open-source software involves a learning process. Additionally, the complexity and uncertainty of the open-source software development process also lead to stochastically introduced faults when troubleshooting in the open-source software debugging process. Considering the phenomenon of learning factors and the random introduction of faults during the testing process of open-source software, this paper proposes a reliability modeling method for open-source software that considers learning factors and the random introduction of faults. Least square estimation and maximal likelihood estimation are used to determine the model parameters. Four fault data sets from Apache open-source software projects are used to compare the model performances. Experimental results indicate that the proposed model is superior to other models. The proposed model can accurately predict the number of remaining faults in the open-source software and be used for actual open-source software reliability evaluation.

A longitudinal study on the temporal validity of software samples

ContextIn Empirical Software Engineering, it is crucial to work with representative samples that reflect the current state of the software industry. An important consideration, especially in rapidly changing fields like software development, is that if we use a sample collected years ago, it should continue to represent the same population in the present day to produce generalizable results. However, it is seldom the case in which a software sample built several years ago accurately depicts the current state of the development industry. Nevertheless, many recent studies rely on rather old datasets (seven or more years of age) to conduct their investigations. ObjectiveTo analyze the evolution of a population of open-source projects, determine the likelihood of detecting significant differences over time, and study the activity history of the projects. MethodWe performed a longitudinal study with 72 snapshots of quality projects from Github, covering the period between July 1st 2017 and June 1st 2023. We recorded monthly values of seven repository metrics (contributors, commits, closed pull-requests, merged pull-requests, closed issues, number of stars and forks), encompassing data from a total of 1991 repositories. ResultsWe observed significant changes in all the metrics evaluated, with most cases showing negligible to small effect sizes. Notably, merged pull-requests registered medium effect sizes. The evolution was not equal in all the metrics, however, after five years it was unlikely that a sample of projects remained representative for any of the analyzed metrics, showing probabilities below 25%. ConclusionAlthough the temporal validity of a sample depends on the specific data being studied, employing datasets created several years ago does not appear to be a sound strategy if the aim is to produce results that can be extrapolated to the current state of the population.

An empirical study of code reuse between GitHub and stack overflow during software development

With the rise of programming Q&A websites (e.g., Stack Overflow) and the open-source movement, code reuse has become a common phenomenon. Our study aims to provide a comprehensive study of the code reuse behavior of programmers during software development, i.e., we mainly focus on the code reuse between the code snippets in the commits of open-source projects and the code snippets on Stack Overflow (SO). The open-source java project code dataset we construct contains 793 projects which include 342,148 modified code snippets, and the SO code dataset includes 1,355,617 posts. Then, we employ a code clone detection tool to identify the instances of code reuse between the modified code snippets of commits and the code snippets of the SO posts. We find that the average code reuse ratio of the projects is 6.32%, which will have a significant upward trend in the future. Additionally, we find that experienced developers seem to be more likely to reuse the code on SO, and prefer to reuse posts with more favorites and higher scores. We combine deep learning and topic analysis algorithms to fully exploit the semantic information of SO posts. The result shows a certain difference in the distribution of post types reused by bug-related commits and non-bug-related commits. We also discover that the code reuse ratio (14.44%) in java class files that have undergone multiple modifications is more than double the overall code reuse ratio (6.32%). Finally, we discuss the reuse habits of programmers and find that they may refer to multiple posts in one reuse, and these posts are related to a certain extent. From these results, our study provides multiple practical insights for different stakeholders: researchers, developers, and the SO platform.

End-to-end Autonomous Driving: Challenges and Frontiers.

The autonomous driving community has witnessed a rapid growth in approaches that embrace an end-to-end algorithm framework, utilizing raw sensor input to generate vehicle motion plans, instead of concentrating on individual tasks such as detection and motion prediction. End-to-end systems, in comparison to modular pipelines, benefit from joint feature optimization for perception and planning. This field has flourished due to the availability of large-scale datasets, closed-loop evaluation, and the increasing need for autonomous driving algorithms to perform effectively in challenging scenarios. In this survey, we provide a comprehensive analysis of more than 270 papers, covering the motivation, roadmap, methodology, challenges, and future trends in end-to-end autonomous driving. We delve into several critical challenges, including multi-modality, interpretability, causal confusion, robustness, and world models, amongst others. Additionally, we discuss current advancements in foundation models and visual pre-training, as well as how to incorporate these techniques within the end-to-end driving framework.We maintain an active repository that contains up-to-date literature and open-source projects at https://github.com/OpenDriveLab/End-to-end-Autonomous-Driving.

Sustainable Waste Management through ML-based Real-Time Trash Bin Prediction

Waste management has been an issue due to low awareness among people of any country to lead major environmental contamination, tragic accidents, and unfavorable working conditions for landfill workers. The Lack of precise and efficient object detection could be a barrier in the growth of computer vision-based systems. As per the latest research articles, pre-trained models could be used for Trash Bin detection in real time and for recommending appropriate actions after detection. Using a unique validation dataset made up of predicted trash items, the two classes of acceptable object identification models, YOLO (You Only Look Once) and SSD (Single Shot Multibox Detector), are then contrasted. It is concluded that SSD performs noticeably better than YOLO in identifying trash objects based on several performance metrics computed utilizing multiple open-source research projects. The model is then built up to recognize several trash object types after being pre-trained using Microsoft's COCO (Common Objects in Context) dataset. Our initiative intends to enhance sustainable waste management, make trash sorting incredibly simple, and guard against serious illnesses and accidents at landfill and garbage disposal sites.

Trajectory Planning, Kinematics, and Experimental Validation of a 3D-Printed Delta Robot Manipulator

This paper presents the implementation, trajectory planning, kinematics, and experimental validation of an open-source 3D-printed delta robot manipulator. The robot’s hardware consists of three servo motors, an Arduino Uno microcontroller, and a Pulse Width Modulation (PWM) servo module. The software includes a trapezoidal velocity profile planner and an inverse and forward kinematics solver to calculate the motor angles required to achieve a desired end-effector position in task space. The 3D printed parts were obtained from an open-source Thingiverse project and assembled to form the robot’s kinematic structure. The robot’s performance was evaluated in terms of its accuracy, repeatability, and maximum speed for a pick-and-place task. Experimental results show that the robot can achieve a positioning accuracy of 2.2 mm, with a top speed of 0.4 m/s, 30 picks per minute, and load carrying capacity up to 200 g. These results are satisfactory, considering the ease of assembly and the cost-effectiveness of the robot. The comparison of the calculated motor angles with actual motor angles obtained through additional potentiometer wires soldering shows promising results. The proposed robot’s cost-effective characteristics, utilization of open-source additive manufacturing, and motion planning algorithms make it suitable for various applications, including education, research, and small-scale industrial applications.

TOSCA Solves Big Problems in the Cloud and Beyond!

TOSCA, the Topology and Orchestration Specification for Cloud Applications offers an OASIS-recognized, open standard domain-specific language (DSL) that enables portability and automated management of applications, services, and resources regardless of underlying cloud platform, software defined environment, or infrastructure. With a growing, interoperable eco-system of open source projects, solutions from leading cloud platform and service providers, and research, TOSCA empowers the definition and modeling of applications and their services (microservices or traditional services) across their entire lifecycle by describing their components, relationships, dependencies, requirements, and capabilities for orchestrating software in the context of associated operational policies. The authors introduce important TOSCA concepts and benefits in the context of commonly understood cloud use cases as a foundation to future discussions regarding advanced TOSCA concepts and additional breakthrough issues.

A Comparative Study Of MVC Architecture Model Of Open Source Server Side Scripting Language Jsp And Php For Client-Server Architecture Based Applications Development

The Model-View-Controller (MVC) architecture pattern has become a popular way to structure web applications, separating the data, presentation, and application logic into modular components. This review paper provides a comparative analysis of implementing MVC architecture using two major open-source server-side scripting languages - JavaServer Pages (JSP) and PHP. Over 10,000 open source projects utilizing JSP/Java and PHP are analyzed to compare how the languages lend themselves to the MVC pattern. The challenges and advantages of both platforms for real-world development of thin-client applications are assessed. Quantitative metrics on performance, scalability, code reuse and integration with MVC frameworks like Spring and Laravel are provided. The findings indicate strengths and weaknesses unique to both languages, with outcome being that PHP+Laravel offers faster initial development time, while JSP+Spring provides more enterprise-grade scalability. The insights can guide developers to make an informed choice between the two platforms for MVC-based, client-server application development.

On the Automated Unit Tests Generation for Java Applications using Spring Framework

This paper considers the automated unit tests generation for programs written in Java using the Spring framework. Although several test generation tools for “pure” Java applications have been developed in recent decades, the features of this framework are mostly not taken into account. However, Spring is used to develop many industrial Java applications. At the same time, the presence of Spring components in the application for which the tests are generated imposes additional requirements not only on the code analysis approaches, but also on the structure of the generated tests. The main source of the information about object types and their properties is the Spring application context. The paper proposes an instrument for analyzing the application context, that in some cases allows generating test scenarios corresponding to real program executions and avoiding excessive mocking. The full initialization of the application context does not occur during this analysis. It makes the test generation safe for user data. The proposed instrument for analyzing the Spring context has been integrated into the UnitTestBot Java automatic test generation tool. We also provide examples of tests generated for real open-source projects.

CodonU: A Python Package for Codon Usage Analysis.

Codon Usage Analysis (CUA) has been accompanied by several web servers and independent programs written in several programming languages. Also this diversity speaks for the need of a reusable software that can be helpful in reading, manipulating and acting as a pipeline for such data and file formats. This kind of analyses use multiple tools to address the multifaceted aspects of CUA. So, we propose CodonU, a package written in Python language to integrate all aspects. It is compatible with existing file formats and can be used solely or with a group of other such packages. The proposed package incorporates various statistical measures necessary for codon usage analysis. The measures vary with nature of the sequences, viz. for nucleotide, codon adaptation index (CAI), codon bias index (CBI), tRNA adaptation index (tAI) etc. and for protein sequences Gravy score etc. Users can also perform the correspondence analysis (COA). This package also provides the liberty to generate graphics to users, and also develop phylogenetic tree. Capabilities of the proposed package were checked thoroughly on a genomic set of Staphylococcus aureus.

Thefittest: evolutionary machine learning in Python

Thefittest is a new Python library specializing in evolutionary optimization methods and machine learning methods that use evolutionary optimization methods. Thefittest provides both classical evolutionary algorithms and efficient modifications of these algorithms that do not have implementations in the open access. Among the advantages of the library are the performance of the implemented methods, accessibility and ease of use. The paper discusses the motivation for developing and leading the project, describes the structure of the library with examples of use, and provides a comparison with other projects with a similar development goal. Thefittest is an open-source project published on GitHub and PyPi, developed using modern methods of code analysis and testing. At the moment of writing the paper, the latest version of the library is 0.2.3.

PAVLIB4SWAT: a Python analysis and visualization tool and library based on Kepler.gl for SWAT models

Abstract The Soil and Water Assessment Tool (SWAT) has been widely applied to simulate the hydrological cycle, investigate cause-and-effect relationships, and aid decision-making for better watershed management. However, the software tools for model dataset analysis and visualization to support informed decision-making in a web environment are not considered fully fledged and are technically intensive to implement. This study focuses on addressing these issues by establishing a tool and library (named PAVLIB4SWAT) that can largely reduce technical expertise requirements for developers to adopt and customize this work to their own demands. Specifically, we created PAVLIB4SWAT based on a Kepler.gl widget to visualize SWAT model data, including shapefiles from the watershed delineation process, model inputs, and simulated results via dynamic and interactive maps. We evaluated PAVLIB4SWAT through a Jinjiang watershed SWAT model use case to demonstrate its utility and ease of adoption. The case study shows that PAVLIB4SWAT can provide various geospatial analysis and mapping functionalities for SWAT models and can flexibly distribute visualized results as standalone offline web pages and web servers. In addition, PAVLIB4SWAT was designed as an open-source project and implemented purely in the Python programming language; thus, developers can easily adapt and customize it to suit their demands.

Face Recognition using Deep Learning and TensorFlow framework

Detecting human faces and recognizing faces and facial expressions have always been an area of interest for different applications such as games, utilities and even security. With the advancement of machine learning, the techniques of detection and recognition have become more accurate and precise than ever before. However, machine learning remains a relatively complex field that could feel intimidating or inaccessible to many of us. Luckily, in the last couple of years, several organizations and open-source communities have been developing tools and libraries that help abstract the complex mathematical algorithms in order to encourage developers to easily create learning models and train them using any programming languages.
 As part of this project, we will create a Face Detection framework in Python built on top of the work of several open-source projects and models with the hope to reduce the entry barrier for developers and to encourage them to focus more on developing innovative applications that make use of face detection and recognition.

Class correlation correction for unbiased scene graph generation

The long-tail distribution in the scene graph generation (SGG) task has spurred immense interest in unbiased SGG. However, current state-of-the-art debiasing techniques extract statistics from the independent category, while ignoring the correlation between categories. To address this issue, we propose a simple but effective method, class correlation correction, to aggregate dependency knowledge among various classes. Specifically, given biased predictions, two kinds of debiasing transformations are developed employing the class correlation aware label to recover the unbiased estimates. We also propose to retrain SGG models with the biasing transformations adapted to the biased data distribution. The proposed debiasing method is evaluated using several biased datasets that are constructed from CIFAR-10 and Fashion-MNIST, as well as the commonly used SGG dataset and Caltech 101 dataset. Multiple evaluation metrics are used to assess the debiasing performance, and the results of extensive experiments show the effectiveness of the proposed method. The Pytorch® implementations can be downloaded from an open-source GitHub project https://github.com/Dlut-lab-zmn/class-correlation-correction.

Big textual data research for operations management: topic modelling with grounded theory

PurposeThere is a growing need for methodological plurality in advancing operations management (OM), especially with the emergence of machine learning (ML) techniques for analysing extensive textual data. To bridge this knowledge gap, this paper introduces a new methodology that combines ML techniques with traditional qualitative approaches, aiming to reconstruct knowledge from existing publications.Design/methodology/approachIn this pragmatist-rooted abductive method where human-machine interactions analyse big data, the authors employ topic modelling (TM), an ML technique, to enable constructivist grounded theory (CGT). A four-step coding process (Raw coding, expert coding, focused coding and theory building) is deployed to strive for procedural and interpretive rigour. To demonstrate the approach, the authors collected data from an open-source professional project management (PM) website and illustrated their research design and data analysis leading to theory development.FindingsThe results show that TM significantly improves the ability of researchers to systematically investigate and interpret codes generated from large textual data, thus contributing to theory building.Originality/valueThis paper presents a novel approach that integrates an ML-based technique with human hermeneutic methods for empirical studies in OM. Using grounded theory, this method reconstructs latent knowledge from massive textual data and uncovers management phenomena hidden from published data, offering a new way for academics to develop potential theories for business and management studies.

Understanding the Helpfulness of Stale Bot for Pull-Based Development: An Empirical Study of 20 Large Open-Source Projects

Pull Requests (PRs) that are neither progressed nor resolved clutter the list of PRs, making it difficult for the maintainers to manage and prioritize unresolved PRs. To automatically track, follow up, and close such inactive PRs, Stale bot was introduced by GitHub. Despite its increasing adoption, there are ongoing debates on whether using Stale bot alleviates or exacerbates the problem of inactive PRs. To better understand if and how Stale bot helps projects in their pull-based development workflow, we perform an empirical study of 20 large and popular open source projects. We find that Stale bot can help deal with a backlog of unresolved PRs, as the projects closed more PRs within the first few months of adoption. Moreover, Stale bot can help improve the efficiency of the PR review process as the projects reviewed PRs that ended up merged and resolved PRs that ended up closed faster after the adoption. However, Stale bot can also negatively affect the contributors, as the projects experienced a considerable decrease in their number of active contributors after the adoption. Therefore, relying solely on Stale bot to deal with inactive PRs may lead to decreased community engagement and an increased probability of contributor abandonment.

LoGenText-Plus : Improving Neural Machine Translation Based Logging Texts Generation with Syntactic Templates

Developers insert logging statements in the source code to collect important runtime information about software systems. The textual descriptions in logging statements (i.e., logging texts) are printed during system executions and exposed to multiple stakeholders including developers, operators, users, and regulatory authorities. Writing proper logging texts is an important but often challenging task for developers. Prior studies find that developers spend significant efforts modifying their logging texts. However, despite extensive research on automated logging suggestions, research on suggesting logging texts rarely exists. To fill this knowledge gap, we first propose LoGenText (initially reported in our conference paper), an automated approach that uses neural machine translation (NMT) models to generate logging texts by translating the related source code into short textual descriptions. LoGenText takes the preceding source code of a logging text as the input and considers other context information, such as the location of the logging statement, to automatically generate the logging text. LoGenText ’s evaluation on 10 open source projects indicates that the approach is promising for automatic logging text generation and significantly outperforms the state-of-the-art approach. Furthermore, we extend LoGenText to LoGenText-Plus by incorporating the syntactic templates of the logging texts. Different from LoGenText , LoGenText-Plus decomposes the logging text generation process into two stages. LoGenText-Plus first adopts an NMT model to generate the syntactic template of the target logging text. Then LoGenText-Plus feeds the source code and the generated template as the input to another NMT model for logging text generation. We also evaluate LoGenText-Plus on the same 10 projects and observe that it outperforms LoGenText on 9 of them. According to a human evaluation from developers’ perspectives, the logging texts generated by LoGenText-Plus have a higher quality than those generated by LoGenText and the prior baseline approach. By manually examining the generated logging texts, we then identify five aspects that can serve as guidance for writing or generating good logging texts. Our work is an important step toward the automated generation of logging statements, which can potentially save developers’ efforts and improve the quality of software logging. Our findings shed light on research opportunities that leverage advances in NMT techniques for automated generation and suggestion of logging statements.

Beyond Accuracy: An Empirical Study on Unit Testing in Open-source Deep Learning Projects

Deep Learning (DL) models have rapidly advanced, focusing on achieving high performance through testing model accuracy and robustness. However, it is unclear whether DL projects, as software systems, are tested thoroughly or functionally correct when there is a need to treat and test them like other software systems. Therefore, we empirically study the unit tests in open-source DL projects, analyzing 9,129 projects from GitHub. We find that: 1) unit tested DL projects have positive correlation with the open-source project metrics and have a higher acceptance rate of pull requests, 2) 68% of the sampled DL projects are not unit tested at all, 3) the layer and utilities (utils) of DL models have the most unit tests. Based on these findings and previous research outcomes, we built a mapping taxonomy between unit tests and faults in DL projects. We discuss the implications of our findings for developers and researchers and highlight the need for unit testing in open-source DL projects to ensure their reliability and stability. The study contributes to this community by raising awareness of the importance of unit testing in DL projects and encouraging further research in this area.

Injectiondesign: web service of plate design with optimized stratified block randomization for modern GC/LC-MS-based sample preparation

BackgroundPlate design is a necessary and time-consuming operation for GC/LC-MS-based sample preparation. The implementation of the inter-batch balancing algorithm and the intra-batch randomization algorithm can have a significant impact on the final results. For researchers without programming skills, a stable and efficient online service for plate design is necessary.ResultsHere we describe InjectionDesign, a free online plate design service focused on GC/LC-MS-based multi-omics experiment design. It offers the ability to separate the position design from the sequence design, making the output more compatible with the requirements of a modern mass spectrometer-based laboratory. In addition, it has implemented an optimized block randomization algorithm, which can be better applied to sample stratification with block randomization for an unbalanced distribution. It is easy to use, with built-in support for common instrument models and quick export to a worksheet.ConclusionsInjectionDesign is an open-source project based on Java. Researchers can get the source code for the project from Github: https://github.com/CSi-Studio/InjectionDesign. A free web service is also provided: http://www.injection.design.

A Vulnerability Assessment of Open-Source Implementations of Fifth-Generation Core Network Functions

The paper presents an experimental security assessment within two widely used open-source 5G projects, namely Open5GS and OAI (Open-Air Interface). The examination concentrates on two network functions (NFs) that are externally exposed within the core network architecture, i.e., the Access and Mobility Management Function (AMF) and the Network Repository Function/Network Exposure Function (NRF/NEF) of the Service-Based Architecture (SBA). Focusing on the Service-Based Interface (SBI) of these exposed NFs, the analysis not only identifies potential security gaps but also underscores the crucial role of Mobile Network Operators (MNOs) in implementing robust security measures. Furthermore, given the shift towards Network Function Virtualization (NFV), this paper emphasizes the importance of secure development practices to enhance the integrity of 5G network functions. In essence, this paper underscores the significance of scrutinizing security vulnerabilities in open-source 5G projects, particularly within the core network’s SBI and externally exposed NFs. The research outcomes provide valuable insights for MNOs, enabling them to establish effective security measures and promote secure development practices to safeguard the integrity of 5G network functions. Additionally, the empirical investigation aids in identifying potential vulnerabilities in open-source 5G projects, paving the way for future enhancements and standard releases.