ABSTRACT Merge conflicts arise when multiple developers simultaneously modify the same part of a codebase and attempt to merge their changes. These conflicts occur because the version control system (VCS) cannot automatically determine which changes should take precedence. Resolving such conflicts involves manually reviewing the conflicting changes and deciding how to integrate them to maintain a functional and coherent codebase. This process is often time‐consuming, complex, and prone to errors. Consequently, the software engineering community has focused on predicting merge conflicts to warn developers early and allow them to address conflicts before they escalate. Despite several efforts to predict merge conflicts, no perfect solution has been identified. Fortunately, many machine learning techniques have demonstrated potential in improving prediction performance across various contexts. This study aims to empirically investigate the effectiveness of stacking heterogeneous ensembles in enhancing merge conflict prediction performance. We empirically compared the prediction performance of the following individual models: decision trees (DT); support vector machine (SVM) with a linear kernel; naive Bayes (NB) with Bernoulli, Gaussian, and Multinomial variants; logistic regression (LR); multilayer perceptron (MLP); stochastic gradient descent (SGD); and k‐nearest neighbors (KNN). Additionally, we evaluated three heterogeneous stacking ensembles: Stack‐DT, Stack‐SVM, and Stack‐LR, which were constructed using the aforementioned individual models as base models. We utilized gain ratio (GR) to identify the most important technical and social features for predicting merge conflicts and assessed the impact of using only these important features on the performance of both individual and stacking models. The study revealed variability in the performance of individual models, with DT demonstrating the best predictive performance among them. Heterogeneous stacking ensembles demonstrated potential to enhance merge conflict prediction, with Stack‐SVM emerging as the top‐performing model. GR analysis highlighted the importance of both social and technical features in predicting merge conflicts. However, using only the most important features identified by GR led to a decline in the performance of most models compared to using all features. Heterogeneous stacking ensembles significantly improve prediction performance over individual models. Both social and technical features are important in predicting merge conflicts, and utilizing the full set of features instead of only the most important ones generally yields better results.

Mobile applications have become ubiquitous and are essential in various aspects of life. Developing cross-platform applications represents a significant challenge in mobile application development. Ionic is a software framework that aims to simplify the creation of cross-platform applications through a unified codebase. Stack Overflow (SO) has continuously demonstrated its utility in gaining insights into various subjects within the field of software engineering. Hence, this study aims to uncover the challenges faced by developers when utilizing Ionic through an analysis of SO Ionic-related questions. We identified a set of 81,748 SO Ionic-related questions, which we further analyzed using Latent dirichlet allocation (LDA) to reveal their topics. Subsequently, we estimated the popularity and difficulty of these topics using several proxy measures. The findings revealed that SO Ionic-related questions encompass eight topics, with building errors being the most popular and Cordova plugins the most difficult. Software engineering researchers, practitioners, educators, and Ionic contributors can benefit from these findings in guiding their future endeavors related to Ionic.

Web‐based applications are popular in demand and usage. To facilitate the development of web‐based applications, the software engineering community developed multiple web application frameworks, one of which is Flask. Flask is a popular web framework that allows developers to speed up and scale the development of web applications. A review of the software engineering literature revealed that the Stack Overflow (SO) website has proven its effectiveness in providing a better understanding of multiple subjects within the software engineering field. This study aims to analyze SO Flask‐related questions to gain a better understanding of the stance of Flask on the website. We identified a set of 70,230 Flask‐related questions that we further analyzed to estimate how the interest towards the framework evolved over time on the website. Afterward, we utilized the Latent Dirichlet Allocation (LDA) algorithm to identify Flask‐related topics that are discussed within the set of the identified questions. Moreover, we leveraged a number of proxy measures to examine the difficulty and popularity of the identified topics. The study found that the interest towards Flask has been generally increasing on the website, with a peak in 2020 and drops in the following years. Moreover, Flask‐related questions on SO revolve around 12 topics, where Application Programming Interface (API) can be considered the most popular topic and background tasks can be considered the most difficult one. Software engineering researchers, practitioners, educators, and Flask contributors may find this study useful in guiding their future Flask‐related endeavors.

Abstract Technical debt (TD) is a metaphor used to refer to the added software system costs acquired from taking shortcuts. Unfortunately, large amounts of TD can lead to serious consequences, and, thus, the management of TD is essential. Due to TD being a relatively new subject of study, many aspects of TD remain ambiguous. Fortunately, Twitter has been proven to hold a wealth of information on many subjects. As such, this survey study aims to gain a better understanding on how interest in TD has evolved over time and how TD is addressed on Twitter. A total of 128,897 TD‐related tweets were scrapped from Twitter and analyzed using a number of proxy measures and Latent Dirichlet Allocation (LDA). The results revealed that interest in TD on Twitter has been generally increasing since the platform's early stages. Furthermore, TD‐related tweets were found to revolve around 11 distinct categories. The TD in games category was discovered to be the most popular category, followed by TD communication and TD repayment. The results highlight that TD is a diverse and overarching topic that contains many potential avenues for further exploration. Software engineering researchers, practitioners, and educators can utilize this study to help steer their TD‐related future efforts.

Software engineering ethics has been an interest of the software engineering community for over two decades, as evidenced by the creation of the joint ACM/IEEE-CS Soft-ware Engineering Code of Ethics. When reviewing the cur-rent software engineering literature, it was found that Stack Exchange question-and-answer (Q&A) websites are particularly good means of gaining a better understanding on a given subject: what topics are addressed within a subject area, the popularity of these topics, and the difficulty of these topics. As such, this paper utilizes Stack Exchange Q&A websites to review software engineering ethics and presents a case study that aims to provide a better understanding of the presence of software engineering ethics on three popular Stack Exchange Q&A websites, which are Stack Overflow (SO), Software Engineering (SE), and Project Management (PM). The study analyzes over 2,170 posts, using Latent Dirichlet Allocation (LDA), to better understand what ethic-related topics are discussed. Subsequently, the authors analyzed the popularity and difficulty of each identified topic. The study found that users discuss six ethic-related topics, which are as follows: web scraping, software quality, software security, open-source software usage, team and employers, and software billing. Moreover, the results revealed that software security is the most popular and the most difficult topic. This study highlights ethic-related challenges that are faced by Q&A website users. Software practitioners, researchers, and educators can utilize the results presented in this study to pursue new avenues when addressing pressing issues related to software engineering ethics.

Repaying all technical debt (TD) present in a system may be unfeasible, as there is typically a shortage in the resources allocated for TD repayment. Therefore, TD prioritization is essential to best allocate such resources to determine which TD items are to be repaid first and which items are to be delayed until later releases. This study conducts a systematic literature review (SLR) to identify and analyze the currently researched TD prioritization approaches. The employed search strategy strove to achieve high completeness through the identification of a quasi-gold standard set, which was used to establish a search string to automatically retrieve papers from select research databases. The application of selection criteria, along with forward and backward snowballing, identified 24 TD prioritization approaches. The analysis of the identified approaches revealed a scarcity of approaches that account for cost, value, and resources constraint and a lack of industry evaluation. Furthermore, this SLR unveils potential gaps in the current TD prioritization research, which future research may explore.

Background: Software projects are facing the need to adopt security practices during the software development life cycle (SDLC). Nevertheless, the amount of effort to be invested in order to achieve a certain level of software security is not clear yet. Aims: The goal of this study is to get an overview of the application of software security practices in the industry and to identify the impact of the introduction of such activities in software development projects in terms of effort/cost. Method: We conducted a survey on a software security group of a professional social network by applying a random sampling strategy to establish a representative set of participants. Results: The questionnaire was fully answered by 110 participants, from the 808 profiles that were invited from the sampling frame. The results show that security practices have been applied thoroughly in the projects and revealed high variability in secure software development effort across the participants' projects. Further research is needed to understand the different professionals' perspectives regarding security effort in projects. As lessons learned, we found that the professional social network offered a demographically diverse sampling frame, but this comes with hurdles that need to be overcome. Conclusions: The experiences of the participants showed that security is a factor that drives effort in software projects, and security practices need to be taken into account when planning software development initiatives. Our findings about the current state of practices and adoptions can help practitioners and researchers in future endeavors.

Technical Debt (TD) prioritization is the process of deciding which TD items should be repaid first and which items can be endured until later releases. The goal of the process is to maximize the value of the TD repayment with limited resources. Unfortunately, researchers have indicated the scarcity of TD prioritization techniques and limitations in them. To address these limitations, we propose a novel search-based approach for prioritizing TD using a Multi-objective Evolutionary Algorithm (MOEA). The approach indicates which TD items should be repaid to maximize the value of a repayment activity within a specific cost constraint. An empirical evaluation that we performed on 40 Open-Source Software (OSS) systems demonstrated our approach's ability to improve the value of TD repayment by 1,796 over random search. Additionally, a user study that we conducted with developers confirmed the suitability of our approach in industry and its usefulness in improving the value of TD repayment over developers' prioritization by 423.

Software systems are often developed by many developers who have a varying range of skills and habits. These developers have a big impact on software quality. Understanding how different developers and developer characteristics impact the quality of a software is crucial to properly deploy human resources and help managers improve quality outcomes which is essential for software systems success. Addressing this concern, we conduct a study on how different developers and developer characteristics such as developer seniority in a system, frequency of commits, and interval between commits relate to Technical Debt (TD). We performed a large-scale analysis on 19,088 commits from 38 Apache Java systems and applied multiple statistical analysis tests to evaluate our hypotheses. Our empirical evaluation suggests that developers unequally increase and decrease TD, a developer seniority in a software system and frequency of commits are negatively correlated with the TD the developer induces, and a developer commit interval has a positive correlation with the TD the developer induces.

Developers intend to improve the quality of the software as it evolves. However, as software becomes larger and more complex, those intended actions may lead to unintended consequences. Analyzing change in software quality among different releases overlooks fine-grained changes that each commit introduces. We believe that studying software quality before and after each commit (commit-impact analysis) can reveal a wealth of information about how the software evolves and how each change impacts its quality. In this paper, we explore whether each commit has an impact on the source code, investigate the compilability of each impactful commit, examine how source code changes affect software quality metrics, and study the effectiveness of using a certain metric as software quality indicator. We analyze a total of 19,580 commits from 38 Apache Java software systems to better understand how change occurs, why, and by who.