Journal of Software-Evolution and Process最新文献

As society's reliance on software systems escalates over time, so too does the cost of failure of these systems. Meanwhile, the complexity of software systems, as well as of their designs, is also ever-increasing, influenced by the proliferation of new tools and technologies to address intended societal needs. The traditional response to this complexity in software engineering and software architecture has been to apply rationalistic approaches to software design through methods and tools for capturing design rationale and evaluating various design options against a set of criteria. However, research from other fields demonstrates that intuition may also hold benefits for making complex design decisions. All humans, including software designers, use intuition and rationality in varying combinations. The aim of this article is to provide a comprehensive overview of what is known and unknown from existing research regarding the use and performance consequences of using intuition and rationality in software design decision-making. To this end, a systematic literature review has been conducted, with an initial sample of 3909 unique publications and a final sample of 26 primary studies. We present an overview of existing research, based on the literature concerning intuition and rationality use in software design decision-making and propose a research agenda with 14 questions that should encourage researchers to fill identified research gaps. This research agenda emphasizes what should be investigated to be able to develop support for the application of the two cognitive processes in software design decision-making.

Developers are encouraged to adopt good design practices to maintain good software quality during the system's evolution. However, some modifications and changes to the system could cause code smells and pattern grime, which might incur more maintenance effort. As the presence of both code smells and pattern grime is considered a bad sign and raises a flag at code segments that need more careful examination, a potential connection between them may exist. Therefore, the main objective of this paper is to (1) empirically investigate the potential relationship between the accumulation of pattern grime and the presence of code smells and (2) evaluate the significance of individual code smells when they appear in a specific pattern grime category. To achieve this goal, we performed an empirical study using six-grime metrics and 10 code smells on five Java open-source projects ranging from 217 to 563 classes. Our statistical results indicate that, in general, the growth of grime is more likely to co-occur with code smells using Spearman's correlation and Odd Ratio test. Specifically, there is a strong positive association between the growth of pattern grime at the class level and the presence of Shotgun Surgery smell according to the result of applying the Apriori algorithm, which gives conviction values equal to 1.66. The findings in this paper are helpful for developers and researchers as the presence of pattern grime could be considered a factor in improving the performance of existing smell detection methods. Furthermore, the link between grime and smells can be exploited as a hint for smell distribution in the system.

As the predominant modern version control system, Git has become an indispensable tool for both commercial and open-source software projects. It substantially improves software development effectiveness and efficiency through its distributed version control system, fostering seamless collaboration among teams and across locations. However, research has found that many developers have doubts about using Git commands, while the official Git documentation is rather scanty, that is, lacking sufficient explanations and examples. To help developers learn and use Git commands, we propose the first approach (Richen) for enriching Git documentation with usage examples and scenarios by leveraging crowd knowledge from Stack Overflow. Richen retrieves Git-related posts from Stack Overflow, extracts relevant Q&A pairs, and selects representative command usages, including usage examples and scenarios, for different Git commands. Experimental results have shown that Richen can extract informative and concise command usages for Git commands. Compared with alternative methods adapted from API usage mining, the command usages obtained by Richen have significant advantages in terms of relevance, readability, and usability. Furthermore, we have shown through an empirical study that the command usages extracted by Richen can better help developers complete Git command-related tasks.

The instanceof pattern matching can improve the code quality and readability by removing the redundant typecasting and simplifying the design in different scenarios. However, existing works do not provide sufficient support for refactoring instanceof pattern matching. This paper first identifies several cases that cannot be well handled by existing IDEs. Based on these observations, we propose a novel approach called ReInstancer to refactor instanceof pattern matching automatically. ReInstancer conducts program analysis for multi-branch statements to obtain pattern variables. After analyzing these patterns, the multi-branch statements are optimized and finally refactored into switch statements or expressions. ReInstancer is evaluated by 20 real-world projects with more than 7,700 instanceof pattern matching. The experimental results demonstrate that a total of 3,558 instanceof expressions and 228 multi-branch statements are refactored within 10.8 s on average for each project. ReInstancer improves the code quality by reducing redundant typecasting, demonstrating its effectiveness.

Application programming interface (API) recommendation plays a crucial role in facilitating smart contract development by providing developers with a ranked list of candidate APIs for specific recommendation points. Deep learning-based approaches have shown promising results in this field. However, existing approaches mainly rely on token sequences or abstract syntax trees (ASTs) for learning recommendation point-related features, which may overlook the essential knowledge implied in the relations between or within statements and may include task-irrelevant components during feature learning. To address these limitations, we propose a novel code graph called pruned and augmented AST (pa-AST). Our approach enhances the AST by incorporating additional knowledge derived from the control and data flow relations between and within statements in the smart contract code. Through this augmentation, the pa-AST can better represent the semantic features of the code. Furthermore, we conduct AST pruning to eliminate task-irrelevant components based on the identified flow relations. This step helps mitigate the interference caused by these irrelevant parts during the model feature learning process. Additionally, we extract the API sequence surrounding the recommendation point to provide supplementary knowledge for the model learning. The experimental results demonstrate our proposed approach achieving an average mean reciprocal rank (MRR) of 68.02%, outperforming the baselines' performance. Furthermore, through ablation experiments, we explore the effectiveness of our proposed code representation approach. The results indicate that combining pa-AST with the API sequence yields improved performance compared with using them individually. Moreover, our AST augmentation and pruning techniques significantly contribute to the overall results.

The precise evaluation of predicting software development effort is a serious process in software engineering. The underestimates require more time, which seems to be the negotiation of complete efficient design and complete software testing. Thus, this paper devises a novel model for inspecting the effort taken for the design of software. The Mayfly Lion Optimization (MFLion) algorithm is devised, which ensembles the Mayfly Algorithm (MA) with the Lion Optimization Algorithm (LOA) for precise estimation. The deep maxout network (DMN) is adapted wherein the different weights are produced out of which the most suitable is infused considering the MFLion during model training. The optimal features are selected using recursive feature elimination (RFE) wherein the best features are selected and the remaining irrelevant features are eliminated from the list. The proposed MFLion obtained better performance with the smallest mean magnitude of relative error (MMRE) of 5.909 and the smallest root mean square error (RMSE) of 75.505, respectively. Each technique is produced using a separate database generated using the Promise software engineering repository. The outcomes produced from the assessment of the accuracies of models suggested that the MFLion-DMN is a substitute to forecast software effort, which is extensively devised in engineering platforms.

DevOps has emerged as a practical approach to the interaction between development and operations. This approach has been extended to the interaction with business functions, generating the term BizDevOps. Although many proposals and tools support BizDevOps from a technical viewpoint, there has been no significant improvement in management aspects, such as evaluating the practices and processes involved in the area. This paper presents two case studies on the assessment of BizDevOps practices using MMBDO (Maturity Model for BizDevOps), a maturity model for BizDevOps based on international ICT standards. The case studies were conducted in two organizations with different profiles: a large multinational ICT company with a unit specialized in providing DevOps to the rest of the company and a small software development company that implements DevOps practices as part of its development system. The evidence we obtained in the case studies supports the adequacy of MMBDO for assessing the maturity of BizDevOps in real companies. Also, the combination of the two case studies supports the adequacy of the model for being used in companies with different sizes and levels of maturity. MMBDO is an adequate proposal for assessing the maturity of BizDevOps in software organizations and a suitable tool for process improvement.

An automated task for finding the essential buggy files among software projects with the help of a given bug report is termed bug localization. The conventional approaches suffer from the challenges of performing lexical matching. Particularly, the terms utilized for describing the bugs in the bug reports are observed to be irrelevant to the terms used in the source code files. To resolve these problems, we propose an optimized and ensemble deep learning model for software bug localization. These features are reduced by the principle component analysis (PCA). Then, they are selected by the weighted convolutional neural network (CNN) model with the support of the Modified Scatter Probability-based Coyote Optimization Algorithm (MSP-COA). Finally, the optimal features are subjected to the ensemble deep neural network and long short-term memory (DNN-LSTM), with parameter tuning by the MSP-COA. Experimental results show that the proposed approach can achieve higher bug localization accuracy than individual models.

Software managers constantly look out for methods that ensure cost effective development of good quality software products. An important means of accomplishing this is by allocating more resources to weak classes of a software product, which are prone to changes. Therefore, correct prediction of these change-prone classes is critical. Though various researchers have investigated the performance of several algorithms for identifying them, the search for an optimum classifier still persists. To this end, this study critically investigates the use of six Heterogenous Ensemble Classifiers (HEC) for Software Change Prediction (SCP) by empirically validating datasets obtained from 12 open-source software systems. The results of the study are statistically assessed using three robust performance indicators (AUC, F-measure and Mathew Correlation Coefficient) in two different validation scenarios (within project and cross-project). They indicate the superiority of Average Probability Voting Ensemble, a heterogenous classifier for determining change-proneness in the investigated systems. The average AUC values of software change prediction models developed using this ensemble classifier exhibited an improvement of 3%-9% and 3%-11% respectively when compared with its base learners and homogeneous counter parts. Similar observations were inferred using other investigated performance measures. Furthermore, the evidence obtained from the results suggests that the change in number of base learners or type of meta-learner does not exhibit significant change in the performance of corresponding heterogenous ensemble classifiers.