Search

It has been argued that reporting software engineering experiments in a standardized way helps researchers find relevant information, understand how experiments were conducted and assess the validity of their results. Various guidelines have been proposed specifically for software engineering experiments. The benefits of such guidelines have often been emphasized, but the actual uptake and practice of reporting have not yet been investigated since the introduction of many of the more recent guidelines. In this research, we utilize a mixed-method study design including sequence analysis techniques for evaluating to which extent papers follow such guidelines. Our study focuses on the four most prominent software engineering journals and the time period from 2000 to 2020. Our results show that many experimental papers miss information suggested by guidelines, that no de facto standard sequence for reporting exists, and that many papers do not cite any guidelines. We discuss these findings and implications for the discipline of experimental software engineering focusing on the review process and the potential to refine and extend guidelines, among others, to account for theory explicitly. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special issue of the journal "Programming & Computer Software" titled "Recent Trends on Advanced Computing: The Converging Technologies." The issue features research and practical implementation results from researchers and industry experts in computer science, engineering, and technology. The papers cover a range of topics including microservices, software quality, user engagement on social media, non-functional requirements, medical software architecture, fallacies in political speeches, intelligent learning environments, and more. The guest editors for this special issue are Prof. Dr. Andrei Tchernykh, Prof. Reyes Juárez Ramírez, Dr. Esteban Mocskos, and Prof. Sergio Nesmachnow. [Extracted from the article]

Effort estimation is a crucial aspect of software development, as it helps project managers plan, control, and schedule the development of software systems. This research study compares various machine learning techniques for estimating effort in software development, focusing on the most widely used and recent methods. The paper begins by highlighting the significance of effort estimation and its associated difficulties. It then presents a comprehensive overview of the different categories of effort estimation techniques, including algorithmic, model-based, and expert-based methods. The study concludes by comparing methods for a given software development project. Random Forest Regression algorithm performs well on the given dataset tested along with various Regression algorithms, including Support Vector, Linear, and Decision Tree Regression. Additionally, the research identifies areas for future investigation in software effort estimation, including the requirement for more accurate and reliable methods and the need to address the inherent complexity and uncertainty in software development projects. This paper provides a comprehensive examination of the current state-of-the-art in software effort estimation, serving as a resource for researchers in the field of software engineering. [ABSTRACT FROM AUTHOR]

Practitioners perceive software productivity as one of the most important subjects of software engineering (SE) because it connects technical to social and economic aspects. Nonetheless, software processes are complex and productivity means different things to different people. In order to realize the full contribution of software productivity research to the industrial practice of SE, the analysis and synthesis of existing practitioner viewpoints and concerns are required. A systematic mapping study is developed here to investigate the existence of diverse empirical perceptions of productivity within the distinct business sectors and knowledge areas covered by the industrial practice of SE, also identifying the commonalities among them. This study adopts the DBLP and Scopus search engines to identify bibliographic references from 1987 to 2021 related to software productivity. References that do not correspond to complete not-later-subsumed articles published in peer-reviewed journals and proceedings are excluded from the analyses. Only papers reporting on empirical studies based on software industry data or that present industry practitioner viewpoints are included in these analyses. In total, 99 papers are analyzed. The mapping found great variability in study findings, particularly concerning the impacts of agile development practices on software productivity. The systematic mapping also drew methodological recommendations to help industry practitioners address this subject and develop further research. [ABSTRACT FROM AUTHOR]

The manufacturing sector is increasingly integrating additive manufacturing and robotics, marking a significant evolution in production methods. This paper delves into the field of robotic-assisted additive manufacturing, highlighting the use of robotic arms to enhance the efficiency and precision of the 3D printing process. Central to this research is the adaptation of the Universal Robot UR3e model within a 3D printing system. The study confronts and resolves numerous challenges, such as selecting a suitable printing extruder, determining appropriate material types, and optimizing nozzle dimensions. Essential aspects like developing control software for the robot arm and extruder, interpreting 3D models into robotic instructions, and calibrating the hardware are examined in detail. These processes involve fine-tuning the arm's motion, optimizing material extrusion rates, and conducting comprehensive testing to ensure accuracy and quality of the printed objects. This multidisciplinary approach underlines the complexities of merging 3D printing with robotic technology, necessitating expertise across mechanical, electrical, automation, and software engineering domains. A key focus of this paper is not just the technical implementation but also the practical outcomes. Experiments were conducted to evaluate the compatibility between the G-code program and the RoboDK software, leading to the successful physical realization of the printed products. These experiments demonstrated not only the feasibility of the system but also its potential for producing high-quality, precise 3D printed objects. The results obtained underscore the effectiveness of the integrated system in actual manufacturing scenarios, paving the way for advanced applications in robotic-assisted 3D printing. [ABSTRACT FROM AUTHOR]

Background: Research shows that emotional intelligence (EI) should be used alongside cognitive intelligence during requirements change (RC) handling in Software Engineering (SE), especially in agile settings. Objective: We wanted to study the role of EI in-depth during RC handling. Method: We conducted a mixed-methods study (an interview study followed by a survey study) with 124 software practitioners. Findings: We found the causal condition, intervening condition and causes lead to key direct consequences of regulating own emotions, managing relationships, and extended consequences of sustaining productivity, setting and sustaining team goals. We found several strategies of supporting EI during RC handling. Further, we found strong correlations between six strategies and one being aware of own emotions, regulating own emotions, sustaining team productivity, and setting and sustaining team goals. Conclusion: Empathising with others and tracking commitments and decisions as a team are key strategies that have strong correlations between managing emotions, between sustaining team productivity, and between setting and sustaining team goals. To the best of our knowledge, the framework we present in this paper is the first theoretical framework on EI in SE research. We provide recommendations for software practitioners to consider during RC handling. [ABSTRACT FROM AUTHOR]

Automated software transformations and the process of automated program repair and improvement are an important aspect of modern software engineering practices. In this paper, we describe a system which uses a graph-based deep learning model that can be trained to automatically transform and improve computer programs. By operating on language-agnostic, universal graph-like structures easily extractable from source code files (abstract syntax trees), the deep learning agent learns which transformations should be effectively applied to various structures recognized in the source code in order to improve it. By defining a metric which we want to improve and introducing an optimization task—a reinforcement learning setting, an agent learns to automatically apply a chain of transformations to the program, drastically improving it. While similar program improvement processes exist, they exclusively use exhaustive search algorithms to try all the possible code transformations which is a long process susceptible to local optimum issues. Our solution aims to model and embed structural knowledge about the programs being transformed which greatly helps the agent to choose best possible code transformations to apply. Elements of the approach we present in this paper are further applicable not just to automatic software improvement tasks, but also to other code-related tasks. [ABSTRACT FROM AUTHOR]

Models are the key tools humans use to manage complexity in description, development, and analysis. This applies to all scientific and engineering disciplines and in particular to the development of software and data-intensive systems. However, different methods and terminologies have become established in the individual disciplines, even in the sub-fields of Informatics, which raises the need for a comprehensive and cross-sectional analysis of the past, present, and future of modeling research. This paper aims to shed some light on how different modeling disciplines emerged and what characterizes them with a discussion of the potential toward a common modeling future. It focuses on the areas of software, data, and process modeling and reports on an analysis of the research approaches, goals, and visions pursued in each, as well as the methods used. This analysis is based on the results of a survey conducted in the communities concerned, on a bibliometric study, and on interviews with a prominent representative of each of these communities. The paper discusses the different viewpoints of the communities, their commonalities and differences, and identifies possible starting points for further collaboration. It further discusses current challenges for the communities in general and modeling as a research topic in particular and highlights visions for the future. [ABSTRACT FROM AUTHOR]

Engineers use software defect prediction (SDP) to locate vulnerable areas of software. Recently, statement-level SDP has attracted the attention of researchers due to its ability to localize faulty code areas. This paper proposes DP-Tramo, a new model dedicated to improving the state-of-the-art statement-level SDP. We use Clang to extract abstract syntax trees from source code and extract 32 statement-level metrics as static features for each sentence. Then we feed static features and token sequences as inputs to our improved R-Transformer to learn the syntactic and semantic features of the code. Furthermore, we use label smoothing and weighted loss to improve the performance of DP-Tramo. To evaluate DP-Tramo, we perform a 10-fold cross-validation on 119,989 C/C++ programs selected from Code4Bench. Experimental results show that DP-Tramo can classify the dataset with an average performance of 0.949, 0.602, 0.734 and 0.737 regarding the recall, precision, accuracy and F1-measure, respectively. DP-Tramo outperforms the baseline method on F1-measure by 1.2% while maintaining a high recall rate. [ABSTRACT FROM AUTHOR]

Software defect prediction is a critical task in software engineering that aims to identify and mitigate potential defects in software systems. In recent years, numerous techniques and approaches have been developed to improve the accuracy and efficiency of the defect prediction model. In this research paper, we proposed a comprehensive approach that addresses class imbalance by utilizing stratified splitting, explainable AI techniques, and a hybrid machine learning algorithm. To mitigate the impact of class imbalance, we employed stratified splitting during the training and evaluation phases. This method ensures that the class distribution is maintained in both the training and testing sets, enabling the model to learn from and generalize to the minority class examples effectively. Furthermore, we leveraged explainable AI methods, Lime and Shap, to enhance interpretability in the machine learning models. To improve prediction accuracy, we propose a hybrid machine learning algorithm that combines the strength of multiple models. This hybridization allows us to exploit the strength of each model, resulting in improved overall performance. The experiment is evaluated using the NASA-MD datasets. The result revealed that handling the class imbalanced data using stratify splitting approach achieves a better overall performance than the SMOTE approach in SDD (Software Defect Detection). [ABSTRACT FROM AUTHOR]

An inherent problem in software engineering is that competing prediction systems have been found to produce conflicting results. Yet accurate prediction is crucial because the complexity and quality of software requirements have dramatically changed in recent years, and consumers have become considerably more demanding in terms of the cost, timeframe, and quality of software solutions. Moreover, these variables may also be in direct conflict and can only be resolved by the optimum development of software by using reliable software engineering strategies. In this paper, a novel method based on the integration of the mine blast algorithm (MBA) and the simulated annealing (SA) algorithm is used to create input connection weights and biases for a back propagation neural network (BPNN) for the purpose of addressing the software fault prediction problem (SFP). The aim of hybridizing the MBA and SA is to find a way to efficiently explore and manipulate the search space. The proposed MBA-SA was tested on 18 datasets for SFP. The results indicated that the MBA-SA outperformed the MBA on all datasets. These results were subjected to additional statistical validity, boxplot distribution, and convergence analysis. Furthermore, a comparative evaluation of MBA-SA against twenty state-of-the-art methods for various output metrics was performed, and the result indicated that the hybrid MBA-SA outperformed most other state-of-the-art methods in the majority of datasets. [ABSTRACT FROM AUTHOR]

Measuring software quality requires software engineers to understand the system’s quality attributes and their measurements. The quality attribute is a qualitative property; however, the quantitative feature is needed for software measurement, which is not considered during the development of most software systems. Many research studies have investigated different approaches for measuring software quality, but with no practical approaches to quantify and measure quality attributes. This paper proposes a software quality measurement model, based on a software interconnection model, to measure the quality of software components and the overall quality of the software system. Unlike most of the existing approaches, the proposed approach can be applied at the early stages of software development, to different architectural design models, and at different levels of system decomposition. This article introduces a software measurement model that uses a heuristic normalization of the software’s internal quality attributes, i.e., coupling and cohesion, for software quality measurement. In this model, the quality of a software component is measured based on its internal strength and the coupling it exhibits with other component(s). The proposed model has been experimented with nine software engineering teams that have agreed to participate in the experiment during the development of their different software systems. The experiments have shown that coupling reduces the internal strength of the coupled components by the amount of coupling they exhibit, which degrades their quality and the overall quality of the software system. The introducedmodel can help in understanding the quality of software design. In addition, it identifies the locations in software design that exhibit unnecessary couplings that degrade the quality of the software systems, which can be eliminated. [ABSTRACT FROM AUTHOR]

Deep learning (DL) has become a key component of modern software. In the “big model” era, the rich features of DL-based software (i.e., DL software) substantially rely on powerful DL models, e.g., BERT, GPT-3, and the recently emerging GPT-4, which are trained on the powerful cloud with large datasets. Hence, training effective DL models has become a vital stage in the whole software lifecycle. When training deep learning models, especially those big models, developers need to parallelize and distribute the computation and memory resources amongst multiple devices (e.g., a cluster of GPUs) in the training process, which is known as distributed deep learning training, or distributed training for short. However, the unique challenges that developers encounter in distributed training process have not been studied in the software engineering community. Given the increasingly heavy dependence of current DL-based software on distributed training, this paper aims to fill in the knowledge gap and presents the first comprehensive study on developers’ issues in distributed training. To this end, we focus on popular DL frameworks that support distributed training (including TensorFlow, PyTorch, Keras, and Horovod) and analyze 1,131 real-world developers’ issues about using these frameworks reported on Stack Overflow and GitHub. We construct a fine-grained taxonomy consisting of 30 categories regarding the fault symptoms and summarize common fix patterns for different symptoms. We find that: (1) many distributed-specific faults and non-distributed-specific faults inherently share the same fault symptoms, making it challenging to debug; (2) most of the fault symptoms have frequent fix patterns; (3) about half of the faults are related to system-level configurations. Based on the results, we suggest actionable implications on research avenues that can potentially facilitate the distributed training to develop DL-based software, such as focusing on the frequent and common fix patterns when designing testing or debugging tools, developing efficient testing and debugging techniques for communication configuration along with the synthesis of network configuration analysis, designing new multi-device checkpoint-and-replay techniques to help reproduction, and designing serverless APIs for cloud platforms. [ABSTRACT FROM AUTHOR]

The text of software knowledge community contains abundant knowledge of software engineering field. The software knowledge entity and relation can be extracted automatically and efficiently to form the software knowledge graph, which is helpful for software knowledge-centric intelligent applications, such as intelligent question answering, automatic document generation and software expert recommendation. Most existing methods are confronted with problems of task dependence and entity overlap. In this paper, we propose a software knowledge extraction method based on span-level contrastive learning. From the level of sentence sequence modelling, we model the sentence sequence with span as a unit, and generate abundant positive and negative samples of entity span through the span representation layer to avoid the problem that the token-level method cannot select overlapping entities. From the level of feature learning, we propose supervised entity contrastive learning and relation contrastive learning, which obtain enhanced feature representation of entity span and entity pair through positive and negative sample enhancement and contrastive loss function construction. Experiments are conducted on the dataset which is constructed based on texts of the StackOverflow, and show that our approach achieves a better performance than baseline models. [ABSTRACT FROM AUTHOR]

The nine papers in this special section focus on new developments in agile software and reports on applications for its use. A key aspect for the extensive use of agile software is that it supports developers with coping with the growing uncertainty and turbulence in technological and market environments. Feedback and change are at the core of Agile for a dynamic, evolving, and organic, rather than static, predefined, and mechanistic development process advocated by waterfall management. To create timely, high-quality, cost-efficient, and innovative solutions, Agile developers organized in small, colocated, autonomous teams, build and test software in rapid iterative cycles, actively involving users to gather feedback, updating the project scope, and plan "on-the-fly," using face-to-face communication as opposed to documentation. These papers contribute to the state-of-the-art of agile research by offering a rich, up-todate account of the dynamics occurring when expanding Agile into "not-just-software" contexts of the key challenges and perils related to the scaling and of the possible solutions to them. [ABSTRACT FROM AUTHOR]

Summary: In software development, developer turnover is among the primary reasons for project failures, leading to a great void of knowledge and strain for newcomers. Unfortunately, no established methods exist to measure how the problem domain knowledge is distributed among developers. Awareness of how this knowledge evolves and is owned by key developers in a project helps stakeholders reduce risks caused by turnover. To this end, this paper introduces a novel, realistic representation of problem domain knowledge distribution: the ConceptRealm. To construct the ConceptRealm, we employ a latent Dirichlet allocation model to represent textual features obtained from 300 K issues and 1.3 M comments from 518 open‐source projects. We analyze whether the newly emerged issues and developers share similar concepts or how aligned the individual developers' concepts are with the team over time. We also investigate the impact of leaving developers on the frequency of concepts. Finally, we also evaluate the soundness of our approach on a closed‐source software project, thus allowing the validation of the results from a practical standpoint. We find out that the ConceptRealm can represent the problem domain knowledge within a project and can be utilized to predict the alignment of developers with issues. We also observe that projects exhibit many keepers independent of project maturity and that abruptly leaving keepers correlates with a decline of their core concepts as the remaining developers cannot quickly familiarize themselves with those concepts. [ABSTRACT FROM AUTHOR]

Concept drift (CD) refers to a phenomenon where the data distribution within datasets changes over time, and this can have adverse effects on the performance of prediction models in software engineering (SE), including those used for tasks like cost estimation and defect prediction. Detecting CD in SE datasets is difficult, but important, because it identifies the need for retraining prediction models and in turn improves their performance. If the concept drift is caused by symmetric changes in the data distribution, the model adaptation process might need to account for this symmetry to maintain accurate predictions. This paper explores the impact of CD within the context of cross-version defect prediction (CVDP), aiming to enhance the reliability of prediction performance and to make the data more symmetric. A concept drift detection (CDD) approach is further proposed to identify data distributions that change over software versions. The proposed CDD framework consists of three stages: (i) data pre-processing for CD detection; (ii) notification of CD by triggering one of the three flags (i.e., CD, warning, and control); and (iii) providing guidance on when to update an existing model. Several experiments on 30 versions of seven software projects reveal the value of the proposed CDD. Some of the key findings of the proposed work include: (i) An exponential increase in the error-rate across different software versions is associated with CD. (ii) A moving-window approach to train defect prediction models on chronologically ordered defect data results in better CD detection than using all historical data with a large effect size (δ ≥ 0.427) . [ABSTRACT FROM AUTHOR]

Requirements prioritization is essential for development of quality software products. Requirements prioritization helps focus on the most important requirements between the available software requirements. This process is also called preserving core vision according to customer viewpoint or managing the quality requirements. Many requirements prioritization techniques have been proposed in the Software Engineering field. However, one requirement prioritization technique can only be generalized for some software projects. This research effort aims to develop a sustainable hybrid model for requirements prioritization, utilizing critical software project factors. The prioritization technique is shortlisted from a pool of software prioritization techniques, based on these project factors and their quantized scores. The proposed model is equipped with state-of-the-art literature to provide a customized prioritization technique improving the requirements prioritization process for a specific software project. The paper also presents popular software prioritization techniques used in the software industry and an extensive comparison using a thorough empirical analysis. Finally, the quantization of the software project factors for each technique has been assessed for better understanding, and a sustainable hybrid model has been constructed. With the proposed hybrid model, requirements prioritization in software development has been controlled effectively, reducing the failure risks and increasing the overall benefit and success rate. The success of the proposed hybrid approach is verified with two software case studies attaining satisfactory results and improving the organization's productivity by incorporating pivotal software requirements on which all the stakeholders agree. Furthermore, an automated approach will be developed by implementing the proposed approach to benefit from human–machine collaboration, improving user satisfaction by incorporating end-user opinions effectively and timely. [ABSTRACT FROM AUTHOR]

Software Defect Prediction (SDP) involves the early detection of fault-prone modules and reduces the testing efforts and cost. Support Vector Machine (SVM)-based SDP classifiers use large amount of high-dimensional data, and hence feature selection (FS) is applied for better accuracy. Search-based feature selection is found effective to improve the efficiency of predictors. This paper proposes a genetic evolution (GeEv) technique to select features. The GeEv technique involves introduction of diversity at intermediate level by the genetic evolution of random offspring with better survival capability. GeEv searches the feature space for an optimal feature subset using the performance of classification and number of features selected as the fitness function. The FS is modeled as an optimization problem and optimal solution is sought using GeEv. The performance is compared with baseline technique. From the experimental results, it is shown GeEv outperforms the competing FS approach and can achieve better accuracy than others statistically. [ABSTRACT FROM AUTHOR]

Identifying software identifiers that implement a particular feature of a software product is known as feature identification. Feature identification is one of the most critical and popular processes performed by software engineers during software maintenance activity. However, a meaningful name must be assigned to the Identified Feature Implementation Block (IFIB) to complete the feature identification process. The feature naming process remains a challenging task, where the majority of existing approaches manually assign the name of the IFIB. In this paper, the approach called FeatureClouds was proposed, which can be exploited by software developers to name the IFIBs from software code. FeatureClouds approach incorporates word clouds visualization technique to name Feature Blocks (FBs) by using the most frequent words across these blocks. FeatureClouds had evaluated by assessing its added benefit to the current approaches in the literature, where limited tool support was supplied to software developers to distinguish feature names of the IFIBs. For validity, FeatureClouds had applied to draw shapes and ArgoUML software. The findings showed that the proposed approach achieved promising results according to well-known metrics in terms of Precision and Recall. [ABSTRACT FROM AUTHOR]

Software effort estimation is a vital process in the software industry for successfully administering 5Ds of the software development life cycle (SDLC). The 5Ds stand for demand, development, direction, deployment, and designated cost of the software. Software development effort estimation (SDEE) is an effort prediction mechanism to calculate the effort for the development of the software product in order to minimize the challenges in the software field. Academics and practitioners are striving to identify which machine learning estimation technique yields more accurate results based on evaluation metrics, datasets, and other pertinent aspects. The feature selection techniques impact accuracy by selecting the main and relevant features in the dataset and eliminating the redundant and irrelevant features in the dataset. To achieve accurate estimations, the paper utilizes feature selection algorithms, along with various machine learning techniques, which predict the desired effort and the performance of the model has been measured in terms of prediction accuracy, R2 value, relative error, and mean absolute error. The datasets China and Maxwell are trained with the relevant features by applying feature selection algorithms, and estimation techniques are applied to predict the effort. The performance is compared with the regression models and feature selection techniques utilized by many authors previously. The result of the proposed methodology significantly gives the best performance with the combination of feature selection and estimation models than all regression models when applied alone, to both datasets. From the results, it is perceptible that random forest is performing well with the feature selection techniques and obtains the highest prediction accuracy of 99.33% with the China and 89.47% with the Maxwell datasets. [ABSTRACT FROM AUTHOR]

The realm of software engineering continually seeks methodologies to refine project estimations and resource allocations. This paper introduces an ingenious adaptation of the PERT (Program Evaluation and Review Technique) for software development, proposing a three-point strategy to estimate software development efforts. By incorporating best case, most likely, and worst case forecasts, the model transcends traditional singlepoint estimates, offering a probabilistic approach that embraces the inherent uncertainty of software tasks. The methodology dissects projects into manageable components, consults with experts for informed predictions, and utilises a beta distribution-based formula for a balanced approximation of outcomes. The resultant labour productivity coefficient, a ratio reflecting actual versus expected task duration, serves as a strategic gauge for developers' productivity. This study illuminates the potential of the PERT-based three-point evaluation to revolutionise productivity metrics, fostering a culture of continuous improvement and strategic foresight in software project management. [ABSTRACT FROM AUTHOR]

Software component selection is critical in software engineering due to its vital role in reducing software development cost and time. This study analyzes software component selection research studies on methodologies, criteria, and multi-criteria decision-making (MCDM) techniques. The key study findings are: first, comprehensive standardized criteria for software component selection are lacking, with ambiguous terminology used in research. Second, current ad hoc selection processes need streamlining to reduce time, cost, and effort. Thus, an integrated approach is required to aid decision-makers. The review suggests developing automated tools or decision support systems combining multiple criteria decision methods to improve selection accuracy and efficiency. Standardized criteria catalogs can also assist software developers in the evaluation. The findings highlight that despite extensive academic research, component selection in practice remains sub-optimal. By informing future research and tool development, this review can benefit practitioners to systematically select the most appropriate software components meeting software requirements. [ABSTRACT FROM AUTHOR]

Predicting software faults at the primary stage is a challenging role for software engineers and tech industries. During the development of software projects, it is necessary to predict the number of probable faults to have occurred on software rather than detecting whether the software modules are faulty or not. Discovering the number of expected faults helps software professionals to develop more reliable and high-quality software systems. However, the prediction model's performance gets affected while dealing with complicated software projects with increased cost factors such as time, effort, and resources. Therefore, to address the issue associated with handling complex software projects, a novel weighted dual cross-recurrent network-based levy sparrow search (WDCRN-LSS) model is proposed in this paper. The WDCRN-LSS approach by learning the data features with optimal hyperparameters accurately predicts the expected software faults in an earlier phase. Here, 17 PROMISE datasets containing 20 features each are utilized as input data for the proposed WDCRN-LSS model. The data inconsistencies are eliminated and then transformed to a suitable format for training through normalization, data transformation, and label encoding procedures. The preprocessed data are then trained using the proposed WDCRN-LSS model for the prediction of the expected number of software faults in the projects. With the excellent learning capability of feature representations, the proposed WDCRN-LSS model predicts software faults on upcoming/under-development software projects precisely. Thus, the proposed WDCRN-LSS model enhances software quality and minimizes cost factors such as time, resources, and effort that are depleted in developing software. The proposed WDCRN-LSS model's efficiency is investigated by utilizing evaluation measures namely error rate, precision, recall, F1-measure, the area under the curve, accuracy, and specificity. The experimental result manifests the efficiency of the proposed WDCRN-LSS model with a software fault detection accuracy of about 98.1%. [ABSTRACT FROM AUTHOR]

Multi-agent systems are proposed as a solution to mitigate nowadays software requirements: open and distributed architectures with dynamic and adaptive behaviour. Like any other software, multi-agent systems development process is error-prone; thus testing is a key activity to ensure the quality of the developed product. This paper sheds light on agent testing as it is the primary artefact for any multi-agent system's testing process. A framework called JADE Testing Framework (JTF) for JADE platform's agent testing is proposed. JTF allows testing agents at two levels: unit (inner-components) and agent (agent interactions) levels. JTF is the result of the integration of two testing solutions: JAT a well-known framework for JADE's agent's interaction testing and UJade, a new solution that was developed for agent's unit testing. UJade provides also a toolbox that allows for enhancing JAT capabilities. The evidence of JTF usability and effectiveness in JADE agent testing was supported by an empirical study conducted on seven multi-agent systems. The results of the study show that: when an agent's code can be tested either at agent or unit levels UJade is less test's effort consuming than JAT; JTF provides better testing capabilities and the developed tests are more effective than those developed using UJade or JAT alone. [ABSTRACT FROM AUTHOR]

The development of software tools is a collaborative process involving both the domain experts and the software engineers. This requires efficient communication considering different expertise and perspectives. Additionally, the two groups utilize language and communication tools in disparate ways. This, in turn, may lead to hidden misunderstandings in the requirement analysis phase and potentially result in implementation problems later on, that is difficult and costly to correct. In this paper, we demonstrate the above mentioned challenge via a use case from the tunneling domain. In particular, during the requirement analysis phase for a software capable of handling the data model of the subsoil. The domain experts in the field can best express the complexity of their domain by describing its artifacts, which in most cases are incomprehensible to the software engineers. We outline a method that interleaves requirement analysis and software modeling to enable an iterative increase of the accuracy and completeness of the information extracted from those artifacts and integrated into a flexible software model, which can produce testable software code automatically. Furthermore, we present a prototypical implementation of our method and a preliminary evaluation of the approach. [ABSTRACT FROM AUTHOR]

Version Control and Source Code Management Systems, such as GitHub, contain a large amount of unstructured historical information of software projects. Recent studies have introduced Natural Language Processing (NLP) to help software engineers retrieve information from a very large collection of unstructured data. In this study, we have extended our previous study by increasing our datasets and machine learning and clustering techniques. We have followed a complex methodology made up of various steps. Starting from the raw commit messages we have employed NLP techniques to build a structured database. We have extracted their main features and used them as input of different clustering algorithms. Once each entry was labelled, we applied supervised machine learning techniques to build a prediction and classification model. We have developed a machine learning-based model to automatically classify commit messages of a software project. Our model exploits a ground-truth dataset that includes commit messages obtained from various GitHub projects belonging to the High Energy Physics context. The contribution of this paper is two-fold: it proposes a ground-truth database and it provides a machine learning prediction model that automatically identifies the more change-prone areas of code. Our model has obtained a very high average accuracy (0.9590), precision (0.9448), recall (0.9382), and F1-score (0.9360). [ABSTRACT FROM AUTHOR]

In our research study spanning 2015-2021, we analyzed Software Engineering (SE) across 15 Knowledge Areas (KAs) outlined by SWEBoK. Using Web of Science (WoS) database, we examined 32,232 articles (2015-2017), 31,459 articles (2018-2020), and 6,919 articles (2021). Collaborative and co-word networks were generated using VOS Viewer. Our findings reveal SE's influence in 81 research areas. English dominated, but Spanish and Portuguese were notable. Europe led in publications, with USA and China prominent. Stronger collaboration networks, especially in the USA and China, correlated with increased research output. Asian countries' rise was evident from 2018-2021. Top 10 highly cited papers and co-word analysis were included, aiding researchers and educators. SE's impact crossed domains, enabling cross-disciplinary research and informing educators' course designs. Institutional and country productivity influenced partnerships and academia-industry collaborations. Multinational companies gauged research potential through active countries. Analyzing co-words depicted trends, and highly cited papers set industry standards. Bibliometric analysis offered qualitative and quantitative research evaluation.

Software bug prediction aims to enhance software quality and testing efficiency by constructing predictive classification models using code properties. This enables the prompt detection of fault‐prone modules. There are several machine learning‐based software bug prediction studies, which mainly focus on single view data by disregarding the natural ordering relation among the class labels in the literature. Thus, these studies cause losing each view's own intrinsic structure and the inherent order of the labels that positively affect the prediction performance. To overcome this drawback, this study focuses on integrating ordering information and a multi‐view learning strategy. This paper proposes a novel approach multi‐view ordinal classification (MVOC), which learns from different views (complexity, coupling, cohesion, inheritance and scale) of the software dataset separately and predicts software bugs taking the inherent order of class labels (non‐buggy, less buggy and more buggy) into consideration. To demonstrate its prediction performance, the MVOC approach was executed on the 40 different real‐world software datasets using six different classification algorithms as base learners. In the experiments, the MVOC approach was compared with traditional classifiers and their multi‐view implementations in terms of precision, recall, f‐measure and accuracy rate metrics. The results indicate that the MVOC approach presents better prediction performance on average than the multi‐view‐based and traditional classifiers. It is also observed from the results that the MVOC.RF model achieved the highest classification performance with an average accuracy rate of 85.65%. [ABSTRACT FROM AUTHOR]

Developing successful software with no defects is one of the main goals of software projects. In order to provide a software project with the anticipated software quality, the prediction of software defects plays a vital role. Machine learning, and particularly deep learning, have been advocated for predicting software defects, however both suffer from inadequate accuracy, overfitting, and complicated structure. In this paper, we aim to address such issues in predicting software defects. We propose a novel structure of 1- Dimensional Convolutional Neural Network (1D-CNN), a deep learning architecture to extract useful knowledge, identifying and modelling the knowledge in the data sequence, reduce overfitting, and finally, predict whether the units of code are defects prone. We design large-scale empirical studies to reveal the proposed model's effectiveness by comparing four established traditional machine learning baseline models and four state-of-the-art baselines in software defect prediction based on the NASA datasets. The experimental results demonstrate that in terms of f-measure, an optimal and modest 1DCNN with a dropout layer outperforms baseline and state-of-the-art models by 66.79% and 23.88%, respectively, in ways that minimize overfitting and improving prediction performance for software defects. According to the results, 1D-CNN seems to be successful in predicting software defects and may be applied and adopted for a practical problem in software engineering. This, in turn, could lead to saving software development resources and producing more reliable software. [ABSTRACT FROM AUTHOR]

Copyright of InfoM is the property of Belgrade University, Faculty of Organizational Science 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.)

Software benchmarks are only as good as the performance measurements they yield. Unstable benchmarks show high variability among repeated measurements, which causes uncertainty about the actual performance and complicates reliable change assessment. However, if a benchmark is stable or unstable only becomes evident after it has been executed and its results are available. In this paper, we introduce a machine-learning-based approach to predict a benchmark's stability without having to execute it. Our approach relies on 58 statically-computed source code features, extracted for benchmark code and code called by a benchmark, related to (1) meta information, e.g., lines of code (LOC), (2) programming language elements, e.g., conditionals or loops, and (3) potentially performance-impacting standard library calls, e.g., file and network input/output (I/O). To assess our approach's effectiveness, we perform a large-scale experiment on 4,461 Go benchmarks coming from 230 open-source software (OSS) projects. First, we assess the prediction performance of our machine learning models using 11 binary classification algorithms. We find that Random Forest performs best with good prediction performance from 0.79 to 0.90, and 0.43 to 0.68, in terms of AUC and MCC, respectively. Second, we perform feature importance analyses for individual features and feature categories. We find that 7 features related to meta-information, slice usage, nested loops, and synchronization application programming interfaces (APIs) are individually important for good predictions; and that the combination of all features of the called source code is paramount for our model, while the combination of features of the benchmark itself is less important. Our results show that although benchmark stability is affected by more than just the source code, we can effectively utilize machine learning models to predict whether a benchmark will be stable or not ahead of execution. This enables spending precious testing time on reliable benchmarks, supporting developers to identify unstable benchmarks during development, allowing unstable benchmarks to be repeated more often, estimating stability in scenarios where repeated benchmark execution is infeasible or impossible, and warning developers if new benchmarks or existing benchmarks executed in new environments will be unstable. [ABSTRACT FROM AUTHOR]

The requirements form the basis for all software products. Apparently, the requirements are imprecisely stated when scattered between development teams. Therefore, software applications released with some bugs, missing functionalities, or loosely implemented requirements. In literature, a limited number of related works have been developed as a tool for software requirements inspections. This paper presents a methodology to verify that the system design fulfilled all functional requirements. The proposed approach contains three phases: requirements collection, facts collection, and matching algorithm. The feedback results provided enable analysist and developer to make a decision about the initial application release while taking on consideration missing requirements or over-designed .requirements. [ABSTRACT FROM AUTHOR]

Copyright of Memoria Investigaciones en Ingeniería is the property of Universidad de Montevideo 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.)

Software deffect prediction, a problem of major relevance within the search-based software engineering field, aims to enhance software quality by early and precisely uncovering faulty software modules. Accurate detection of software defects in new software releases might increase the performance of the software development process in terms of cost, time and software quality. Most approaches from the software deffect prediction literature try to develop general solutions that are designed to work with any type of software deffect. From a software engineering perspective, software defects may take various forms and identifying/fixing different types of defects requires different approaches. Starting from the assumption that specific types of software defects have a particular behaviour, we are introducing in this paper, as a proof of concept, an unsupervised learning-based methodology for mining behavioural patterns for specific classes of software defects and identifying features which would be relevant for detecting the uncovered classes. The experiments performed on an open-source software deffect prediction data set collected from all releases of the Apache Ivy software highlight that the results obtained by applying the proposed methodology are highly correlated with the way human domain experts categorise and address software defects. Creating software deffect prediction models that are specifically tailored for different software deffect types may improve the accuracy of the developed models, open the possibility to apply different sets of predictive models based on the domain of the software and may accelerate the adoption of software deffect prediction approaches by the industry. [ABSTRACT FROM AUTHOR]

The quality of software projects is measured by different attributes such as efficiency, security, robustness, or understandability, among others. In this paper, we focus on maintainability by studying the optimization of software modularity, which is one of the most important aspects in this regard. Specifically, we study two well-known and closely related multi-objective optimization problems: the Equal-size Cluster Approach Problem (ECA) and the Maximizing Cluster Approach Problem (MCA). Each of these two problems looks for the optimization of several conflicting and desirable objectives in terms of modularity. To this end, we propose a method based on the Multi-Objective Variable Neighborhood Search (MO-VNS) methodology in combination with a constructive procedure based on Path-Relinking. As far as we know, this is the first time that a method based on MO-VNS is proposed for the MCA and ECA problems. To enhance the performance of the proposed algorithm, we present three advanced strategies: an incremental evaluation of the objective functions, an efficient exploration of promising areas in the search space, and an analysis of the objectives that better serve as guiding functions during the search phase. Our proposal has been validated by experimentally comparing the performance of our algorithm with the best previous state-of-the-art method for the problem and three reference methods for multi-objective optimization. The experiments have been performed on a set of 124 real software instances previously reported in the literature. [ABSTRACT FROM AUTHOR]

The underlying infrastructure paradigms behind the novel usage scenarios and services are becoming increasingly complex—from everyday life in smart cities to industrial environments. Both the number of devices involved and their heterogeneity make the allocation of software components quite challenging. Despite the enormous flexibility enabled by component-based software engineering, finding the optimal allocation of software artifacts to the pool of available devices and computation units could bring many benefits, such as improved quality of service (QoS), reduced energy consumption, reduction of costs, and many others. Therefore, in this paper, we introduce a model-based framework that aims to solve the software component allocation problem (CAP). We formulate it as an optimization problem with either single or multiple objective functions and cover both cases in the proposed framework. Additionally, our framework also provides visualization and comparison of the optimal solutions in the case of multi-objective component allocation. The main contributions introduced in this paper are: (1) a novel methodology for tackling CAP-alike problems based on the usage of model-driven engineering (MDE) for both problem definition and solution representation; (2) a set of Python tools that enable the workflow starting from the CAP model interpretation, after that the generation of optimal allocations and, finally, result visualization. The proposed framework is compared to other similar works using either linear optimization, genetic algorithm (GA), and ant colony optimization (ACO) algorithm within the experiments based on notable papers on this topic, covering various usage scenarios—from Cloud and Fog computing infrastructure management to embedded systems, robotics, and telecommunications. According to the achieved results, our framework performs much faster than GA and ACO-based solutions. Apart from various benefits of adopting a multi-objective approach in many cases, it also shows significant speedup compared to frameworks leveraging single-objective linear optimization, especially in the case of larger problem models. [ABSTRACT FROM AUTHOR]

Fault detection is a process of quality assurance which aims to identify where a fault has occurred and pinpoint the type of fault. However, in the field of software engineering, researchers mainly focus on statically or dynamically analyzing faults or vulnerabilities after the program is completed, and there are few works proposed to detect hidden faults that can only be discovered during program execution during the programming process. In this paper, we propose an automatic fault detection technology called Program Segment Testing (PST) based on the idea of Human-Machine Pair Programming (HMPP), which can automatically detect program segments during the programming process and give prompts when there are vulnerabilities or faults that trigger runtime exceptions. First, we introduce some preliminary definitions and notations that are used in our technology. Then, we use the array index overflow exception as a case to introduce the PST in detail, point out the issues that need to be resolved in order to complete this technology and the corresponding solutions. [ABSTRACT FROM AUTHOR]

This paper presents ThreadAbs , an extension of the layer-based software formal verification toolkit CCAL (Gu et al., 2018). ThreadAbs is specifically designed to provide better expressiveness and proof management for thread abstraction in multithreaded libraries. Thread abstraction isolates the behavior of each thread from others when providing a top-level formal specification for software. Compared to the original CCAL , ThreadAbs offers significant improvements in this regard. CCAL is a verification framework that enables a layered approach to building certified software, as demonstrated by multiple examples (Gu et al. 2016; Li et al. 2021; Shin et al. 2019). Obviously, its main targets usually include multithread libraries, which support significant improvement in the utilization and isolation of system resources. However, it poses new challenges for formal verification. Firstly, it requires a sudden change in the granularity of concurrency during the implementation and verification of the target software. Typically, systems are associated with software schedulers that are built on top of several underlying components in the system (e.g. , thread spawn, yield, sleep, and wake-up). Due to the software scheduler, these systems can be divided into low-level components consisting of modules that the software scheduler depends on (e.g. , allocators for shared resources and scheduling queues) and high-level components that use software schedulers (e.g. , condition variables, semaphores, and IPCs). Therefore, software formal verification on those systems has to provide proper method to deal with those distinct features, which is usually abstracting other threads' behavior as much as possible to provide an independent thread model and its formal specification. Secondly, it requires handling side effects from other threads, such as dynamic resource allocation from parents with proper isolation of all threads from each other. CCAL has limited support for two crucial aspects of formal verification in multithreaded systems. Firstly, its previous thread abstraction method does not handle the side effects caused by a parent thread during dynamic initial state allocation properly. Secondly, the proofs produced by CCAL are tied to CertiKOS , which makes it challenging to use them for similar proofs that use CCAL as their verification toolkit. To address these issues, we introduce ThreadAbs , a new mechanized methodology that provides proper thread abstraction to reason about multithreaded programs in conjunction with CCAL. We also extend the previous CertiKOS proof with ThreadAbs to demonstrate its usability and expressiveness. [ABSTRACT FROM AUTHOR]

In software engineering, the planning and budgeting stages of a software project are of great importance to all stakeholders, including project managers as well as clients. The estimated costs and scheduling time needed to develop any software project before and/or during startup form the basis of a project's success. The main objective of soft- ware estimation techniques is to determine the actual effort and/or time required for project development. The use of machine learning methods to address the estimation problem has, in general, proven remarkably successful for many engineering problems. In this study, a fully connected neural network (FCNN) model and a metaheuristic, gray wolf optimizer (GWO), called GWO-FC, is proposed to tackle the software development effort estimation (SEE) problem. The GWO is integrated with FCNN to optimize the FCNN parameters in order to enhance the accuracy of the obtained results by improving the FCNN's ability to explore the parameter search field and avoid falling into local optima. The proposed technique was evaluated utilizing various benchmark SEE datasets. Furthermore, various recent algorithms from the literature were employed to verify the GWO-FC performance. In terms of accuracy, comparative outcomes reveal that the GWO-FC performs better than other methods in most datasets and evaluation criteria. Experimental outcomes reveal the strong potential of the GWO-FC method to achieve reliable estimation results. [ABSTRACT FROM AUTHOR]

The outbreak of the novel Coronavirus in late 2019 brought severe devastation to the world. The pandemic spread across the globe, infecting more than ten million people and disrupting several businesses. Although social distancing and the use of protective masks were suggested all over the world, the cases seem to rise, which led to worldwide lockdown in different phases. The rampant escalation in the number of cases, the global effects, and the lockdown may have a severe effect on the psychology of people. The emergency protocols implemented by the authorities also lead to increased use in the number of multimedia devices. Excessive use of such devices may also contribute to psychological disorders. Hence, hence it is necessary to analyze the state of mind of people during the lockdown. In this paper, we perform a sentiment analysis of Twitter data during the pandemic lockdown, i.e., two weeks and four weeks after the lockdown was imposed. Investigating the sentiments of people in the form of positive, negative, and neutral tweets would assist us in determining how people are dealing with the pandemic and its effects on a psychological level. Our study shows that the lockdown witnessed more number positive tweets globally on multiple datasets. This is indicative of the positivity and optimism based on the sentiments and psychology of Twitter users worldwide. The study will be effective in determining people's mental well-being and will also be useful in devising appropriate lockdown strategies and crisis management in the future.

Today, users can't even imagine the creative and advanced methods of disguising and hiding our data. However, the free software tools available for such purposes are often outdated or rudimentary in terms of functionality, and sometimes even contain vulnerabilities. The purpose of this article is to design and implement an easy-to-use and secure data hiding application that meets modern expectations and requirements, and also has a functionality that also returns the detectability level of the data to the user. The study first explores and evaluates currently available free software based on a certain set of criteria. After that, we describe in detail the development of a multi-platform stegenographic application with a new function, focusing on the methods and algorithms used. After successful implementation, the finished application is evaluated and compared with the tested, freely available software based on the set criteria. [ABSTRACT FROM AUTHOR]

Background: Issues of lack of consideration for professional responsibility by software engineers (SEs) present major challenges and concerns to software users. Previous studies on the subject of ethical responsibility in software development assessed whether software development key stakeholders should take ethical responsibility for their actions in software development. However, such studies focused on assessing responses from a particular grouping in software development. Objective: Based on the revelation, this study seeks to evaluate the perceived ethical responsibilities in software development by juxtaposing the perceptions of students, educators and industry-based software practitioners on the ethical responsibility of software development key stakeholders in South Africa. Methods: To meet this objective, the study collected data using a survey, which was shared on an online platform. A total of 561 (44 from computing academics; 103 from industry-based software practitioners and 414 from software development students) responses were received. The collected data were analysed using descriptive and variance statistical analysis approaches. Results: The study found that there is no significant statistical difference in how students, educators and software practitioners perceive the ethical responsibility of software development key stakeholders. Conclusions: This finding of the study shows that the prevailing view is that various software development key stakeholders should be held ethically responsible for their contribution to software development. Furthermore, the organisation of ethical responsibilities used in this study provides a useful framework to guide future studies on this subject. [ABSTRACT FROM AUTHOR]