Yuehua Lin

DSMDiff: a differentiation tool for domain-specific models

Model differentiation techniques, which provide the capability to identify mappings and differences between models, are essential to many model development and management practices. There has been initial research toward model differentiation applied to Unified Modeling Language (UML) diagrams, but differentiation of domain-specific models has not been explored deeply in the modeling community. Traditional modeling practice using the UML relies on a single fixed general-purpose language (i.e., all UML diagrams conform to a single metamodel). In contrast, Domain-Specific Modeling (DSM) is an emerging model-driven paradigm in which multiple metamodels are used to define various modeling languages that represent the key concepts and abstractions for particular domains. Therefore, domain-specific models may conform to various metamodels, which requires model differentiation algorithms be metamodel-independent and able to apply to multiple domain-specific modeling languages. This paper presents metamodel-independent algorithms and associated tools for detecting mappings and differences between domain-specific models, with facilities for graphical visualization of the detected differences.

Generic and Domain-Specific Model Refactoring Using a Model Transformation Engine

Refactoring is an essential approach toward improving the internal structure of a software system while preserving its external behavior. Traditional refactoring techniques have focused on the implementation stage, with source code as the primary artifact of the refactoring process. However, a recent trend is to apply the concepts of refactoring to higher levels of abstraction. Consequently, model refactoring is emerging as a desirable means to improve design models using behavior-preserving transformations.

Automating change evolution in model-driven engineering

The escalating complexity of software and system models is making it difficult to rapidly explore the effects of a design decision. Automating such exploration with model transformation and aspect-oriented techniques can improve both productivity and model quality. The combination of model transformation and aspect weaving provides a powerful technology for rapidly transforming legacy systems from the high-level properties that models describe. Further, by applying aspect-oriented techniques and program transformation, small changes at the modeling level can trigger very large transformations at the source code level. Thus, model engineers can explore alternative configurations using an aspect weaver targeted for modeling tools and then use the models to generate program transformation rules for adapting legacy source code on a wide scale.

A Testing Framework for Model Transformations

As models and model transformations are elevated to first-class artifacts within the software development process, there is an increasing need to provide support for techniques and methodologies that are currently missing in modeling practice, but provided readily in other stages of the development lifecycle. Within a model transformation infrastructure, it is vital to provide foundational support for validation and verification of model transformations by investigating and constructing a testing framework focused at the modeling level, rather than source code at the implementation level. We present a framework for testing model transformations that is based on the concepts of model difference and mapping. This framework is integrated with an existing model transformation engine to provide facilities for construction of test cases, execution of test cases, comparison of the output model with the expected model, and visualization of test results. A case study in model transformation testing is presented to illustrate the feasibility of the framework.

Replicators: transformations to address model scalability

In Model Integrated Computing, it is desirable to evaluate different design alternatives as they relate to issues of scalability. A typical approach to address scalability is to create a base model that captures the key interactions of various components (i.e., the essential properties and connections among modeling entities). A collection of base models can be adorned with necessary information to characterize their replication. In current practice, replication is accomplished by scaling the base model manually. This is a time-consuming process that represents a source of error, especially when there are deep interactions between model components. As an alternative to the manual process, this paper presents the idea of a replicator, which is a model transformation that expands the number of elements from the base model and makes the correct connections among the generated modeling elements. The paper motivates the need for replicators through case studies taken from models supporting different domains.

Aspect mining from a modelling perspective

Aspect mining aims at identifying, analysing, and refactoring crosscutting concerns throughout a legacy system for the purpose of improving software modularisation. This paper presents our investigation into raising the benefits of aspect mining to high level domain-specific models. A key contribution is the capability to identify crosscutting concerns early in development, which will assist in the modularisation of a design through aspects, before proceeding to the implementation level. Furthermore, our experience has led us to believe that aspects are easier to identify at the modelling level, because much of the accidental complexities of implementation concerns are not present in the corresponding modelling abstractions.

WEAVING DEPLOYMENT ASPECTS INTO DOMAIN-SPECIFIC MODELS ⁄

Domain-specific models increase the level of abstraction used to develop large-scale component-based systems. Model-driven development (MDD) approaches (e.g., Model-Integrated Computing and Model-Driven Architecture) emphasize the use of models at all stages of system development. Decomposing problems using MDD approaches may result in a separation of the artifacts in a way that impedes comprehension. For example, a single concern (such as deployment of a distributed system) may crosscut different orthogonal activities (such as component specification, interaction, packaging and planning). To keep track of all entities associated with a component, and to ensure that the constraints for the system as a whole are not violated, a purely model-driven approach imposes extra effort, thereby negating some of the benefits of MDD. This paper provides three contributions to the study of applying aspect-oriented techniques to address the crosscutting challenges of model-driven component-based distributed systems development. First, we identify the sources of crosscutting concerns that typically arise in model-driven development of component-based systems. Second, we describe how aspect-oriented model weaving helps modularize these crosscutting concerns using model transformations. Third, we describe how we have applied model weaving using a tool called the Constraint-Specification Aspect Weaver (C-SAW) in the context of the Platform-Independent Component Modeling Language (PICML), which is a domain-specific modeling language for developing component-based systems. A case study of a joint-emergency response system is presented to express the challenges in modeling a typical distributed system. Our experience shows that model weaving is an effective and scalable technique for dealing with crosscutting aspects of component-based systems development.

Model-driven generative techniques for scalable performability analysis of distributed systems

The ever increasing societal demand for the timely availability of newer and feature-rich but highly dependable network-centric applications imposes the need for these applications to be constructed by the composition, assembly and deployment of off-the-shelf infrastructure and domain-specific services building blocks. Service oriented architecture (SOA) is an emerging paradigm to build applications in this manner by defining a choreography of loosely coupled building blocks. However, current research in SOA does not yet address the per for mobility (i.e., performance and dependability) challenges of these modern applications. Our research is developing novel mechanisms to address these challenges. We initially focus on the composition and configuration of the infrastructure hosting the individual services. We illustrate the use of domain-specific modeling languages and model weavers to model infrastructure composition using middleware building blocks, and to enhance these models with the desired performability attributes. We also demonstrate the use of generative tools that synthesize metadata from these models for performability validation using analytical, simulation and empirical benchmarking tools.

A model-driven approach to enforce crosscutting assertion checking

Design by Contract provides an effective principle to enable the construction of robust software by describing properties of a module using logical assertions. This paper presents a model-driven approach for weaving assertion checking aspects into a large software system. The approach is based on a technique called two-level aspect weaving. At the top level, crosscutting assertions are weaved into a model by use of a model weaver. The second step of the weaving process occurs when the Model-Driven Program Transformation technique is applied to perform large-scale adaptation of the underlying source code from the contracts specified in the high-level models. The paper briefly presents a case study to illustrate the concept.

Model replication: transformations to address model scalability

This paper presents a variation of the visitor pattern which allows programmers to write visitor-like code in a concise way. The Runabout is a library extension that adds a limited form of multi-dispatch to Java. While the Runabout is not as expressive as a general multiple dispatching facility, the Runabout can be significantly faster than existing implementations of multiple dispatch for Java, such as MultiJava. Unlike MultiJava, the Runabout does not require changes to the syntax and the compiler. This paper illustrates how to use the Runabout, details its implementation and provides benchmarks comparing its performance with other approaches. Furthermore, the effect of an automatic static program transformation tool that translates bytecode using the Runabout to equivalent bytecode is evaluated. The tool uses double dispatch and runtime-type checks to achieve the same semantics that the Runabout has. The performance comparisons on large benchmarks that make extensive use of multiple dispatch show that using the Runabout does not result in a significant loss of performance for realistic applications and that, depending on the application and platform, small performance gains are also possible. Copyright