Guiding Software Design Evolution by Constraint Transformation

In model-driven software engineering, model transformation plays a key role to automatically generate and update models. Most traditional transformation approaches are batch like and the notion of change is only present in specialized solutions. There are many complex issues that need to be solved for model transformation to be incremental. For example, a common issue is the possible loss of manual changes to the generated models. The issue is even more severe with bidirectional transformations. Transformation generates a target model from a source model. In case of bidirectional transformation changes to the source model need to be transformed to the target model and, concurrently, changes to the target model need to be transformed back to the source model (concurrent model synchronizing), with many race condition problems. Furthermore, there are situations where a target model cannot be updated because of uncertainties: uncertainties as in there being no unique transformation result or uncertainties due to incomplete source model changes. Again, this problem is most severe in context of incremental transformation because changes to the source model may not be sufficient to infer precise changes to the target model, leading to missed opportunities for model transformation. This proposed work introduces constraint transformation to generate model constraints instead of models. The novel idea is that constraints, generated from source models, restrict target models and hence avoid the problem of manual information loss. Constraints can embody uncertainties and they can reduce common race-condition problems. Our proposed approach complements traditional model transformation. Traditional model transformation is most useful in situations where a model needs to be first generated (the initial version of a generated model). However, once generated, our proposed approach may be most suited in evolving them thereafter (analogous to co- evolution). The goal of this proposed work is to 1) research the methodology for incremental constraint transformation across arbitrary design models, 2) develop a proof-of-concept tool to demonstrate the approach, and 3) evaluate the methodology and tool on industrial models. We will publish the research results in major peer- reviewed journals and conferences; and pursuit its transition to industrial use. This proposal requests funding for two PhD students and one Master`s student plus their travel needs.

Today, the engineering of systems is unimaginable without software tools. Engineers use them to capture and analyze engineering problems; specify, implement, test, and maintain engineering solutions, and manage engineering processes. Obviously, these tools are quite distinct and engineers use them for different purposes and to capture different kinds of engineering artifacts (e.g., requirements, design or code). Herein lays a key challenge. How do engineers propagate artifacts from one tool to another (e.g., from a requirement specification to a design or from a design to code)? Model transformation is part of the answer to this challenge. In model-driven software engineering, model transformation is used to generate some target model out of a source model (e.g., code out of a design). However, it is problematic when engineers manipulate the source and target models concurrently as is normally the case and/or if there are multiple possible interpretations of a source model and hence multiple possible target models. This project developed constraint-driven modeling (CDM) where transformation is used to generate constraints on the target model rather than the target model itself. In doing so, CDM does not overwrite the target model (avoiding information loss during concurrent engineering) and enumerates multiple transformation options. This project successfully developed CDM and extensively published about it. Its usability is shown in context of several application domains.