David H. Akehurst

A Relational Approach to Defining Transformations in a Metamodel

Metamodelling is becoming a standard way of defining languages such as the UML. A language definition distinguishes between concrete syntax, abstract syntax and semantics domain. It is possible to define all three using a metamodelling approach, but it is less clear how to define the transformations between them. This paper proposes an approach which uses metamodelling patterns that capture the essence of mathematical relations. It shows how these patterns can be used to define both the relationship between concrete syntax and abstract syntax, and between abstract syntax and semantics domain, for a fragment of UML. A goal of the approach is to provide a complete specification of a language from which intelligent tools can be generated. The extent to which the approach meets this goal is discussed in the paper.

SiTra: simple transformations in Java

A number of different Model Transformation Frameworks (MTF) are being developed, each of them requiring a user to learn a different language and each possessing its own specific language peculiarities, even if they are based on the QVT standard. To write even a simple transformation, these MTFs require a large amount of learning time. We describe in this paper a minimal, Java based, library that can be used to support the implementation of many practical transformations. Use of this library enables simple transformations to be implemented simply, whilst still providing some support for more complex transformations.

Supporting viewpoint-oriented enterprise architecture

Increasingly, organisations establish what is called an enterprise architecture. The enterprise architecture combines and relates all architectures describing some aspect of the organization, such as the business process architecture, the information architecture, and the application architecture. It is a blueprint of the organisation, which serves as a starting point for analysis, design and decision making. Viewpoints define abstractions on the set of models representing the enterprise architecture, each aimed at a particular type of stakeholder and addressing a particular set of concerns. The use of viewpoints is widely advocated for managing the inherent complexity in enterprise architecture. Viewpoints can both be used to view certain aspects in isolation, and for relating two or more aspects. However, in order to make such a viewpoint-oriented approach practically feasible, architects require a tool environment, which supports the definition, generation, editing and management of architectural views. Moreover, such an environment should work in concert with existing domain-specific modelling tools. We present the design of such a tool environment for viewpoint-oriented enterprise architecture.

On Querying UML Data Models with OCL

UML is the de-facto standard language for Object-Oriented analysis and design of information systems. Persistent storage and extraction of data in such systems is supported by databases and query languages. UML sustains many aspects of software engineering; however, it does not provide explicit facility for writing queries. It is crucial for any such query language to have, at least, the expressive power of Relational Algebra, which serves as a benchmark for evaluating its expressiveness. The combination of UML and OCL can form queries with the required expressive power. However, certain extensions to OCL are essential if it is to be used effectively as a Query Language. The adoption of the ideas presented in this paper will enable query expressions to be written using OCL, that are elegant and ideally suited for use in conjunction with UML data models. This technique is illustrated by expressing the UML equivalent of an example Relational data model and associated query expressions.

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.

A Model-Driven Development Approach to Mapping UML State Diagrams to Synthesizable VHDL

With the continuing rise in the complexity of embedded systems, there is an emerging need for a higher level modeling environment that facilitates efficient handling of this complexity. The aim here is to produce such a high-level environment using model- driven development (MDD) techniques that map a high-level abstract description of an electronic embedded system into its low-level implementation details. The Unified Modeling Language (UML) is a high-level graphical-based language that is broad enough in scope to model embedded systems hardware circuits. The authors have developed a framework for deriving very high speed integrated circuit hardware description language (VHDL) code from UML state diagrams and defined a set of rules that enable automated generation of synthesizable VHDL code from UML specifications using MDD techniques. By adopting the techniques and tools described in this paper, the design and implementation of complex state-based systems is greatly simplified.

Implementing associations: UML 2.0 to Java 5

A significant current software engineering problem is the conceptual mismatch between the abstract concept of an association as found in modelling languages such as UML and the lower level expressive facilities available in object-oriented languages such as Java. This paper introduces some code generation patterns that aid the production of Java based implementations from UML models. The work is motivated by a project to construct model driven development tools in support of the construction of embedded systems. This involves the specification and implementation of a number of meta-models (or models of languages). Many current UML oriented tools provide code generation facilities, in particular the generation of object-oriented code from class diagrams. However, many of the more complex aspects of class diagrams, such as qualified associations are not supported. In addition, several concepts introduced in UML version 2.0 are also not supported.The aim of the work presented in this paper is to develop a number of code generation patterns that allow us to support the automatic generation of Java code from UML class diagrams that support these new and complex association concepts. These patterns significantly improve the code generation abilities of UML tools, providing a useful automation facility that bridges the gap between the concept of an association and lower level object-oriented programming languages.

OCL 2.0 - Implementing the Standard for Multiple Metamodels

OCL 2.0 is the newest version of the OMG’s constraint language to accompany their suit of Object Oriented modelling languages. The use of OCL as an accompanying constraint and query language to modelling with these languages is essential. As tools are built to support the modelling languages, it is also necessary to implement the OCL. This paper reports our experience of implementing OCL based on the latest version of the OMG’s OCL standard. We provide an ecient LALR grammar for parsing the language and describe an architecture that enables the language to be bridged to any OO modelling language. In addition we give feedback on problems and ambiguities discovered in the standard, with some suggested solutions.

Addressing computational viewpoint design

Distributed system design is a highly complicated and non-trivial task. The problem is the characterised by the need to design multi-threaded, multi-processor, and multimedia systems. Design frameworks such as open distributed processing (ODP), the ITU/ISO standard, define a number of viewpoints from which the design of a distributed system should be approached. To use the framework, a design language for each of these viewpoints must be defined. This paper defines a computational viewpoint language based on the Unified Modelling Language (UML) and Component Quality Modelling Language (CQML). The use of this approach to provide the ODP viewpoint languages enables standard UML tools to be used as part of an ODP compliant design process; and in addition, it will potentially enable the use of Meta Object Facility (MOF) based generation tools for constructing tool support for our language.

OCL: Modularising the Language.

ion / Binding