A relational approach to defining and implementing transformations between metamodels

The Model-Driven Architecture initiative of the OMG promotes the idea of transformations in the context of mapping from platform independent to platform specific models. Additionally, the popularity of XML and the wide spread use of XSLT has raised the profile of model transformation as an important technique for computing. In fact, computing may well be moving to a new paradigm in which models are considered first class entities and transformations between them are a major function performed on those models. This paper proposes an approach to defining and implementing model transformations which uses metamodelling patterns to capture the essence of mathematical relations. It shows how these patterns can be used to define the relationship between two different metamodels. A goal of the approach is to enable complete specifications from which tools can be generated. The paper describes implementations of the examples, which have been partially generated from the definitions using a tool generation tool. A number of issues emerge which need to be solved in order to achieve the stated goal; these are discussed.     

Definitions and approaches to model quality in model-based software development – A review of literature

More attention is paid to the quality of models along with the growing importance of modelling in software development. We performed a systematic review of studies discussing model quality published since 2000 to identify what model quality means and how it can be improved. From forty studies covered in the review, six model quality goals were identified; i.e., correctness, completeness, consistency, comprehensibility, confinement and changeability. We further present six practices proposed for developing high-quality models together with examples of empirical evidence. The contributions of the article are identifying and classifying definitions of model quality and identifying gaps for future research.     

A model-driven approach for the derivation of architectural requirements of software product lines

The alignment of the software architecture and the functional requirements of a system is a demanding task because of the difficulty in tracing design elements to requirements. The four-step rule set (4SRS) is a unified modeling language (UML)-based model-driven method for single system development which provides support to the software architect in this task. This paper presents an evolution of the 4SRS method aimed at software product lines. In particular, we describe how to address the transformation of functional requirements (use cases) into component-based requirements for the product line architecture. The result is a UML-based model-driven method that can be applied in combination with metamodeling tools such as the eclipse modeling framework (EMF) to derive the architecture of software product lines. We present our approach in a practical way and illustrate it with an example. We also discuss how our proposals are related to the work of other authors.     

A connectionist approach to rule refinement

A novel approach to rule refinement based upon connectionism is presented. This approach is capable of performing rule deletion, rule addition, changing rule quality, and modification of rule strengths. The fundamental algorithm is referred to as the Consistent-Shift algorithm. Its basis for identifying incorrect connections is that incorrect connections will often undergo larger inconsistent weight shift that correct ones during training with correct samples. By properly adjusting the detection threshold, incorrect connections would be uncovered, which can then be deleted or modified. Deletion of incorrect connections and addition of correct connections then translate into various forms of rule refinement just mentioned. The viability of this approach is demonstrated empirically.     

Model-driven engineering: A survey supported by the unified conceptual model

During the last decade a new trend of approaches has emerged, which considers models not just documentation artefacts, but also central artefacts in the software engineering field, allowing the creation or automatic execution of software systems starting from those models. These proposals have been classified generically as Model-Driven Engineering (MDE) and share common concepts and terms that need to be abstracted, discussed and understood. This paper presents a survey on MDE based on a unified conceptual model that clearly identifies and relates these essential concepts, namely the concepts of system, model, metamodel, modeling language, transformations, software platform, and software product. In addition, this paper discusses the terminologies relating MDE, MDD, MDA and others. This survey is based on earlier work, however, contrary to those, it intends to give a simple, broader and integrated view of the essential concepts and respective terminology commonly involved in the MDE, answering to key questions such as: What is a model? What is the relation between a model and a metamodel? What are the key facets of a modeling language? How can I use models in the context of a software development process? What are the relations between models and source code artefacts and software platforms? and What are the relations between MDE, MDD, MDA and other MD approaches?     

Tool support for the rapid composition, analysis and implementation of reactive services

We present the integrated set of tools Arctis for the rapid development of reactive services. In our method, services are composed of collaborative building blocks that encapsulate behavioral patterns expressed as UML 2.0 collaborations and activities. Due to our underlying semantics in temporal logic, building blocks as well as their compositions can be transformed into formulas and model checked incrementally in order to guarantee that important system properties are kept. The process of model checking is fully automated. Error traces are presented to the users as easily understandable animations, so that no expertise in temporal logic is needed. In addition, the results of model checking are analyzed, so that in some cases automated diagnoses and fixes can be provided as well. The formal semantics also enables the correct, automatic synthesis of the activities to state machines which form the input of our code generators. Thus, the collaborative models can be fully automatically transformed into executable Java code. We present the development of a mobile treasure hunt system to exemplify the method and the tools.     

A model-driven approach to building modern Semantic Web-Based User Interfaces

The Semantic Web has widely spread in the last 10 years as a suitable web platform to support semantics and expressive information seeking. However, one of the main problems with this paradigm is still the representation and manipulation of ontologies as well as the complex relationships that they implicitly represent. Actually, this remains a challenge when unskilled users have to deal with this abstract representation in order to carry out daily solving-problem activities (e.g., designing web applications based on ontologies). This probably made the Semantic Web to decrease in popularity, also being commercially unsupported and overcame by recent technologies and services based on the Web 2.0, the emerging end-user-focused web concept. All in all, the specification of Model-Based User Interfaces fits very well to both paradigms. Accordingly, the aim of this work is to provide new ways of modeling user interfaces based on semantic models that better fit the domain problem. At the same time, we think of exploiting interactive features through current and modern end-user programming elements based on the Web 2.0, finally contributing to an architecture that supports higher interactive end-user interfaces on the web.     

Rule-based update transformations and their application to model refactorings

A rule-based update transformation is a model transformation where a single model is transformed in place. A model refactoring is a model transformation that improves the design described in the model. A refactoring should only affect a previously chosen subset of the original model. In this paper, we discuss how to define and execute model refactorings as rule-based transformations in the context of the UML and MOF standards. We also present an experimental tool to execute this kind of transformation.     

A refinement framework to support validation and maintenance of knowledge-based systems

In this article, we argue that a refinement tool capable of assisting the maintainer of a Knowledge-Based System (KBS) with updating and upgrading of its knowledge base can substantially expand the scope of his activities and prolong the life of the system. We show that refinement tasks involved in KBS maintenance are similar to those taking place at the development stage, and thus a uniform refinement framework can be designed to support both activities. After defining refinement tasks expected to take place at different stages of a KBS's life cycle, we present a refinement framework capable of supporting them. It utilizes a small number of domain-independent heuristics to search for possible rule revisions which are expected to eliminate errors detected during KBS validation. An extended example is given to illustrate how different refinement tasks are carried out.