Search

ABSTRACT DevOps is a collaborative software development process where practitioners work as a team to continuously develop, deploy, and deliver software. DevOps practices still need to be mature, and practitioners face numerous challenges while considering DevOps as a software development process. The mainstream research community has helped simplify the DevOps adoption process and eliminate complexities by developing DevOps maturity models. However, the current maturity frameworks cannot measure every component of DevOps and do not mention metrics as parameters for measuring different DevOps practices or features. Therefore, this study aims to identify metrics for measuring practices and activities responsible for DevOps implementation. The systematic literature review (SLR) method was used to determine the metrics needed to measure DevOps practices. Using SLR, we have identified 32 metrics from 57 articles. The metrics identified in this study can be used to measure the impact of the practices adopted for DevOps implementation within software development organizations. Furthermore, we divided the identified metrics into Dev and Ops categories and five significant categories based on the DevOps lifecycle. The classification of metrics in our study into diverse regions provides a conceptual framework and understanding of DevOps measures. [ABSTRACT FROM AUTHOR]

Code smells indicate potential symptoms or problems in software due to inefficient design or incomplete implementation. These problems can affect software quality in the long-term. Code smell detection is fundamental to improving software quality and maintainability, reducing software failure risk, and helping to refactor the code. Previous works have applied several prediction methods for code smell detection. However, many of them show that machine learning (ML) and deep learning (DL) techniques are not always suitable for code smell detection due to the problem of imbalanced data. So, data imbalance is the main challenge for ML and DL techniques in detecting code smells. To overcome these challenges, this study aims to present a method for detecting code smell based on DL algorithms (Bidirectional Long Short-Term Memory (Bi-LSTM) and Gated Recurrent Unit (GRU)) combined with data balancing techniques (random oversampling and Tomek links) to mitigate data imbalance issue. To establish the effectiveness of the proposed models, the experiments were conducted on four code smells datasets (God class, data Class, feature envy, and long method) extracted from 74 open-source systems. We compare and evaluate the performance of the models according to seven different performance measures accuracy, precision, recall, f-measure, Matthew's correlation coefficient (MCC), the area under a receiver operating characteristic curve (AUC), the area under the precision–recall curve (AUCPR) and mean square error (MSE). After comparing the results obtained by the proposed models on the original and balanced data sets, we found out that the best accuracy of 98% was obtained for the Long method by using both models (Bi-LSTM and GRU) on the original datasets, the best accuracy of 100% was obtained for the long method by using both models (Bi-LSTM and GRU) on the balanced datasets (using random oversampling), and the best accuracy 99% was obtained for the long method by using Bi-LSTM model and 99% was obtained for the data class and Feature envy by using GRU model on the balanced datasets (using Tomek links). The results indicate that the use of data balancing techniques had a positive effect on the predictive accuracy of the models presented. The results show that the proposed models can detect the code smells more accurately and effectively. [ABSTRACT FROM AUTHOR]

Code smells are specific patterns or characteristics in software code that indicate potential design or implementation problems. Identifying code smells has gained significant attention in software engineering. It is essential to address code smells to maintain high-quality software systems. Machine learning (ML) models, such as Long Short-Term Memory (LSTM), have been to detect code smells automatically based on source code features. However, the imbalanced distribution of code smells within software projects poses a challenge to the accuracy of these models. This study explores the role of data balancing methods in optimizing the accuracy of the LSTM model for code smell detection. We investigate different techniques for addressing the class imbalance problem, including random oversampling and synthetic minority oversampling techniques (SMOTE). We evaluate the performance of the LSTM model with and without data balancing methods using accuracy, precision, recall, f-measure, Matthew's correlation coefficient (MCC), and the area under a receiver operating characteristic curve (AUC). Our experimental results, conducted on four code smell datasets (God class, data class, feature envy, and long method) extracted from 74 open-source systems, demonstrate the effectiveness of data balancing methods in improving the accuracy of the LSTM model for code smell detection. The results indicate that the use of data balancing methods had a positive effect on the predictive accuracy of the LSTM model. In addition, we compared our proposed method with state-of-the-art code smell detection approaches. The findings from the comparison indicate that our proposed method performs notably better than existing state-ofthe-art approaches across the majority of datasets. [ABSTRACT FROM AUTHOR]

Dependability of software systems is one of the challenging issues for software developers. Main software dependability issues include reliability, security, performability, availability, maintainability, and aging. Software becomes non-dependable due to the overconfidence of developers, lack of knowledge about dependability issues, or ignorance of dependability attributes during software development. Classification and ranking of these non-dependable software modules based on above-mentioned dependability attribute values in early phase are the main aspects of this article. Hence, computation of dependability attribute values becomes a primitive concern here. The values of software dependability attributes depend on various software metrics like: requirement stability, cyclomatic complexity, essential complexity, lines of code, and so on. Neutrosophic inference system (NIS) has been used here to compute the values of dependability attributes accurately, reducing incompleteness, indeterminacy, and impreciseness from metric values by incorporating expert knowledge. An Elman Recurrent Neural Network (ERNN)-based algorithm has been proposed here based on predicted dependability attribute values to classify dependable and non-dependable software modules. Backpropagation algorithm and Genetic Algorithm are used during training of ERNN. Mahalanobis distance (MD) is used to rank software modules based on dependability attributes at early phase of development. This entire process of dependability analysis will help to optimize resource utilization, development cost, and meet the target release time. Different comparison criteria are used to compare the effectiveness of the proposed model with some existing models based on four datasets. Performance analysis demonstrates effectiveness and usefulness for identifying and ranking the non-dependable software modules during early phase of development. [ABSTRACT FROM AUTHOR]

Cross-project defect prediction (CPDP) plays an essential role in identifying potential defects in target projects, especially those with limited historical data, using relevant information from similar source projects. The current studies focused on three main types of software metrics for CPDP: static metrics, code-change metrics, and semantic features. However, these existing CPDP studies encounter two primary challenges: class overlap due to reduced feature dimensions and multicollinearity from integrating various software metrics. To address these challenges, we propose a CPDP model based on both reduction and hybridization techniques (RH-CPDP). The proposed model uses hybrid deep neural networks as a hybridization technique to combine the essential metrics from all metric categories, addressing the issue of class overlap to enhance prediction model efficiency. Principal component analysis (PCA) was used as a reduction method to keep the number of metrics used small, focusing on influential relationships among metrics and fault proneness and avoiding the multicollinearity problem. The experimental analysis conducted using nine open-source projects from the PROMISE dataset demonstrates that RH-CPDP surpasses current CPDP methods (TCSBoost, TPTL, DA-KTSVMO, DBN, and 3SW-MSTL) regarding area under the curve (AUC) and F1-measure. These findings highlight the effectiveness of RH-CPDP in improving the performance of CPDP techniques.

This paper discusses software metrics and their impact on software defect prediction values in the NASA metric data program (MDP) dataset. The NASA MDP dataset consists of four categories of software metrics: halstead, McCabe, LoC, and misc. However, there is no study showing which metrics participate in increasing the area under the curve (AUC) value of the NASA MDP dataset. This study utilizes 12 modules from the NASA MDP dataset, where these 12 modules are being tested into 14 relationships of software metrics derived from the four existing metric categories. Subsequently, classification is performed using the k-nearest neighbor (kNN) method. The research concludes that software metrics have a significant impact on the AUC value, with the LoC+McCabe+misc metrics relationship influencing the improvement of the AUC value. However, the metrics relationship that has the most impact on achieving less optimal AUC values is McCabe. Halstead metric also plays a role in decreasing the performance of other metrics. [ABSTRACT FROM AUTHOR]

Measurement, which can be done directly or indirectly, is the process of providing a quantitative indication of the scope, quantity, dimension, capacity, or characteristics of a process or product. Software may be measured directly in a number of ways, such as cost, effort, amount of code lines, functionality, speed of execution, memory size, documentation, number of inputs and outputs, and flaws in individual units. In contrast, features like functionality, efficiency, dependability, and maintainability are measured by indirect metrics like software quality. A metric is a quantitative measure of the degree of an attribute of an object, system, or process that is produced by the gathering of data for measurement. These metrics need to be gathered and converted into indicators in order to assess the quality of the program. Metrics, or sets of metrics, known as indicators, give management thorough information about a product and aid in process and product control. A system is made up of several interrelated parts that work together to accomplish a certain objective. These systems are broken down into more manageable subsystems that assist the main system. This research seeks to examine how software quality is measured on Marshal Suryadarma Aerospace University's Academic Information System. In addition to helping university administration regulate and enhance the information systems in use, this research is anticipated to offer a thorough grasp of the application of metrics and indicators in assessing and enhancing the caliber of academic software. [ABSTRACT FROM AUTHOR]

Industry practitioners assess software from a security perspective to reduce the risks of deploying vulnerable software. Besides following security best practice guidelines during the software development life cycle, predicting vulnerability before roll‐out is crucial. Software metrics are popular inputs for vulnerability prediction models. The objective of this study is to provide a comprehensive review of the source code‐level security metrics presented in the literature. Our systematic mapping study started with 1451 studies obtained by searching the four digital libraries from ACM, IEEE, ScienceDirect, and Springer. After applying our inclusion/exclusion criteria as well as the snowballing technique, we narrowed down 28 studies for an in‐depth study to answer four research questions pertaining to our goal. We extracted a total of 685 code‐level metrics. For each study, we identified the empirical methods, quality measures, types of vulnerabilities of the prediction models, and shortcomings of the work. We found that standard machine learning models, such as decision trees, regressions, and random forests, are most frequently used for vulnerability prediction. The most common quality measures are precision, recall, accuracy, and F‐measure. Based on our findings, we conclude that the list of software metrics for measuring code‐level security is not universal or generic yet. Nonetheless, the results of our study can be used as a starting point for future studies aiming at improving existing security prediction models and a catalog of metrics for vulnerability prediction for software practitioners. [ABSTRACT FROM AUTHOR]

Insufficient knowledge about a new bug or a new developer, in the context of recommendations done in software bug repositories (SBR) mining, impacts the recommender-system performance and gives rise to a cold start problem (CSP). Many recent cold start solutions based on machine learning in general, and specifically on reinforcement and deep learning, have been published, but the insights from these works are not presented comprehensively and remain scattered, as a result, it is difficult for budding researchers to conclude further enhancements. Also, there is a lack of a survey covering both ML and RL-based solutions for CSP under one hood. So, to bridge these gaps, this article presents a critical review using the PRISMA model. Both ML and RL-based solutions for Cold start problems have been presented in this model through a well-defined taxonomy along with its detailed bibliometric analysis. This article provides 78 significant primary studies published from 2012 to 2022. Findings from this review indicate that different solution strategies based on MABs as well as CMABs, need to be designed for handling cold start settings in the bug and developer context. Moreover, there is a great scope for performance improvement in the state-of-the-art solutions by either improving the accuracy, feature engineering integration, different process metrics exploration, or hyper-parameter tuning. This review will give directions to novice researchers, academicians, and practitioners to work ahead on the issues identified in this contemporary challenging problem. [ABSTRACT FROM AUTHOR]

Software defects are a critical issue in software development that can lead to system failures and cause significant financial losses. Predicting software defects is a vital aspect of ensuring software quality. This can significantly impact both saving time and reducing the overall cost of software testing. During the software defect prediction (SDP) process, automated tools attempt to predict defects in the source codes based on software metrics. Several SDP models have been proposed to identify and prevent defects before they occur. In recent years, recurrent neural network (RNN) techniques have gained attention for their ability to handle sequential data and learn complex patterns. Still, these techniques are not always suitable for predicting software defects due to the problem of imbalanced data. To deal with this problem, this study aims to combine a bidirectional long short-term memory (Bi-LSTM) network with oversampling techniques. To establish the effectiveness and efficiency of the proposed model, the experiments have been conducted on benchmark datasets obtained from the PROMISE repository. The experimental results have been compared and evaluated in terms of accuracy, precision, recall, f-measure, Matthew's correlation coefficient (MCC), the area under the ROC curve (AUC), the area under the precision-recall curve (AUCPR) and mean square error (MSE). The average accuracy of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) was 88%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average accuracy by 6 and 4% compared to the original datasets. The average F-measure of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) were 51%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average F-measure by 43 and 41% compared to the original datasets. The experimental results demonstrated that combining the Bi-LSTM network with oversampling techniques positively affects defect prediction performance in datasets with imbalanced class distributions. [ABSTRACT FROM AUTHOR]

In the recent years some unprecedented changes in business processes have been observed due to pandemic. The world has experienced the power of information technology to sail through this testing times. A huge number of software have been created and used during this pandemic. Agile is the most popular software development methodology in the current decade and its key values are frequent interactions, development of working software, customer collaboration and response to change. These values are heavily dependent on interactions among key stakeholders like developers, testers, scrum masters and customers. Now due to pandemic situation, software development process itself has undergone a few key changes i.e. shifting the workspace to home, restricted travels, challenges in collaborative work in global platform, etc. The research work takes a deep dive into the impact of COVID-19 specially on the health of the software, work environment factors including challenges and survival strategies. The health of a software is investigated by software metrics like productivity, customer satisfaction, defect counts. The work environment aspects include employee motivation, work life balance, ease of global team management, etc. A survey is conducted to collect feedback from more than 4000 IT professionals working on 177 different projects. Finally the results are analyzed both quantitatively and qualitatively and a sustainable future path is suggested with mixed mode of work. To verify the strength and internal consistency of the survey, Cronbach Alpha coefficient method is implemented. The suggested future mode of work is also validated by evidence of implementation of revised work policies in different organization across the globe. [ABSTRACT FROM AUTHOR]

Developers aim to create software with the least possible flaws and good quality. Hence, they apply a sequence of program transformation operations known as refactoring to create such software. Refactoring is a widely known code restructuring technique that enhances the program's structure without modifying its functionality. Internal properties of a system are generally measured using software metrics that help to understand both qualitative and quantitative aspects of the software. The authors explored the interrelationship between batch refactorings and software metrics in this study. Batch refactorings are a set of multiple inter-related refactoring operations that a developer applies to achieve the desired quality of the system. The refactorings have been extracted from different versions of three open-source datasets, Thumbnailator, Mp3agic, and Tabula-java. The extracted refactorings are studied under five categories of refactoring batches, i.e., class, method, field, parameter, and attribute. In addition, seven prominent software metrics have been used to investigate the impact of batch refactorings on critical software metrics and software quality. A software metric is considered critical if it does not lie within the set threshold value of the respective metric. The findings of the study show that 43% of the batch refactorings belong to method-level batches. Approximately 74.3% of the batch refactorings have been applied to the classes that comprise at least one critical software metric. Also, on an average method level batches improved the metrics by 27.7% and thus outperformed other batches in improving the overall quality of the software. The results of this study help in better understanding the relationship between batch refactoring and software quality, and thus the developers can make an appropriate decision in choosing the best refactoring batches for achieving the maximum software quality. [ABSTRACT FROM AUTHOR]

The advent of Generative Artificial Intelligence is opening essential questions about whether and when AI will replace human abilities in accomplishing everyday tasks. This issue is particularly true in the domain of software development, where generative AI seems to have strong skills in solving coding problems and generating software source code. In this paper, an empirical evaluation of AI-generated source code is performed: three complex coding problems (selected from the exams for the Java Programming course at the University of Insubria) are prompted to three different Large Language Model (LLM) Engines, and the generated code is evaluated in its correctness and quality by means of human-implemented test suites and quality metrics. The experimentation shows that the three evaluated LLM engines are able to solve the three exams but with the constant supervision of software experts in performing these tasks. Currently, LLM engines need human-expert support to produce running code that is of good quality. [ABSTRACT FROM AUTHOR]

Summary: Software evolution is the process of adapting, maintaining, and updating a software system. This process concentrates the most significant part of the software costs. Many works have studied software evolution and found relevant insights, such as Lehman's laws. However, there is a gap in how software systems evolve from an internal dimensions point of view. For instance, the literature has indicated how systems grow, for example, linearly, sub‐linearly, super‐linearly, or following the Pareto distribution. However, a well‐defined pattern of how this phenomenon occurs has not been established. This work aims to define a novel method to analyze and predict software evolution. We based our strategy on time series analysis, linear regression techniques, and trend tests. In this study, we applied the proposed model to investigate how the internal structure of object‐oriented software systems evolves in terms of four dimensions: coupling, inheritance hierarchy, cohesion, and class size. Applying the proposed method, we identify the functions that better explain how the analyzed dimensions evolve. Besides, we investigate how the relationship between dimension metrics behave over the systems' evolution and the set of classes existing in the systems that affect the evolution of these dimensions. We mined and analyzed data from 46 Java‐based open‐source projects. We used eight software metrics regarding the dimensions analyzed in this study. The main results of this study reveal ten software evolution properties, among them: coupling, cohesion, and inheritance evolve linearly; a relevant percentage of classes contributes to coupling and size evolution; a small percentage of classes contributes to cohesion evolution; there is no relation between the software internal dimensions' evolution. The results also indicate that our method can accurately predict how the software system will evolve in short‐term and long‐term predictions. [ABSTRACT FROM AUTHOR]

Behavioral diagrams in Unified Modeling Language reflect the interaction between system components and give a comprehensive description and visualization of the system during the design phase. One of the most important behavioral diagrams is the sequence diagram which describes the chronological sequence of events between the components of the system. The process of extracting information and metrics from a sequence diagram is time-consuming so creating a special tool to help developers obtain information from the sequence diagram has become necessary because of the great advantages and ease it provides. This paper aims to build a tool that extracts information from the sequence diagram, creates a table that includes this information, and then calculates three categories of metrics related to the sequence diagram which are size, complexity, and level of detail. These categories include 15 metrics to give quantitative values that indicate software quality which is used to estimate the schedule, cost, effort, and other resources in the software development process. As a case study, the hotel reservation system is adopted and constructed as two versions of sequence diagrams for comparison purposes. The results showed a quantitative measurement of small and unnoticeable differences between the two diagrams.

[Context:] Failure to predict vulnerability in the earlier stage of development can cause vulnerable code being written and deployed in the final software product. Vulnerability prediction using software metrics as features can support the discovery process by localizing vulnerable code. Existing studies have successfully employed metrics for vulnerability prediction for some platforms (C/C++ or Java projects). We propose that a comparative evaluation of how these metrics perform in projects of different languages can help the developers in deciding whether metrics-based prediction approach can be effective in their own project's context. [Objective:] The purpose of this research is to analyze/compare the performance of software metrics in vulnerability-prediction for different programming language contexts (Java vs. Python). [Method:] We conducted experiments on vulnerabilities reported for Apache Tomcat (releases 6 and 7), Apache CXF, and two Python projects (Django and Keystone). We applied machine learning for predicting a particular type of code component (Java and Python classes) as vulnerable/non-vulnerable. [Results:] We found that metrics-based prediction can predict Java vulnerable classes with higher recall and precision than the Python vulnerable classes. [Conclusion:] This study at class-level will help developers to predict vulnerabilities at the class-level and assist in secure coding in object-oriented programming. [ABSTRACT FROM AUTHOR]

Refactoring is a maintenance task that aims at enhancing the quality of a software's source code by restructuring it without affecting the external behavior. Move method refactoring (MMR) involves reallocating a method by moving it from one class to the class in which the method is used most. Several studies have been performed to explore the impact of MMR on several quality attributes. However, these studies have several limitations related to the applied approaches, considered quality attributes, and size of the selected datasets. This paper reports an empirical study that applies statistical and machine learning (ML) approaches to explore the impact of MMR on code quality. The study overcame the limitations of the existing studies, and this improvement is expected to make the results of this study more reliable and trustworthy. We considered eight quality attributes and thirty quality measures, and a total of approximately 4 K classes from seven Java open-source systems were involved in the study. The results provide evidence that most of the quality attributes were significantly improved by MMR in most cases. In addition, the results show that a limited number of measures, when considered individually, have a significant ability to predict MMR, whereas most of the considered measures, when considered together, significantly contribute to the MMR prediction model. The constructed ML-based prediction model has an area under curve (AUC) value of 96.6%. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Education & Science is the property of Republic of Iraq Ministry of Higher Education & Scientific Research (MOHESR) and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Effort estimations are a crucial aspect of software development. The tasks should be completed before the start of any software project. Accurate estimations increase the chances of project success, and inaccurate information can lead to severe issues. This study systematically reviewed the literature on effort-estimating models from 2015-2024, identifying 69 relevant studies from various publications to compile information on various software work estimation models. This review aims to analyze the models proposed in the literature and their classification, the metrics used for accuracy measurement, the leading model that has been chiefly applied for effort estimation, and the benchmark datasets available. The study utilized 542 relevant articles on software development, cost, effort, prediction, estimation, and modelling techniques in the search strategy. After 194 selections, the authors chose 69 articles to understand ML applications in SEE comprehensively. The researchers used a scoring system to assess each study’s responses (from 0 to 5 points) to their research questions. This helped them identify credible studies with higher scores for a comprehensive review aligned with its objectives. The data extraction process identified 91% (63) of 69 studies as either highly or somewhat relevant, demonstrating a successful search strategy for analysis. The literature review on SEE indicates a growing preference for ML-based models in 59% of selected studies. 17% of the studies chosen favor hybrid models to overcome software development challenges. We qualitatively analyzed all the literature on software effort estimation using expert judgment, formal estimation techniques, ML-based techniques, and hybrid techniques. We discovered that researchers have frequently used ML-based models to estimate software effort and are currently in the lead. This study also explores the application of feature importance and selection in machine learning models for Software Effort Estimation (SEE) using popular algorithms like support Vector Machine (SVM), AdaBoost (AB), Gradient Boost (GB), and Random Forest (RF) with six benchmark datasets like CHINA, COCOMO-NASA2, COCOMO, COCOMO81, DESHARNAIS, and KITCHENHAM. We analyze the dataset descriptions and feature importance of the dataset analysis using ML models for choosing crucial play attributes in SEE.

The cause–effect relationship has tremendous role in interpreting the engineering and scientific problems which basically deals with the identifying potential causes of problem. Bayesian belief networks (BBN) also referred as Bayesian casual probabilistic network used widely to deal with probabilistic events to elucidate the complications having uncertainty. A major challenge in BBN is to construct a node probability table (NPT), which grows exponentially with the rising number of variables. Various approaches exist for NPT construction, including expert elicitation, data analysis, survey and weighted functions, noisy-OR, noisy-MAX, recursive noisy-OR (ROR), extended recursive noisy-OR, and ranked nodes. However, these methods are problem-specific and lacking behind a generalized approach applicable to all problem types. To address this issue, this paper proposes a generalized universal approach for constructing the NPT using fuzzy logic. The suggested strategy has been validated by applying it to a BBN prototype for software design and development. The proposed strategy has been evaluated with best-case and worst-case software metrics. [ABSTRACT FROM AUTHOR]

The complexity of the software allows us to analyze how difficult to understand, implement and maintain the program can be. The metrics allow us to measure and estimate certain characteristics of the software to make decisions and corrective or preventive actions. The definition of the complexity of the microservices-based applications design is fundamental since it directly affects the performance of the application, development, testing, maintainability, storage (transactions and distributed queries), and the use and consumption of computational resources. In this paper, a cognitive complexity metric is proposed to evaluate the design and granularity of microservices-based applications, which define the required effort, or degree of difficulty to understand the microservices that make up the system. Typical cases were analyzed, which can appear in the design of microservices-based applications, the calculation of cognitive complexity was correct and consistent with the difficulty of understanding, maintaining, and developing a microservice system, therefore it is a viable option for analyzing complexity in microservices-based architecture. [ABSTRACT FROM AUTHOR]

Over the years, various software quality measurement models have been proposed and used in academia and the software industry to assess the quality of produced code and to obtain guidelines for its improvement. In this article, we describe the design and functionality of SQMetrics, a tool for calculating object-oriented quality metrics for projects written in Java. SQMetrics provides the convenience of measuring small code, mainly covering academic or research needs. In this context, the application can be used by students of software engineering courses to make measurements and comparisons in their projects and gradually increase their quality by improving the calculated metrics. Teachers, on the other hand, can use SQMetrics to evaluate students' Java projects and grade them in proportion to their quality. The contribution of the proposed tool is three-fold, as it has been: (a) tested for its completeness and functionality by comparing it with widely known similar tools, (b) evaluated for its usability and value as a learning aid by students, and (c) statistically tested for its value as a teachers' aid assisting in the evaluation of student projects. Our findings verify SQMetrics' effectiveness in helping software engineering students learn critical concepts and improve the quality of their code, as well as in helping teachers assess the quality of students' Java projects and make more informed grading decisions. [ABSTRACT FROM AUTHOR]

Code 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.

Over the years, various software quality measurement models have been proposed and used in academia and the software industry to assess the quality of produced code and to obtain guidelines for its improvement. In this article, we describe the design and functionality of SQMetrics, a tool for calculating object-oriented quality metrics for projects written in Java. SQMetrics provides the convenience of measuring small code, mainly covering academic or research needs. In this context, the application can be used by students of software engineering courses to make measurements and comparisons in their projects and gradually increase their quality by improving the calculated metrics. Teachers, on the other hand, can use SQMetrics to evaluate students’ Java projects and grade them in proportion to their quality. The contribution of the proposed tool is three-fold, as it has been: (a) tested for its completeness and functionality by comparing it with widely known similar tools, (b) evaluated for its usability and value as a learning aid by students, and (c) statistically tested for its value as a teachers’ aid assisting in the evaluation of student projects. Our findings verify SQMetrics’ effectiveness in helping software engineering students learn critical concepts and improve the quality of their code, as well as in helping teachers assess the quality of students’ Java projects and make more informed grading decisions.

Abstract The ever‐growing open‐source software tools in different domains increase the difficulty of software selection from the end‐users perspective. The process of evaluating, comparing, and selecting open‐source solutions is far from trivial. Especially, when additional requirements need to be considered, the existing methodologies will fail to adapt to the new tasks. The objective of this study is to present a solution for dealing with this issue. A novel approach, CTHP, is presented for the evaluation and selection of open‐source software in the Bioinformatics domain. First, the ISO 25010 quality model is chosen as the basis. This model is customised according to the special characteristics of the Bioinformatics applications. The customisation is done by extracting the quality factors from the Bioinformatics applications, weighting these factors from the viewpoints of both developers and end‐users, and adding them to the model. After that, Three‐way Decision and Delphi Hierarchy Process are integrated to assist in the selection for adoption. Finally, as a case study, the proposed approach is applied to assist the decision‐making process of two popular natural language processing frameworks in the Bioinformatics area. Our study is a valuable contribution since it provides a systematic way to document the decision‐making process and help the researchers and practitioners of Bioinformatics to make better decisions among the alternatives.

Abstract Effort‐aware cross‐project defect prediction (EACPDP), which uses cross‐project software modules to build a model to rank within‐project software modules based on the defect density, has been suggested to allocate limited testing resource efficiently. Recently, Ni et al. proposed an EACPDP method called EASC, which used all cross‐project modules to train a model without considering the data distribution difference between cross‐project and within‐project data. In addition, Ni et al. employed the different defect density calculation strategies when comparing EASC and baseline methods. To explore the effective defect density calculation strategies and methods on EACPDP, the authors compare four data filtering methods and five transfer learning methods with EASC using four commonly used defect density calculation strategies. The authors use three classification evaluation metrics and seven effort‐aware metrics to assess the performance of methods on 11 PROMISE datasets comprehensively. The results show that (1) The classification before sorting (CBS+) defect density calculation strategy achieves the best overall performance. (2) Using balanced distribution adaption (BDA) and joint distribution adaptation (JDA) with the K‐nearest neighbour classifier to build the EACPDP model can find 15% and 14.3% more defective modules and 11.6% and 8.9% more defects while achieving the acceptable initial false alarms (IFA). (3) Better comprehensive classification performance of the methods can bring better EACPDP performance to some extent. (4) A flexible adjustment of the defect threshold λ of the CBS+ strategy contribute to different goals. In summary, the authors recommend researchers and practitioners use to BDA and JDA with the CBS+ strategy to build the EACPDP model.

The reliability of software product is seen as critical quality factor that cannot be overemphasized. Since real world application is loaded with high amount of uncertainty, such as applicable to software reliability, there should be a technique of dealing with such uncertainty. This paper presents a reliability model to effectively handle uncertainty in software data to enhance reliability prediction of software at the early (requirements and design) stages of Software Development Life Cycle (SDLC). In this paper, a hybrid methodology of Takagi Sugeno Kang (TSK)-based Interval Type-2 Fuzzy Logic System (IT2FLS) with Artificial Neural Network (ANN) learning is employed for the prediction of software reliability. The parameters of the model are optimized using Gradient Descent (GD) back-propagation method. Relevant reliability software requirement and design metrics and software size metrics are utilized as inputs. The proposed approach uses twenty-eight real software project data. The performance of the model is evaluated using five performance metrics and found to provide output values that are very close to the actual output showing better predictive accuracy.

Code 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. [ABSTRACT FROM AUTHOR]

The 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-shortterm 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. [ABSTRACT FROM AUTHOR]

Software measures play an eminent role in the evaluation of quality of a web-based application. As people increasingly rely on web-based applications, the importance of examining web quality parameters has escalated. Customer acceptability is low when a low-quality web application fails to meet the implicit and explicit expectations of customers. Many frameworks for measuring quality criteria of web-based applications have been proposed so far, but they all fall short in some way. The majority of existing frameworks are either limited to a specific web-based application perspective or deal with a limited set of quality attributes. Based on the constraints of current frameworks, this paper offers the multi-attribute quality model (MAQM), a generic conceptual object-oriented framework for quantifying non-functional aspects of web development. This paper quantifies charismatic quality parameters which is non-functional parameter and sub-characteristic under web visitor's perspective of MAQM model, using fuzzy logic. The approach is chosen due to the heterogeneous and unpredictable nature of the web applications. Charismatic non-functional parameters are the important feature in customer entrenchment towards any web-based application. [ABSTRACT FROM AUTHOR]

Software development has a problem with transparency/visibility. As an intangible product, software and its intermediate development results are hard to see or touch. Customers of custom software have difficulties checking progress, and risk coming out with costly but low-quality software. In the space domain with its often expensive and one-of-a-kind devices, which are developed in complex multitier supply chains, the risk is even greater. This paper presents the SKQuest data set. It contains the completed responses with 190 variables from an empirical study with over 100 software experts. The data set covers distinct aspects of measuring metrics and transparency in software projects. To show what information lies in the data set, the paper investigates, and affirms, from different perspectives, the following questions: Is transparency a problem in software development projects? Is there a desire for more transparency in projects? Can metrics contribute to improving the situation? Moreover, it attempts to replicate the results of an earlier study. The main contribution of this paper is, however, the SKQuest data set that is published with this paper in CSV formatas. It is a tool that enables systematic investigations of software metrics and allows research on how they can improve the efficiency of the software lifecycle, not limited to, but particularly with respect to transparency. Consequently, the paper may serve as a starting point for future research avenues in academia and industry and help to improve existing and future standards in software development.

The Internet of Things (IoT) touches almost every aspect of modern society and has changed the way people live, work, travel and, do business. Because of its importance, it is essential to ensure that an IoT system is performing well, as desired and expected, and that this can be assessed and managed with an adequate set of IoT performance metrics. The aim of this study is to systematically inventory and classify recent studies that have investigated IoT metrics. The authors conducted a literature review based on studies published between January 2010 and December 2021 using a set of five research questions (RQs) on the current knowledge bases for IoT metrics. A total of 158 IoT metrics were identified and classified into 12 categories according to the different parts and aspects of an IoT system. To cover the overall performance of an IoT system, the 12 categories were organized into an ontology. The results show that the category of network metrics was most frequently discussed in 43% of the studies and, with the highest number of metrics at 37%. This study can provide guidelines for researchers and practitioners in selecting metrics for IoT systems and valuable insights into areas for improvement and optimization.

The advent of Generative Artificial Intelligence is opening essential questions about whether and when AI will replace human abilities in accomplishing everyday tasks. This issue is particularly true in the domain of software development, where generative AI seems to have strong skills in solving coding problems and generating software source code. In this paper, an empirical evaluation of AI-generated source code is performed: three complex coding problems (selected from the exams for the Java Programming course at the University of Insubria) are prompted to three different Large Language Model (LLM) Engines, and the generated code is evaluated in its correctness and quality by means of human-implemented test suites and quality metrics. The experimentation shows that the three evaluated LLM engines are able to solve the three exams but with the constant supervision of software experts in performing these tasks. Currently, LLM engines need human-expert support to produce running code that is of good quality.

Developing error-free applications is a major challenge for computer scientists. Tools to remedy this problem have been developed, notably Rule Checkers and proof assistants. As a particular case of error, a bug is by nature intangible, invisible and difficult to trace. We propose to investigate the correlations between the alerts generated by rule checkers and the internal quality of the software system. In this first version of the work, we present M2SmallLint, a tool for visualizing and navigating through source code properties in order to locate potential errors. This tool enables the visualization of software health.

The software is changing rapidly with the invention of advanced technologies and methodologies. The ability to rapidly and successfully upgrade software in response to changing business requirements is more vital than ever. For the long‐term management of software products, measuring software maintainability is crucial. The use of soft computing techniques for software maintainability prediction has shown immense promise in software maintenance process by providing accurate prediction of software maintainability. To better understand the role of soft computing techniques for software maintainability prediction, we aim to provide a systematic literature review of soft computing techniques for predicting software maintainability. Firstly, we provide a detailed overview of software maintainability. Following this, we explore the fundamentals of software maintainability and the reasons for adopting soft computing methodologies for predicting software maintainability. Later, we examine the soft computing approaches employed in the process of software maintainability prediction. Furthermore, we discuss the difficulties and potential solutions associated with the use of soft computing techniques in predicting maintainability of software. Finally, we conclude the review with some promising future directions to drive further research innovations and developments in this promising area. This systematic literature review provides a comprehensive overview of the soft computing strategies utilized for software maintainability for future researchers. [ABSTRACT FROM AUTHOR]

The ever‐growing open‐source software tools in different domains increase the difficulty of software selection from the end‐users perspective. The process of evaluating, comparing, and selecting open‐source solutions is far from trivial. Especially, when additional requirements need to be considered, the existing methodologies will fail to adapt to the new tasks. The objective of this study is to present a solution for dealing with this issue. A novel approach, CTHP, is presented for the evaluation and selection of open‐source software in the Bioinformatics domain. First, the ISO 25010 quality model is chosen as the basis. This model is customised according to the special characteristics of the Bioinformatics applications. The customisation is done by extracting the quality factors from the Bioinformatics applications, weighting these factors from the viewpoints of both developers and end‐users, and adding them to the model. After that, Three‐way Decision and Delphi Hierarchy Process are integrated to assist in the selection for adoption. Finally, as a case study, the proposed approach is applied to assist the decision‐making process of two popular natural language processing frameworks in the Bioinformatics area. Our study is a valuable contribution since it provides a systematic way to document the decision‐making process and help the researchers and practitioners of Bioinformatics to make better decisions among the alternatives. [ABSTRACT FROM AUTHOR]

Effort‐aware cross‐project defect prediction (EACPDP), which uses cross‐project software modules to build a model to rank within‐project software modules based on the defect density, has been suggested to allocate limited testing resource efficiently. Recently, Ni et al. proposed an EACPDP method called EASC, which used all cross‐project modules to train a model without considering the data distribution difference between cross‐project and within‐project data. In addition, Ni et al. employed the different defect density calculation strategies when comparing EASC and baseline methods. To explore the effective defect density calculation strategies and methods on EACPDP, the authors compare four data filtering methods and five transfer learning methods with EASC using four commonly used defect density calculation strategies. The authors use three classification evaluation metrics and seven effort‐aware metrics to assess the performance of methods on 11 PROMISE datasets comprehensively. The results show that (1) The classification before sorting (CBS+) defect density calculation strategy achieves the best overall performance. (2) Using balanced distribution adaption (BDA) and joint distribution adaptation (JDA) with the K‐nearest neighbour classifier to build the EACPDP model can find 15% and 14.3% more defective modules and 11.6% and 8.9% more defects while achieving the acceptable initial false alarms (IFA). (3) Better comprehensive classification performance of the methods can bring better EACPDP performance to some extent. (4) A flexible adjustment of the defect threshold λ of the CBS+ strategy contribute to different goals. In summary, the authors recommend researchers and practitioners use to BDA and JDA with the CBS+ strategy to build the EACPDP model. [ABSTRACT FROM AUTHOR]