publications

2024

1. Journal-First: A flexible operation-based infrastructure for collaborative model-driven engineering

   Edvin Herac, Luciano Marchezan, Wesley Assunção , and 2 more authors

   In Modellierung 2024 , 2024
2. Using reactive links to propagate changes across engineering models

   Cosmina-Cristina Ratiu, Wesley KG Assunção, Edvin Herac , and 3 more authors

   In Software and Systems Modeling , 2024

   Abs

   Collaborative model-driven development is a de facto practice to create software-intensive systems in several domains (e.g., aerospace, automotive, and robotics). However, when multiple engineers work concurrently, keeping all model artifacts synchronized and consistent is difficult. This is even harder when the engineering process relies on a myriad of tools and domains (e.g., mechanic, electronic, and software). Existing work tries to solve this issue from different perspectives, such as using trace links between different artifacts or computing change propagation paths. However, these solutions mainly provide additional information to engineers, still requiring manual work for propagating changes. Yet, most modeling tools are limited regarding the traceability between different domains, while also lacking the efficiency and granularity required during the development of software-intensive systems. Motivated by these limitations, in this work, we present a solution based on what we call “reactive links”, which are highly granular trace links that propagate change between property values across models in different domains, managed in different tools. Differently from traditional “passive links”, reactive links automatically propagate changes when engineers modify models, assuring the synchronization and consistency of the artifacts. The feasibility, performance, and flexibility of our solution were evaluated in three practical scenarios, from two partner organizations. Our solution is able to resolve all cases in which change propagation among models were required. We observed a great improvement of efficiency when compared to the same propagation if done manually. The contribution of this work is to enhance the engineering of software-intensive systems by reducing the burden of manually keeping models synchronized and avoiding inconsistencies that potentially can originate from collaborative engineering in a variety of tool from different domains.

3. Exploring Dependencies Among Inconsistencies to Enhance the Consistency Maintenance of Models

   Luciano Marchezan, Wesley KG Assunção, Edvin Herac , and 2 more authors

   2024

   Abs

   Consistency maintenance is paramount for software engineering, as it improves/guarantees the quality of artifacts (e.g., models) during maintenance and evolution. To perform this maintenance, consistency rules (CR) are commonly defined and applied to evaluate model elements according to desired properties. By empirical studies, it is known that CRs commonly evaluate similar model elements (e.g., multiple CRs checking the consistency of a UML class). Thus, we hypothesize that CRs can be used as a means to identify dependencies among inconsis- tencies and support consistency maintenance tasks. Currently, however, no study investigates to what extent dependencies can be identified and how they can be used to repair inconsistencies. In this paper, we explore dependencies between CRs to identify and group dependent inconsistencies. For that, we define a metamodel that allows dependencies to be expressed. Further- more, we propose a consistency maintenance and dependency analysis mechanism that uses such a metamodel. Additionally, the approach generates repairs for the inconsistencies, considering the groups of dependencies to identify overlapping and conflicting repairs. To evaluate the approach, we conducted an empirical study with 48 UML models and 27 CRs. The results show that our approach identifies dependencies between inconsistencies (46% of the inconsistencies have dependencies), within a reasonable time, 10ms on average in the worst case. Results also show that dependent inconsistencies can be grouped and used together to identify repairs that are either overlapping (26% on average) or conflicting (58% on average).

4. Conflict-based Change Awareness for Collaborative Model-driven Software Engineering

   Edvin Herac, Wesley K. G. Assunção, Luciano Marchezan , and 2 more authors

   In Journal of Object Technology , 2024

   The 20th European Conference on Modelling Foundations and Applications (ECMFA 2024)

   Abs

   Collaborative Model-driven Software Engineering (CoMDSE) involves multiple engineers working together on modifying domain-specific models. This collaborative effort, however, can lead to conflicts during merges due to differing perspectives and goals among engineers. Solutions primarily focus on resolving conflicts during merges, but these approaches can be cumbersome and time-intensive. Thus, researchers also propose secondary strategies such as change awareness to notify engineers of each other’s model changes mitigating conflicts before they happen. Change awareness strategies, however, often overwhelm engineers with a bulk of change notifications, many of which are irrelevant to their immediate tasks. Additionally, they are required to manually analyze these notifications for conflicts, which adds significant overhead, leading to decreased productivity and increased frustration. Thus, in this paper, we propose a novel approach for conflict-based change awareness. It utilizes an incremental growing operation tree data structure to promptly detect potential conflicts after a model change. It specifically targets conflicts detectable through the analysis of changes in property-value based models, such as syntactic conflicts. The obtained results are utilized to filter corresponding change notifications, which are then sent to the engineers. This empowers engineers to proactively identify and address conflicts before merging their work. Moreover, by filtering out irrelevant or non-critical notifications, engineers can focus their attention on changes that are most relevant to their work, reducing cognitive overload and improving efficiency, as demonstrated by related work. With this approach, we aim to enhance collaboration and productivity in CoMDSE environments. We evaluate the completeness of our approach by applying it to a variety of conflict scenarios, as defined by the EMFCompare completeness tests. We also apply our approach in a feasibility CoMDSE scenario using Visio to test the conflict-based notifications. Lastly, we evaluate our approach’s performance evidencing that it can detect a large number of conflicts in a reasonable time as it detected almost 20K conflicts in less than 20 seconds.

2023

1. Fulfilling Industrial Needs for Consistency Among Engineering Artifacts

   Luciano Marchezan, Wesley K. G. Assunção, Edvin Herac , and 3 more authors

   In IEEE/ACM 45th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP) , 2023

   Abs

   Maintaining the consistency of engineering artifacts is a challenge faced by several engineering companies. This is more evident when the engineering artifacts are created using different tools and have different formats. This is the context of a company that builds agricultural machines, where components are developed using a decentralized iterative process. In this study, we present an approach developed in collaboration with an industry partner to address the issues and requirements of a real engineering scenario. These issues include the manual execution of consistency checking, without guidelines that formalize the activity. Furthermore, the industry partner aims at a flexible solution that can be applied without disrupting the current development process significantly. The proposed approach applies consistency rules (CR) defined to automatically detect and provide inconsistency feedback to engineers in real-time. The approach presented in this work also allows the customization of the CRs, giving flexibility to how the consistency checking is applied. The feasibility of our approach is demonstrated in such an industrial scenario, with a discussion about how the issues were addressed and the limitations of the current solution. We also perform a scalability evaluation showing that the approach can be applied in large systems (up to 21,061 elements) in a reasonable amount of time, taking less than 0.25 milliseconds to apply a CR, in the worst cases.

2. A flexible operation-based infrastructure for collaborative model-driven engineering

   Edvin Herac, Wesley K. G. Assunção, Luciano Marchezan , and 2 more authors

   In Journal of Object Technology , 2023

   The 19th European Conference on Modelling Foundations and Applications (ECMFA 2023)

   Abs

   Collaborative model-driven engineering infrastructures are used to concurrently deal with models from diverse engineering domains. However, studies within the industry have shown that existing infrastructures often offer insufficient collaborative support or do not incorporate features to handle multiple engineering domains, which leads to inefficient collab- oration and reduced team productivity. In this paper, we propose a flexible operation-based infrastructure for collaborative model-driven engineering that addresses these issues. The infrastructure supports lock-free collaboration within co-existing metamodels of different domains. It also allows engineers to arbitrarily push or pull changes of divergent versions and to deal with appearing conflicts. To achieve those functionalities, the infrastructure relies on operations that represent atomic changes on our simplified version of the Meta-Object Facility, such as creating and deleting new types, instances, or modifying properties. The infrastructure manages those operations within a tree-like structure that grows incrementally. Sequences of operations, going from the root to a leaf, represent different versions of a complete model history (including metamodels). Model versions can be merged by concatenating their corresponding branches and handling occurring conflicts. We evaluated the infrastructure by applying it in practical scenarios in collaboration with an industrial partner. These scenarios demonstrate the feasibility of our infrastructure by complying with our derived requirements for collaborative model-driven engineering infrastructures.

2022

1. Code smell analysis in cloned Java variants: the apo-games case study

   Luciano Marchezan, Wesley K. G. Assunção, Gabriela Michelon , and 2 more authors

   In Proceedings of the 26th ACM International Systems and Software Product Line Conference - Volume A , 2022

   Abs

   Families of software products are usually created using opportunistic reuse (clone-and-own) in which products are cloned and adapted to meet new requirements, user preferences, or non-functional properties. Opportunistic reuse brings short-term benefits, e.g., reduced time-to-market, whereas creating long-term drawbacks, e.g., the need of changing multiple variants for any maintenance and evolution activity. This situation is even worse when the individual products have poor design or implementation choices, the so-called code smells. Due to their harmfulness to software quality, code smells should be detected and removed as early as possible. In a family of software products, the same code smell must be identified and removed in all variants where it is are present. Identifying instances of similar code smells affecting different variants has not been investigated in the literature yet. This is the case of the Apo-Games family, which has the challenge of identifying the flaws in the design and implementation of cloned games. To address this challenge, we applied our inconsistency and repair approach to detect and suggest solutions for six types of code smells in 19 products of the Apo-games family. Our results show that a considerable number of smells were identified, most of them for the long parameter list and data class types. The number of the same smells identified in multiple variants ranged between 2.9 and 20.2 on average, showing that clone-and-own may lead to the replication of code smells in multiple products. Lastly, our approach was able to generate between 4.9 and 28.98 repair alternatives per smell on average.