1,720,959 research outputs found
Detection of God Class and Data Class code smells based on an automatic machine learning tool
No full textCode smells are symptoms of poor design or incomplete implementation that can degrade software quality and maintainability. Detecting them is crucial for improving software reliability and guiding refactoring efforts. Traditional detection methods rely on predefined rules or thresholds, which are inflexible and prone to errors, while modern machine learning approaches require significant expertise and large, balanced datasets. To address these challenges, we propose an automated code smell detection method using AutoGluon, an AutoML framework that streamlines model selection, hyperparameter tuning, and handling of imbalanced datasets. To evaluate the effectiveness of the proposed method, experiments were conducted using two code smell datasets: God Class and Data Class. The performance of the method was evaluated using six different metrics: accuracy, precision, recall, F-measure, Matthew’s correlation coefficient (MCC), and the area under the receiver operating characteristic curve (AUC). Additionally, we have also compared our proposed method with stateof- the-art code smell detection methods. Experimental results show that AutoGluon achieves high predictive performance—up to 0.98 accuracy for God Class and 1.00 for Data Class, which often matches or outperforms stateof- the-art methods, demonstrating the potential of AutoGluon for efficient and scalable code smell detection
Comparison of version control system tools
Get PDFVersion control systems (VCS) are widely applied at software companies as a collaborative tool and to maintain multiple versions of source code and documentation. VCS is a software tool that manages development of software projects and provides methods to manage several developers working together and track them. Collaboration considers the master purpose of version control systems. Modern VCS supports the parallel development of artifacts using branches and merges. Currently, the version control system adopts on two approaches to software development, the Centralized Version Control System (CVCS) and the Distributed Version Control System (DVCS). This article introduces the concepts and comparison of Version Control Systems and some criteria to consider when selecting
Deep convolutional neural network model for bad code smells detection based on oversampling method
Get PDFCode smells refers to any symptoms or anomalies in the source code that shows violation of design principles or implementation. Early detection of bad code smells improves software quality. Nowadays several artificial neural network (ANN) models have been used for different topics in software engineering: software defect prediction, software vulnerability detection, and code clone detection. It is not necessary to know the source of the data when using ANN models but require large training sets. Data imbalance is the main challenge of artificial intelligence techniques in detecting the code smells. To overcome these challenges, the objective of this study is to presents deep convolutional neural network (D-CNN) model with synthetic minority over-sampling technique (SMOTE) to detect bad code smells based on a set of Java projects. We considered four code-smell datasets which are God class, data class, feature envy and long method and the results were compared based on different performance measures. Experimental results show that the proposed model with oversampling techniques can provide better performance for code smells detection and prediction results can be further improved when the model is trained with more datasets. Moreover, more epochs and hidden layers help increase the accuracy of the model
A new approach to software defect prediction based on convolutional neural network and bidirectional long short-term memory
Get PDFSoftware defect prediction (SDP) plays an important role in improving software quality and reliability while reducing software maintenance cost. The problem in the field of SDP is how to determine the defective source code with high accuracy. To build more accurate predictor models, a lot of features are presented, e.g., static code features, social network features, and process features, etc. Several machine learning (ML) and deep learning (DL) algorithms have been developed and adopted to identify and remove defects from the source code, where previous studies have proved that DL algorithms are promising techniques for predicting software defects. The aim of this study is to investigate the prediction performance of two DL algorithms namely, Convolutional Neural Network (CNN) and Bidirectional Long short-term memory (BI-LSTM) in the domain of SDP. To establish the effectiveness of the proposed approach, the experiments were conducted on the available benchmark datasets which obtained from open-source java projects GitHub repository and the models were evaluated by applying seven evaluation metrics which are accuracy, precision, recall, f-measure, matthews correlation coefficient (MCC), area under the ROC curve (AUC), mean square error (MSE). We found out that the best accuracy obtained on training dataset is 81% by using CNN model, while the best accuracy obtained on validation dataset is 80% by using BI-LSTM model. The best AUC obtained on training dataset is 88% by using CNN model, while the best AUC obtained on validation dataset is 83% by using the both models. It is nearly impossible to rule which model is better than the other so every model can be analyzed separately and the best model according to the problem at hand can be used, therefore, based on the problem of this study, The evaluation results show the effectiveness of our proposed models based on standard performance evaluation criteria
Merging problems in modern version control systems
Get PDFDuring software development, when developers change the same part of the code concurrently, this may be led to merging conflicts. Resolving these conflicts might be costly and time-consuming. Three types of conflicts may arise during merge processes: textual, syntactic, and semantic. Textual conflicts occur when merging a concurrent operation, such as addition, removal or edition take place over the same parts of code. Syntactic conflicts occur when concurrent operations break the syntactic structure of the source code files when merged. Finally, a semantic conflict occurs when the merged modification is compiled without error but malfunctions. Version management systems usually use textual merging technique; users can synchronize their modifications with other users working in parallel with them, in this process, a merge is performed between local modifications and remote modifications. The previous work has examined different mechanisms to detect and resolve conflicts and proposed different tools for resolving merge conflicts, such as two-way merging, three-way merging, state-based merging, and operation-based merging. This paper discusses and investigates many concepts related to merging conflicts by asking and answering these questions; what are the factors that most affect in a merge conflict, how to avoiding and reducing merge conflicts, how to detecting merge conflicts, and how to resolve them.During software development, when developers change the same part of the code concurrently, this may be led to merging conflicts. Resolving these conflicts might be costly and time-consuming. Three types of conflicts may arise during merge processes: textual, syntactic, and semantic. Textual conflicts occur when merging a concurrent operation, such as addition, removal or edition take place over the same parts of code. Syntactic conflicts occur when concurrent operations break the syntactic structure of the source code files when merged. Finally, a semantic conflict occurs when the merged modification is compiled without error but malfunctions. Version management systems usually use textual merging technique; users can synchronize their modifications with other users working in parallel with them, in this process, a merge is performed between local modifications and remote modifications. The previous work has examined different mechanisms to detect and resolve conflicts and proposed different tools for resolving merge conflicts, such as two-way merging, three-way merging, state-based merging, and operation-based merging. This paper discusses and investigates many concepts related to merging conflicts by asking and answering these questions; what are the factors that most affect in a merge conflict, how to avoiding and reducing merge conflicts, how to detecting merge conflicts, and how to resolve them
Detection of code smells using machine learning techniques combined with data-balancing methods
Get PDFCode smells are prevalent issues in software design that arise when implementation or design principles are violated. These issues manifest as symptoms or anomalies in the source code. Timely identification of code smells plays a crucial role in enhancing software quality and facilitating software maintenance. Previous studies have shown that code smell detection can be accomplished through the utilization of machine learning (ML) methods. However, despite their increasing popularity, research suggests that the suitability of these methods are not always appropriate due to the problem of imbalanced data. Consequently, the effectiveness of ML models may be negatively affected. This study aims to propose a novel method for detecting code smells by employing five ML algorithms, namely decision tree (DT), k-nearest neighbors (K-NN), support vector machine (SVM), XGboost (XGB), and multi-layer perceptron (MLP). Additionally, to tackle the challenge of imbalanced data, the proposed method incorporates the random oversampling technique. Experiments were conducted in this study using four datasets that encompassed code smells, specifically god-class, data-class, long-method, and feature-envy. The experimental outcomes were evaluated and compared using various performance metrics. Upon comparing the outcomes of our models on both the balanced and original datasets, we found that the XGB model achieved the highest accuracy of 100% for detecting the data class and long method on the original datasets. In contrast, the highest accuracy of 100% was obtained for the data class and long method using DT, SVM, and XGB models on the balanced datasets. According to the empirical findings, there is significant promise in using ML techniques for the accurate prediction of code smells
Improving the accuracy of recurrent neural networks models in predicting software bug based on undersampling methods
Get PDFThe process of identifying software bugs is of paramount importance as it ensures software reliability and facilitates maintenance activities. The quality improvement process of software relies heavily on software bug prediction (SBP). In SBP, the task of accurately identifying defective source code poses a significant challenge. Numerous of machine learning (ML) models has been developed specifically to address this challenge in SBP. Nonetheless, the class imbalance issue restricts the potential of these models to predict software bugs accurately. This issue poses a significant hindrance to the efficiency of these models, leading to imbalanced false-positive and false-negative outcomes. Previous studies have paid limited attention to addressing the challenge of class imbalance in SBP. This study aims to fill this research gap by employing a combination of two recurrent neural networks (RNNs), namely long-short-term memory (LSTM) and gated recurrent unit (GRU), along with an undersampling method (near miss) to effectively tackle this issue. Experiments have been conducted on publicly available benchmark datasets, considering both class-level and file-level metrics. The experimental results lead to the conclusion that our models outperform others and the combination of RNNs models with undersampling methods leads to improved bug prediction performance, particularly for datasets with imbalanced class distributions
Going Beyond Counting First Authors in Author Co-citation Analysis
Get PDFThe present study examines one of the fundamental aspects of author co-citation analysis (ACA) - the way co-citation
counts are defined. Co-citation counting provides the data on which all subsequent statistical analyses and mappings
are based, and we compare ACA results based on two different types of co-citation counting - the traditional type that
only counts the first one among a cited work's authors on the one hand and a non-traditional type that takes into
account the first 5 authors of a cited work on the other hand. Results indicate that the picture produced through this non-traditional author co-citation counting contains more coherent author groups and is therefore considerably clearer. However, this picture represents fewer specialties in the research field being studied than that produced through the traditional first-author co-citation counting when the same number of top-ranked authors is selected and analyzed. Reasons for these effects are discussed
Variations on the Author
Get PDF“Variations on the Author” discusses two of Eduardo Coutinho’s recent films (Um Dia na Vida, from 2010, and Últimas Conversas, posthumously released in 2015) and their contribution to the general question of documentary authorship. The director’s filmography is characterized by a consistent yet self-effacing form of authorial self-inscription: Coutinho often features as an interviewer that rather than express opinions propels discourses; an interviewer that is good at listening. This mode of self-inscription characterizes him as an author who is not expressive but who is nonetheless markedly present on the screen. In Um Dia na Vida, however, Coutinho is completely absent form the image, while Últimas Conversas, on the contrary, includes a confessional prologue that moves the director from the margins to the center of his films. This article examines the ways in which these works stand out in the filmography of a director who offers new insights into the notion of cinematic authorship
- …
