Search-based Software Engineering Research Articles

Software Product Line Maintenance Using Multi-Objective Optimization Techniques

Currently, software development is more associated with families of configurable software than the single implementation of a product. Due to the numerous possible combinations in a software product line, testing these families of software product lines (SPLs) is a difficult undertaking. Moreover, the presence of optional features makes the testing of SPLs impractical. Several features are presented in SPLs, but due to the environment’s time and financial constraints, these features are rendered unfeasible. Thus, testing subsets of configured products is one approach to solving this issue. To reduce the testing effort and obtain better results, alternative methods for testing SPLs are required, such as the combinatorial interaction testing (CIT) technique. Unfortunately, the CIT method produces unscalable solutions for large SPLs with excessive constraints. The CIT method costs more because of feature combinations. The optimization of the various conflicting testing objectives, such as reducing the cost and configuration number, should also be considered. In this article, we proposed a search-based software engineering solution using multi-objective evolutionary algorithms (MOEAs). In particular, the research was applied to different types of MOEA method: the Indicator-Based Evolutionary Algorithm (IBEA), Multi-objective Evolutionary Algorithm based on Decomposition (MOEA/D), Non-dominant Sorting Genetic Algorithm II (NSGAII), NSGAIII, and Strength Pareto Evolutionary Algorithm 2 (SPEA2). The results of the algorithms were examined in the context of distinct objectives and two quality indicators. The results revealed how the feature model attributes, implementation context, and number of objectives affected the performances of the algorithms.

An Automated Path-Focused Test Case Generation with Dynamic Parameterization Using Adaptive Genetic Algorithm (AGA) for Structural Program Testing

Various software engineering paradigms and real-time projects have proved that software testing is the most critical and highly important phase in the SDLC. In general, software testing takes approximately 40–60% of the total effort and time involved in project development. Generating test cases is the most important process in software testing. There are many techniques involved in the automatic generation of these test cases which aim to find a smaller group of cases that could allow for an adequacy level to be achieved which will hence reduce the effort and cost involved in software testing. In the structural testing of a product, the auto-generation of test cases that are path focused in an efficient manner is a challenging process. These are often considered optimization problems and hence search-based methods such as genetic algorithm (GA) and swarm optimizations have been proposed to handle this issue. The significance of the study is to address the optimization problem of automatic test case generation in search-based software engineering. The proposed methodology aims to close the gap of genetic algorithms acquiring local minimum due to poor diversity. Here, dynamic adjustment of cross-over and mutation rate is achieved by calculating the individual measure of similarity and fitness and searching for the more global optimum. The proposed method is applied and experimented on a benchmark of five industrial projects. The results of the experiments have confirmed the efficiency of generating test cases that have optimum path coverage.

The Weights Can Be Harmful: Pareto Search versus Weighted Search in Multi-objective Search-based Software Engineering

In presence of multiple objectives to be optimized in Search-Based Software Engineering (SBSE), Pareto search has been commonly adopted. It searches for a good approximation of the problem’s Pareto-optimal solutions, from which the stakeholders choose the most preferred solution according to their preferences. However, when clear preferences of the stakeholders (e.g., a set of weights that reflect relative importance between objectives) are available prior to the search, weighted search is believed to be the first choice, since it simplifies the search via converting the original multi-objective problem into a single-objective one and enables the search to focus on what only the stakeholders are interested in. This article questions such a “ weighted search first ” belief. We show that the weights can, in fact, be harmful to the search process even in the presence of clear preferences. Specifically, we conduct a large-scale empirical study that consists of 38 systems/projects from three representative SBSE problems, together with two types of search budget and nine sets of weights, leading to 604 cases of comparisons. Our key finding is that weighted search reaches a certain level of solution quality by consuming relatively less resources at the early stage of the search; however, Pareto search is significantly better than its weighted counterpart the majority of the time (up to 77% of the cases), as long as we allow a sufficient, but not unrealistic search budget. This is a beneficial result, as it discovers a potentially new “rule-of-thumb” for the SBSE community: Even when clear preferences are available, it is recommended to always consider Pareto search by default for multi-objective SBSE problems, provided that solution quality is more important. Weighted search, in contrast, should only be preferred when the resource/search budget is limited, especially for expensive SBSE problems. This, together with other findings and actionable suggestions in the article, allows us to codify pragmatic and comprehensive guidance on choosing weighted and Pareto search for SBSE under the circumstance that clear preferences are available. All code and data can be accessed at https://github.com/ideas-labo/pareto-vs-weight-for-sbse .

A novel multi-objective learning-to-rank method for software defect prediction

Search-Based Software Engineering (SBSE) is one of the techniques used for software defect prediction (SDP), in which search-based optimization algorithms are used to identify the optimal solution to construct a prediction model. As we know, the ranking methods of SBSE are used to solve insufficient sample problems, and the feature selection approaches of SBSE are employed to enhance the prediction model?s performance with curse-of-dimensionality or class imbalance problems. However, it is ignored that there may be a complex problem in the process of building prediction models consisting of the above problems. To address the complex problem, two multi-objective learning-to-rank methods are proposed, which are used to search for the optimal linear classifier model and reduce redundant and irrelevant features. To evaluate the performance of the proposed methods, excessive experiments have been conducted on 11 software programs selected from the NASA repository and AEEEM repository. Friedman?s rank test results show that the proposed method using NSGA-II outperforms other state-of-the-art singleobjective methods for software defect prediction.

Balancing Constraints and Objectives by Considering Problem Types in Constrained Multiobjective Optimization.

Constrained multiobjective optimization problems widely exist in real-world applications. To handle them, the balance between constraints and objectives is crucial, but remains challenging due to non-negligible impacts of problem types. In our context, the problem types refer particularly to those determined by the relationship between the constrained Pareto-optimal front (PF) and the unconstrained PF. Unfortunately, there has been little awareness on how to achieve this balance when faced with different types of problems. In this article, we propose a new constraint handling technique (CHT) by taking into account potential problem types. Specifically, inspired by the prior work, problems are classified into three primary types: 1) I; 2) II; and 3) III, with the constrained PF being made up of the entire, part and none of the unconstrained counterpart, respectively. Clearly, any problem must be one of the three types. For each possible type, there exists a tailored mechanism being used to handle the relationships between constraints and objectives (i.e., constraint priority, objective priority, or the switch between them). It is worth mentioning that exact problem types are not required because we just consider their possibilities in the new CHT. Conceptually, we show that the new CHT can make a tradeoff among different types of problems. This argument is confirmed by experimental studies performed on 38 benchmark problems, whose types are known, and a real-world problem (with unknown types) in search-based software engineering. Results demonstrate that within both decomposition-based and nondecomposition-based frameworks, the new CHT can indeed achieve a good tradeoff among different problem types, being better than several state-of-the-art CHTs.

An unsupervised learning-based methodology for uncovering behavioural patterns for specific types of software defects

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

Empowering the Human as the Fitness Function in Search-Based Model-Driven Engineering

In Search-Based Software Engineering, more than 100 works have involved the human in the search process to obtain better results. However, the case where the human completely replaces the fitness function remains neglected. There is a good reason for that; no matter how intelligent the human is, humans cannot assess millions of candidate solutions as heuristics do. In this work, we study the influence of using the Human as the Fitness Function (HaFF) on the quality of the results. To do that, we focus on Search-Based Model-Driven Engineering (SBMDE) because inspecting models should require less human effort than inspecting code thanks to the abstraction of models. Therefore, we analyze the impact of HaFF in a real-world industrial case study of feature location in models. Furthermore, we also consider a reformulation operation (replacement) in the evaluation because a recent work reported that this operation significantly reduces the number of iterations required in comparison to the widespread crossover and mutation operations. The combination of HaFF and the reformulation operation (HaFF_R) improves the results of the best baseline by 0.15% in recall and 14.26% in precision. Analyzing the results, we learned how to better leverage HaFF_R, which increased the improvement with regard to the best baseline to 1.15% in recall and 20.05% in precision. HaFF_R significantly improves precision because humans are immune to the main limitations of the baselines: vocabulary mismatch and tacit knowledge. A focus group confirmed the acceptance of HaFF. These results are relevant for SBMDE because feature location is one of the main activities performed during maintenance and evolution. Our results, and what we learned from them, can also motivate and help other researchers to explore the benefits of HaFF. In fact, we provide a guideline that further discusses how to apply HaFF to other software engineering problems.

Optimizing the Energy Consumption of Blockchain-Based Systems Using Evolutionary Algorithms: A New Problem Formulation

Blockchain technology has gained recognition in industrial, financial, and various technological domains for its potential in decentralizing trust in peer-to-peer systems. A core component of blockchain technology is a consensus algorithm, most commonly Proof of Work (PoW). PoW is used in blockchain-based systems to establish trust among peers; however, it does require the expenditure of an enormous amount of energy that affects the environmental sustainability of blockchain-based systems. Energy minimization, whilst ensuring trust within blockchain-based systems that use PoW, is a challenging problem. The solution has to consider how energy consumption can be minimized without compromising trust, whilst still ensuring, for instance, scalability, security, and decentralization. In this paper, we represent the problem as a subset selection problem of miners in a blockchain-based system. We formulate the problem of blockchain energy consumption as a Search-Based Software Engineering problem with four objectives: energy consumption, carbon emission, decentralization, and trust. We propose a model composed of multiple fitness functions. The model can be used to explore the complex search space by selecting a subset of miners that minimizes the energy consumption without drastically impacting the primary goals of the blockchain technology (i.e., security/trustworthiness and decentralization). We integrate our proposed fitness functions into five evolutionary algorithms to solve the problem of blockchain miners selection. Our results show that the environmental sustainability of blockchain-based systems (e.g. reduced energy use) can be enhanced with little degradation in other competing objectives. We also report on the performance of the algorithms used.

On the preferences of quality indicators for multi-objective search algorithms in search-based software engineering

On the preferences of quality indicators for multi-objective search algorithms in search-based software engineering

Search based Software Engineering of Software Metrics, Code Smells and Refactoring Techniques Using Optimization Algorithms

Software refactoring is a technique for reorganising and improving the efficiency of existing software code. By refining the non-functional aspects of software, numerous refactoring methods are currently being employed to build more intelligible and less composite codes. By applying multiple systems to the source code, refactoring can improve code maintainability even further, preserving the behaviour of the code. Refactoring allows for the eradication of bugs and the expansion of the program's capabilities. This paper provides a comprehensive assessment of source code with foul odours, the influence on software quality of using certain refactoring methodologies to eradicate the foul smell. Between 2008 and 2010, a total of 76 studies from 42 journals, 20 conferences, and 14 additional sources in the year 2008 and 2022 were available. This study was graded on the number of unpleasant odours identified, refactoring strategies applied, and their impact on software metrics. The foul smells of "method of long," "envious feature “and” class of data" were discovered or corrected in the majority of inquiries. The odour of "envious feature" was detected in 39.66 per cent of nominated investigations. The majority of studies looked at the effects of restructuring on software intricacy and coupling measures. Surprisingly, instead of patented software, the majority of the investigations employed massive opensource datasets released in Java. Finally, this research makes suggestions for further into the refactoring research code.

An efficient heuristic algorithm for software module clustering optimization

In the lifecycle of software projects, maintenance tasks usually entail 75% of the total costs, where most efforts are spent in understanding the program. To improve the maintainability of software projects, the code is often divided into components, which are then grouped in different modules following good design principles, lowering coupling and increasing cohesion. The Software Module Clustering Problem (SMCP) is an optimization problem that looks for maximizing the modularity of software projects in the context of Search-Based Software Engineering. In the SMCP, projects are often modeled as graphs. Therefore, the SMCP can be interpreted as a graph partitioning problem, which is proved to be NP-hard. In this work, we propose a new heuristic algorithm for software modularization, based on a Greedy Randomized Adaptive Search Procedure with Variable Neighborhood Descent. We present a three-fold categorization of neighborhoods for the SMCP and leverage domain-specific information to filter unpromising solutions. Our proposal has been successfully tested over a dataset of real software projects, outperforming the previous state-of-the-art approach in terms of Modularization Quality in very short computing times. Therefore, it could be integrated in software development tools to improve the quality of software projects in real time.

Exploration strategies for balancing efficiency and comprehensibility in model checking with ant colony optimization

ABSTRACT Model checking is a formal and automated verification technique to show that a software system behaves in accordance with the given specification. Traditional model checking uses exhaustive search techniques for finding violative behaviours of the specification. The techniques, however, often do not work for huge systems because it demands a huge amount of computational resources. Search-Based Software Engineering is known to effectively solve many software engineering problems including model checking. It pursues the good balance between efficiency and qualities of solutions by using swarm intelligence and metaheuristic search methodologies. This article focuses on the state-of-the-art model checking with Ant Colony Optimization. Ant Colony Optimization is a metaheuristic, population-based and stochastic optimization algorithm. We propose two exploration strategies to further improve the balance in model checking based on Ant Colony Optimization. The proposed strategies introduce different kinds of randomized selection mechanisms to diversify solutions found by many agents. The strategies help the search algorithm extend the reachable regions effectively. Through numerical experiments, we confirmed that the proposed strategies require less computation time and memory as compared to the existing model checking with Ant Colony Optimization at the cost of finding slightly less qualified solutions.

Multimedia in search-based software engineering: challenges and opportunities within a new research domain

Multimedia in search-based software engineering: challenges and opportunities within a new research domain

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.

Maintain Optimal Configurations for Large Configurable Systems Using Multi-Objective Optimization

To improve the maintenance and quality of software product lines, efficient configurations techniques have been proposed. Nevertheless, due to the complexity of derived and configured products in a product line, the configuration process of the software product line (SPL) becomes time-consuming and costly. Each product line consists of a various number of feature models that need to be tested. The different approaches have been presented by Search-based software engineering (SBSE) to resolve the software engineering issues into computational solutions using some metaheuristic approach. Hence, multiobjective evolutionary algorithms help to optimize the configuration process of SPL. In this paper, different multi-objective Evolutionary Algorithms like Non-Dominated Sorting Genetic algorithms II (NSGA-II) and NSGA-III and Indicator based Evolutionary Algorithm (IBEA) are applied to different feature models to generate optimal results for large configurable. The proposed approach is also used to generate the optimized test suites with the help of different multi-objective Evolutionary Algorithms (MOEAs).

Can We Trust Theorem Provers for Industrial AI?

There are three technologies a modern AI-aware software engineer needs to know: data mining, theorem proving, and nonlinear optimization (also called search-based SE). While much of the current industrial AI activity is focused on data mining, these other technologies are starting to achieve prominence. Optimization technology is discussed in the editorial “A Watershed Moment for Search-Based Software Engineering” (see IEEE Software, July-August 2021). Here, we offer a tutorial on theorem proving (what it is, how to use it, how it can sometimes go wrong, and how to fix that).

HABCSm: A Hamming Based t-way Strategy based on Hybrid Artificial Bee Colony for Variable Strength Test Sets Generation

Search-based software engineering that involves the deployment of meta-heuristics in applicable software processes has been gaining wide attention. Recently, researchers have been advocating the adoption of meta-heuristic algorithms for t-way testing strategies (where t points the interaction strength among parameters). Although helpful, no single meta-heuristic based t-way strategy can claim dominance over its counterparts. For this reason, the hybridization of meta-heuristic algorithms can help to ascertain the search capabilities of each by compensating for the limitations of one algorithm with the strength of others. Consequently, a new meta-heuristic based t-way strategy called Hybrid Artificial Bee Colony (HABCSm) strategy, based on merging the advantages of the Artificial Bee Colony (ABC) algorithm with the advantages of a Particle Swarm Optimization (PSO) algorithm is proposed in this paper. HABCSm is the first t-way strategy to adopt Hybrid Artificial Bee Colony (HABC) algorithm with Hamming distance as its core method for generating a final test set and the first to adopt the Hamming distance as the final selection criterion for enhancing the exploration of new solutions. The experimental results demonstrate that HABCSm provides superior competitive performance over its counterparts. Therefore, this finding contributes to the field of software testing by minimizing the number of test cases required for test execution.

Metaheuristics and Software Engineering: Past, Present, and Future

This work aims at giving an updated vision on the successful combination between Metaheuristics and Software Engineering (SE). Mostly during the 90s, varied groups of researchers dealing with search, optimization, and learning (SOL) met SE researchers, all of them looking for a quantified manner of modeling and solving problems in the software field. This paper will discuss on the construction, assessment, and exploitation tasks that help in making software programs a scientific object, subject to automatic study and control. We also want to show with several case studies how the quantification of software features and the automatic search for bugs can improve the software quality process, which eases compliance to ISO/IEEE standards. In short, we want to build intelligent automatic tools that will upgrade the quality of software products and services. Since we approach this new field as a cross-fertilization between two research domains, we then need to talk not only on metaheuristics for SE (well known by now), but also on SE for metaheuristics (not so well known nowadays). In summary, we will discuss here with three time horizons in mind: the old times [before the term search-based SE (SBSE) was used for this], the recent years on SBSE, and the many avenues for future research/development. A new body of knowledge in SOL and SE exists internationally, which is resulting in a new class of researchers able of building intelligent techniques for the benefit of software, that is, of modern societies.

Automatic generation of atomic multiplicity-preserving search operators for search-based model engineering

Recently, there has been increased interest in combining model-driven engineering and search-based software engineering. Such approaches use meta-heuristic search guided by search operators (model mutators and sometimes breeders) implemented as model transformations. The design of these operators can substantially impact the effectiveness and efficiency of the meta-heuristic search. Currently, designing search operators is left to the person specifying the optimisation problem. However, developing consistent and efficient search-operator rules requires not only domain expertise but also in-depth knowledge about optimisation, which makes the use of model-based meta-heuristic search challenging and expensive. In this paper, we propose a generalised approach to automatically generate atomic multiplicity-preserving search operators for a given optimisation problem. This reduces the effort required to specify an optimisation problem and shields optimisation users from the complexity of implementing efficient meta-heuristic search mutation operators. We evaluate our approach with a set of case studies and show that the automatically generated rules are comparable to, and in some cases better than, manually created rules at guiding evolutionary search towards near-optimal solutions.

A Watershed Moment for Search-Based Software Engineering

Software engineering is about understanding and making the right tradeoffs. Many software engineering tasks-such as test case generation, design, sprint planning, and refactoring-boil down to understanding tradeoffs including concretely expressing the attributes to optimize and elements and decisions that will maximize their intended outcomes. Consequently, many software engineering problems can be formulated as search problems. Driven by these observations, Harman and Jones in 2001 emphasized the importance of concentrated research on the application of search-based techniques in software engineering and coined the subfield of search-based software engineering (SBSE) in software engineering research.1 During the two decades that followed, SBSE has seen a significant amount of increased research where metaheuristic algorithms are used to create recommendations for software engineering tasks.