What should HCI scholars consider when reporting and reviewing papers that involve LLM-integrated systems? We interview 18 authors of LLM-integrated system papers on their authoring and reviewing experiences. We find that norms of trust-building between authors and reviewers appear to be eroded by the uncertainty of LLM behavior and hyperbolic rhetoric surrounding AI. Authors perceive that reviewers apply uniquely skeptical and inconsistent standards towards papers that report LLM-integrated systems, and mitigate mistrust by adding technical evaluations, justifying usage, and de-emphasizing LLM presence. Authors’ views challenge blanket directives to report all prompts and use open models, arguing that prompt reporting is context-dependent and that proprietary model usage can be justified despite ethical concerns. Finally, some tensions in peer review appear to stem from clashes between the norms and values of HCI and ML/NLP communities, particularly around what constitutes a contribution and an appropriate level of technical rigor. Based on our findings and additional feedback from six expert HCI researchers, we present a set of considerations for authors, reviewers, and HCI communities around reporting and reviewing papers that involve LLM-integrated systems.

• Domain-specific version control system: DSMCompare • Domain-specific model merging • Curated labeled dataset for model merging • Comparative evaluation with EMFCompare and Git • User study validating DSMCompare Software developers often collaborate by contributing to different branches in a version control system. However, merging the changes from the different branches often leads to conflicts, and resolving these conflicts is a tedious task. This challenge is exacerbated when the software to merge are domain-specific models, since they follow a graph-like structure rather than linear text. DSMCompare is a tool for comparing domain-specific models, detecting differences, and visualizing conflicts using the concrete syntax of the domain-specific language. In this paper, we enhance DSMCompare with conflict resolution capabilities to reduce the effort of merging model versions. Our evaluation demonstrates that DSMCompare is effective in achieving highly accurate automatic conflict resolution with minimal manual intervention. A user study further validates the tool, revealing a significant decrease in resolution time coupled with higher accuracy and user satisfaction.

In model-driven engineering, the concrete syntax of a domain-specific modeling language (DSML) is fundamental as it constitutes the primary point of interaction between the user and the DSML. Nevertheless, the conventional one-size-fits-all approach to concrete syntax often undermines the effectiveness of DSMLs, as it fails to accommodate the diverse constraints and specific requirements inherent to diverse users and usage contexts. Such shortcomings can lead to a significant decline in the performance, usability, and efficiency of DSMLs. This vision paper proposes a conceptual framework to generate concrete syntax intelligently. Our framework considers multiple concerns of users and aims to align the concrete syntax with the context of the DSML usage. Additionally, we detail a baseline process to employ our framework in practice, leveraging large language models to expedite the generation of tailored concrete syntax. We illustrate the potential of our vision with two concrete examples and discuss the shortcomings and research challenges of current intelligent generation techniques.

Abstract Modelling is an important activity in software development and it is essential that students learn the relevant skills. Modelling relies on dedicated tools and these can be complex to install, configure, and use—distracting students from learning key modelling concepts and creating accidental complexity for teachers. To address these challenges, we believe that modelling tools specifically aimed at use in teaching are required. Based on discussions at a working session organised at MODELS 2023 and the results from an internationally shared questionnaire, we report on requirements for such modelling tools for teaching. We also present examples of existing modelling tools for teaching and how they address some of the requirements identified.

Real-time collaboration has become a prominent feature of nowadays' software engineering practices.Conflictfree replicated data types (CRDT) offer efficient mechanisms for implementing real-time collaborative environments.However, the lack of extensibility of CRDT limits their applicability.This is a particularly important problem in settings relying on complex, non-linear data types.In this paper, we report our results in augmenting primitive CRDT with extension mechanisms.We demonstrate our technique through an example from the realm of model-driven engineering, where graph types are prevalent.

To succeed with the development of modern software, organizations must have the agility to adapt faster to constantly evolving environments to deliver more reliable and optimized solutions that can be adapted to the needs and environments of their stakeholders including users, customers, business, development, and IT. However, stakeholders do not have sufficient automated support for global decision making, considering the increasing variability of the solution space, the frequent lack of explicit representation of its associated variability and decision points, and the uncertainty of the impact of decisions on stakeholders and the solution space. This leads to an ad-hoc decision making process that is slow, error-prone, and often favors local knowledge over global, organization-wide objectives. The Multi-Plane Models and Data (MP-MODA) framework explicitly represents and manages variability, impacts, and decision points. It enables automation and tool support in aid of a multi-criteria decision making process involving different stakeholders within a feedback-driven software development process where feedback cycles aim to reduce uncertainty. We present the conceptual structure of the framework, discuss its potential benefits, and enumerate key challenges related to tool supported automation and analysis within MP-MODA.

Current software engineering practices rely on highly heterogeneous and distributed teams working in a collaborative setting. Between 2013–2020, the publication output in the field of collaborative Model-Driven Software Engineering (MDSE) has significantly increased. However, the only systematic mapping study available is limited to studies published until 2015. In this paper, we provide an update on that study for the complementing 2016–2020 period, and report the latest results, challenges, and trends. Our analysis led to selecting 29 clusters of 54 new peer-reviewed publications on collaborative MDSE. Based on the novel developments in the field, we have extended and improved the original classification framework, making it applicable to recent and future research contributions on collaborative MDSE. The insights in this paper relate to the changing trends in the field and present new relevant information.

Statecharts are one of the most popular formalisms to model the behavior of reactive systems and are especially used in cyber-physical systems. Following common step-wise refinement strategies, modelers often develop and evolve Statecharts models incrementally to satisfy requirements and changes. Typically, modelers start with a more abstract model that satisfies important properties. They then refine the model gradually by introducing detail in steps that are guaranteed to preserve the important properties. The literature is rich with Statecharts refinement approaches, where the main concern is to preserve the behavior of the original model. However, they provide insufficient guarantees that the structure of the original model is preserved after refinement. This reduces the practicality of applying refinements: the structure of a Statecharts model encodes design decisions that developers must properly maintain.

A long shortcoming in the automatic generation of domain-specific modeling (DSM) editors has been the lack of user experience, in particular, user interaction adapted to its user. The current practice relies solely on the abstract and concrete syntax of the language, restricting the user interaction with the editor to a set of generic interactions built-in the tool. To increase the user experience with DSM editors, we propose to specify the different viewpoints of interactions (e.g., I/O devices, component of the interface, behavior of the editor) each modeled at the right level of abstraction for its user expert. The goal of this paper is to demonstrate the feasibility of the approach, by anchoring the operational semantics of all these viewpoints in a Statecharts model that controls the DSM editor. We report on the complex transformation that takes as input different viewpoints are expressed in at distinct levels of abstraction, to produce a custom interaction with the DSM editor based on a RETE algorithm. Our implementation shows that we can produce correct and responsive results by emulating existing DSM editors.

Like any other software artifact, models evolve and need to be versioned. In the last few years, dedicated support for model versioning has been proposed to improve the default text-based versioning that version control systems offer. However, there is still the need to comprehend model differences in terms of the semantics of the modeling language. For this purpose, we propose a comprehensive approach that considers both abstract and concrete syntax, to express model differences in terms of the domain-specific language (DSL) used and define domain-specific semantics for specific difference patterns. The approach is based on the automatic extension of the DSL to enable the representation of changes, on the definition of rules to capture recurrent domain-specific difference patterns, and on the automatic adaptation of the graphical concrete syntax to visualize the differences. We present a prototype tool support and discuss its application on versioned models created by third parties.

Models, like other first-class artifacts such as source code, are maintained and may be refactored to improve their quality and, consequently, one of the derived artifacts. Considering the size of the manipulated models, automatic support is necessary for refactoring tasks. When the refactoring rules are known, such a support is simply the implementation of these rules in editors. However, for less popular and proprietary modeling languages, refactoring rules are generally difficult to define. Nevertheless, their knowledge is often embedded in practical examples. In this paper, we propose an approach to recommend refactoring rules that we lean automatically from refactoring examples. The evaluation of our approach on three modeling languages shows that, in general, the learned rules are accurate.

A critical step in model-driven engineering (MDE) is the automatic synthesis of a textual artifact from models. This is a very useful model transformation to generate application code, to serialize the model in persistent storage, generate documentation or reports. Among the various model-to-text (M2T) paradigms, template-based code generation is the most popular in MDE. This is supported by over 70 different tools, whether they are model-based (e.g., Acceleo, EGL) or code-based (JET, Velocity). To help developers in their difficult choice of selecting the M2T tool, we compare the expressiveness power and performance of the nine most popular tools spanning the different technological approaches. We evaluate the expressiveness based on common metamodel patterns and evaluate the performance on a range of models that conform to a metamodel composed by the combination of these patterns. The results show that MDE-based tools are more expressive, but that code-based tools are more performant. Xtend2 offers the best compromise between the expressiveness and the performance.

As a contribution to the adoption of the Model-Driven Engineering (MDE) paradigm, the research community has proposed concrete model transformation solutions for the MDE infrastructure and for domain-specific problems. However, as the adoption increases and with the advent of the new initiatives for the creation of repositories, it is legitimate to question whether proposals for concrete transformation problems can be still considered as research contributions or if they respond to a practical/technical work. In this paper, we report on a systematic mapping study that aims at understanding the trends and characteristics of concrete model transformations published in the past decade. Our study shows that the number of papers with, as main contribution, a concrete transformation solution, is not as high as expected. This number increased to reach a peak in 2010 and is decreasing since then. Our results also include a characterization and an analysis of the published proposals following a rigorous classification scheme.

In model-driven engineering, stakeholders work on models in order to design, transform, simulate, and analyze systems. Complex systems typically involve many stakeholder groups working in a coordinated manner on different aspects of a system. Therefore, there is a need for collaborative platforms to allow modelers to work together. Previously, we introduced the cloud-based multi-user tool AToMPM, designed to address the challenges for building a collaborative platform for modeling. This paper presents on the multi-user, multi-view architecture of AToMPM and an initial evaluation of its performance and scalability.

Model-Driven Engineering (MDE) is a victim of its own success: being able to quickly generate software tools, many modeling tools exist today, but their usability is far from efficient. Complex processes and repetitive tasks are often required to perform a modeling activity, such as creating a domain-specific language or creating a domain-specific model. The goal of this paper is to increase the productivity of modelers in their every day activities by automating the tasks they perform in current MDE tools. We propose an MDE-based solution where the user defines a workflow that can be parametrized at run-time and executed. Our solution works for frameworks that support two level metamodeling as well as deep metamodeling. We implemented our solution in the MDE tool AtoMPM. We also performed a preliminary empirical evaluation of our approach and showed that we reduce both mechanical and cognitive efforts of the user.

Domain-specific modeling languages (DSMLs) are designed to model particular domains of interest using graphical, textual, or mixed syntax. Although most metamodeling tools offer an environment that automates several language development tasks, there is still a lack of support for aiding the domain expert to capture the requirements of a graphical DSML. We introduce the Syntax Map as an approach to address the challenges of graphical DSML requirements specification. It is designed to aid domain experts in describing a first-class graphical DSML requirement using a set of graphical notations. In addition, the Syntax Map can be used to generate a metamodel by means of model transformations. This short paper motivates the need for the Syntax Map, provides several brief examples, and discusses lessons learned in our investigation of this approach.

Domain-Specific Modeling Languages (DSMLs) have received recent interest due to their conciseness and rich expressiveness for modeling a specific domain. However, DSML adoption has several challenges because development of a new DSML requires both domain knowledge and language development expertise (e.g., defining abstract/concrete syntax and specifying semantics). Abstract syntax is generally defined in the form of a metamodel, with semantics associated to the metamodel. Thus, designing a metamodel is a core DSML development activity. Furthermore, DSMLs are often developed incrementally by iterating across complex language development tasks. An iterative and incremental approach is often preferred because the approach encourages end-user involvement to assist with verifying the DSML correctness and feedback on new requirements. However, if there is no tool support, iterative and incremental DSML development can be mundane and error-prone work. To resolve issues related to DSML development, we introduce a new approach to create DSMLs from a set of domain model examples provided by an end-user. The approach focuses on (1) the identification of concrete syntax, (2) inducing abstract syntax in the form of a metamodel, and (3) inferring static semantics from a set of domain model examples. In order to generate a DSML from user-supplied examples, our approach uses graph theory and metamodel design patterns.

Designing a high quality model transformation is critical, because it is the pivotal mechanism in many mission applications for evolving the intellectual design described by models. This paper proposes solution ideas to assist modelers in developing high quality transformation models. We propose to initiate a design pattern movement in the context of model transformation. The resulting catalog of patterns shall satisfy quality attributes identified beforehand. Verification and validation of these patterns allow us to assess whether the cataloged design patterns are sound and complete with respect to the quality criteria. This will lead to techniques and tools that can detect bad designs and propose alternatives based on well-thought design patterns during the development or maintenance of model transformation.