Search

This book constitutes the proceedings of the 13th International Symposium on Search-Based Software Engineering, SSBSE 2021, which was held in Bari, Italy, during October 11-12, 2021. The 9 full and 2 short papers included in this volume were carefully reviewed and selected from 19 submissions. The papers deal with novel ideas and applications of search-based software engineering, focusing on engineering challenges and the application of automated approaches and optimization techniques from AI and machine learning research.

Search-Based Software Engineering (SBSE) researchers who apply multi-objective search algorithms (MOSAs) often assess the quality of solutions produced by MOSAs with one or more quality indicators (QIs). However, SBSE lacks evidence providing insights on commonly used QIs, especially about agreements among them and their relations with SBSE problems and applied MOSAs. Such evidence about QIs agreements is essential to understand relationships among QIs, identify redundant QIs, and consequently devise guidelines for SBSE researchers to select appropriate QIs for their specific contexts. To this end, we conducted an extensive empirical evaluation to provide insights on commonly used QIs in the context of SBSE, by studying agreements among QIs with and without considering differences of SBSE problems and MOSAs. In addition, by defining a systematic process based on three common ways of comparing MOSAs in SBSE, we present additional observations that were automatically produced based on the results of our empirical evaluation. These observations can be used by SBSE researchers to gain a better understanding of the commonly used QIs in SBSE, in particular, regarding their agreements. Finally, based on the results, we also provide a set of guidelines for SBSE researchers to select appropriate QIs for their particular context.

The ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) was held in Tallinn2 -- Estonia, from the 28th to the 30th of August 2019. Additionally, the 11th Symposium on Search-Based Software Engineering (SSBSE) 3was co-located with ESEC/FSE on the 31st of August and 1st of September. Search-based software engineering (SBSE) [1] investigates the usage of search based algorithms to solve hard software engineering problems. Among the applied techniques, evolutionary algorithms are the most commonly used. SBSE has matured along the years, and this can be seen in the visibility it has reached in top-tier software engineering venues such as ESEC/FSE, and of course, in top-tier evolutionary computation venues such as GECCO (which has a special SBSE track!). This year ESEC/FSE held an entire session for SBSE papers, while also being rich in artificial intelligence papers across all other sessions.

Software is vital to modern life, yet much of it is old and suffers from bit-rot. There are not and never will be enough software experts to keep it all up to date by hand. Instead we suggest combining data driven learning with evolutionary search to maintain computer systems. @RE: N. Alshahwan. Industrial experience of genetic improvement in Facebook. In J. Petke, S. H. Tan, W. B. Langdon, and W. Weimer, editors, GI-2019, ICSE workshops proceedings, page 1, Montreal, 28 May 2019. IEEE. Invited Keynote. W. Banzhaf, P. Nordin, R. E. Keller, and F. D. Francone. Genetic Programming - An Introduction; On the Automatic Evolution of Computer Programs and its Applications. Morgan Kaufmann, San Francisco, CA, USA, Jan. 1998. N. Hansen and A. Ostermeier. Completely derandomized self-adaptation in evolution strategies. Evolutionary Computation, 9(2):159--195, Summer 2001. S. Haraldsson, A. Brownlee, and J. R. Woodward. Computers will soon be able to fix themselves - are IT departments for the chop? The Conversation, page 3.29pm BST, Oct. 12 2017. S. O. Haraldsson, J. R. Woodward, A. E. I. Brownlee, and K. Siggeirsdottir. Fixing bugs in your sleep: How genetic improvement became an overnight success. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1513--1520, Berlin, 15--19 July 2017. ACM. Best paper. M. Harman and B. F. Jones. Search based software engineering. Information and Software Technology, 43(14):833--839, Dec. 2001. F. Hutter, H. H. Hoos, K. Leyton-Brown, and T. Stuetzle. ParamILS: An automatic algorithm configuration framework. JAIR, 36:267--306, 2009. G. Kendall. Evolutionary computation has been promising self-programming machines for 60 years - so where are they? The Conversation, page 8.54am BST, Mar. 27 2018. J. R. Koza. Genetic Programming: On the Programming of Computers by Natural Selection. MIT press, 1992. W. B. Langdon. Genetic improvement of programs. In R. Matousek, editor, 18th International Con- ference on Soft Computing, MENDEL 2012, Brno, Czech Republic, 27--29 June 2012. Brno University of Technology. Invited keynote. W. B. Langdon and M. Harman. Optimising existing software with genetic programming. IEEE Transactions on Evolutionary Computation, 19(1):118--135, Feb. 2015. W. B. Langdon, B. Y. H. Lam, J. Petke, and M. Harman. Improving CUDA DNA analysis soft- ware with genetic programming. In S. Silva, A. I. Esparcia-Alcazar, M. Lopez-Ibanez, S. Mostaghim, J. Timmis, C. Zarges, L. Correia, T. Soule, M. Giacobini, R. Urbanowicz, Y. Akimoto, T. Glasmach- ers, F. Fernandez de Vega, A. Hoover, P. Larranaga, M. Soto, C. Cotta, F. B. Pereira, J. Handl, J. Koutnik, A. Gaspar-Cunha, H. Trautmann, J.-B. Mouret, S. Risi, E. Costa, O. Schuetze, K. Kraw- iec, A. Moraglio, J. F. Miller, P. Widera, S. Cagnoni, J. Merelo, E. Hart, L. Trujillo, M. Kessentini, G. Ochoa, F. Chicano, and C. Doerr, editors, GECCO '15: Proceedings of the 2015 Annual Conference on Genetic and Evolutionary Computation, pages 1063--1070, Madrid, 11--15 July 2015. ACM. W. B. Langdon and R. Lorenz. Improving SSE parallel code with grow and graft genetic programming. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1537--1538, Berlin, 15--19 July 2017. ACM. W. B. Langdon and J. Petke. Evolving better software parameters. In T. E. Colanzi and P. McMinn, editors, SSBSE 2018 Hot off the Press Track, volume 11036 of LNCS, pages 363--369, Montpellier, France, 8--9 Sept. 2018. Springer. W. B. Langdon, J. Petke, and R. Lorenz. Evolving better RNAfold structure prediction. In M. Castelli, L. Sekanina, and M. Zhang, editors, EuroGP 2018: Proceedings of the 21st European Conference on Genetic Programming, volume 10781 of LNCS, pages 220--236, Parma, Italy, 4--6 Apr. 2018. Springer Verlag. C. Le Goues, M. Pradel, and A. Roychoudhury. Automated program repair. Communications of the ACM. To appear. M. Orlov. Evolving software building blocks with FINCH. In J. Petke, D. R. White, W. B. Langdon, and W. Weimer, editors, GI-2017, pages 1539--1540, Berlin, 15--19 July 2017. ACM. L. Perez Caceres, M. Lopez-Ibanez, H. Hoos, and T. Stuetzle. An experimental study of adaptive capping in irace. In R. Battiti, D. E. Kvasov, and Y. D. Sergeyev, editors, Learning and Intelligent Optimization - 11th International Conference, LION 11, Nizhny Novgorod, Russia, June 19--21, 2017, Revised Selected Papers, volume 10556 of Lecture Notes in Computer Science, pages 235--250. Springer, 2017. J. Petke. Constraints: The future of combinatorial interaction testing. In 2015 IEEE/ACM 8th International Workshop on Search-Based Software Testing, pages 17--18, Florence, May 2015. J. Petke, S. O. Haraldsson, M. Harman, W. B. Langdon, D. R. White, and J. R. Woodward. Genetic improvement of software: a comprehensive survey. IEEE Transactions on Evolutionary Computation, 22(3):415--432, June 2018. J. Petke, M. Harman, W. B. Langdon, and W. Weimer. Specialising software for different downstream applications using genetic improvement and code transplantation. IEEE Transactions on Software Engineering, 44(6):574--594, June 2018. R. Poli, W. B. Langdon, and N. F. McPhee. A field guide to genetic programming. Published via http://lulu.com and freely available at http://www.gp-field-guide.org.uk, 2008. (With contri- butions by J. R. Koza). E. Schulte, S. Forrest, and W. Weimer. Automated program repair through the evolution of assembly code. In Proceedings of the IEEE/ACM International Conference on Automated Software Engineering, pages 313--316, Antwerp, 20--24 Sept. 2010. ACM. E. Schulte, W. Weimer, and S. Forrest. Repairing COTS router firmware without access to source code or test suites: A case study in evolutionary software repair. In W. B. Langdon, J. Petke, and D. R. White, editors, Genetic Improvement 2015 Workshop, pages 847--854, Madrid, 11--15 July 2015. ACM. Best Paper. J. R. Woodward, J. Petke, and W. Langdon. How computers are learning to make human software work more efficiently. The Conversation, page 10.08am BST, June 25 2015. K. Yeboah-Antwi and B. Baudry. Online genetic improvement on the java virtual machine with ECSELR. Genetic Programming and Evolvable Machines, 18(1):83--109, Mar. 2017.

This paper discusses the development of a Symbiotic Organisms Search Algorithm (SOS) variant, called Adaptive Fuzzy SOS (FSOS). Like SOS, FSOS exploits three types of symbiosis operators namely mutualism, commensalism, and parasitism in order to undertake the search process. Unlike SOS, FSOS is able to adaptively select a single or any combination of mutualism, commensalism, and parasitism update operator(s) as the search progresses based on the current search status controlled by their individual probabilities via the fuzzy decision-making. To validate its performance, we have evaluated FSOS to solve 23 benchmark functions and take a $t$ -way test generation as our case study. Experimental results demonstrate that FSOS exhibits competitive performance against its predecessor (SOS) and other competing metaheuristic algorithms.

Reducing the energy consumption of software systems through optimisation techniques such as genetic improvement is gaining interest. However, efficient and effective improvement of software systems requires a better understanding of the code-change search space. One important choice practitioners have is whether to preserve the system's original output or permit approximation, with each scenario having its own search space characteristics. When output preservation is a hard constraint, we report that the maximum energy reduction achievable by the modification operators is 2.69 percent (0.76 percent on average). By contrast, this figure increases dramatically to 95.60 percent (33.90 percent on average) when approximation is permitted, indicating the critical importance of approximate output quality assessment for code optimisation. We investigate synergy, a phenomenon that occurs when simultaneously applied source code modifications produce an effect greater than their individual sum. Our results reveal that 12.0 percent of all joint code modifications produced such a synergistic effect, though 38.5 percent produce an antagonistic interaction in which simultaneously applied modifications are less effective than when applied individually. This highlights the need for more advanced search-based techniques.

Context Search-Based Software Engineering, in particular multi-objective evolutionary algorithm, is a promising approach to engineering software service composition while simultaneously optimizing multiple conflicting Quality-of-Service (QoS) objectives. Yet, existing applications of evolutionary algorithms have failed to consider domain knowledge about the problem into the optimization, which is a perhaps obvious but challenging task. Objective This paper aims to investigate different strategies of exploring and injecting knowledge about the problem into the Multi-Objective Evolutionary Algorithm (MOEA) by seeding. Further, we investigate various factors that contribute to the effectiveness of seeding, including the number of seeds, the importance of crossover operation and the similarity of historical problems. Method We conduced empirical evaluations with NSGA-II, MOEA/D and IBEA based on a wide spectrum of problem instances, including 10 different workflow structures, from 5 to 100 abstract services and 510 to 5.529 × 10203 candidate concrete services with diverse QoS on latency, throughput and cost, which was chosen from the real-world WS-DREAM dataset that contains 4500 QoS values. Results We found that, (i) all seeding strategies generally outperform their non-seeded counterparts under the same search budget with large statistical significance. Yet, they may involve relatively smaller compromise on one or two of the quality aspects among convergence, uniformity and spread. (ii) The implication of the number of seeds on the service composition problems is minimal in general (except for IBEA). (iii) In contrast to the non-seeded counterparts, the seeding strategies suffer much less implications by the crossover operation. (iv) The differences of historical problems, which are important for two proposed seeding strategies, can indeed affect the results in a non-linear manner; however, the results are still greatly better than the non-seeded counterparts even with up to 90% difference of the problem settings. Conclusion The paper concludes that (i) When applying the seeding strategies, the number of seeds to be placed in is less important in general, except for the pre-optimization based strategies under IBEA. (ii) Eliminating or having less crossover is harmful for multi-objective service composition optimization, but the seeding strategies are much less sensitive to this operator than their non-seeded counterparts. (iii) For the history based seeding strategies, the seeds do not have to come from the most similar historical composition problem to achieve the best HV value, but a largely different historical problem should usually be avoided, unless they are the only available seeds.

An effective method for addressing the configuration optimization problem (COP) in Software Product Lines (SPLs) is to deploy a multi-objective evolutionary algorithm, for example, the state-of-the-art SATIBEA. In this paper, an improved hybrid algorithm, called SATIBEA-LSSF, is proposed to further improve the algorithm performance of SATIBEA, which is composed of a multi-children generating strategy, an enhanced mutation strategy with local searching and an elite inheritance mechanism. Empirical results on the same case studies demonstrate that our algorithm significantly outperforms the state-of-the-art for four out of five SPLs on a quality Hypervolume indicator and the convergence speed. To verify the effectiveness and robustness of our algorithm, the parameter sensitivity analysis is discussed and three observations are reported in detail.

This work provides a systematic literature review of the software project scheduling problem, in the context of search-based software engineering, and summarizes the main models, techniques, search algorithms and evaluation criteria applied to solve this problem. We also discuss trends and research opportunities. Our keyword search found 438 papers, published in the last 20 years. After considering the inclusion and exclusion criteria and performing the snowballing procedure, we have analyzed 37 primary studies. The results show the predominance of the use of evolutionary algorithms. The static model, in which the scheduling is performed once during the project, is considered in the majority of the papers. Synthetic instances are commonly used to validate the heuristic and hypervolume and execution time are the mostly applied evaluating criteria.

Search-Based Software Engineering (SBSE) has been successfully applied to automate a wide range of software development activities. Nevertheless, in those software engineering problems where human evaluation and preference are crucial, such insights have proved difficult to characterize in search, and solutions might not look natural when that is the expectation. In an attempt to address this, an increasing number of researchers have reported the incorporation of the ’human-in-the-loop’ during search and interactive SBSE has attracted significant attention recently. However, reported results are fragmented over different development phases, and a great variety of novel interactive approaches and algorithmic techniques have emerged. To better integrate these results, we have performed a systematic literature review of interactive SBSE. From a total of 669 papers, 26 primary studies were identified. To enable their analysis, we formulated a classification scheme focused on four crucial aspects of interactive search, i.e., the problem formulation, search technique, interactive approach, and the empirical framework. Our intention is that the classification scheme affords a methodological approach for interactive SBSE. Lastly, as well as providing a detailed cross analysis, we identify and discuss some open issues and potential future trends for the research community.

Exploring iterative and incremental approaches, current software projects define various delivery releases, which ought to be developed within budgetary constraints, but raising customers’ satisfaction as much as possible. In search based software engineering, such a problem is referred to as next release problem (NRP), in which the selection of software requirements for the next release is reformulated as an optimization problem. More recently, NRP proposals have evolved to a multi-objective perspective, providing non-dominated recommendations that balance the trade-off surface with respect to customers’ satisfaction and development cost. Despite key advancements in NRP proposals, most of them do not deal with software risks, which represent a vital aspect that can deeply impact on project cost and customers’ satisfaction. In such a direction, using multi-objective evolutionary algorithms (MOEAs), this paper proposes and evaluates a risk-driven systematic approach for the NRP problem, in which a risk analysis is incorporated for estimating the impact of software risks in development cost and customers’ satisfaction. By contrasting three different well-known MOEAs, empirical results based on two semi-real datasets reveal the potential efficiency and practical applicability, bringing not only more realistic, precise and meaningful estimations, but also finding a significant percentage of unanticipated solutions.

Search-based software testing (SBST) has been shown to be an effective technique to generate test cases automatically. Its effectiveness strongly depends on the guidance of the fitness function. Unfortunately, a common issue in SBST is the so-called flag problem , where the fitness landscape presents a plateau that provides no guidance to the search. In this article, we provide a series of novel testability transformations aimed at providing guidance in the context of commonly used API calls (e.g., strings that need to be converted into valid date/time objects). We also provide specific transformations aimed at helping the testing of REST Web Services. We implemented our novel techniques as an extension to EvoMaster , an SBST tool that generates system-level test cases. Experiments on nine open-source REST web services, as well as an industrial web service, show that our novel techniques improve performance significantly.

Search-Based Software Engineering (SBSE) approaches adopt search-based techniques to solve Software Engineering (SE) optimization problems. Among these techniques, evolutionary algorithms are the most popular and successfully used, such as multi-objective evolutionary algorithms. However, some challenges still need to be addressed. Firstly, SE problems are complex and commonly impacted by many conflicting factors. In this context, the use of many-objective algorithms is necessary. Secondly, the users very often do not recognise the found solutions as feasible because these solutions are usually not generated considering the users’ needs and preferences. Thus, to deal properly with this situation, preference-based algorithms should be applied. Moreover, there are some practical issues regarding the choice of operators, evaluation of algorithms and visualization of solutions. Existing frameworks do not provide support to address these challenges. To overcome these limitations, we present Nautilus, an open-source Java web-platform tool that works with plugins to ease the addition of new problem instances, implementation of search operators and different multi and many-objective optimization algorithms, guided (or not) by human participation. This paper describes Nautilus-NRP, an extension implemented to address the Next Release Problem (NRP). NRP refers to the selection of requirements to be implemented in the next release of a software and is used to illustrate Nautilus’ main functionalities and how it can be extended to solve a SE problem. Link for the video: https://youtu.be/2dbwslTrvhg.

Automatically tuning software configuration for optimizing a single performance attribute (e.g., minimizing latency) is not trivial, due to the nature of the configuration systems (e.g., complex landscape and expensive measurement). To deal with the problem, existing work has been focusing on developing various effective optimizers. However, a prominent issue that all these optimizers need to take care of is how to avoid the search being trapped in local optima — a hard nut to crack for software configuration tuning due to its rugged and sparse landscape, and neighboring configurations tending to behave very differently. Overcoming such in an expensive measurement setting is even more challenging. In this paper, we take a different perspective to tackle this issue. Instead of focusing on improving the optimizer, we work on the level of optimization model. We do this by proposing a meta multi-objectivization model (MMO) that considers an auxiliary performance objective (e.g., throughput in addition to latency). What makes this model unique is that we do not optimize the auxiliary performance objective, but rather use it to make similarly-performing while different configurations less comparable (i.e. Pareto nondominated to each other), thus preventing the search from being trapped in local optima. Experiments on eight real-world software systems/environments with diverse performance attributes reveal that our MMO model is statistically more effective than state-of-the-art single-objective counterparts in overcoming local optima (up to 42% gain), while using as low as 24% of their measurements to achieve the same (or better) performance result.

Continuous Integration (CI) aims at supporting developers in inte-grating code changes quickly through automated building. How-ever, there is a consensus that CI build failure is a major barrierthat developers face, which prevents them from proceeding furtherwith development. In this paper, we introduceBF-Detector, anautomated tool to detect CI build failure. Based on the adaptationof Non-dominated Sorting Genetic Algorithm (NSGA-II), our toolaims at finding the best prediction rules based on two conflictingobjective functions to deal with both minority and majority classes.We evaluated the effectiveness of our tool on a benchmark of 56,019CI builds. The results reveal that our technique outperforms state-of-the-art approaches by providing a better balance between bothfailed and passed builds.BF-Detectortool is publicly available,with a demo video, at: https://github.com/stilab-ets/BF-Detector.

A test suite is a set of test cases that evaluate the quality of software. The aim of whole test suite generation is to create test cases with the highest coverage scores possible. This study investigated the efficiency of a multiple-searching genetic algorithm (MSGA) for whole test suite generation. In previous works, the MSGA has been effectively used in multicast routing of a network system and in the generation of test cases on individual coverage criteria for small- to medium-sized programs. The performance of the algorithms varies depending on the problem instances. In this experiment were generated whole test suites for complex programs. The MSGA was expanded in the EvoSuite test generation tool and compared with the available algorithms on EvoSuite in terms of the number of test cases, the number of statements, mutation score, and coverage score. All algorithms were evaluated on 14 problem instances with different corpus to satisfy multiple coverage criteria. The problem instances were Java open-source projects. Findings demonstrate that the MSGA generated test cases reached greater coverage scores and detected a larger number of faults in the test class when compared with the others.

Testing with simulation environments helps to identify critical failing scenarios for self-driving cars (SDCs). Simulation-based tests are safer than in-field operational tests and allow detecting software defects before deployment. However, these tests are very expensive and are too many to be run frequently within limited time constraints. In this article, we investigate test case prioritization techniques to increase the ability to detect SDC regression faults with virtual tests earlier. Our approach, called SDC-Prioritizer , prioritizes virtual tests for SDCs according to static features of the roads we designed to be used within the driving scenarios. These features can be collected without running the tests, which means that they do not require past execution results. We introduce two evolutionary approaches to prioritize the test cases using diversity metrics (black-box heuristics) computed on these static features. These two approaches, called SO-SDC-Prioritizer and MO-SDC-Prioritizer , use single-objective and multi-objective genetic algorithms ( GA ), respectively, to find trade-offs between executing the less expensive tests and the most diverse test cases earlier. Our empirical study conducted in the SDC domain shows that MO-SDC-Prioritizer significantly ( P - value e -10) improves the ability to detect safety-critical failures at the same level of execution time compared to baselines: random and greedy-based test case orderings. Besides, our study indicates that multi-objective meta-heuristics outperform single-objective approaches when prioritizing simulation-based tests for SDCs. MO-SDC-Prioritizer prioritizes test cases with a large improvement in fault detection while its overhead (up to 0.45% of the test execution cost) is negligible.

Deep Learning (DL) has been successfully applied to a wide range of application domains, including safety-critical ones. Several DL testing approaches have been recently proposed in the literature but none of them aims to assess how different interpretable features of the generated inputs affect the system's behaviour. In this paper, we resort to Illumination Search to find the highest-performing test cases (i.e., misbehaving and closest to misbehaving), spread across the cells of a map representing the feature space of the system. We introduce a methodology that guides the users of our approach in the tasks of identifying and quantifying the dimensions of the feature space for a given domain. We developed DeepHyperion, a search-based tool for DL systems that illuminates, i.e., explores at large, the feature space, by providing developers with an interpretable feature map where automatically generated inputs are placed along with information about the exposed behaviours., To be published in Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA '21), July 11-17, 2021, Virtual, Denmark. ACM, New York, NY, USA, 12 pages

In Search-based Software Engineering (SBSE), researchers and practitioners (SBSE users) using multi-objective search algorithms (MOSAs) often select commonly used MOSAs to solve their search problems. Such a selection is usually not justified, and the main selection criterion is the MOSA popularity. On the other hand, SBSE users are usually aware of the desired qualities of solutions of their search problem, captured by Quality Indicators (QIs). Consequently, to guide SBSE users in selecting MOSAs for their specific SBSE problems, we study preference relationships between QIs and MOSAs with an empirical evaluation. Given a QI or a quality aspect (e.g., convergence), we suggest a MOSA that is highly likely to produce solutions representing the QI or the quality aspect. Based on our experiments' results, we provide insights and suggestions for SBSE users to choose a MOSA based on experimental evidence. This is an extended abstract of the paper [2]: S. Ali, P. Arcaini, and T. Yue, "Do Quality Indicators Prefer Particular Multi-Objective Search Algorithms in Search-Based Software Engineering?", 12th International Symposium on Search-Based Software Engineering (SSBSE 2020).

Many software engineering activities process the events contained in log files. However, before performing any processing activity, it is necessary to correctly parse the entries in a log file to retrieve the actual events recorded in the log. In the case of cyber-physical systems, execution logs are highly important because such systems integrate multiple third-party components where their source code is not always available. This limits the visibility of the system behavior to what is collected in the execution logs. The increasing amount of logs produced by cyber-physical systems calls for 1) more advanced techniques for accurate log parsing, 2) scalable model inference that will enabling efficient program comprehension and, 3) cost-effective software testing to ensuring the quality of complex soft- ware systems.

Concurrent model synchronisation, i.e. the (bidirectional) propagation of updates between two models, is an important problem in the area of model-driven engineering (MDE). Compared to other consistency management tasks, synchronising concurrent updates is especially challenging as they can be conflicting, such that restoring a consistent state is not possible when all updates must be considered. Recent approaches create a search space of possible solutions and determine the optimum solution via exact methods, such as integer linear programming (ILP), via a configurable, scalarised objective function that takes conflicting goals into account. However, the determination of suitable configuration parameters and runtime efficiency improvements are still an open issue, which is commonly addressed by using heuristics instead of exact methods. We investigate on whether it is beneficial to apply heuristics to solve concurrent model synchronisation problems. First, a multiobjective evolutionary algorithm is used for small instances for which all pareto-optimal solutions can be presented to a user to select the best one. Second, for larger models, we propose a method to determine suitable weightings for aggregating all objectives into a single function. Finally, these insights are used to recommend a strategy for determining solutions of satisfying quality within an acceptable amount of time.