Search

Maintaining software quality is crucial in the dynamic landscape of software development. Regression testing ensures that software works as expected after changes are implemented. However, re-executing all test cases for every modification is often impractical and costly, particularly for large systems. Although very effective, traditional test suite optimization techniques are often impractical in resource-constrained scenarios, as they are computationally expensive. Hence, quantum computing solutions have been developed to improve their efficiency, but have shown drawbacks in terms of effectiveness. We propose reformulating the regression test case selection problem to use quantum computation techniques better. Our objectives are (i) to provide more efficient solutions than traditional methods and (ii) to improve the effectiveness of previously proposed quantum-based solutions. We propose SelectQA, a quantum annealing approach that can outperform the quantum-based approach BootQA in terms of effectiveness while obtaining results comparable to those of the classic Additional Greedy and DIV-GA approaches. Regarding efficiency, SelectQA outperforms DIV-GA and has similar results with the Additional Greedy algorithm, but is exceeded by BootQA. [ABSTRACT FROM AUTHOR]

Background: Search-based refactoring involves searching for a sequence of refactorings to achieve specific objectives. Although a typical objective is improving code quality, a different perspective is also required; the searched sequence must undergo review before being applied and may not be applied if the review fails or is postponed due to no proper reviewers. Aim: Therefore, it is essential to ensure that the searched sequence of refactorings can be reviewed promptly by reviewers who meet two criteria: (1) having enough expertise and (2) being free of heavy workload. The two criteria are regarded as the review availability of the refactoring sequence. Method: We propose MORCoRA, a multi-objective search-based technique that can search for code quality improvable, semantic preserved, and high review availability possessed refactoring sequences and corresponding proper reviewers. Results: We evaluate MORCoRA on six open-source repositories. The quantitative analysis reveals that MORCoRA can effectively recommend refactoring sequences that fit the requirements. The qualitative analysis demonstrates that the refactorings recommended by MORCoRA can enhance code quality and effectively address code smells. Furthermore, the recommended reviewers for those refactorings possess high expertise and are available to review. Conclusions: We recommend that refactoring recommenders consider both the impact on quality improvement and the developer resources required for review when recommending refactorings. [ABSTRACT FROM AUTHOR]

Genetic Improvement (GI) uses search-based optimisation algorithms to automatically improve software with respect to both functional and non-functional properties. Our previous work showed that Regression Test Selection (RTS) can help speed up the use of GI and enhance the overall results while not affecting the software system's validity. This article expands upon our investigation by answering further questions about safety and applying a GI algorithm based on Local Search (LS) in addition to the previously explored Genetic Programming (GP) approach. Further, we extend the number of subjects to 12 by analysing five larger real-world open-source programs. We empirically compare two state-of-the-art RTS techniques combined with GP and LS for these 12 programs. The results show that both RTS techniques are safe to use and can reduce the cost of GI by up to 80% and by 31% on average across programs. We also observe that both search-based algorithms impact the effectiveness gains of GI differently, and that various RTS strategies achieve differing gains in terms of efficiency. These results serve as further evidence that RTS must be used as a core component of the GI search process to maximise its effectiveness and efficiency. [ABSTRACT FROM AUTHOR]

Due to the rapid adoption of Deep Neural Networks (DNNs) into larger software systems, testing of DNN-based systems has received much attention recently. While many different test adequacy criteria have been suggested, we lack effective test input generation techniques. Inputs such as images of real-world objects and scenes are not only expensive to collect but also difficult to randomly sample. Consequently, current testing techniques for DNNs tend to apply small local perturbations to existing inputs to generate new inputs. We propose SINVAD (Search-based Input space Navigation using Variational AutoencoDers), a way to sample from, and navigate over, a space of realistic inputs that resembles the true distribution in the training data. Our input space is constructed using Variational Autoencoders (VAEs), and navigated through their latent vector space. Our analysis shows that the VAE-based input space is well-aligned with human perception of what constitutes realistic inputs. Further, we show that this space can be effectively searched to achieve various testing scenarios, such as boundary testing of two different DNNs or analyzing class labels that are difficult for the given DNN to distinguish. Guidelines on how to design VAE architectures are presented as well. Our results have the potential to open the field to meaningful exploration through the space of highly structured images. [ABSTRACT FROM AUTHOR]

Self-adaptation solutions need to periodically monitor, reason about, and adapt a running system. The adaptation step involves generating an adaptation strategy and applying it to the running system whenever an anomaly arises. In this article, we argue that rather than generating individual adaptation strategies, the goal should be to adapt the control logic of the running system in such a way that the system itself would learn how to steer clear of future anomalies, without triggering self-adaptation too frequently. Although the need for adaptation is never eliminated, especially noting the uncertain and evolving environment of complex systems, reducing the frequency of adaptation interventions is advantageous for various reasons, such as to increase performance and to make a running system more robust. We instantiate and empirically examine the preceding idea for software-defined networking—a key enabling technology for modern data centers and Internet of Things applications. Using genetic programming (GP), we propose a self-adaptation solution that continuously learns and updates the control constructs in the data-forwarding logic of a software-defined network. Our evaluation, performed using open source synthetic and industrial data, indicates that compared to a baseline adaptation technique that attempts to generate individual adaptations, our GP-based approach is more effective in resolving network congestion, and further, it reduces the frequency of adaptation interventions over time. In addition, we show that for networks with the same topology, reusing over larger networks the knowledge that is learned on smaller networks leads to significant improvements in the performance of our GP-based adaptation approach. Finally, we compare our approach against a standard data-forwarding algorithm from the network literature, demonstrating that our approach significantly reduces packet loss. [ABSTRACT FROM AUTHOR]

Software developers often need to combine their contributions. This operation is called merge. When the contributions happen at the same physical region in the source code, the merge is marked as conflicting and must be manually resolved by the developers. Existing studies explore why conflicts happen, their characteristics, and how they are resolved. This paper investigates a subset of merge conflicts, which may be resolved using a combination of existing lines. We analyze 10,177 conflict chunks of popular projects that were resolved by combining existing lines, aiming at characterizing and finding patterns frequently addressed by developers to resolve them. We found that these conflicting chunks and their resolutions are usually small (they have a median of 6 LOC and 3 LOC, respectively). Moreover, 98.6% of the analyzed resolutions preserve the order of the lines in the conflicting chunks. We also found that 72.7% of the chunk resolutions do not interleave lines from different contributions more than once. Finally, developers prefer to resolve conflicts containing only Import statements using lines from the local version of the conflict. When used as heuristics for automatic merge resolution, these findings could reduce the search space by 94.7%, paving the road for future search-based software engineering tools for this problem. [ABSTRACT FROM AUTHOR]

Self-adaptive systems are capable of reconfiguring themselves while in use to reduce the risks forced by environments for which they may not have been specifically designed. Runtime validation techniques are required because complex self-adaptive systems must consistently offer acceptable behavior for important services. The runtime testing can offer further confidence that a self-adaptive system will continue to act as intended even when operating in unknowable circumstances. This article introduces an evolutionary framework that supports adaptive testing for self-adaptive systems. The objective is to ensure that the adaptive systems continue to operate following its requirements and that both test plans and test cases continuously stay relevant to shifting operational conditions. The proposed approach using the Strength Pareto Evolutionary Algorithm 2 (SPEA2) algorithm facilitates both the execution and adaptation of runtime testing operations. [ABSTRACT FROM AUTHOR]

Recently, spectrum-based fault localization approaches have been widely used for its fast and perform well for programs with only one fault.However, most of the existing methods do not consider the fact that the programs tend to have multiple faults. To address the above issue, we propose a Particle Swarm Optimization with genetic operation based Multiple-Fault Localization (PSOMFL). Our method models the software multiple-fault localization process as a search process for the particle swarm algorithm, which can quickly find the optimal solution in the multi-dimensional hyper-volume, and finally analyzes the optimal solution set to obtain the locations of multiple faults. We have implemented a prototype and conducted several experiments to compare PSOMFL against the existing fault localization approaches. The experimental results show that PSOMFL outperforms the compared methods and can reduce the costs by 5%-25% on average.

Optimization problems in software engineering typically deal with structures as they occur in the design and maintenance of software systems. In model-driven optimization (MDO), domain-specific models are used to represent these structures while evolutionary algorithms are often used to solve optimization problems. However, designing appropriate models and evolutionary algorithms to represent and evolve structures is not always straightforward. Domain experts often need deep knowledge of how to configure an evolutionary algorithm. This makes the use of model-driven meta-heuristic search difficult and expensive. We present a graph-based framework for MDO that identifies and clarifies core concepts and relies on mutation operators to specify evolutionary change. This framework is intended to help domain experts develop and study evolutionary algorithms based on domain-specific models and operators. In addition, it can help in clarifying the critical factors for conducting reproducible experiments in MDO. Based on the framework, we are able to take a first step toward identifying and studying important properties of evolutionary operators in the context of MDO. As a showcase, we investigate the impact of soundness and completeness at the level of mutation operator sets on the effectiveness and efficiency of evolutionary algorithms. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Abstract The optimal requirements selection set aims primarily at careful search for the best requirements set of the next release of software during development process. This procedure is widely defined as the next release problem (NRP), which is also classified as NP‐hard dilemma. Several techniques, in literature, have been proposed to tackle NRP. However, in real examples, the earlier studies still immature as NRP still suffers interactions and restrictions that makes the problem more complicated. Although few interesting works have been presented, yet NRP, based on our study, could be further investigated and effectively tackled. In this research, therefore, NRP is devised as a multi‐objective optimisation problem. Two clashing objectives (satisfaction and cost) and two constraints (interactions forms) are formulated. To tackle NRP effectively, a new hybrid genetic and artificial bee colony algorithm (HGABC) is introduced. HGABC combines features of genetic and artificial bee colony algorithms. Experimental study, using case studies and three criteria, have been conducted to show HGABC's power of generating non‐dominated effective Pareto solutions versus the state‐of‐the‐art algorithms. Results indicate that HGABC does not just outperform its rivals, yet also gives better Pareto solutions in terms of diversity and quality for almost all the instances of this problem.

The cost of software maintenance increases as the continuous iterative development of software.To reduce this cost,automated software refactoring is proven to be an effective solution.One of the most typical automated software refactoring approaches is the search-based refactoring.This approach refactors software according to some predefined objectives.Existing stu-dies show that the selection of objectives plays a decisive role in the search process.Although many quality objectives and non-quality objectives are proposed,there is no research to analyze that in the same evaluation framework which objectives can guide the software refactoring to achieve results that meet developers’ expectations.Meanwhile,whether the combination of quality objectives and non-quality objectives will have better results is not analyzed.To answer these questions,this paper designs a search-based multi-objective software refactoring evaluation framework.Under the framework,this paper investigates the impact of the combination of seven different objectives on software refactoring with six open-source software projects in different scales;the software quality before and after refactoring is evaluated using a variety of indicators,and the effectiveness of different objective combinations is also analyzed.Experimental results show that the combination of quality objectives and non-quality objectives can better improve the effectiveness of software refactoring than using one single type of objectives,and the combination of the ‘qua-lity’ objective and the ‘similarity with recorded code changes’ objective is important to the improvement of software refactoring effectiveness.

Debugging programs involves a considerable amount of time and resources spent on identifying the source of errors. Spectrum-based fault localization techniques are becoming increasingly popular due to their quick and effective performance when dealing with programs that have a single fault. However, these methods do not take into account the reality that most programs tend to have multiple faults. To address the above challenges, we propose an automatic approach using ant colony algorithm via genetic operation for multiple fault localization (ACOMFL). Our approach first constructs the search graph by the coverage information. Secondly, it designs the fitness function to select the best paths and dynamically adjusts the pheromone updating. Finally, it computes the suspiciousness ranking of each statement by the ant path information in the optimal path set. Four open-source benchmarks are utilized to validate the performance of the ACOMFL approach. The experimental results show ACOMFL achieves better results for multi-fault programs in comparison with six spectrum-based fault localization approaches and a genetic algorithm-based multiple fault localization approach. The ACOMFL is effective at locating multi-fault, serving as a helpful method for locating faults.

Recently, SaaS applications are developed as a composition of microservices that serve diverse tenants having similar but different requirements, and hence, can be developed as variability-intensive microservices. Manual identification of these microservices is difficult, time-consuming, and costly, since, they have to satisfy a set of quality metrics for several SaaS architecture configurations at the same time. In this paper, we tackle the multi-objective optimization problem of identifying variable microservices aiming optimal granularity (new metric proposed), commonality, and data convergence, with a search-based approach employing the MOEA/D algorithm. We empirically and experimentally evaluated the proposed method following the Goal-Question-Metric approach. The results show that the method is promising in identifying fully consistent, highly reusable, variable microservices with an acceptable multi-tenancy degree. Moreover, the identified microservices, although not structurally very similar to those identified by the expert architects, provide design quality measures (granularity, etc.) close to (and even better than) the experts. [ABSTRACT FROM AUTHOR]

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 single-objective methods for software defect prediction. [ABSTRACT FROM AUTHOR]

Configurable software systems can be tuned for better performance. Leveraging on some Pareto optimizers, recent work has shifted from tuning for a single, time-related performance objective to two intrinsically different objectives that assess distinct performance aspects of the system, each with varying aspirations to be satisfied, e.g., “the latency is less than 10s” while “the memory usage is no more than 1GB”. Before we design better optimizers, a crucial engineering decision to make therein is how to handle the performance requirements with clear aspirations in the tuning process. For this, the community takes two alternative optimization models: either quantifying and incorporating the aspirations into the search objectives that guide the tuning, or not considering the aspirations during the search but purely using them in the later decision-making process only. However, despite being a crucial decision that determines how an optimizer can be designed and tailored, there is a rather limited understanding of which optimization model should be chosen under what particular circumstance, and why. In this article, we seek to close this gap. Firstly, we do that through a review of over 426 articles in the literature and 14 real-world requirements datasets, from which we summarize four performance requirement patterns that quantify the aspirations in the configuration tuning. Drawing on these, we then conduct a comprehensive empirical study that covers 15 combinations of the state-of-the-art performance requirement patterns, four types of aspiration space, three Pareto optimizers, and eight real-world systems/environments, leading to 1,296 cases of investigation. Our findings reveal that (1) the realism of aspirations is the key factor that determines whether they should be used to guide the tuning; (2) the given patterns and the position of the realistic aspirations in the objective landscape are less important for the choice, but they do matter to the extents of improvement; (3) the available tuning budget can also influence the choice for unrealistic aspirations but it is insignificant under realistic ones. [ABSTRACT FROM AUTHOR]

In industry, software projects might span over decades, with many engineers joining or leaving the company over time. In these circumstances, no single engineer has all of the knowledge when maintenance tasks such as Traceability Link Recovery (TLR), Bug Localization (BL), and Feature Location (FL) are performed. Thus, collaboration has the potential to boost the quality of maintenance tasks since the solution advanced by one engineer might be enhanced with contributions from other engineers. However, assembling a team of software engineers to collaborate may not be as intuitive as we might think. In the context of a worldwide industrial supplier of railway solutions, this work evaluates how the quality of TLR, BL, and FL is affected by the criteria for selecting engineers for collaboration. The criteria for collaboration are based on engineers’ profile information to select the set of search queries that are involved in the maintenance task. Collaboration is achieved by applying automatic query reformulation, and the location relies on an evolutionary algorithm. Our work uncovers how software engineers who might be seen as not being relevant in the collaboration can lead to significantly better results. A focus group confirmed the relevance of the findings. [ABSTRACT FROM AUTHOR]

Recently, spectrum-based fault localization approaches have been widely used for its fast and perform well for programs with only one fault.However, most of the existing methods do not consider the fact that the programs tend to have multiple faults. To address the above issue, we propose a Particle Swarm Optimization with genetic operation based Multiple-Fault Localization (PSOMFL). Our method models the software multiple-fault localization process as a search process for the particle swarm algorithm, which can quickly find the optimal solution in the multi-dimensional hyper-volume, and finally analyzes the optimal solution set to obtain the locations of multiple faults. We have implemented a prototype and conducted several experiments to compare PSOMFL against the existing fault localization approaches. The experimental results show that PSOMFL outperforms the compared methods and can reduce the costs by 5%-25% on average. [ABSTRACT FROM AUTHOR]

IntroductionWhen solving multi-objective combinatorial optimization problems using a search algorithm without a priori information, the result is a Pareto front. Selecting a solution from it is a laborious task if the number of solutions to be analyzed is large. This task would benefit from a systematic approach that facilitates the analysis, comparison and selection of a solution or a group of solutions based on the preferences of the decision makers. In the last decade, the research and development of algorithms for solving multi-objective combinatorial optimization problems has been growing steadily. In contrast, efforts in the a posteriori exploration of non-dominated solutions are still scarce.MethodsThis paper proposes an abstract framework based on hierarchical clustering in order to facilitate decision makers to explore such a Pareto front in search of a solution or a group of solutions according to their preferences. An extension of that abstract framework aimed at addressing the bi-objective Next Release Problem is presented, together with a Dashboard that implements that extension. Based on this implementation, two studies are conducted. The first is a usability study performed with a small group of experts. The second is a performance analysis based on computation time consumed by the clustering algorithm.ResultsThe results of the initial empirical usability study are promising and indicate directions for future improvements. The experts were able to correctly use the dashboard and properly interpret the visualizations in a very short time. In the same direction, the results of the performance comparison highlight the advantage of the hierarchical clustering-based approach in terms of response time.DiscussionBased on these excellent results, the extension of the framework to new problems is planned, as well as the implementation of new validity tests with expert decision makers using real-world data.

Estimating worst-case execution time (WCET) is an important activity at early design stages of real-time systems. Based on WCET estimates, engineers make design and implementation decisions to ensure that task executions always complete before their specified deadlines. However, in practice, engineers often cannot provide precise point WCET estimates and prefer to provide plausible WCET ranges. Given a set of real-time tasks with such ranges, we provide an automated technique to determine for what WCET values the system is likely to meet its deadlines and, hence, operate safely with a probabilistic guarantee. Our approach combines a search algorithm for generating worst-case scheduling scenarios with polynomial logistic regression for inferring probabilistic safe WCET ranges. We evaluated our approach by applying it to three industrial systems from different domains and several synthetic systems. Our approach efficiently and accurately estimates probabilistic safe WCET ranges within which deadlines are likely to be satisfied with a high degree of confidence. [ABSTRACT FROM AUTHOR]

Software developers want to meet the requirements of customers in next versions. Choosing which set of requirements can be done according to cost and time is an NP-hard problem known as Next Release Problem (NRP). In this article, a multi objective evolutionary algorithm (MOEA) framework is proposed to solve NRP. The framework applies the non-repetitive population, integrates solutions and external repository. Furthermore, a novel approach is implemented to satisfy the constraints of the problem. In this framework, six evolutionary algorithms are implemented and using seven quality indicators, the achieved results of that algorithms are compared with the original versions of same algorithms. Through using HV (the ratio of the region covered by Pareto Front) and NDS (the number of solutions in the Pareto Front) metrics, the effects of the proposed algorithms are compared with other works' results. The efficacy of the proposed MOEA framework is measured using three real world datasets. The gained results represent that the implemented algorithms perform better than other related algorithms previously published. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

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.

The challenge of automatically repairing bugs in programs to reduce debugging expenses and increase program quality is known as automated program repair. To overcome this issue, test-suite-based repair techniques use a specified test suite as an oracle and alter the input faulty program to pass the full test suite. GenProg is a well-known example of this kind of repair, in which genetic programming is used to reorder the statements already present in the faulty program. However, recent practical experiments suggest that GenProg’s performance, notably for Java, is not sufficient. Improved program dependability necessitates the use of automatic program repair techniques. Template-based program repair techniques have recently been combined with search-based techniques to solve program issues automatically. Although intriguing, it has two fundamental drawbacks: Its search space often lacks the correct solution, and the technique disregards program expertise, such as precise code language. Compared with the template-based program repair approach, existing neural-machine-translation-based approaches are not limited by these constraints due to their ability to learn and generate new solutions. We propose an approach that combines a search-based automatic program repair technique with a neural-machine-translation-based approach. More specifically, we use both redundancy assumption and sequence-to-sequence learning of correct patches as the source for potential fix statements that feed into a multiobjective evolutionary search algorithm to find test-suite-adequate patches. In this work, a novel framework called ARJANMT is introduced for automatically repairing Java programs. Two sets of controlled experiments are conducted on 410 bugs from two benchmarks to investigate the repairability and correctness of our proposed framework. A comparison between state-of-the-art automatic program repair frameworks is made. The experimental results indicate that combining those two types of repair techniques (search-based and neural-machine-translation-based) produces better results or fixes bugs that they previously were unable to fix individually.

Forming effective teams is an essential but challenging task, especially for organizations that carry out multiple projects simultaneously, a problem known as the Multiple Team Formation (MTF) problem. The literature presents several solutions for the MTF problem, mostly modeling it as a search problem. However, the existing solutions are not suitable for Scrum projects. We addressed this gap by developing an approach composed of two main steps. First, we designed a Structured Task Model to support creating developers’ profiles given their performance on past Scrum projects. Then, given a set of target projects’ technology requirements and the available developers’ profiles, we developed a Genetic Algorithm to form the teams for a set of target projects. We evaluated the proposed approach by comparing the teams formed by our approach with the ones formed by project managers from one organization. Our approach achieved 85% of precision when compared with the teams provided by the project managers who worked on the same target projects. We also recorded an acceptance rate of up to 75%. The significant value of precision achieved suggests that our approach can provide teams close to the project managers’ expectations. In addition, our Structured Task Model offers a promising way to build technical profiles semi-automatically for Scrum developers. In future work, we intend to investigate how to complement the developers’ profiles by using other types of attributes and knowledge sources.

Self-adaptive systems are capable of reconfiguring themselves while in use to reduce the risks forced by environments for which they may not have been specifically designed. Runtime validation techniques are required because complex self-adaptive systems must consistently offer acceptable behavior for important services. The runtime testing can offer further confidence that a self-adaptive system will continue to act as intended even when operating in unknowable circumstances. This article introduces an evolutionary framework that supports adaptive testing for self-adaptive systems. The objective is to ensure that the adaptive systems continue to operate following its requirements and that both test plans and test cases continuously stay relevant to shifting operational conditions. The proposed approach using the Strength Pareto Evolutionary Algorithm 2 (SPEA2) algorithm facilitates both the execution and adaptation of runtime testing operations.

The optimal requirements selection set aims primarily at careful search for the best requirements set of the next release of software during development process. This procedure is widely defined as the next release problem (NRP), which is also classified as NP‐hard dilemma. Several techniques, in literature, have been proposed to tackle NRP. However, in real examples, the earlier studies still immature as NRP still suffers interactions and restrictions that makes the problem more complicated. Although few interesting works have been presented, yet NRP, based on our study, could be further investigated and effectively tackled. In this research, therefore, NRP is devised as a multi‐objective optimisation problem. Two clashing objectives (satisfaction and cost) and two constraints (interactions forms) are formulated. To tackle NRP effectively, a new hybrid genetic and artificial bee colony algorithm (HGABC) is introduced. HGABC combines features of genetic and artificial bee colony algorithms. Experimental study, using case studies and three criteria, have been conducted to show HGABC's power of generating non‐dominated effective Pareto solutions versus the state‐of‐the‐art algorithms. Results indicate that HGABC does not just outperform its rivals, yet also gives better Pareto solutions in terms of diversity and quality for almost all the instances of this problem. [ABSTRACT FROM AUTHOR]

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 timeconsuming 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). [ABSTRACT FROM AUTHOR]

Metamodels evolve even more frequently than programming languages. This evolution process may result in a large number of instance models that are no longer conforming to the revised metamodel. On the one hand, the manual adaptation of models after the metamodels' evolution can be tedious, error-prone, and time-consuming. On the other hand, the automated co-evolution of metamodels/models is challenging, especially when new semantics is introduced to the metamodels. While some interactive techniques have been proposed, designers still need to explore a large number of possible revised models, which makes the interaction time-consuming. Existing interactive tools are limited to interactions with the designers to evaluate the impact of the co-evolved models on different objectives of the number of inconsistencies, number of changes and the deviation from the initial models. However, designers are also interested to check the impact of introduced changes on the decision space which is composed by model elements. These interactions help designers to understand the differences of the co-evolved models solution that have similar objectives value to select the best one based on their preferences. In this paper, we propose an interactive approach that enables designers to select their preference simultaneously in the objective and decision spaces. Designers may be interested in looking at co-evolution operations that can improve a specific objective such as number of non-conformities with the revised metamodel (objective space), but such operations may be related to different model locations (decision space). A set of co-evolution solutions is generated at first using multi-objective search that suggests edit operations to designers based on three objectives: minimizing the deviation with the initial model, the number of non-conformities with the revised metamodel and the number of changes. Then, the approach proposes to the user few regions of interest by clustering the set of recommended co-evolution solutions of the multi-objective search. Also, another clustering algorithm is applied within each cluster of the objective space to identify solutions related to different model element locations. The objective and decision spaces can now be explored more efficiently by the designers, who can quickly select their preferred cluster and give feedback on a smaller number of solutions by eliminating similar ones. This feedback is then used to guide the search for the next iterations if the user is still not satisfied. We evaluated our approach on a set of metamodel/model co-evolution case studies and compared it to existing fully automated and interactive co-evolution techniques. [ABSTRACT FROM AUTHOR]

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.