Search

In fault‐based Boolean expression testing, the main challenge is to generate effective test cases that can detect faults within expressions. Previous studies show that it is hard to detect literal insertion faults, more specifically Disjunctive literal insertion fault (LIF[+]) compared with other faults in Boolean expressions. Researchers have been using different strategies such as multiple near false point coverage (MNFP) and modified condition decision coverage (MCDC) to detect LIF[+] faults. However, these strategies have their own limitations. For example, MNFP can only be applied when the expression is in irredundant disjunctive normal form (IDNF), and MCDC detects a low percentage of LIF[+] faults. In this paper, we propose an abstract syntax tree (AST)‐based test case generation strategy for LIF[+] fault detection that overcomes these limitations. Furthermore, our experimental results indicate that, on average, the test suites satisfying the proposed strategy can detect approximately 97.3% of LIF[+] faults for general form expressions and 89.7% of LIF[+] faults for IDNF expressions, which are 15.6% and 13.8% improvement, respectively, compared to the MCDC test suites. Moreover, the size of the required test suite is smaller than that of MCDC test suite. [ABSTRACT FROM AUTHOR]

With digitalization and with technologies such as software, data, and artificial intelligence, companies in the embedded systems domain are experiencing a rapid transformation of their conventional businesses. While the physical products and associated product sales provide the core revenue, these are increasingly being complemented with service offerings, new data‐driven services, and digital products that allow for continuous value creation and delivery to customers. However, although there is significant research on digitalization and digital transformation, few studies highlight the specific needs of embedded systems companies and what it takes to transform from a traditional towards a digital company within business domains characterized by high complexity, hardware dependencies, and safety‐critical system functionality. In this paper, we capture the difference between what constitutes a traditional and a digital company and we detail the typical evolution path embedded systems companies take when transitioning towards becoming digital companies. [ABSTRACT FROM AUTHOR]

This volume comprises a selected set of high‐quality and extended articles of the 26th Systems, Software and Services Process Improvement (EuroSPI) Conference, held during September 18–20, 2019 in Edinburgh, UK. Conferences were held in Dublin (Ireland) in 1994, in Vienna (Austria) in 1995, in Brighton (UK) in 1996, in Budapest (Hungary) in 1997, in Gothenburg (Sweden) in 1998, in Pori (Finland) in 1999, in Copenhagen (Denmark) in 2000, in Limerick (Ireland) in 2001, in Nuremberg (Germany) in 2002, in Graz (Austria) in 2003, in Trondheim (Norway) in 2004, in Budapest (Hungary) in 2005, in Joensuu (Finland) in 2006, in Potsdam (Germany) in 2007, in Dublin (Ireland) in 2008, in Alcala (Spain) in 2009, in Grenoble (France) in 2010, in Roskilde (Denmark) in 2011, in Vienna (Austria) in 2012, in Dundalk (Ireland) in 2013, in Luxembourg in 2014, in Ankara (Turkey) in 2015, in Graz (Austria) in 2016, in Ostrava (Czech Republic) in 2017, in Bilbao (Spain) in 2018, and in Edinburgh (UK) in 2019. [ABSTRACT FROM AUTHOR]

Due to the high cost of repairing defective programs, many researches focus on automatic program repair (APR). In recent years, the new trend of APR is to apply neural networks to mine the relations between defective programs and corresponding patches automatically, which is known as neural program repair (NPR). The community, however, ignores some important properties that could impact the applicability of NPR systems, such as robustness. For semantic‐identical buggy programs, NPR systems may produce totally different patches. In this paper, we propose an evaluation tool named RobustNPR, the first NPR robustness evaluation tool. RobustNPR employs several mutators to generate semantic‐identical mutants of defective programs. For an original defective program and its mutant, it checks two aspects of NPR: (a) Can NPR fix mutants when it can fix the original defective program? and (b) can NPR generate semantic‐identical patches for the original program and the mutant? Then, we evaluate four SOTA NPR models and analyze the results. From the results, we find that even for the best‐performing model, 20.16% of the repair success is unreliable, which indicates that the robustness of NPR is not perfect. In addition, we find that the robustness of NPR is correlated with model settings and other factors. [ABSTRACT FROM AUTHOR]

Enterprise architecture is a growing trend that aims to help deal with the complexity of socio‐technical systems such as human organizations, as well as their information technology and systems areas. Nevertheless, the contribution of enterprise architecture to the field of software engineering remains unclear. The purpose of this systematic literature review is to see how enterprise architecture is used in software development and maintenance practice. To this end, we first carried out a search in the SCOPUS database and then organized the papers according to the Software Engineering Body of Knowledge to determine what areas of software engineering are covered by each research study. To understand how enterprise architecture is used, we established a classification based on ISO 42010 and TOGAF. From the systematic literature review, we noticed that the early stages of development are the most impacted by the enterprise architecture. On the other hand, we observed that enterprise architecture is of assistance in the areas of engineering management, engineering processes, and engineering models and methods; these tasks are carried out by teams or managers using different, often agile, development methods or standards. In turn, we found that the most common categories are architecture descriptions; these are often used to facilitate communication and information‐sharing between different stakeholders, in addition to frameworks, which will help to establish common practices in the organization related to the joint use of enterprise architecture and software development. [ABSTRACT FROM AUTHOR]

Summary: Software complexity is the very essence of computer programming. As the complexity increases, the potential risks and defects of software systems will increase. This makes the software correctness analysis and the software quality improvement more difficult. In this paper, we present a quantitative metric to describe the complexity of a hierarchical software and a Complexity‐oriented Software Architecture Refactoring (CoSSR) approach to reduce the complexity. The main idea is to identify and then reassemble subcomponents into one hierarchical component, which achieves minimum complexity in terms of the solution algorithm. Moreover, our algorithm can be improved by introducing partition constraint, heuristic search strategy, and spectral clustering. We implement the proposed method as an automated refactoring tool and demonstrate our algorithm through a case study of battery management system (BMS). The results show that our approach is more efficient and effective to reduce the complexity of hierarchical software system. [ABSTRACT FROM AUTHOR]

Because defects in software modules (e.g., classes) might lead to product failure and financial loss, software defect prediction enables us to better understand and control software quality. Software development is a dynamic evolutionary process that may result in data distributions (e.g., defect characteristics) varying from version to version. In this case, effective cross‐version defect prediction (CVDP) is not easy to achieve. In this paper, we aim to investigate whether the defect prediction method of the threshold‐based active learning (TAL) can tackle the problem of the different data distribution between successive versions. Our TAL method includes two stages. At the active learning stage, a committee of investigated metrics is constructed to vote on the unlabeled modules of the current version. We pick up the unlabeled module with the median of voting scores to domain experts. The domain experts test and label the selected unlabeled module. Then, we merge the selected labeled module and the remaining modules with pseudo‐labels from the current version into the labeled modules of the prior version to form enhanced training data. Based on the training data, we derive the metric thresholds used for the next iteration. At the defect prediction stage, the iterations stop when a predefined threshold is reached. Finally, we use the cutoff threshold of voting scores, that is, 50%, to predict the defect‐prone of the remaining unlabeled modules. We evaluate the TAL method on 31 versions of 10 projects with three prevalent performance indicators. The results show that TAL outperforms the baseline methods, including three variations methods, two common supervised methods, and the state‐of‐the‐art method Hybrid Active Learning and Kernel PCA (HALKP). The results indicate that TAL can effectively address the different data distribution between successive versions. Furthermore, to keep the cost of extensive testing low in practice, selecting 5% of candidate modules from the current version is sufficient for TAL to achieve a good performance of defect prediction. [ABSTRACT FROM AUTHOR]

Many test coverage metrics have been proposed to measure the deep neural network (DNN) testing effectiveness, including structural coverage and nonstructural coverage. These test coverage metrics are proposed based on the fundamental assumption: They are correlated with test effectiveness. However, the fundamental assumption is still not validated sufficiently and reasonably, which brings question on the usefulness of DNN test coverage. This paper conducted a revisiting study on the existing DNN test coverage from the test effectiveness perspective, to effectively validate the fundamental assumption. Here, we carefully considered the diversity of subjects, three test effectiveness criteria, and both typical and state‐of‐the‐art test coverage metrics. Different from all the existing studies that deliver negative conclusions on the usefulness of existing DNN test coverage, we identified some positive conclusions on their usefulness from the test effectiveness perspective. In particular, we found the complementary relationship between structural and nonstructural coverage and identified the practical usage scenarios and promising research directions for these existing test coverage metrics. [ABSTRACT FROM AUTHOR]

At present, formal methods significantly facilitate the specification and verification of security requirements in requirement engineering, which can reduce requirement errors in the early stage of system development. Extracting formal specifications from security requirements and then evaluating the quality of the requirements are regarded as a promising solution to ensure software quality. Propositional projection temporal logic (PPTL) with a strong mathematical basis and full regular expressiveness is a suitable language for formal specifications. Inspired by natural language processing and text mining techniques, this paper designs and implements a tool, namely, NL2PPTL, to generate formal coarse‐grained and fine‐grained specifications in terms of PPTL formulas automatically. In specific, the grammatical production rules are defined to construct the syntax tree, and then, the formula is obtained by post‐order traversal of the tree. The satisfiability of the PPTL specifications can be checked utilizing PPTLSAT. In addition, the state transformation model is constructed from fine‐grained specifications, so as to discover scope conflicts and verify the security properties of the requirement case. [ABSTRACT FROM AUTHOR]

The safety and robustness of deep neural networks (DNNs) are currently of great concern. Adequate testing is commonly an effective technique to ensure the software's trustworthiness. However, existing DNN testing methods generate many invalid test inputs, which inevitably brings increased computational overhead and reduces the efficiency of DNN testing. In this paper, we focus on testing task‐specific DNN and investigating diverse, valid and natural test input generation based on data augmentation techniques. Specifically, we propose AugTest, a DNN testing method based on stochastic optimization with momentum, searching for optimal compositions of data augmentation parameters to efficiently generate diverse and valid test inputs. Experimental results show that our proposed method can effectively explore the data manifold space and find valid test inputs with high diversity and naturalness. Compared with the best‐performing baseline, AugTest can generate more test inputs with more average diversity and less average time. Furthermore, the generated test inputs have competitive generalizability to DNNs with different structures. The test error rates exceed 70% when testing other DNN models performing similar tasks using the test inputs generated by AugTest. This implies that our method can produce more valid and generalized data to unveil DNNs' errors. [ABSTRACT FROM AUTHOR]

Context: Software development effort estimation (SDEE) is one of the most challenging aspects in project management. The presence of missing data (MD) in software attributes makes SDEE even more complex. K‐nearest neighbors imputation (KNNI) has been widely used in SDEE to deal with the MD issue. However, KNNI, in its classical process, has low tolerance to imprecision and uncertainty especially when dealing with categorical features. When dealing with categorical attributes, KNNI uses a classical approach, employing mainly numbers or classical intervals to represent software attributes and similarity measures originally designed for numerical attributes. Objectives: This paper evaluates the use of an optimized fuzzy clustering‐based KNNI (FC‐KNNI) and compares it with classical KNN when dealing with mixed data in the context of SDEE. Methods: We investigate the effect of two imputation techniques (FC‐KNNI and KNNI) on five SDEE techniques: case‐based reasoning, fuzzy case‐based reasoning, support vector regression, multilayer perceptron, and reduced‐error pruning tree. The evaluation is carried out using six publicly available datasets for SDEE using two performance measures, standardized accuracy (SA), and Pred (0.25). The Wilcoxon statistical test is also performed to assess the significance of results. Results: The results are promising in the sense that using an imputation technique designed for mixed data is better than reusing methods originally designed for numerical data. We found that FC‐KNNI significantly outperforms KNNI regardless of the SDEE technique and dataset used. Another important finding is that F‐CBR improved the analogy process compared to CBR. Conclusion: The introduction of fuzzy sets and fuzzy clustering in the analogy process improves its performances in terms of SA and Pred (0.25). [ABSTRACT FROM AUTHOR]

Many object‐oriented metrics have been proposed in the literature to measure various structural properties of object‐oriented software. Furthermore, many centrality measures have been introduced to identify central nodes in large networks. However, few studies have used them to measure dependencies in software systems. In fact, centrality measures, as opposed to most traditional object‐oriented metrics that mainly focus on intrinsic properties of classes, can be used to better model the control flow and to identify the most important classes in a software system. This paper aims (1) to investigate the relationships between object‐oriented metrics and centrality measures and (2) to explore the ability of their combination to support fault‐proneness prediction from different perspectives (fault‐prone classes, fault severity, and number of faults). Many studies in the literature have addressed the prediction of fault‐prone classes, from different perspectives, using object‐oriented metrics. The main motivation here is in fact to investigate if the information captured by centrality measures is related to fault proneness and complementary to the information captured by object‐oriented metrics and to investigate if the combination of object‐oriented metrics and centrality measures improves the performance of fault‐proneness prediction significantly. We used size, complexity, and coupling object‐oriented metrics in addition to various centrality measures. We collected data from 20 different versions of five open‐source Java software systems. We first studied the relationships between selected metrics and their relationships to fault proneness. Then, we built different models to predict fault‐prone classes using several machine learning algorithms. In addition, we built models to predict if a class contains a high severity fault, and the number of faults in a class. Results indicate that using centrality measures in combination with object‐oriented metrics improves the prediction of fault‐prone classes as well as the prediction of the number of faults in a class. However, the combination has no significant impact, according to the data we collected, on the quality of the prediction of fault severity. Moreover, using centrality measures in combination with object‐oriented metrics also improves the prediction performance of fault proneness and the number of faults in both cross‐version and cross‐system validation. [ABSTRACT FROM AUTHOR]

Infrastructure‐as‐code (IaC) helps keep up with the demand for fast, reliable, high‐quality services by provisioning and managing infrastructures through configuration files. Those files ensure efficient and repeatable routines for system provisioning, but they might be affected by code smells that negatively affect quality and code maintenance. Research has broadly studied code smells for traditional source code development; however, none explored them in the "Topology and Orchestration Specification for Cloud Applications" (TOSCA), the technology‐agnostic OASIS standard for IaC. In this paper, we investigate a prominent traditional implementation code smell potentially applicable to TOSCA: Large Class, or "Blob Blueprint" in IaC terms. We compare metrics‐based and unsupervised learning‐based detectors on a large dataset of manually validated observations related to Blob Blueprints. We provide insights on code metrics that corroborate previous findings and empirically show that metrics‐based detectors perform highly in detecting Blob Blueprints. We deem our results put forward a new research path toward dealing with this problem, for example, in the scope of fully automated service pipelines. [ABSTRACT FROM AUTHOR]

Catalogs of refactoring have key importance in software maintenance and evolution, since developers rely on such documents to understand and perform refactoring operations. Furthermore, these catalogs constitute a reference guide for communication between practitioners since they standardize a common refactoring vocabulary. Fowler's book describes the most popular catalog of refactorings, which documents single and well‐known refactoring operations. However, sometimes, refactorings are composite transformations, that is, a sequence of refactorings is performed over a given program element. For example, a sequence of Extract Method operations (a single refactoring) can be performed over the same method, in one or in multiple commits, to simplify its implementation, therefore, leading to a Method Decomposition operation (a composite refactoring). In this paper, we propose and document a catalog with eight composite refactorings. We also implement a set of scripts to mine composite refactorings by preprocessing the results of refactoring detection tools. Using such scripts, we search for composites in a representative refactoring oracle with hundreds of confirmed single refactoring operations. Next, to complement this first study, we also search for composites in the full history of 10 well‐known open‐source projects. We characterize the detected composite refactorings, under dimensions such as size and location. We conclude by addressing the applications and implications of the proposed catalog. [ABSTRACT FROM AUTHOR]

Deep learning is a powerful technique to boost application performance in various fields, including face recognition, image classification, natural language understanding, and recommendation system. With the rapid increase in the computing power of mobile devices, developers can embed deep learning models into their apps for building more competitive products with more accurate and faster responses. Although there are several works of adversarial attacks against deep learning models in apps, they all need information about the models' internals (i.e., structures and weights) or need to modify the models. In this paper, we propose an effective black‐box approach by training substitute models to spoof the deep learning systems inside the apps. We evaluate our approach on 10 real‐world deep‐learning apps from Google Play to perform black‐box adversarial attacks. Through the study, we find three factors that can affect the performance of attacks. Our approach can reach a relatively high attack success rate of 66.60% on average. Compared with other adversarial attacks on mobile deep learning models, in terms of the average attack success rates, our approach outperforms its counterparts by 27.63%. [ABSTRACT FROM AUTHOR]

Over the past few years, the software engineering (SE) community has widely employed deep learning (DL) techniques in many source code processing tasks. Similar to other domains like computer vision and natural language processing (NLP), the state‐of‐the‐art DL techniques for source code processing can still suffer from adversarial vulnerability, where minor code perturbations can mislead a DL model's inference. Efficiently detecting such vulnerability to expose the risks at an early stage is an essential step and of great importance for further enhancement. This paper proposes a novel black‐box effective and high‐quality adversarial attack method, namely CodeBERT‐Attack (CBA), based on the powerful large pre‐trained model (i.e., CodeBERT) for DL models of source code processing. CBA locates the vulnerable positions through masking and leverages the power of CodeBERT to generate textual preserving perturbations. We turn CodeBERT against DL models and further fine‐tuned CodeBERT models for specific downstream tasks, and successfully mislead these victim models to erroneous outputs. In addition, taking the power of CodeBERT, CBA is capable of effectively generating adversarial examples that are less perceptible to programmers. Our in‐depth evaluation on two typical source code classification tasks (i.e., functionality classification and code clone detection) against the most widely adopted LSTM and the powerful fine‐tuned CodeBERT models demonstrate the advantages of our proposed technique in terms of both effectiveness and efficiency. Furthermore, our results also show (1) that pre‐training may help CodeBERT gain resilience against perturbations further, and (2) certain pre‐training tasks may be beneficial for adversarial robustness. [ABSTRACT FROM AUTHOR]

In the process of mobile crowdsourced testing, a large number of test reports are generated, which often consist of short text and rich image information. One of the critical issues is how to review these reports efficiently. Researchers have recently proposed clustering, classification, and prioritization techniques to solve this problem. However, existing studies directly use related technologies to text description and segment the text content without further understanding of the text content. By deeply digging into the text information and distinguishing it according to its actual meaning, the sentences described in the text can be categorized into two types: Describing abnormal system behavior and describing reproduction steps. This paper proposes a mobile crowdsourced test report prioritization technique to improve performance. First, we use a TextCNN trained on large‐scale projects to distinguish the text descriptions of reports, then extract features from the text and screenshot information, respectively. Then we apply a clustering technique to gather similar reports. Finally, the inspection order is sampled from the clustering results. To validate our approach, we conduct experiments on six industrial crowdsourced projects. The results show that our method can detect all bugs faster in a limited time than existing prioritization methods, which can improve the bug reports review efficiency. [ABSTRACT FROM AUTHOR]

In this paper, we outline an approach for automatically generating challenging road networks for virtual testing of an automated lane‐keeping system. Based on a set of control points, we construct a parametric curve representing a road network, defining the dynamic driving task an automated lane‐keeping system‐equipped vehicle must perform. Changing control points has a global influence on the resulting road geometry. Our approach uses search to find control‐point sets that result in a challenging road, eventually forcing the vehicle to leave the intended path. We apply our approach in different search variants to evaluate their performance regarding test efficiency and the diversity of failing tests. In addition, we evaluate different genetic algorithm control parameter configurations to investigate the most influential parameters and if specific configurations can be seen as optimal, leading to better results than others. For both studies, we consider another search‐based test method and two different random test generators as a baseline for comparison. The empirical results indicate that specific control parameter settings increase the overall performance for each search variant. While the population size is the most influential control parameter for all methods, the performance improvement when using optimal settings is only significant for one method. [ABSTRACT FROM AUTHOR]

The compatibility issues caused by Android fragmentation have become a vital task in the development of Android applications. To locate those issues, thousand of crowd testers run apps on different devices with different configurations to achieve the largest coverage, which might be costly and time‐consuming. Since existing approaches to selecting optimal devices are device‐side analysis without the information of the internal structures of apps, app‐side analysis that flags the essential devices for testers has remained elusive. To mitigate this gap of compatibility crowdtesting, this paper proposes an app constraint analysis approach named CompatDroid to generate the optimal device set to guide crowd testers. By evaluating 46 benchmark apps on 14 SDK versions, the optimal device sets are successfully generated, and CompatDroid only needs no more than 7 Android versions to achieve almost the same code coverage (i.e., 33.13%) testing on all 14 android versions (i.e., 34.65%) in 36 of 46 apps, which indicates that it can drastically reduce the consumption of test resources while losing little test coverage. On a larger dataset, CompatDroid successfully analyzes 98.3% of 645 apps, in which the median number of the optimal SDK versions set is 2.5 versions, and 68.92% of those apps contain the constraints of SDK version (i.e., SDK version) while 84.86% of them do not have the constraints of hardware information (i.e., model name and manufacture name). [ABSTRACT FROM AUTHOR]

In recent years, stakeholders expect the delivery of new features almost every day to give fast feedback about changes or issues in software projects. To achieve this, they have opted to try new practices such as those from DevOps to improve their processes. Organizations such as IBM, Facebook, Amazon, and so on are implementing a DevOps culture. However, for small organizations, which are a large majority in the software development market, it is complicated to adopt DevOps because there is no guide to follow. Organizations have experienced issues trying to implement a DevOps approach, mainly for reasons such as a lack of process, guidance, or uncoordinated activities among organizations. Moreover, some organizations have a wrong understanding of DevOps: as just a set of automation tools to achieve a continuous release. This paper presents a guide to implement or reinforce a DevOps approach. Besides, the results of a case study of implementing the guide in a small organization are included. These results have shown that the guide helped the team: to identify its gaps toward the implementation of a DevOps approach; to have a better understanding of DevOps; and to facilitate the DevOps implementation providing a set of tasks, roles, and metrics. [ABSTRACT FROM AUTHOR]

In software Q&A sites, there are many code‐solving examples of individual program problems, and these codes with explanatory natural language descriptions are easy to understand and reuse. Code search in software Q&A sites increases the productivity of developers. However, previous approaches to code search fail to capture structural code information and the interactivity between source codes and natural queries. In other words, most of them focus on specific code structures only. This paper proposes TCS (Transformer‐based code search), a novel neural network, to catch structural information for searching valid source codes from the query, which is vital for code search. The multi‐head attention mechanism in Transformer helps TCS learn enough information about the underlying semantic vector representation of codes and queries. An aligned attention matrix is also employed to catch relationships between codes and queries. Experimental results show that the proposed TCS can learn more structural information and has better performance than existing models. [ABSTRACT FROM AUTHOR]

Vulnerability classification is a significant activity in software development and software maintenance. Natural Language Processing (NLP) techniques, which utilize the descriptions in public repositories, are widely used in automatic software vulnerability classification. However, vulnerability descriptions are ordinarily short and contain many technical terms, making them difficult for machines to automatically comprehend. In this paper, we present an approach based on vulnerability triggers to automatically classify vulnerabilities. First, we extract vulnerability triggers with Bert Question and Answer (Bert Q&A). Then, we use Recurrent Convolutional Neural Networks for Text classification (TextRCNN) to classify vulnerabilities based on Common Weakness Enumeration (CWE). We statistically perform an analysis of vulnerability triggers and comprehensively evaluate the classification performance of our approach on a set of 4769 prelabeled vulnerability entries, as well as compare it with state‐of‐the‐art vulnerability classification approaches. Experiment results show that our approach can achieve a F1‐measure of 95% on extraction and 80.8% on classification. [ABSTRACT FROM AUTHOR]

Cloud computing is characterized as a shared computing and communication infrastructure. It encourages the efficient and effective developmental processes that are carried out in various organizations. Cloud computing offers both possibilities and solutions of problems for outsourcing and management of software developmental operations across distinct geography. Cloud computing is adopted by organizations and application developers for developing quality software. The cloud has the significant impact on utilizing the artificial complexity required in developing and designing quality software. Software developmental organization prefers cloud computing for outsourcing tasks because of its available and scalable nature. Cloud computing is the ideal choice utilized for development modern software as they have provided a completely new way of developing real‐time cost‐effective, efficient, and quality software. Tenants (providers, developers, and consumers) are provided with platforms, software services, and infrastructure based on pay per use phenomenon. Cloud‐based software services are becoming increasingly popular, as observed by their widespread use. Cloud computing approach has drawn the interest of researchers and business because of its ability to provide a flexible and resourceful platform for development and deployment. To determine a cohesive understanding of the analyzed problems and solutions to improve the quality of software, the existing literature resources on cloud‐based software development should be analyzed and synthesized systematically. Keyword strings were formulated for analyzing relevant research articles from journals, book chapters, and conference papers. The research articles published in (2011–2021) various scientific databases were extracted and analyzed for retrieval of relevant research articles. A total of 97 research publications are examined in this SLR and are evaluated to be appropriate studies in explaining and discussing the proposed topic. The major emphasis of the presented systematic literature review (SLR) is to identify the participating entities of cloud‐based software development, challenges associated with adopting cloud for software developmental processes, and its significance to software industries and developers. This SLR will assist organizations, designers, and developers to develop and deploy user‐friendly, efficient, effective, and real time software applications. [ABSTRACT FROM AUTHOR]

The advancement in the field of artificial intelligence (AI) has revolutionized every field of life, including the learning of second languages. These intelligent devices are capable of effectively and efficiently utilizing the time and energy of both learners and teachers. Students can learn at their own pace and at their own skill level. They can learn and practice in an interactive and fruitful environment thanks to intelligent chatbots and voice assistants. Students no longer require humanized teachers as a result of the use of these new methodologies; instead, they can learn more effectively by interacting with computer‐assisted systems. With the integration of information and communication technology (ICT) and AI, new technologies like computer‐assisted language learning (CALL) and mobile‐assisted language learning (MALL) are playing a very crucial role in the learning of the English language. Due to the various AI‐based applications and technologies available, learners are unable to use the most valuable and effective ones. This paper focuses on the role of AI in the learning of the English language. The study will help learners in the selection of efficient and effective AI‐powered paradigms for the teaching and learning process of the English language. Various features have been selected from the identified ones, and then, on the basis of these features, different AI‐grounded paradigms for English learning are ranked using analytical hierarchy process (AHP) and Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS). The alternative with the highest performance value is ranked at the top of all available alternatives, while the one with the lowest performance score is placed at the last. [ABSTRACT FROM AUTHOR]

The success of software depends upon functional and non‐functional requirements as both requirements are equally important in software development. However, the requirements engineering community still lacks in comprehensive understanding of functional and non‐functional requirements. In addition, the requirements in software documents are expressed in natural language and also intertwined with each other. Requirements classification is a crucial task that correctly extracts functional and non‐functional requirements and organizes them in specified categories. Automated classification of software requirements leads to reduced ambiguity, misunderstanding, and development cost. Most of the recent studies have used machine learning and deep learning techniques for automatic classification of requirements. However, there is one drawback of such techniques, that is, poor generalization. To address these problems, this research work proposes self‐attention based bidirectional LSTM deep model. This automated approach has used recurrent neural network, which handle long sequential natural language requirements statements and classify them into five classes such as capability, maintainability, performance, security, and usability. The proposed approach train and evaluate over pre‐labeled dataset comprised of 34 industrial requirements specifications and PROMISE dataset. Over this dataset, the proposed approach yields 95% of precision, 96% of recall, 96% of F‐measure, and 96% of accuracy. The proposed approach can be applied to wide variety of datasets with different domain. Furthermore, this paper applies pre‐processing techniques to improve the performance of the requirements classification model. The results of the proposed model are compared with existing baseline state‐of‐art techniques, and it is shown that the proposed model outperforms the baseline models in requirements classification. [ABSTRACT FROM AUTHOR]

Dependency cycles have been claimed to incur negative impacts on software quality and make a system difficult to test, maintain, and reuse. Previous studies have investigated dependency cycles' evolution and proposed various methods to detect and break dependency cycles. While these studies provide valuable inputs for understanding dependency cycles, we do not know how developers address dependency cycles in their daily activities and whether dependency cycles' resolution follows certain patterns. Therefore, in this paper, using the data from 18 open‐source projects, we extracted dependency cycles along with their changes from each commit and studied how dependency cycles evolved in a fine‐grained level. Our results demonstrate that, 28.4% of dependency cycles have been continuously changing through different status: aggregating, breaking, newly‐forming, and disappearing. Furthermore, we found that dependency cycles in different shapes present their specific evolution characteristics, for example, star and circle dependency cycles tend to preserve their original shape during aggregation or breaking. In addition, we discovered several recurring patterns that developers applied in fully breaking star and circle dependency cycles. We believe the recurring patterns we summarized have the potential to be automated in breaking dependency cycles in practice. [ABSTRACT FROM AUTHOR]

Cross‐project defect prediction (CPDP) is used to build defect prediction models when data from the target project are not enough. There has been several approaches to improve the performance of CPDP, such as feature transformation and instance selection methods. However, existing techniques are strongly dependent on the target data to reduce the distribution discrepancy between source and target projects. That is, the performance of these methods is determined by the effectiveness of feature transformation or the similarity between two projects. Additionally, when there is a large amount of source data that needs to be matched with target data, it will take much time and reduce the efficiency of model construction. Therefore, it is vital to explore a target project‐agnostic approach to build CPDP models. This paper presents a Weighted Isolation Forest with class Label information Filter (WIFLF) to relieve the issues above. Four groups of datasets from AEEEM, Relink and PROMISE Data Repository are used to conduct CPDP models. Besides, WIFLF is compared with 12 approaches. The experimental results indicate that WIFLF significantly outperforms all the baselines. Specifically, WIFLF with random forest significantly improves the performance over the baselines on average by at least 14.64% and 4.90% with respect to Skewed F‐Measure and G‐Measure, respectively. [ABSTRACT FROM AUTHOR]

Cloud testing is gaining much attention in both academia and industry as an emerging concept in the field of software testing. Cloud testing implies leveraging the resources of the cloud computing environment to overcome deficiencies of the traditional testing approaches. As a result, testing‐as‐a‐service (TaaS) is introduced as a service model that conducts all testing activities in a fully automated manner using cloud‐based resources. Performance testing is a type of software testing that validates the performance characteristics of the application under test (AUT) when subjected to different workloads during its operation. Performance characteristics include throughput, response time, and resource utilization of the AUT under a certain workload. This paper focuses on reviewing the literature related to the provision of performance testing as a service (P‐TaaS). In this study, we survey the previous work related to cloud‐based performance testing. We show the strengths and weaknesses of the current research. Besides, we compare the P‐TaaS with the traditional performance testing methodologies. A detailed discussion of the benefits and challenges of P‐TaaS is introduced along with identifying the research gaps and the future directions that can be adopted. [ABSTRACT FROM AUTHOR]

Test amplification aims to automatically improve a test suite. One technique generates new test methods through transformations of the original tests. These test amplification tools heavily rely on analysis techniques that benefit a lot from type declarations present in the source code of projects written in statically typed languages. In dynamically typed languages, such type declarations are not available, and therefore, research regarding test amplification for those languages is sparse. Recent work has brought test amplification to the dynamically typed language Pharo Smalltalk by introducing the concept of dynamic type profiling. The technique is dependent on Pharo‐specific frameworks and has not yet been generalized to other languages. Another significant downside in test amplification tools based on the mutation score of a test suite is their high time cost. In this paper, we present AmPyfier, a tool that brings test amplification and type profiling to the dynamically typed language Python. AmPyfier introduces multi‐metric selection in order to increase the time efficiency of test amplification. We evaluated AmPyfier on 11 open‐source projects and found that AmPyfier could strengthen 37 out of 54 test classes. Multi‐metric selection decreased the time cost ranging from 17% to 98% as opposed to selection based on the full mutation score. [ABSTRACT FROM AUTHOR]

Minimizing failing test cases is an important preprocessing step on the path of debugging. If much of a test case that triggered a bug does not contribute to the actual failure, then the time required to fix the bug can increase considerably. However, test case reduction itself can be a time‐consuming task, especially if done manually. Therefore, automated minimization techniques have been proposed, the minimizing Delta Debugging and the Hierarchical Delta Debugging (HDD) algorithms being the most well known. In this paper, we investigated the input format of HDD, searching for structures that the algorithm cannot reduce. Motivated by the findings, we have created an algorithmic framework that enabled the use of transformations other than pruning. Furthermore, with the Transformation‐based Minimization framework, we propose to extend HDD and its coarse and recursive variants with a reduction method that does not prune subtrees but replaces them with compatible subtrees further down the hierarchy, called hoisting. We have evaluated various combinations of pruning and hoisting on multiple test suites and found that hoisting can help to further reduce the size of test cases by 27% on average and by 80% as best case compared with the baseline algorithm. [ABSTRACT FROM AUTHOR]

Model transformation testing has become crucial as model‐driven engineering has raised the abstraction level for developing software systems. Transformation is written to transform models from one level of abstraction to another, for example, model to model or model to code. A major challenge in testing the transformation is the creation of test models, such that (i) they conform to the source meta‐model (i.e., multiplicities and Object Constraint Language [OCL] constraints on meta‐model) and (ii) they provide coverage of the complete transformation (solving branch conditions for traversing all paths). Manual creation of test models requires a lot of time and effort. Still, the validity of the developed test models cannot be ensured. This paper aims to solve the above challenges using an automated search‐based strategy. The proposed approach is two‐stepped. First, valid test models are generated by solving source meta‐model constraints. Second, the generated models are evolved for achieving the structural coverage of the transformation by solving the branch conditions. A toolset model transformation testing environment (MOTTER) is developed to automate the search‐based solution. The proposed work is empirically evaluated on two case studies using four search algorithms. The result reflects that it successfully generates valid test models for achieving desired structural coverage with high performance on both the case studies. [ABSTRACT FROM AUTHOR]

A large volume of highly diverse and real‐time data provided by social network sites has revolutionized several data analytical sciences such as stock exchange fluctuation prediction, sentiment analysis, and political affiliations prediction. From a software engineering viewpoint, social network sites have produced an unprecedented opportunity for software development organizations to monitor the opinion of the large population of users of their systems. The extracted data from social network sites can be used to extract information about newly launched systems, and it enable software development organizations to obtain rapid technical and social feedback about their systems. This paper presents on a systematic literature review of the published research articles on how requirements engineering (RE) activities are conducted using social network sites, elaborated in studies published between 2011 and 2019. From the resulting studies, we extracted data to answer our four questions related to social network site (SNS)‐based RE approaches focusing on requirements elicitation, prioritization, and negotiation activities. Thirty‐one relevant studies were identified and analyzed to answer our research questions. Among 31 studies, 62% of the studies reportedly support requirements elicitation activity, and 14% of the studies reportedly support requirements elicitation, prioritization, and negotiation activities. Ten percent studies were about requirements elicitation and prioritization activities, 7% of the studies support both requirements elicitation and negotiation activities, and prioritization activity was supported by 7% of the studies. It was also observed that 58% of the selected studies adopted semi‐automatic approaches to conduct RE activities while 21% of the selected studies proposed automatic tools, and 21% of the selected studies adopted manual approaches to conduct RE activities. The outcomes of this systematic literature review indicate that social network sites can be a major source that can be used successfully to extract and identify user requirements. Moreover, this systematic literature review also presents implications of this study for practitioners and researchers including challenges, unresolved issues, and future research directions. [ABSTRACT FROM AUTHOR]

Against the backdrop of the growing adoption of Kanban in a variety of software development domains, this paper reports on how a Systems Thinking approach was used to implement Kanban within a business unit of a government organization. Based on an in‐depth case study in the development organization, we describe how Kanban practices such as visualization, manage flow, classes of service, and board design were implemented. Stages in the double diamond design thinking process of exploring an issue more widely (divergent thinking) and then taking focused action (convergent thinking) were incorporated to adapt Kanban practices such as board design. Positive experiences included improved visibility, improved collaboration, and improvements in lead time. Challenges included lack of team buy‐in, setting work‐in‐progress limits, and short‐term Kanban coach. We present the key lessons learned and offer practical recommendations on how teams can better produce knowledge work in today's fast‐paced dynamic business environment. [ABSTRACT FROM AUTHOR]

[Context]A software vulnerability becomes harmful for software when an attacker successfully exploits the insecure code and reveals the vulnerability. A single vulnerability in code can put the entire software at risk. Therefore, maintaining software security throughout the software life cycle is an important and at the same time challenging task for development teams. This can also leave the door open for vulnerable code being evolved during successive releases. In recent years, researchers have used software metrics‐based vulnerability prediction approaches to detect vulnerable code early and ensure secure code releases. Software metrics have been employed to predict vulnerability specifically in C/C++ and Java‐based systems. However, the prediction performance of metrics at different granularity levels (class level or method level) has not been analyzed. In this paper, we focused on metrics that are specific to lower granularity levels (Java classes and methods). Based on statistical analysis, we first identified a set of class‐level metrics and a set of method‐level metrics and then employed them as features in machine learning techniques to predict vulnerable classes and methods, respectively. This paper describes a comparative study on how our selected metrics perform at different granularity levels. Such a comparative study can help the developers in choosing the appropriate metrics (at the desired level of granularity). [Objective] The goal of this research is to propose a set of metrics at two lower granularity levels and provide evidence for their usefulness during vulnerability prediction (which will help in maintaining secure code and ensure secure software evolution). [Method] For four Java‐based open source systems (including two releases of Apache Tomcat), we designed and conducted experiments based on statistical tests to propose a set of software metrics that can be used for predicting vulnerable code components (i.e., vulnerable classes and methods). Next, we used our identified metrics as features to train supervised machine learning algorithms to classify Java code as vulnerable or non‐vulnerable. [Result] Our study has successfully identified a set of class‐level metrics and a second set of method‐level metrics that can be useful from a vulnerability prediction standpoint. We achieved recall higher than 70% and precision higher than 75% in vulnerability prediction using our identified class‐level metrics as features of machine learning. Furthermore, method‐level metrics showed recall higher than 65% and precision higher than 80%. [ABSTRACT FROM AUTHOR]

An introduction to the journal is presented in which the guests editors discuss source code analysis and manipulation.

This volume comprises a selected set of high quality and extended articles of the 25th Systems, Software and Services Process Improvement (EuroSPI) Conference, held during September 5-7, 2018, in Bilbao, Spain. Establishing an annual EuroSPI conference supported by software process improvement networks from different EU countries. 7 Khan AA, Keung J, Niazi M, Hussain S, Shameem M. GSEPIM: A roadmap for software process assessment and improvement in the domain of global software development. 12 Barafort B, Shrestha A, Cortina S, Renault A. A software artefact to support standard-based process assessment: Evolution of the TIPA® framework in a design science research project. [Extracted from the article]

Blockchain is considered as a major emerging technology that is having an ever‐increasing spread both in industrial and academic contexts. As the usage of blockchain keeps increasing, a fourth generation of blockchain platforms is being proposed. Thus, applications of blockchain have evolved towards wider scopes than cryptocurrency and asset management. In this context, it is important for practitioners to have deep understanding of various blockchain assessment initiatives. Therefore, this work discusses blockchain assessment initiatives from a technology evolution viewpoint. Furthermore, a mapping was conducted to identify factors that impact blockchain initiatives, synthesize available evidence, and identify gaps between relevant approaches available in the literature. As a result, nine selected works were analyzed based on applicability, research approach, assessment process, blockchain adoption process, and blockchain waves. The findings can help practitioners to understand the main assessment factors that undermine blockchain implementations. [ABSTRACT FROM AUTHOR]

Free and open source software package ecosystems have existed for a long time, but such collaborative development practice has surged in recent years. One of the oldest and most popular package ecosystems is Comprehensive R Archive Network (CRAN), the repository of packages of the statistical language R, a popular statistical computing environment. CRAN stores a large number of packages that are updated regularly and depend on many other packages in a complex graph of relations. As the repository grows, its sustainability could be threatened by that complexity or nonuniform evolution of some packages. This paper provides an empirical analysis of the evolution of the CRAN repository in the last 20 years, considering the laws of software evolution and the effect of CRAN's policies on such development. Results show how the progress of CRAN is consistent with the laws of continuous growth and change and how there seems to be a relevant increase in complexity in recent years. Significant challenges are raising related to the scale and scope of software package managers and the services they provide; understanding how they change over time and what might endanger their sustainability are key factors for their future improvement, maintenance, policies, and, eventually, sustainability of the ecosystem. This paper provides an empirical analysis of the evolution of the CRAN repository in the last 20 years, considering the laws of software evolution and the effect of CRAN's policies on such development. Results show how the progress of CRAN is consistent with the laws of continuous growth and change and how there seems to be a relevant increase in complexity in recent years. [ABSTRACT FROM AUTHOR]

We are living in an age of growing demand for software products. This growing demand creates opportunities for very small entities (VSEs) to not only survive but also flourish. In this context, VSEs need to produce high‐quality products to meet market needs. However, in their quest to produce high‐quality software, VSEs need to overcome the challenge of implementing international standards, which they find difficult to do because of lack of knowledge and practical experience. This paper provides an analysis performed to 13 teams of VSEs, using different life cycles, which achieved the implementation of the ISO/IEC 29110, to analyze the effort each team invests to implement the best practices provided by the standard. Besides, the paper provides an analysis of the difficulties, and the benefits of using the six‐step method are included. This analysis is of interest because software engineering knowledge developed by researchers should be transferred to the industry to reduce the gap between them. The results highlight, on the one hand, the practices representing more effort for teams by life cycle. On the other hand, the results highlight the six‐step method that allowed the 13 teams to achieve a high level of coverage of the ISO/IEC 29110 international standard. [ABSTRACT FROM AUTHOR]

Abstract: Software developing organizations strive to achieve flexibility to maintain a competitive advantage. There is no common understanding of what characterize flexibility for a software organization beyond the scope of the software product. Without a common understanding, it is difficult to evaluate the degrees of flexibility of software development approaches. The aim of this literature review is to collect attributes that characterize flexibility. The collected attributes are consolidated into a flexibility framework with 3 main attributes: properties of change, flexibility perspectives, and flexibility enablers. The resulting flexibility framework is then used to evaluate Agile and Lean practices. The evaluation shows that Agile and Lean practices address many flexibility attributes. However, some attributes are not addressed, such as infrastructure flexibility and strategic flexibility. On the basis of our evaluation, the classifications of flexibility attributes that we present in this paper could be used to aid software organization flexibility evaluation. [ABSTRACT FROM AUTHOR]

Abstract: Green and sustainable software development has emerged in recent years, and vendors are constantly striving to develop software that has a less hazardous impact on the environment, economy, and human beings. However, developing green software in the context of software multisourcing is not a risk‐free activity, and vendors are exposed to several challenges. The authors have conducted both a systematic literature review and an industrial survey to identify the challenges faced by multisourcing vendors in the development of green and sustainable software. The final publication sample for the systematic literature review is composed of 54 research papers. Similarly, the final sample of the industrial survey is composed of 108 relevant experts. The authors have identified a list of 14 challenges. Of these challenges/risk factors, 8 have been tagged as critical risk factors. These critical risk factors are “lack of green RE practices,” “high power consumption,” “high carbon emission throughout the software development,” “poor software design (architectural, logical, physical, and user interface),” “lack of ICTs for coordination and communication,” “high resource requirements,” “lack of coding standards,” and “lack of green software development knowledge.” [ABSTRACT FROM AUTHOR]

Abstract: Over the last decade, the use of agile methods has grown dramatically for software development. Agile methods guarantee to accelerate the delivery of remarkable software with increased user satisfaction and reduced cost. However, in recent years, due to the emergence of green software engineering, software developers are compelled to focus more on green and sustainable aspects of software. Green software engineering aims to design, develop, and use the software with confined energy and computing resources. Recently, software engineers in global software development have adapted agile methods for quick, interactive, and environment‐friendly software development. In this study, we have identified 16 success factors, through systematic literature review (SLR) and applied contrived search criteria derived from the research questions; 80 relevant papers were identified and reviewed. Findings of the SLR study were then empirically validated through questionnaire survey in global software development industry, in which 106 experts from 25 different countries participated. The findings of our industrial survey are mostly in coherence with the SLR findings. However, there is a difference in ranks of the various success factors across the 2 data sets (SLR and industrial survey). [ABSTRACT FROM AUTHOR]

Reverse engineering of sequence diagrams refers to the process of extracting meaningful information about the behavior of software systems in the form of appropriately generated sequence diagrams. This process has become a practical method for retrieving the behavior of software systems, primarily those with inadequate documentation. Various approaches have been proposed in the literature to produce from a given system a series of interactions that can be used for different purposes. The reason for such diversity of approaches is the need to offer sequence diagrams that can cater for the users' specific goals and needs, which can vary widely depending on the users' perception and understandability of visual representations and the target application domains. In this paper, we systematically review existing techniques in this context while focusing on their distinct purposes and potentials of providing more understandable sequence diagrams. In addition, a qualitative evaluation of such techniques is conducted to expose their adequacy and applicability for effective program comprehension. Finally, we list a set of possible extensions to the unified modeling language sequence diagram standard that we anticipate will enhance its versatility and understandability of program control flow, followed by a number of concluding remarks. [ABSTRACT FROM AUTHOR]

Despite the particular standards, technologies, and trends (W3C, RESTful, microservices, etc.) that a team decides to follow for the development of a service‐oriented system, most likely the team members will have to use one or more services that solve general‐purpose problems like cloud computing, networking and content delivery, storage and database, management and governance, and application integration. Typically, general‐purpose services are long‐lived, they have several responsibilities, their interfaces are complex, and they grow over time. The way that these services evolve also affects the evolution of any system that will depend on them. Consequently, the selection of the particular services that will be used is a main concern for the team. In this paper, we report a pattern, called the athletic heart syndrome, which facilitates the selection of services that evolve properly. Patterns specify best practices that emerge from multiple real‐world cases. In our context, the athletic heart syndrome comes out from a study that concerns the evolution of a set of popular, long‐lived Amazon services that cover different domains. According to the athletic heart syndrome, the developers should select services whose heartbeat of changes looks like the heartbeat of an athlete when he is at rest. Specifically, the heartbeat of changes should consist mostly of calm periods, interrupted by few spikes of change. Similarly, the incremental growth of the services should involve mainly calm periods of maintenance, separated by spikes of growth. Selecting services that adhere to the pattern signifies high chances that the services evolve to deal with changing requirements. The pattern further guarantees that the service evolution involves both the expansion of the services with new functionalities and the maintenance of existing ones. The pattern also assures that the complexity increase in the service interfaces will be smooth and tolerable. Finally, conformance with the pattern implies that the growth of the services will be predictable. [ABSTRACT FROM AUTHOR]

Safe handling of hazardous driving situations is a task of high practical relevance for building reliable and trustworthy cyber‐physical systems such as autonomous driving systems. This task necessitates an accurate prediction system of the vehicle's confidence to prevent potentially harmful system failures on the occurrence of unpredictable conditions that make it less safe to drive. In this paper, we discuss the challenges of adapting a misbehavior predictor with knowledge mined during the execution of the main system. Then, we present a framework for the continual learning of misbehavior predictors, which records in‐field behavioral data to determine what data are appropriate for adaptation. Our framework guides adaptive retraining using a novel combination of in‐field confidence metric selection and reconstruction error‐based weighing. We evaluate our framework to improve a misbehavior predictor from the literature on the Udacity simulator for self‐driving cars. Our results show that our framework can reduce the false positive rate by a large margin and can adapt to nominal behavior drifts while maintaining the original capability to predict failures up to several seconds in advance. [ABSTRACT FROM AUTHOR]

Open Source Software (OSS) projects have long been studied to understand the need of community support for their growth and survival. However, there has been limited research on developers' abandonment, though it is found to have detrimental effect on quality and sustainability of OSS projects. This paper examines the impact of developer and project‐related factors on developer abandonment in OSS projects. Factors include developer attributes: experience, role, coding language, and joining date, and project attributes: change complexity and sentiments in commit logs. The findings are (1) for developer experience, core/non‐core member, and joining date; there exists a pattern of developers abandoning the projects. (2) There is no definite answer for coding language. (3) It does not relate to the change profile of a project except a few indicators. Sentiments can also not be linked. These results provide OSS community and researchers with useful insights on developer abandonment and the factors influencing it or not. [ABSTRACT FROM AUTHOR]

Modern Cloud applications have evolved from monolithic systems to numerous distributed microservices whose workflows interact via Remote Procedure Calls (RPCs). The benchmarks focusing on individual microservice components are insufficient because the reference relationships between components, which form the microservice workflow structure, are another critical aspect of microservice applications. Unfortunately, understanding the characteristics of microservice workflow in the production Cloud remains a missing piece in the literature, which prevents the representative of microservice benchmarks. In this paper, we fill this gap by characterizing and synthesizing the microservice workflows based on the trace data of the Toutiao application that is running on ByteDance Cloud. We examine the microservice workflows starting from DAG graphs, introduce observed properties that are easy to ignore but important, show the artificiality of the workflow by statistic description, and explore the high cost of network overhead. We further synthesize the workflow following the characteristics observed. The extensive evaluations show that the synthesized microservice workflows have consistent statistical characteristics as the production ones. A case study applying the synthesized workflows proves its usability. [ABSTRACT FROM AUTHOR]

Accurate prediction of software effort is important for planning, scheduling, and allocating resources. However, software effort estimation has been a challenging task. Although numerous estimation models have been proposed, few achieve anything close to accurate prediction of software development effort. To achieve optimal results, machine learning techniques have recently been employed for predicting software development effort using relatively large software repositories. However, some issues remain unresolved, and this paper aims to address the following issues. First, feature selection methods often neglected the information rich variables present in the dataset. Second, selection of important features was done through statistical methods, which lack domain knowledge. Third, missing values in the data that significantly influence the prediction outcome was not efficiently handled. Fourth, majority of the literature neglected advanced evaluation measures, which thoroughly evaluate the ability of learning models to produce accurate results. To address the above issues, a machine learning‐based model has been proposed in this paper, which not only allows effective preprocessing of data but also provides highly accurate prediction results with minimum error rate. The purpose is to best identify attributes (predictors) from large software repositories that are most influential in the estimation of effort. In addition, we apply MMRE for better performance analysis. [ABSTRACT FROM AUTHOR]

Bug assignment is the task of ranking candidate developers in terms of their potential competence to fix a bug report. Numerous methods have been developed to address this task, relying on different methodological assumptions and demonstrating their effectiveness with a variety of empirical studies with numerous data sets and evaluation criteria. Despite the importance of the subject and the attention it has received from researchers, there is still no unanimity on how to validate and comparatively evaluate bug‐assignment methods and, often times, methods reported in the literature are not reproducible. In this paper, we first report on our systematic review of the broad bug‐assignment research field. Next, we focus on a few key empirical studies and review their choices with respect to three important experimental‐design parameters, namely, the evaluation metric(s) they report, their definition of who the real assignee is, and the community of developers they consider as candidate assignees. The substantial variability on these criteria led us to formulate a systematic experiment to explore the impact of these choices. We conducted our experiment on a comprehensive data set of bugs we collected from 13 long‐term open‐source projects, using a simple Tf‐IDf similarity metric. On the basis of our arguments and/or experiments, we provide useful guidelines for performing further bug‐assignment research. We conclude that mean average precision (MAP) is the most informative evaluation metric, the developer community should be defined as "all the project members," and the real assignee should be defined as "any developer who worked toward fixing a bug." [ABSTRACT FROM AUTHOR]

Bad smells are bad practices in developing software. These poor solutions significantly influence the understandability and maintainability of source code. Therefore, bad smell detection plays a vital role in the refactoring, maintaining, and measuring the quality of large and complex software systems. Researchers believe that bad smells should be precisely identified and addressed. However, bad smell detection is complicated by issues such as informal and inconsistent specifications of bad smells and high false positive rates in the detection process, all of which affect the success rate in detection. In this paper, we present a new method to detect bad smells in code by addressing the aforementioned issues. Our proposed method is a multi‐step process using software quality metrics and refactoring opportunities. In this method, after obtaining the bad smell formal specifications based on software metrics, we utilize them to achieve a set of candidates for each bad smell. Afterwards, each of the instances will be examined and compared with the corresponding refactoring situations specified for that bad smell. This examination strikes out the false positives created in the previous step. The evaluation of this method on four open‐source systems demonstrates the improved effectiveness of bad smell detection in code. [ABSTRACT FROM AUTHOR]