一种基于规则的模型转换方法*

尽管模型驱动开发(MDD)代表软件工程的发展方向,但是目前MDD还缺乏一套完整的转换规则描述方法和相应的实现机制,难以实现模型的自动转换。为此定义了一个平台独立模型到平台相关模型的转换框架,采用UML活动图说明模型转换的实现机制;基于OCL定义了转换规则的表示法,并结合UML模型到Java模型的转换给出了转换规则的定义。最后在一个具体的实例中验证了此方法的合理性和易用性。     

Leveraging UML Profiles to Generate Plugins From Visual Model Transformations

Model transformation is a fundamental technology in the MDA. Therefore, model transformations should be treated as first class entities, that is, models. One could use the metamodel of SDM, a graph based object transformation language, as the metamodel of such transformation models. However, there are two problems associated with this. First, SDM has a non-standardized metamodel, meaning a specific tool (Fujaba) would be needed to write transformation specifications. Secondly, due to assumptions of the code generator, the transformations could only be deployed on the Fujaba tool itself. In this paper, we describe how these issues have been overcome through the development of a template based code generator that translates instances of a UML profile for SDM to complete model transformation code that complies to the JMI standard. We have validated this approach by specifying a simple visual refactoring in one UML tool and deploying the generated plugin on another UML tool.     

Identifying refactoring opportunities in process model repositories

Context

In order to ensure high quality of a process model repository, refactoring operations can be applied to correct anti-patterns, such as overlap of process models, inconsistent labeling of activities and overly complex models. However, if a process model collection is created and maintained by different people over a longer period of time, manual detection of such refactoring opportunities becomes difficult, simply due to the number of processes in the repository. Consequently, there is a need for techniques to detect refactoring opportunities automatically.

Objective

This paper proposes a technique for automatically detecting refactoring opportunities.

Method

We developed the technique based on metrics that can be used to measure the consistency of activity labels as well as the extent to which processes overlap and the type of overlap that they have. We evaluated it, by applying it to two large process model repositories.

Results

The evaluation shows that the technique can be used to pinpoint the approximate location of three types of refactoring opportunities with high precision and recall and of one type of refactoring opportunity with high recall, but low precision.

Conclusion

We conclude that the technique presented in this paper can be used in practice to automatically detect a number of anti-patterns that can be corrected by refactoring.     

Modeling control in rule-based systems

The Comex modeling tool (control knowledge modeling and execution tool) focuses on modeling a problem-solving strategy and representing control knowledge, the knowledge of how to select among several problem-solving actions. In addition, Comex has facilities that let you execute early versions of the model to simulate the intended system's behavior and continuously execute the evolving model, until it becomes the real system. Comex addresses the rule-based paradigm's biggest shortcoming by adding control structures to executable models. Beginning with the specification phase, you can simulate a system's behavior, then map tasks to a rule base. The result is a structured, rule-based system built according to accepted software-engineering principles     

A Pattern-Matching Compiler

Implementation of a rule-based transformation engine consists of several tasks with various abstraction levels. We present a new tool called mtom for the efficient implementation of rule-based transformations. This engine should help to bridge the gap between rewriting implementations and practical applications. It aims at implementing well-identified parts of complex applications where the use of rewriting is natural or crucial. These parts are specified using rewrite rules and integrated with the rest of the application, which is kept in a classical imperative language such as C, C++ or Java. Our tool, which can be viewed as a Yacc-like pre-processor, does not depend on a given term representation, rather it accepts implementation of terms (or term like data-types) of yet existing applications and it permits to define and execute rewrite rules upon those types. From our experiences, this system is well-suited for industrial use as well as for implementations of rule-based languages. The paper introduces several features supported by mtom.     

一种模型重构冲突消解算法

冲突是研究模型重构中的一个重要问题,多数研究将该问题的重点放在冲突检测上,通过对已知冲突的分析,找出冲突消解的手工实现方式.为实现模型重构的自动过程而寻找自动消解冲突的方法是主要研究内容.根据冲突发生的条件将冲突分为3种类型:同一规则的并行使用产生的冲突、对称冲突、非对称冲突.该方法建立在手工分析这3类重构冲突消解的基础上,将重构规则预设为一个规则矩阵,对图转换系统中出现的重构规则进行扫描.扫描结果对照规则矩阵,判断冲突是同一规则还是不同规则的并行使用所产生;分别对这两种情况下的冲突所操作的对象进行分析,根据已有手工消解方法有针对性地进行消解操作.这一算法可以初步实现并行执行的3类冲突的自动消解.     

Modularization of model transformations through a phasing mechanism

In recent years a great effort has been devoted to understanding the nature of model transformations. As a result, several mechanisms to improve model transformation languages have been proposed. Phasing has been mentioned in some works as a rule scheduling or organization mechanism, but without any detail. In this paper, we present a phasing mechanism in the context of rule-based transformation languages. We explain the structure and the behavior of the mechanism, and how it can be integrated in a language. We also analyze how the mechanism promotes modularity, internal transformation composition and helps to solve usual transformation problems. Besides, we show several examples of application to illustrate the usefulness of the mechanism.     

软件重构中Visitor*设计模式和应用

对当前软件重构领域中的研究作了概括性介绍。对作为重构的主导思想和系统体系结构的总体转换方向的设计模式进行介绍，针对原有的Visitor设计模式在运行中操作调用频繁时资源消耗过大和运行效率降低的不足，在原模式基础上进行改良和优化，生成一种新的设计模式Visitor＊，并对其具体分析，通过操作函数的上移和accept方法的重定义，实现了操作定义由Element层到Visitor层的等价转化，大大节省资源和提高运行效率。最后运用Visitor^＊实现了一个面向对象设计过程中的重构，并结合一些重要概念对其进行具体分析。     

Automating feature model refactoring: A Model transformation approach

Context: Feature model is an appropriate and indispensable tool for modeling similarities and differences among products of the Software Product Line (SPL). It not only exposes the validity of the products’ configurations in an SPL but also changes in the course of time to support new requirements of the SPL. Modifications made on the feature model in the course of time raise a number of issues. Useless enlargements of the feature model, the existence of dead features, and violated constraints in the feature model are some of the key problems that make its maintenance difficult.Objective: The initial approach to dealing with the above-mentioned problems and improving maintainability of the feature model is refactoring. Refactoring modifies software artifacts in a way that their externally visible behavior does not change.Method: We introduce a method for defining refactoring rules and executing them on the feature model. We use the ATL model transformation language to define the refactoring rules. Moreover, we provide an Alloy model to check the feature model and the safety of the refactorings that are performed on it.Results: In this research, we propose a safe framework for refactoring a feature model. This framework enables users to perform automatic and semi-automatic refactoring on the feature model.Conclusions: Automated tool support for refactoring is a key issue for adopting approaches such as utilizing feature models and integrating them into the software development process of companies. In this work, we define some of the important refactoring rules on the feature model and provide tools that enable users to add new rules using the ATL M2M language. Our framework assesses the correctness of the refactorings using the Alloy language.