Search-based Software Engineering Techniques Research Articles

A Systematic Mapping Study of Search-Based Software Engineering for Enterprise Application Integration

Search-Based Software Engineering (SBSE) is widely used in different fields of Software Engineering, notoriously, in Enterprise Application Integrations (EAIs). EAI encompasses methodologies, techniques and tools that a software engineer can use to create integration solutions. SBSE is currently an active research topic of increasing interest. The number and diversity of publications produced yearly are large to the extent that it is hard to identify the active research groups, their locations, techniques used and research topics that have not received enough attention. To answer these questions categorically, we have conducted systematic mapping study of the literature. In this paper, we report our methodology and findings. In our study, we used systematic search strategies that resulted in the retrieval of 560 articles, of which we first selected 25. Second, on the basis of the authors’ experience, we included eight additional articles. Finally, we used a snowballing sample technique to include another 12 articles. The results demonstrate that during the last two decades (1999–2020) EAI has benefited from the use of Search-Based Software Engineering techniques.

The Acceptance of Search-Based Software Engineering Techniques: An Empirical Evaluation Using the Technology Acceptance Model

Numerous topics in software engineering can be formulated as optimization problems. Due to the large scale of modern software systems, the methods of mathematical optimization have high computational complexity, and their application in many cases is not possible. To overcome this problem, search-based software engineering (SBSE) develops and applies metaheuristic search techniques to find near-optimal solutions. Despite the significant development that the SBSE techniques (SBSET) achieved in the last years, the level of SBSET use is very low. Therefore, this paper proposes and tests a model which evaluates and predicts the acceptance of SBSET by software engineering practitioners. The model is based on the technology acceptance model (TAM) and extended by the SBSET desired properties. A total of 163 practitioners participated in the study. The perceived ease of use, perceived usefulness, and organizational and team-based factors were all found to have significant positive effects on the actual use of the SBSET. This study also analyses the obstacles of SBSET acceptance and provides several proposals for its improvement in the software industry.

Achieving Feature Location in Families of Models Through the Use of Search-Based Software Engineering

The application of search-based software engineering techniques to new problems is increasing. Feature location is one of the most important and common activities performed by developers during software maintenance and evolution. Features must be located across families of products and the software artifacts that realize each feature must be identified. However, when dealing with industrial software artifacts, the search space can be huge. We propose and compare five search algorithms to locate features over families of product models guided by latent semantic analysis (LSA), a technique that measures similarities between textual queries. The algorithms are applied to two case studies from our industrial partners (leading manufacturers of home appliances and rolling stock) and are compared in terms of precision and recall. Statistical analysis of the results is performed to provide evidence of the significance of the results. The combination of an evolutionary algorithm with LSA can be used to locate features in families of models from industrial scenarios such as the ones from our industrial partners.

Genetic Programming varvec{+} Proof Search varvec{=} Automatic Improvement

Search Based Software Engineering techniques are emerging as important tools for software maintenance. Foremost among these is Genetic Improvement, which has historically applied the stochastic techniques of Genetic Programming to optimize pre-existing program code. Previous work in this area has not generally preserved program semantics and this article describes an alternative to the traditional mutation operators used, employing deterministic proof search in the sequent calculus to yield semantics-preserving transformations on algebraic data types. Two case studies are described, both of which are applicable to the recently-introduced ‘grow and graft’ technique of Genetic Improvement: the first extends the expressiveness of the ‘grafting’ phase and the second transforms the representation of a list data type to yield an asymptotic efficiency improvement.

Investigating the effect of “defect co-fix” on quality assurance resource allocation: A search-based approach

Allocation of resources to pre-release quality assurance (QA) tasks, such as source code analysis, peer review, and testing, is one of the challenges faced by a software project manager. The goal is to find as many defects as possible with the available QA resources prior to the release. This can be achieved by assigning more resources to the more defect-prone artifacts, e.g., components, classes, and methods. The state-of-the-art QA resource allocation approaches predict the defect-proneness of an artifact using the historical data of different software metrics, e.g., the number of previous defects and the changes in the artifact. Given a QA budget, an allocation technique selects the most defect-prone artifacts, for further investigation by the QA team. While there has been many research efforts on discovering more predictive software metrics and more effective defect prediction algorithms, the cost-effectiveness of the QA resource allocation approaches has always been evaluated by counting the number of defects per selected artifact. The problem with such an evaluation approach is that it ignores the fact that, in practice, fixing a software issue is not bounded to an artifact under investigation. In other words, one may start reviewing a file that is identified as defect-prone and detect a defect, but to fix the defect one may modify not only the defective part of the file under review, but also several other artifacts that are somehow related to the defective code (e.g., a method that calls the defective code). Such co-fixes (fixing several defects together) during analyzing/reviewing/testing of an artifact under investigation will change the number of remaining defects in the other artifacts. Therefore, a QA resource allocation approach is more effective if it prioritizes the artifacts that would lead to the smallest number of remaining defects. Investigating six medium-to-large releases of open source systems (Mylyn, Eclipse, and NetBeans, two releases each), we found that co-fixes happen quite often in software projects (30–42% of the fixes modify more than one artifact). Therefore, in this paper, we first introduce a new cost-effectiveness measure to evaluate QA resource allocation, based on the concept of “remaining defects” per file. We then propose several co-fix-aware prioritization approaches to dynamically optimize the new measure, based on the historical defect co-fixes. The evaluation of these approaches on the six releases shows that (a) co-fix-aware QA prioritization approaches improve the traditional defect prediction-based ones, in terms of density of remaining defects per file and (b) co-fix-aware QA prioritization can potentially benefit from search-based software engineering techniques.