Resolving merge conflicts manually is a tedious and complex task. While automated approaches exist, many challenges persist. One promising yet underexplored solution is the use of search-based optimization algorithms, which require an evaluation function to measure the quality of intermediary solutions. However, using code compilation and test execution for this purpose is computationally expensive. This study investigates the relationship between conflict resolutions and conflicting content to identify a metric for guiding search-based optimization techniques. We analyzed 9,998 conflict chunks from 1,062 open source projects, focusing on the similarity of resolutions to their parents and the correlation between randomly generated candidates, parent versions, and the resolution. Our findings reveal that conflict resolutions are, on average, 70% similar to both parents. A strong median correlation ( \(\rho=0.791\) ) exists between candidate-parent and candidate-resolution similarities when aggregating parent similarities with the mean function. Based on these findings, we propose and evaluate SBCR, a Search-Based Conflict Resolution approach that uses parent similarity as a guiding function. We found that the resolution candidates generated by SBCR have a median of 86.5% similarity to the expected resolution, achieving 100% of similarity in 25.2% of the conflicts.

JavaScript is one of the most used programming languages for front-end development of Web applications. The increase in complexity of front-end features brings concerns about performance, especially the load and execution time of JavaScript code. In this paper, we propose an evolutionary program improvement technique to reduce the size of JavaScript programs and, therefore, the time required to load and execute them in Web applications. To guide the development of this technique, we performed an experimental study to characterize the patches applied to JavaScript programs to reduce their size while keeping the functionality required to pass all test cases in their test suites. We applied this technique to 19 JavaScript programs varying from 92 to 15,602 LOC and observed reductions from 0.2 to 73.8 percent of the original code, as well as a relationship between the quality of a program's test suite and the ability to reduce the size of its source code.

When multiple developers change a software system in parallel, these concurrent changes need to be merged to all appear in the software being developed. Numerous merge techniques have been proposed to support this task, but none of them can fully automate the merge process. Indeed, it has been reported that as much as 10 to 20 percent of all merge attempts result in a merge conflict, meaning that a developer has to manually complete the merge. To date, we have little insight into the nature of these merge conflicts. What do they look like, in detail? How do developers resolve them? Do any patterns exist that might suggest new merge techniques that could reduce the manual effort? This paper contributes an in-depth study of the merge conflicts found in the histories of 2,731 open source Java projects. Seeded by the manual analysis of the histories of five projects, our automated analysis of all 2,731 projects: (1) characterizes the merge conflicts in terms of number of chunks, size, and programming language constructs involved, (2) classifies the manual resolution strategies that developers use to address these merge conflicts, and (3) analyzes the relationships between various characteristics of the merge conflicts and the chosen resolution strategies. Our results give rise to three primary recommendations for future merge techniques, that - when implemented - could on one hand help in automatically resolving certain types of conflicts and on the other hand provide the developer with tool-based assistance to more easily resolve other types of conflicts that cannot be automatically resolved.

Background: Function point analysis is frequently used to provide early effort estimations for software development. If the effort is large enough, the software tends to be delivered incrementally, its requirements being partitioned into a set of releases. Aims: This work explores the structure of function point analysis to allow deploying more requirements into releases of a software system using the same amount of development effort. To afford these extra requirements, our approach exploits opportunities provided by the estimation procedure. Method: An experimental study was organized to compare the approach with the state-of-practice method of FPA-based estimation using data from four real-world projects. Results: Our findings suggest that stakeholder satisfaction, measured as the ratio of delivered to desired requirements, can be increased by 6.5% if data functions are grouped in estimation. Conclusions: We present actionable advice for companies providing or procuring software development services on the form of effort unit contracts.

IT professionals are frequently subject to working overtime, even knowing that excessive overtime has negative effects both on their lives and the software they produce. This contrast creates the need for overtime policies that attend to the demands of a project using as few overtime hours as possible. However, our knowledge about the dynamics of overtime work and the effects of distinct policies on a software project is limited. In this paper we introduce a formulation for the overtime planning problem which extends the state-of-art by considering both the positive effects of overtime on productivity and its negative effects on product quality. We use heuristic search to explore close to optimal overtime allocations under this formulation and report lessons learned by analyzing these allocations. We present an empirical study that compares our approach with practices from the industry and a similar formulation without negative effects. Evidence supports the industrial practice of concentrating overtime in the second half of a project's schedule. Results also show that ignoring the flip-side of the productivity gains brought by overtime may lead to wrong decisions. For instance, excessive overtime may lead a manager to underestimate project cost and duration by 5.9% and 9.2%, respectively.

Software projects usually maintain bug repositories where both developers and end users can report and track the resolution of software defects. These defects should be fixed and new versions of the software incorporating the patches that solve them must be released. The project manager must schedule a set of error correction tasks with different priorities in order to minimize the time required to accomplish these tasks and guarantee that the more important issues have been fixed. This problem is recurrent for most software organizations and, given the enormous number of potential schedules, a tool that searches for good schedules may be helpful to project managers. In this work we propose a genetic algorithm using information captured from bug repositories to find near optimal schedules. We evaluated our approach using a subset of the Eclipse bug repository and the results suggested better schedules than the schedule followed by the developers and schedules proposed by a simpler search procedure.

The application of multiobjective optimization to address Software Engineering problems is a growing trend. Multiobjective algorithms provide a balance between the ability of the computer to search a large solution space for valuable solutions and the capacity of the human decision-maker to select an alternative when two or more incomparable objectives are presented. However, when more than a single objective is available, the set of objectives to be considered by the search becomes part of the decision. In this paper, we address the efficiency and effectiveness of using two composite objectives while searching solutions for the software clustering problem. We designed an experimental study which shows that a multiobjective genetic algorithm can find a set of solutions with increased quality and using less processing time if these composite objectives are suppressed from the formulation for the software clustering problem.