Abstract The application of Large Language Models (LLMs) in Model-Driven Engineering (MDE) has emerged as a rapidly evolving research area. While existing systematic literature reviews have examined specific technical approaches, a comprehensive mapping of the broader research landscape (e.g., development trends) remains lacking. This study presents a systematic mapping study of LLM applications in MDE, analyzing 86 primary studies collected from five databases, covering publications from 2022 to early 2026. Guided by five research questions, we characterize the field across five dimensions: MDE task distribution and research contribution types, LLM technologies and interaction strategies, artifact representation and processing, validation practices, and publication landscape. Our findings reveal that current LLM4MDE research is heavily concentrated on Model Generation, while tasks such as Model Migration, DSL Engineering, and Metamodeling remain marginal. Most approaches rely on black-box OpenAI models accessed via remote APIs and adapted through prompt engineering, with fine-tuning and retrieval-augmented generation rarely employed. Inputs are predominantly natural-language artifacts, while outputs are model-oriented but usually expressed in lightweight textual formats rather than native MDE exchange formats. Validation is centered on quantitative experimentation, with 42% of studies reporting no baseline and cost efficiency reported in fewer than one quarter of studies. The field has grown rapidly, from one paper in 2022 to 42 in 2025, with research concentrated in Europe and Canada and limited industry involvement. Based on these findings, we identify gaps and opportunities across task coverage, technical configuration, and evaluation practice, offering a knowledge map to guide future work in this cross-disciplinary field.

Abstract Domain-specific languages (DSLs) play a crucial role in facilitating a wide range of software development activities in the context of model-driven engineering (MDE). However, there exists a significant gap in the systematic understanding of how DSLs evolve over time, which could hamper the development of effective methodologies and tools. To address this gap, this paper presents a large-scale study of the development and evolution of textual DSLs created with the Xtext framework and hosted on GitHub. The study focuses on how these languages evolve at the grammar and front-end level, as captured in open-source repositories. We systematically identified and analyzed 1002 GitHub repositories containing Xtext-related projects. A manual classification of the repositories brought forward 226 ones that contain a fully developed language. We further categorized the latter into 18 separate categories of application domains, studied their contained DSL definition artifacts and analyzed the extent to which example instances using the grammar are available. In addition, we explored DSL development practices, focusing on the development scenarios involved, evolution activities, and the modification and co-evolution of related artifacts. We observed that analyzed DSLs evolved faster and were maintained longer when they belonged to specific domains, such as data management and databases. We found grammar definitions of DSLs in 722 repositories in total. While only about a third of them provided corresponding textual instances, community engagement metrics indicate potential usage of the DSLs in downstream repositories. Considering different language development approaches, we found that the majority of analyzed languages were developed following a grammar-driven approach, although a notable number adopted a metamodel-driven approach. Additionally, we identify a trend of retrofitting existing languages in Xtext, illustrating the framework’s flexibility beyond the creation of new DSLs. By investigating software evolution aspects, we found that the development lifecycle of analyzed DSLs varies, but in many cases, updates to grammar definitions and example instances were frequent, and most of the evolution activities can be classified as “perfective” changes. Addressing a need for large and systematically documented datasets in the model-driven engineerifng community, we contribute a dataset of repositories together with our collected meta-information, which can be used to inform our understanding of open-source DSL development practices and the development of improved tools for supporting the development and evolution of DSLs.

Machine learning-based methods are increasingly used to optimize build processes and accelerate the integration of software code. These methods leverage large volumes of historical code changes to train models on predicting and preventing issues in the codebase that could delay code integrations and features delivery to end-users. The objective of this study is to examine the impact of handling class noise present in software code changes collected from Continuous Integration (CI) systems on the predictive performance of machine learning models for predicting the execution outcome of CI builds and negative code reviews. In this study, we conduct a series of computational experiments using data from 110 Java open-source projects, examining the effectiveness of two removal-based statistical techniques - Majority Filter (MF) and Consensus Filter (CF) - and two corrective techniques - Domain Knowledge-based (DB) and CleanLab. Our results show that removal-based techniques significantly improve model predictive performance in both build outcome and negative code review prediction tasks. For build outcome prediction, applying MF increased the F1-score from 82% to 97%, and MCC from 0.13 to 0.58. In negative code review predictions, MF improved the F1-score from 17% to 53%, and MCC from −0.03 to 0.57. The DB technique was effective primarily in the context of code review comments but less so for build outcome predictions. While CleanLab yielded more consistent predictions, its overall impact on model performance was more moderate compared to removal-based techniques. Additionally, our findings show that hyperparameter tuning, applied independently or in combination with CleanLab, can further improve model performance; however, these gains did not surpass those achieved by removal-based techniques alone. We conclude that applying removal-based techniques to the training data of code changes is necessary to improve the prediction of build outcomes and negative code review comments.

The adoption of generative AI (GenAI) in software development practice has introduced significant changes for developers and organizations. However, for now the actual impact is still unknown and the changes to developer practices, behavior, and software quality are unclear. In my thesis, I explore this research area with the goal of contributing valuable insights for practitioners and researchers.

With the integration of generative artificial intelligence (GenAI) tools such as GitHub Copilot into development processes, developers can be supported when writing code. As GitHub Copilot has a feature to provide up to ten solutions at once, we explore, how developers should approach those solutions with the goal of providing recommendations to achieve suitable trade-offs in finding correct solutions and checking solutions. In this study, we analyze a total of 2025 coding problems provided by LeetCode and 17 048 solutions to solve these problems generated by GitHub Copilot in Python. We focus on three key issues: firstly, whether it is beneficial to consider multiple solutions; secondly, the impact of the position of a solution; and thirdly, the number of solutions that should be checked by a developer. Overall, our results point to the following observations: (1) solutions are not less likely to be correct if they appear at later positions; (2) when looking for a solution to a common problem, checking four to five solutions is generally enough; (3) novel or difficult problems are unlikely to be solved by GitHub Copilot; (4) skipping the first solution is advised when considering only one solution, as the first solution is less likely to be correct; and (5) checking all solutions is necessary to not miss correct solutions, but the effort is usually not justified. Based on our study, we conclude that there is potential for improvement in better supporting developers. For instance, there are few cases where ten generated solutions provide more value than fewer solutions. Depending on the use scenario, it could be more useful if GitHub Copilot allowed developers to request a single, comprehensive solution.

Abstract Models play a crucial role in software design, analysis, and supporting new maintainers. However, over time, the benefits of models can diminish as system implementations evolve without corresponding updates to the original models. Reverse engineering methods and tools can help maintain alignment between models and implementation code. Yet, automatically reverse-engineered models often lack abstraction and contain extensive details that hinder comprehension. Recent advancements in AI-based content generation suggest that we may soon see reverse engineering tools capable of human-grade abstraction. To guide the design and validation of such tools, we need a principled understanding of manual abstraction—a topic that has received limited attention in existing literature. In pursuit of this goal, our paper presents a multiple-case study of model-to-code differences, examining nine substantial open-source software projects obtained through repository mining. We manually matched source code from projects comprising 4983 classes, 26k attributes, and 54k operations to 523 model elements (including classes, attributes, operations, and relationships). These mappings precisely capture discrepancies between provided class diagram designs and actual implementation code. By analyzing these differences in detail, we derive a taxonomy of difference types and provide a well-organized list of cases corresponding to identified differences. Our findings have the potential to contribute to improved reverse engineering methods and tools, propose new mapping rules for model-to-code consistency checks, and offer guidelines to avoid over-abstraction and over-specification during the design process.

Microservices-based Architectures (MSAs) are gaining popularity since, among others, they enable rapid and independent delivery of software at scale, facilitating the delivery of business value. Additionally, there are attempts towards understanding practitioners’ roles and technical knowledge. MSAs call for affinity in several technologies as well as business domains. This diversity makes it challenging to scope and describe the roles of practitioners. In addition, practitioners often do not receive training and contents of MSA training remain largely undefined, even though there are challenges in finding or developing relevant technical expertise. In this research, we determine the different technical roles that are required in MSAs, along with their detailed competences. We use public online forums (e.g., StackOverflow), where developers share technical knowledge. We analyze 13,517 public profiles of software engineers, deriving their technical competences. Our taxonomy of technical competences in MSAs, contains 11 competences clusters, organized in 3 collections of competences — Web Technologies, DevOps, and Data Technologies. In addition, we derive the roles of microservice practitioners and the characteristics of their roles. Our findings organize the technical competences of MSAs practitioners and determine the training topics and combination of topics that can prepare engineers for MSAs.

In model-driven engineering, developing a textual domain-specific language (DSL) involves constructing a meta-model, which defines an underlying abstract syntax, and a grammar, which defines the concrete syntax for the DSL. We consider a scenario in which the meta-model is manually maintained, which is common in various contexts, such as blended modeling, in which several concrete syntaxes co-exist in parallel. Language workbenches such as Xtext support such a scenario, but require the grammar to be manually co-evolved, which is laborious and error-prone. In this paper, we present GrammarTransformer, an approach for transforming generated grammars in the context of meta-model-based language evolution. To reduce the effort for language engineers during rapid prototyping and language evolution, it offers a catalog of configurable grammar transformation rules. Once configured, these rules can be automatically applied and re-applied after future evolution steps, greatly reducing redundant manual effort. In addition, some of the supported transformations can globally change the style of concrete syntax elements, further significantly reducing the effort for manual transformations. The grammar transformation rules were extracted from a comparison of generated and existing, expert-created grammars, based on seven available DSLs. An evaluation based on the seven languages shows GrammarTransformer’s ability to modify Xtext-generated grammars in a way that agrees with manual changes performed by an expert and to support language evolution in an efficient way, with only a minimal need to change existing configurations over time.

Xtext is a well-known domain-specific language design framework and technology. It automatically generates a textual grammar for a language, given a meta-model specified in Ecore. These generated textual grammars are typically not user-friendly. Python-style languages are popular among developers for their usability and conciseness. We aim to propose a systematic approach to transform a DSL with a generated grammar into a Python-style DSL. To achieve this, we analyze the problems of grammars generated with Xtext, based on a lightweight architecture description language. In response to these problems, we propose a general semi-automated grammar adaptation approach. We apply the approach to two other DSLs to validate the generalization of the approach. We also discuss the limitations of this approach and prospects for the future.

When a language evolves, meta-models and associated gram- mars need to be co-evolved to stay mutually consistent. Previous work has supported the automated migration of a grammar after changes of the meta-model to retain manual optimizations of the grammar, related to syntax aspects such as keywords, brackets, and component order. Yet, doing so required the manual specification of optimization rule con- figurations, which was laborious and error-prone. In this work, to significantly reduce the manual effort during meta-model and grammar co-evolution, we present an automated approach for extracting optimization rule configurations. The inferred configurations can be used to automatically replay optimizations on later versions of the grammar, thus leading to a fully automated migration process for the supported types of changes. We evaluated our approach on six real cases. Full automation was possible for three of them, with agreement rates between ground truth and inferred grammar between 88% and 67% for the remaining ones.

Context: As many organizations modernize their software architecture and transition to the cloud, migrations towards microservices become more popular. Even though such migrations help to achieve organizational agility and effectiveness in software development, they are also highly complex, long-running, and multi-faceted. Objective: In this study we aim to comprehensively map the journey towards microservices and describe in detail what such a migration entails. In particular, we aim to discuss not only the technical migration, but also the long-term journey of change, on a systemic level. Method: Our research method is an inductive, qualitative study on two data sources. Two main methodological steps take place - interviews and analysis of discussions from StackOverflow. The analysis of both, the 19 interviews and 215 StackOverflow discussions, is based on techniques found in grounded theory. Results: Our results depict the migration journey, as it materializes within the migrating organization, from structural changes to specific technical changes that take place in the work of engineers. We provide an overview of how microservices migrations take place as well as a deconstruction of high level modes of change to specific solution outcomes. Our theory contains 2 modes of change taking place in migration iterations, 14 activities and 53 solution outcomes of engineers. One of our findings is on the architectural change that is iterative and needs both a long and short term perspective, including both business and technical understanding. In addition, we found that a big proportion of the technical migration has to do with setting up supporting artifacts and changing the paradigm that software is developed.

Since 1998, the ACM/IEEE 25th International Conference on Model Driven Engineering Languages and Systems (MODELS) has been studying all aspects surrounding modeling in software engineering, from languages and methods to tools and applications. In order to enable empirical studies, the MODELS community developed a need for having examples of models, especially of models used in real software development projects. Such models may be used for a range of purposes, but mostly related to domain analysis and software design (at various levels of abstraction). However, finding such models was very difficult. The most used ones had their origin in academic books or student projects, which addressed “artificial” applications, i.e., were not base on real-case scenarios. To address this issue, the authors of this reflection paper, members of the modeling and of the mining software repositories fields, came together with the aim of creating a dataset with an abundance of modeling projects by mining GitHub. As a scoping of our effort we targeted models represented using the UML notation because this is the lingua franca in practice for software modeling. As a result, almost 100k models from 22k projects were made publicly available, known as the Lindholmen dataset. In this paper, we analyse the impact of our research, and compare this to what we envisioned in 2016. We draw practical lessons gained from this effort, reflect on the perils and pitfalls of the dataset, and point out promising avenues of research. We base our reflection on the systematic analysis of recent research literature, and especially those papers citing our dataset and its associated publications. What we envisioned in the original research when making the dataset available has to a major extent not come true; however, fellow researchers have found alternative uses of the dataset. By understanding the possibilities and shortcomings of the current dataset, we aim to offer the research community i) future research avenues of how the data can be used; and ii) raise awareness of the limitations, not only to point out threats to validity of research, but also to encourage fellow researchers to find ideas to overcome them. Our reflections can also be helpful to researchers who want to perform similar mining efforts.

Software is the main driver of added-value in many of the systems that surround us. While its complexity is increasing, so is the diversity of systems driven by software. To meet the challenges emerging from this combination, it is necessary to mobilize increasingly large and heterogeneous multidisciplinary teams, comprising software experts, as well as experts from various domains related to the systems driven by software. Hence, the quality of communication about software between stakeholders of different domains and with different personalities is becoming a key issue for successfully engineering software-intensive systems. The goal of this study, thus, is to investigate the effect of the representation of software design models on the communication of design decisions between stakeholders with diverse personality traits. As a result, this study finds that graphical representations of software design models are better than textual representations in enhancing the communication and increasing the productivity of stakeholders with diverse personalities.

Big data and machine learning models have been increasingly used to support software engineering processes and practices. One example is the use of machine learning models to improve test case selection in continuous integration. However, one of the challenges in building such models is the large volume of noise that comes in data, which impedes their predictive performance. In this paper, we address this issue by studying the effect of two types of noise, called class and attribute, on the predictive performance of a test selection model. For this purpose, we analyze the effect of class noise by using an approach that relies on domain knowledge for relabeling contradictory entries and removing duplicate ones. Thereafter, an existing approach from the literature is used to experimentally study the effect of attribute noise removal on learning. The analysis results show that the best learning is achieved when training a model on class-noise cleaned data only — irrespective of attribute noise. Specifically, the learning performance of the model reported 81% precision, 87% recall, and 84% f-score compared with 44% precision, 17% recall, and 25% f-score for a model built on uncleaned data. Finally, no causality relationship between attribute noise removal and the learning of a model for test case selection was drawn.

Together with many success stories, promises such as the increase in production speed and the improvement in stakeholders’ collaboration have contributed to making agile a transformation in the software industry in which many companies want to take part. However, driven either by a natural and expected evolution or by contextual factors that challenge the adoption of agile methods as prescribed by their creator(s), software processes in practice mutate into hybrids over time. Are these still agile? In this article, we investigate the question: what makes a software development method agile? We present an empirical study grounded in a large-scale international survey that aims to identify software development methods and practices that improve or tame agility. Based on 556 data points, we analyze the perceived degree of agility in the implementation of standard project disciplines and its relation to used development methods and practices. Our findings suggest that only a small number of participants operate their projects in a purely traditional or agile manner (under 15 percent). That said, most project disciplines and most practices show a clear trend towards increasing degrees of agility. Compared to the methods used to develop software, the selection of practices has a stronger effect on the degree of agility of a given discipline. Finally, there are no methods or practices that explicitly guarantee or prevent agility. We conclude that agility cannot be defined solely at the process level. Additional factors need to be taken into account when trying to implement or improve agility in a software company. Finally, we discuss the field of software process-related research in the light of our findings and present a roadmap for future research.

Background: Microservices migrations are challenging and expensive projects with many decisions that need to be made in a multitude of dimensions. Existing research tends to focus on technical issues and decisions (e.g., how to split services). Equally important organizational or business issues and their relations with technical aspects often remain out of scope or on a high level of abstraction.

Abstract The volume at hand presents the special issue of the 12th International Conference on Software and Systems Process (ICSSP) 2019, which was held in Montreal, Canada, from May 25 to 26, 2019. ICSSP 2019 is the latest in a series of conferences that have been organized by the International Software and Systems Process Association. In our evolving landscape, many companies are making efforts to move towards new technologies and tools, agile principles, and continuous integration and delivery. In doing so, they find opportunity, flexibility, and strength in evolving towards hybrid processes, which are neither purely traditional nor can count as textbook agile. This special issue focuses on hybrid processes.

Big data and machine learning models have been increasingly used to support software engineering processes and practices. One example is the use of machine learning models to improve test case selection in continuous integration. However, one of the challenges in building such models is the identification and reduction of noise that often comes in large data. In this paper, we present a noise reduction approach that deals with the problem of contradictory training entries. We empirically evaluate the effectiveness of the approach in the context of selective regression testing. For this purpose, we use a curated training set as input to a tree-based machine learning ensemble and compare the classification precision, recall, and f-score against a non-curated set. Our study shows that using the noise reduction approach on the training instances gives better results in prediction with an improvement of 37% on precision, 70% on recall, and 59% on f-score.

Software startups face numerous challenges and many fail in the first two years. Hubs, as nurturing spaces provide incubation, acceleration and co-working space as services to startups to alleviate these challenges. Previous studies have highlighted how early-stage software startups operate internally. However, given that many early-stage startups are nurtured in hubs, there is a need to understand the hub operations in respect to the startups. Using semi-structured interviews with 10 hubs in Uganda and Kenya, we characterize and analyze their current practices and operations. The results show that most hubs combine incubation, acceleration and /or co-working space as services. They offer networking and team building events in addition to value addition activities. They also provide mainly business growth incentives and notice the business and organizational effects of their incentives. They too have varied selection checklists, provide incentives to alumni startups, and measure business, and scalability metrics. Startup hubs in East Africa are therefore prepared in addressing the business aspects of startups. They too may need to improve technical mentorship and can still learn from each other's practices.

The use of autonomous bots for automatic support in software development tasks is increasing. In the past, however, they were not always perceived positively and sometimes experienced a negative bias compared to their human counterparts. We conducted a qualitative study in which we deployed an autonomous refactoring bot for 41 days in a student software development project. In between and at the end, we conducted semi-structured interviews to find out how developers perceive the bot and whether they are more or less critical when reviewing the contributions of a bot compared to human contributions. Our findings show that the bot was perceived as a useful and unobtrusive contributor, and developers were no more critical of it than they were about their human colleagues, but only a few team members felt responsible for the bot.

Developers spend most of their time with program comprehension, obtaining (or recovering) the knowledge they need to perform a task. Researchers have investigated the information needs of developers to understand what knowledge is important and to scope techniques, for example, to facilitate program comprehension, support knowledge recovery, or identify experts. Similarly, researchers analyzed developers' memory to understand how they forget, which essentially causes the need to recover knowledge. However, we are not aware of studies linking these research directions to investigate what knowledge developers aim to keep in their memory, allowing them to ask less and different questions during knowledge recovery. To address this gap, we conducted an interview survey with 17 experienced developers, in which we investigated 1) what knowledge developers consider important to remember; 2) whether developers can correctly recall knowledge about their (smaller) systems; and 3) how their self-assessment relates to their actual knowledge. Our results indicate, among others, that developers consider architecture and abstract code knowledge (e.g., its intent) as most important to remember, that the perceived importance relates to their ability to recall knowledge correctly, and that their self-assessment decreases while reflecting about their system. Based on these findings, we discuss research directions and practical implications for managing and recovering developers' knowledge.

Selecting a suitable development method for a specific project context is one of the most challenging activities in process design. Every project is unique and, thus, many context factors have to be considered. Recent research took some initial steps towards statistically constructing hybrid development methods, yet, paid little attention to the peculiarities of context factors influencing method and practice selection. In this paper, we utilize exploratory factor analysis and logistic regression analysis to learn such context factors and to identify methods that are correlated with these factors. Our analysis is based on 829 data points from the HELENA dataset. We provide five base clusters of methods consisting of up to 10 methods that lay the foundation for devising hybrid development methods. The analysis of the five clusters using trained models reveals only a few context factors, e.g., project/product size and target application domain, that seem to significantly influence the selection of methods. An extended descriptive analysis of these practices in the context of the identified method clusters also suggests a consolidation of the relevant practice sets used in specific project contexts.

Integrating machine learning components in software systems is a task more and more companies are confronted with. However, there is not much knowledge today on how the software development process needs to change, when such components are integrated into a software system. We performed an interview study with 16 participants, focusing on emerging and changing task. The results uncover a set of 25 tasks associated to different software development phases, such as requirements engineering or deployment. We are just starting to understand the implications of using machine-learning components on the software development process. This study allows some first insights into how widespread the required process changes are.

Human, social, organizational, and technical aspects are intertwined with each other in software teams during the software development process. Practices that teams actually adopt often deviate from those of the used frameworks, such as Scrum. However, currently there is little empirical insight explaining typical deviations, including their reasons and consequences. In this paper we use observations to investigate selected activities of the software development process in two companies that use Scrum. We study identified deviations to understand their reasons and consequences, using a survey and interviews. We identify 13 deviations and we categorize reasons based on type. The deviations' consequences are investigated in terms of their impact. Most deviations can be found in multiple teams. Reasons are doubts of the teams, organizational structures and complexity of the work. Consequences of deviations affect product development and team work.

Today, there is a wide range of techniques to support software comprehension. However, we do not fully understand yet what techniques really help novices, to comprehend a software system. In this paper, we present a master level project course on software evolution, which has a large focus on software comprehension. We collected data about student's experience with diverse comprehension techniques during focus group discussions over the course of two years. Our results indicate that systematic code reading can be supported by additional techniques to guiding reading efforts. Most techniques are considered valuable for gaining an overview and some techniques are judged to be helpful only in later stages of software comprehension efforts.

Abstract Context Software engineering is a social and collaborative activity. Communicating and sharing knowledge between software developers requires much effort. Hence, the quality of communication plays an important role in influencing project success. To better understand the effect of communication on project success, more in-depth empirical studies investigating this phenomenon are needed. Objective We investigate the effect of using a graphical versus textual design description on co-located software design communication. Method Therefore, we conducted a family of experiments involving a mix of 240 software engineering students from four universities. We examined how different design representations (i.e., graphical vs. textual) affect the ability to Explain, Understand, Recall, and Actively Communicate knowledge. Results We found that the graphical design description is better than the textual in promoting Active Discussion between developers and improving the Recall of design details. Furthermore, compared to its unaltered version, a well-organized and motivated textual design description–that is used for the same amount of time–enhances the recall of design details and increases the amount of active discussions at the cost of reducing the perceived quality of explaining.

To fulfill the contractual requirement of the Sweden Compact agreement, the following funding note has to be added and placed in the Funding section of the original article: Open access funding provided by University of Gothenburg .

Abstract Software developers in big and medium-size companies are working with millions of lines of code in their codebases. Assuring the quality of this code has shifted from simple defect management to proactive assurance of internal code quality. Although static code analysis and code reviews have been at the forefront of research and practice in this area, code reviews are still an effort-intensive and interpretation-prone activity. The aim of this research is to support code reviews by automatically recognizing company-specific code guidelines violations in large-scale, industrial source code. In our action research project, we constructed a machine-learning-based tool for code analysis where software developers and architects in big and medium-sized companies can use a few examples of source code lines violating code/design guidelines (up to 700 lines of code) to train decision-tree classifiers to find similar violations in their codebases (up to 3 million lines of code). Our action research project consisted of (i) understanding the challenges of two large software development companies, (ii) applying the machine-learning-based tool to detect violations of Sun’s and Google’s coding conventions in the code of three large open source projects implemented in Java, (iii) evaluating the tool on evolving industrial codebase, and (iv) finding the best learning strategies to reduce the cost of training the classifiers. We were able to achieve the average accuracy of over 99% and the average F-score of 0.80 for open source projects when using ca. 40K lines for training the tool. We obtained a similar average F-score of 0.78 for the industrial code but this time using only up to 700 lines of code as a training dataset. Finally, we observed the tool performed visibly better for the rules requiring to understand a single line of code or the context of a few lines (often allowing to reach the F-score of 0.90 or higher). Based on these results, we could observe that this approach can provide modern software development companies with the ability to use examples to teach an algorithm to recognize violations of code/design guidelines and thus increase the number of reviews conducted before the product release. This, in turn, leads to the increased quality of the final software.

Metrics, often visualized with dashboards, are considered crucial to help software start-ups focus on the right aspects during the first years. However, earlier research indicates, metric choices in emerging ecosystems are not necessarily the same as in literature, which mostly focuses on developed countries. More knowledge is required to provide dashboards that suite East African software startups. The aim of this study is to identify key requirements for measurement dashboards for early software start-ups that can be used to monitor the daily health of a start-up and how these dashboards are expected to benefit the start-ups. We performed semi-structured interviews with 36 software start-ups in Uganda and Kenya to identify and categorize requirements for measurement dashboards as well as hopes associated with the use of such dashboards. Our results show that most start-ups want measurements dashboards to visualise performance.

Abstract The International Conference on Software and System Processes (ICSSP) provides a leading forum for the exchange of research outcomes and industrial best practices in process development from software and systems disciplines. ICSSP 2018 was held in Gothenburg, Sweden, May 26 to 27, 2018, colocated with the 40th International Conference on Software Engineering (ICSE). The theme of ICSSP 2018 was studying “Demands on Processes, Processes on Demand” by recognizing the demands on processes that include the need for both well‐developed plans and incremental deliveries (agile and hybrid processes), utilization of increased automation (model‐based engineering and DevOps), higher degrees of customer collaboration, comprehensive analysis of existing products for reuse (open source and COTS), and performance requirements of enterprise‐level architectures. This special issue includes the revised and extended versions of the five highest ranked full research papers and industry experience papers of ICSSP 2018, including the two award‐winning papers.

In Model-Driven Software Development, models are automatically processed to support the creation, build, and execution of systems. A large variety of dedicated model-transformation languages exists, promising to efficiently realize the automated processing of models. To investigate the actual benefit of using such specialized languages, we performed a large-scale controlled experiment in which over 78 subjects solve 231 individual tasks using three languages. The experiment sheds light on commonalities and differences between model transformation languages (ATL, QVT-O) and on benefits of using them in common development tasks (comprehension, change, and creation) against a modern general-purpose language (Xtend). Our results show no statistically significant benefit of using a dedicated transformation language over a modern general-purpose language. However, we were able to identify several aspects of transformation programming where domain-specific transformation languages do appear to help, including copying objects, context identification, and conditioning the computation on types.

Problem: The involvement of external stakeholders in capstone projects and project courses is desirable due to its potential positive effects on the students. Capstone projects particularly profit from the inclusion of an industrial partner to make the project relevant and help students acquire professional skills. In addition, an increasing push towards education that is aligned with industry and incorporates industrial partners can be observed. However, the involvement of external stakeholders in teaching moments can create friction and could, in the worst case, lead to frustration of all involved parties. Contribution: We developed a model that allows analysing the involvement of external stakeholders in university courses both in a retrospective fashion, to gain insights from past course instances, and in a constructive fashion, to plan the involvement of external stakeholders. Key Concepts: The conceptual model and the accompanying guideline guide the teachers in their analysis of stakeholder involvement. The model is comprised of several activities (define, execute, and evaluate the collaboration). The guideline provides questions that the teachers should answer for each of these activities. In the constructive use, the model allows teachers to define an action plan based on an analysis of potential stakeholders and the pedagogical objectives. In the retrospective use, the model allows teachers to identify issues that appeared during the project and their underlying causes. Drawing from ideas of the reflective practitioner, the model contains an emphasis on reflection and interpretation of the observations made by the teacher and other groups involved in the courses. Key Lessons: Applying the model retrospectively to a total of eight courses shows that it is possible to reveal hitherto implicit risks and assumptions and to gain a better insight into the interaction between external stakeholders and students. Our empirical data reveals seven recurring risk themes that categorise the different risks appearing in the analysed courses. These themes can also be used to categorise mitigation strategies to address these risks proactively. Additionally, aspects not related to external stakeholders, e.g., about the interaction of the project with other courses in the study programme, have been revealed. The constructive use of the model for one course has proved helpful in identifying action alternatives and finally deciding to not include external stakeholders in the project due to the perceived cost-benefit-ratio. Implications to Practice: Our evaluation shows that the model is a viable and useful tool that allows teachers to reason about and plan the involvement of external stakeholders in a variety of course settings, and in particular in capstone projects.

Context: Software startups need to tackle a lot of challenges as they grow. Therefore, reoccurring strategies are applied that can be captured in form of patterns. Objectives: While more and more of these patterns are published, we aimed to discover to what degree they are applied within different regions of the world. Method: We studied the cases of 7 software startups within 2 incubation hubs in Uganda, by performing qualitative interviews. We focused on 5 patterns from diverse areas of concerns to analyze whether the Ugandan startups' strategies match these patterns. Results: For most of the patterns we found matches. However, in some cases the startups strategies are only partially described by the known pattern. Conclusion: The findings indicate that startup patterns can often be transferred from countries such as Switzerland and Finland to Uganda. we also found some variations from the known patterns in the contexts and solutions applied in Ugandan startups.

Background: Software measurement systems are used in large companies to provide developers with up-to-date feedback and metrics. Aim /Problem: However, the front-ends of these systems are often not ready to provide a real-time experience for the end-users, who sometimes have to wait minutes before visualizations are provided. Method: In this paper we compare four alternative technological setups for these front-ends that were created within a large international telecommunication provider. We use a publicly available dataset for a performance evaluation and to analyze the results. Results: Our results indicate that the choice of the visualization component has a larger impact on the performance than the choice of the data storage. However, performance is also impacted by the combination of storage and visualization tools used.

The Unified Modeling Language (UML) is widely taught in academia and has good acceptance in industry. However, there is not an ample dataset of UML diagrams publicly available. Our aim is to offer a dataset of UML files, together with meta-data of the software projects where the UML files belong to. Therefore, we have systematically mined over 12 million GitHub projects to find UML files in them. We present a semi-automated approach to collect UML stored in images, .xmi, and .uml files. We offer a dataset with over 93,000 UML diagrams from over 24,000 projects in GitHub.

Abstract The increasing flexibility in industry leads to an ecosystem of change, affecting the balance of processes and technology as well as the developers who have to cope with the change. Furthermore, the change itself might impact the ability to use quantitative methods to learn from previous experience. The goal of this study is to better understand the ecosystem of mutual impacts and changes of process and technologies as well as how developers perceive a technology setting and deal with its change. Therefore, we conducted a case study at Ericsson, performing a series of interviews among 6 employees (senior developers and architects). We identified a time line of changes that happened over 7 years. A set of observations about the relation between processes and tooling, and observations about developer's perceptions of the technology settings, and their strategy to deal with these changing technology settings. We discuss how the observed change impacts the ability to perform quantitative evaluations of technology and processes. The findings show that a bad choice of technologies can lead to unexpected impact on team dynamics. Furthermore, change happens so regular that it needs to be considered when collecting data for a quantitative evaluation of, eg, productivity.

Abstract In the last decades, process verification has been intensively addressed and has become an essential activity to correct and to remove errors before process execution. Typical process verification ecosystems propose to express properties to be verified on the process. A property expresses a desired behavior that must hold or not in the process execution. Processes during their lifespan are continuously adapted for several purposes: enriching, correcting, and refactoring the process. When a process is adapted, the existing properties must naturally be rechecked to ensure that no errors have been introduced, ie, the properties still hold. However, the properties may become outdated and must be coadapted w.r.t. the adapted process before to be rechecked. Otherwise, the verification may raise false alarms or may not detect newly introduced errors. In this paper, we propose a coadaptation approach of properties while considering process adaptation for the different dimensions, namely, control flow, object flow, resources, and timing. We systematically studied process changes in the multiple dimensions to identify those that do impact properties and for which we propose resolution strategies. Our preliminary evaluation shows that our resolutions strategies allow to support users in correctly coadapting impacted properties.

Modeling languages, just as all software artifacts, evolve. This poses the risk that legacy models of a company get lost, when they become incompatible with the new language version. To address this risk, a multitude of approaches for metamodel-model co-evolution were proposed in the last 10 years. However, the high number of solutions makes it difficult for practitioners to choose an appropriate approach. In this paper, we present a survey on 31 approaches to support metamodel-model co-evolution. We introduce a taxonomy of solution techniques and classify the existing approaches. To support researchers, we discuss the state of the art, in order to better identify open issues. Furthermore, we use the results to provide a decision support for practitioners, who aim to adopt solutions from research.

Context: To be more flexible, companies call more and more for an independence between development tools and processes. To enable this form of decoupling we need to understand the interrelation of processes and development tools. However, knowledge about that field is rare. Goal: The goal of this study is to better understand how technologies in use might impact the processes and team interaction. Method: Therefore, we conducted a case study at Ericsson using grounded theory, performing a series of interviews among 6 senior developers and architects. The investigated case is special in that alternative tooling/language settings are used to build the different parts of the same system. Results: As a result we identified several relations between process and tooling. We further report on additional observation about human factors involved in development. Conclusion: The findings show that a bad choice of technologies can lead to unexpected impacts on team dynamics.

Process verification has become an essential activity to correct and to remove errors before process execution. Typical process verification ecosystems propose to express properties to be verified on the process. When a process is adapted, the existing properties must naturally be re-checked to ensure that no errors have been introduced. However, the properties may become outdated and must be co-adapted w.r.t. the adapted process before to be re-checked. Otherwise, the verification may raise false alarms or may not detect newly introduced errors. In this paper, we propose a co-adaptation approach for control-flow process properties. We systematically studied control-flow process changes to identify those that do impact properties, and for which we propose resolution strategies. Our preliminary evaluation shows that our resolutions strategies allow to support users in correctly co-adapting impacted properties.

We present a case study of migrating a legacy language infrastructure and its codebase to a projectional language workbench. Our subject is the generator tool ADS used for generating COBOL code for critical software systems. We decompose the ADS language into smaller sub-languages, which we implement as individual DSLs in the projectional language workbench JetBrains Meta Programming System (MPS). Our focus is on ADS' preprocessor sub-language, used to realize static variability by conditionally including or parameterizing target code. The modularization of ADS supports future extensions and tailoring the language infrastructure to the needs of individual customers. We re-implement the generation process of target code as chained model-to-model and model-to-text transformations. For migrating existing ADS code, we implement an importer relying on a parser in order to create a model in MPS. We validate the approach using an ADS codebase for handling car registrations in the Netherlands. Our case study shows the feasibility and benefits (e.g., language extensibility and modern editors) of the migration, but also smaller caveats (e.g., small syntax adaptations, the necessity of import tools, and providing training to developers). Our experiences are useful for practitioners attempting a similar migration of legacy generators to a projectional language workbench.

Modeling languages evolve regularly. Companies need to maintain all those models that are used in running projects, which can cause these projects to fall back in their schedules. Since 10 years research addresses this issue with approaches for automating co-evolution. The dominant core of these approaches are model resolution strategies. They define 1) how models have to be changed in reaction to specific metamodel changes, 2) what degree of automation can be reached, and 3) to what extent the user can control the resolution outcome. In this paper, we survey existing co-evolution approaches and analyze model resolution strategies. We present a corpus of more than 200 resolution strategies for 116 types of metamodel changes and discuss degree of automation and choices that users have today.

Context: To compare the effectiveness of development techniques, the size of compared software systems needs to be taken into account. However, in industry new development techniques often come with changes in the applied programming languages. Goal: Our goal is to investigate how different size metrics and approximations are biased towards the languages c and c++. Further, we investigate whether triangulation of metrics has the potential to compensate for biases. Method: We identify crucial preconditions for a triangulation and investigate on 34 open source projects, whether a set of 16 size metrics fulfills these preconditions for the languages c and c++. Results: We identify how metrics differ in their biases and find that the preconditions for triangulation are fulfilled. Conclusion: Triangulation has the potential to address language biases, but high variance among metrics and tools need to be taken into account, too.

There is an increasing use of model-driven engineering (MDE) in the industry. Despite the existence of research proposals for MDE-specific processes, the question arises whether and how the processes that are already used within a company can be reused, when MDE is introduced. In this position paper we report on a systematic literature review on the question how standard processes, such as SCRUM or the V-Model XT, can be combined with MDE. We come up with the observation that - although it is in some cases possible to reuse standard processes - the combination with MDE can also result in heavyweight changes to a process. Our goal is to draw attention to two arising research needs: the need to collect systematic knowledge about the influence of MDE on software processes and the need to provide guidance for the tailoring of processes based on the set of used MDE techniques.

Teaching Requirements Engineering needs to be a realistic experience. Otherwise the students might not understand the repercussions of failing to gather requirements correctly. While simulated stakeholders are always a feasible option, only real stakeholders offer an authentic experience since only they are impacted by the system that is being specified. In this paper, we present our experiences of cooperating with the non-governmental organization (NGO) Wasserwacht. In a first requirements engineering course, nine graduate students elicited requirements by interviewing a dozen heterogeneous stakeholders. In a subsequent bachelor's project, four undergraduate students continued by implementing the software system based on these requirements. We discuss the authenticity of our requirements engineering setting, the influence of the collected requirements on the follow-up implementation project and how the Wasserwacht benefited from this cooperation.

There is a growing interest in software summarization and tools for automatically producing summaries. Discussions of relevant papers at recent conferences led to the observation that software summarization needs to consider migrating away from ``is this a good summary?" and towards ``is this a useful summary?" As a result, it has been suggested that to judge usefulness, one needs to view the summary through the lens of a particular task. A preliminary investigation of this suggestion was undertaken at the 2013 ICSE workshop NaturaLiSE. Initial results and lessons learned from this investigation support the notion that task plays a significant role and thus should be considered by researchers building and accessing automatic software summarization tools.

One of the multiple technical factors which affect changeability of software is model-driven engineering (MDE), where often several models and a multitude of manual as well as automated development activities have to be mastered to derive the final software product. The ability to change software with only reasonable costs, however, is of uppermost importance for the iterative and incremental development of software as well as agile development in general. Thus, the effective applicability of agile processes is influenced by the used MDE activities. However, there is currently no approach available to systematically detect and handle such risks to the changeability that result from the embedded MDE activities. In this paper we extend our beforehand-introduced process modeling approach by a notion of process pattern to capture typical situations that can be associated with risk or benefit with respect changeability. In addition, four candidates for the envisioned process patterns are presented in detail in the paper. Further, we developed strategies to handle changeability risks associated to these process patterns.

Model-Driven Engineering (MDE) mixes up manual activities, like coding or modeling, with automated activities, such as transformation or generation steps, which can lead to constraints on the development process. Currently, we know little about such constraints. For gaining more knowledge about this it is necessary to capture and compare MDE activities from practice to identify reoccurring structures that can be associated to constraints on the software development process. However, current techniques to capture MDE activities are not sufficient for comparison. Therefore, we developed a new approach to characterize activities based on relations between consumed and produced artifacts. Further, we evaluated this approach by applying it to activities from industrial case studies. Thereby, we found that our approach is applicable to capture complex industrial activities and that the identification of reoccurring structures is possible. These results enable future research about the influence of MDE activities on software development processes.

The loosely coupled nature of service-oriented architectures raises the question how information for access control can be managed in an efficient way. Several specifications for Web services exist to describe security requirements and to facilitate a provision of identity information. However, the integration of different standards regarding the expression of identity information in policies, claims and assertions comes along with an increased complexity. In order to identify and address the problems occurring with the combined use of standards as XACML, SAML and WS-Trust, we designed and implemented an architecture for identity- and attribute-based access control in decentralized environments. Our implementation provides an automated generation of access control policies in a format called XACML, a way to communicate required user attributes as claims across different domains based on the standards WS-Trust and WS-Policy, and a consistent mapping of retrieved attribute assertions to the XACML attributes in the access control policy.