Uml-Based Comparison of Model Transformational

¶ … UML-Based Comparison of Model

Transformational Tool

Tool Demo

This section demonstrates the Tool Demo that demonstrates the strategy to map model into code. The tools to generate code from models have become valuable tools to assist developers to maintain a consistency between model and implementation. The report presents the strategy to generate Java implementation code from the UML diagram. Major benefits derived from using UML (Unified Modeling Language) diagram is that it assists software developers to better design and manage a complex software systems. Thus, UML modeling tools is a strategy to support the generation of skeletal code either directly or through a standardized format. To use UML model to design and implement code, a developer could be able to manage code easily. This paper develops a code generation from the UML model, and the method demonstrates the strategy to generate model to code. The File Birdcage is a tool demo used to convert UML model into code.

UML Description

The File 3, ValidBirdcage is designed using the UML diagram. The design model uses the entity relational diagram to display different information. The file ValidBirdCage is a UML object model mapped in a relational diagram. The file satisfies the following conditions:

In the UMP mapping, each class is mapped into a table,

UML is constructed in a relational database,

"An instance of class represents a row in the table,"

"A many-to-many association is mapped into its own table." (Cremers, Alda, & Rho, 2009 P. 30).

To enhance greater understanding on implementation of a model to code, the study generates code using the following format:

First, the study generates the code of the following information in the design model after transformation:

Rio: Cocktools,

IhelpU: Veterinary Services

GormetSnacks; Nutrition

Java Code

public class Nutrition {

private String GormetSnacks;

public class VeterinaryServices {

private String IhelpU;

public class Cocktools {

private String Rio;

public class User {

protected String GormetSnacks;

public class GormetSnacks extends

User {

public class VeterinaryServices extends

User {

public class Cocktools extends User {

Chapter 4: Outline of Completed Thesis or Project

This chapter presents the outline of the completed thesis. Moreover, this chapter presents the findings of the chosen tools, their transformational procedures as well as various transformation outcomes.

4.1: Outline of the Completed Thesis

Introduction

The introduction of the thesis reveals the background of UML, based on the model transformation. The paper also describes the various tools used in the project, and the description provides the insight on the tools focused on the project. The thesis discusses the complex process encountered in the development and maintenance of web application, and the abstraction. Typically, the separation process provides the best technique to combat the software design problem and its complexity in the software design. (Harrison, Barton, & Raghavachari).

The chapter one also reveals that a model transformation has become an effective tool to design quality software that could be used to generate code. Typically, model is an effective tool that could be used to generate code. Model to code and code to model transformation could be considered model transformation since program could be considered as model. The thesis also discusses benefits of tracing in the transformation debugging which are generated automatically in the source, target or separate storages. However, the transformation requires more than two models to enhance effective system design.

The chapter one discusses various transformation approaches, which include hybrid approaches, graph-transformation-based, relational approach, and operational approach. Thus, model transformation assists a user to develop dynamic software. For example, tracing model assists in efficient debugging and effective applications of model transformation have been demonstrated in the airspace, military, mobile and automobile industry.

The chapter further discusses the model transformation tools that reveal various strategies to display the model transformation. The graphical model forms the primary strategy for the model mapping and the ATL is one of the graphical models using Eclipse Model-To-Model. On the other hand, Query View Transformation employs UML to define the needs of system development, which invokes a set of languages in form of metal models. The strategy is to transform the model to code. However, ATL has three rules that include lazy rules, matched rules and called rules. However, the thesis argues that modularity is an emerging area in the software development that describes way to express architecture and system requirements at a high abstraction level through models.

Chapter one of the theses develops the research objectives to enhance greater understanding of the objectives that the thesis attempts to achieve.

4.1: Reinstatement of the Project Objectives:

i. To identify various UML-based model transformation tools that have clear attributes.

ii. To investigate and analyze the operation of the UML-based model transformation tools in model transformation and elaborate their functionalities and usage.

iii. To establish the main functionality similarities and differences between the identified UML-based model transformation tools.

Background and Related works

The chapter 2 of the thesis reveals the UML-based model transformation and the development of various UML tools discussed in the project. The study reveals that model-driven engineering (MDE) aims to assist transformation designers with a set of operations dedicated for the models manipulation. From the discussion of the past studies, the UML-based model transformation tools are popular in software design and is able to support UML-UML transformation. The findings of the study reveals that model transformation tools should satisfy the following conditions:

The model transformation should be able to handle security issues, independently implementable, and specify internationalization degrees.

It should support incremental execution in a way that source model should transformed to target models immediately.

Meanwhile, the thesis presents Model-driven engineering (MDE) as a software development methodology focusing on the exploitation of domain models. The MDE assists a developer to maximize compatibility between systems, which is realized through the reuse of standardized models. Moreover, the MDE has been able to enhance effective communication systems among people working on the systems.

Thus, the study reveals various benefits that could be derived from the model applications.

First, models are the main artifact in the development of a specialized language. Through model transformation, developers have been able to develop specialized languages, which assist management to make effective decision-making.

Moreover, MDE assists in the development of code using the executable actions. Importantly, the MDE assists in the code generation, which ranges from the system skeletal to the complete product deployment. The thesis further discusses two types of model transformations, which include model to code transformations and model-to-model transformations. A quality software development is based on one or both of these models. Additionally, MDE improves the quality of software development process.

To enhance the greater understanding of the MDE application, the thesis discusses the features of a Unified Modeling Language (UML).

Unified Modeling Language (UML)

The project reveals that a UML is a language used in documenting, constructing and visualizing the element of software systems. The UML is a standardized tool that uses the graphical notation to model a software system, which enhances a visual presentation of the system. Although, UML is not a programming language, however, it is a standard system design that reveals the specification and visualization of a software system. Typically, the UML diagram enhances effective communication between a developer and stakeholders. Within the UML, the class diagram is used to reveal the method the attributes and the operation collaborate in the system design. The package diagrams in the UML reveals the strategy the large systems are broken down into a subsystem. On the other hand, sequence diagram reveals the dynamic collaboration object and their linkages with networks of object. Component diagram in its own case is used to dynamically link binary codes, source codes, libraries and executable codes. However, deployment diagram reveals the physical relationships between the software and the hardware components and diagram code modules represent and accurately show the package diagrams.

The project proceeds to reveal various benefits that UML delivers within the software environment. First, the UML is used for the object oriented software development and facilitate the elaborate development of object relational databases suitable for the business requirements. More importantly, the UML assists in modeling the computer application and provide diagram that could be used in understanding the development of software application. Moreover, UML assists a developer to develop high quality applications using an object oriented approach. This thesis argues that UML could work with many operating systems and it allows a developer to develop a bug-free application.

The project also discusses the taxonomy of model transformation, which assists in selecting the right transformation approach best suited for a developer's needs. For example, multiple target models assist in combining multiple source models and resulting into target model. Platform-specific models (PSM) and Platform-independent model (PIM) are the example of multiple target models.

The paper discusses the difference between endogenous transformation and exogenous transformation. The exogenous transformations use different languages while the endogenous transformation uses the same language in system design. The endogenous transformation generally involves migrating from one language to the other. On the other hand, vertical transformations are located in different abstraction, horizontal transformations make source, and target models feature in the same level of abstraction.

Generally, the classification of model transformation tools is based on whether it is declarative or operational, directionality or multiplicity.

The study further discusses the sub-categories of model transformation that include:

hybrid transformation tools, graph transformation, relational, template based, operational based, structure driven and direct manipulation.

All the sub-categories of model transformation have the following features:

Hybrid transformation combines two or more transformation approaches;

Graph transformation focuses on graph rewriting over variation and extensions of labeled graphs.

Relational approach uses declarative approach-based mathematical relations; template approach uses model template specifications.

ATL Transformation Tool

The project reveals that ATL is one of the effective transformation tools used to semantic or syntactic translation and it is built on transformation Virtual Machine model. The ATL was developed from the ATLAS framework, which enabled the specification of one or more target models. The project further reveals that ATL is hybrid language providing the mix of imperative and declarative constructs. While imperative is used to construct a complex mapping, however, the declarative is mostly used because it could be used to construct a simple mapping. ATL also supports major tasks during system design that include executing, debugging, editing and compiling.

Rational Rhapsody

The study provides the characteristics of Rational Rhapsody as UML based and use graphical model to generate software application. The system assists model checking, model verification, model execution and stimulation. A special benefit of Rational Rhapsody is that it assists in the code improvement and it enhances visual design environment for creating unified modeling language diagrams. Typically, Rational Rhapsody generates a complete application code from the state charts, activity diagrams, class diagrams and flow charts that supports UML 2.1.

YATL Transformation Tool

The findings of the project also reveal that YATL is a hybrid language used for the mixture of declarative and imperative design construction. Unlike other transformation tools, the YATL does not provide a graphical concrete syntax to assist in system design. However, YALT has a well-defined semantics with deterministic transformation rule used to deliver an efficient transformation. In YATL, the rule of UML profiling mechanism makes it to be a general-purpose language having an ease of use and intuitive clarity.

MOLA Tool Architecture

Based on the thesis results, the MOLA tools consist of two parts:

Transformation Development Environment (TDE)

Transformation Execution Environment (TEE)

However, MOLA widely use Java compiler version the API of Eclipse EMF used for a model transformation.

XSLT Transformation Tool

Analysis of related literatures reveals that XSLT Mapper assists in the data transformation used to create the contents of a map file. Typically, XSLT is a W3C standard language used to describe transformations between XML documents. XSLT also describe the rules to transform the source XML into a result XML.

UMLX Transformation Tool

The results of the project also reveal that UMLX Transformation Tool is used for the annotated Usage, Scan and Build transformation. The UMLX delivers the graphical transformation tool having a minor extension UML and it uses a standard UML class diagram to define information schemas and inter-schema transformations.

BOTL Transformation Tool

BOTL is a mathematical transformation tool that can easily be extended to specify transformations on a single model. Thus, BOLT is an object-oriented model that offers a UML-like notation in order to specify the rules comparable to graph transformations. Typically, BOTL is based on the formalization of UML class diagrams and serve as a protocol for the description of tool chains and model integration. Thus, BOTL is based on formal comprehensive graphical notation using UML-like notations.

VMT Tool.

The thesis further argues that VMT tool is visual declarative language that supports composition, specification, and reuse of model transformation rules. Typically, VMT tool delivers schema of rule to formulate graph transformation.

4.2: Results of the Chosen Tools

The methodology in the chapter 3 reveals the analysis of various transformation tools discussed in chapter 2. Analysis of all the various transformation tools identified reveals that all the tools are UML based. Based on the analysis of the transformation, it is revealed that it is only Rational Rhapsody tool that is able to deliver excellent operational requirements and able to satisfy all the transformational outcomes. Within a software development environment, standardization and quality of the transformation tools are critical for the acceptability of a transformation tool. Typically, transformation tool should possess theoretical properties such as completeness, correctness, and termination. Moreover, a transformation tool should be scalable to cope with complex and large project. The Rational Rhapsody transformation models possess essential features such as reusability, maintenance as well as having ability to perform a large operation.

Thus, the project discusses the operational procedure of the chosen tools, their operational procedures as well as their transformation outcomes.

Operational Procedure and Transformation Outcome of Rational Rhapsody

This section discusses the operational procedure and transformation outcome of Rational Rhapsody. A system architect, software developer and system engineer use Rational Rhapsody as an embedded and real timed system. Generally, Rational Rhapsody uses a visual design environment to create model systems using the Unified Modeling Language diagrams. Rational Rhapsody assists developers to develop a dynamic system using any of the four supported languages, which include Java, Ada, C, and C++.

The development process within the Rational Rhapsody assists a developer to create and test code accurately, and quickly. The operational procedure is implemented using the following procedures:

First, a developer or system engineer will need to download one of the following Rational Rhapsody product families.

Rational Rhapsody Architect for a Systems Engineer

Rational Rhapsody Designer for a Systems Engineer

Rational Rhapsody Architect for a Software Developer

Rational Rhapsody Developer.

When a developer decides to create a new project using Rational Rhapsody it is essential to follow following steps:

"Navigate to the Rational Rhapsody Samples directory in your installation to examine the official Rational Rhapsody sample models."

"Click Proceed in the Project Samples area of the Welcome screen."

"Click the Samples icon on the Welcome screen" (IBM 2009 P. 2).

One of the most important operational functions of the Rational Rhapsody is its ability to create Standard UML diagrams. Typically, Rational Rhapsody assists a system engineer, information architect and software engineer to create the following UML diagram in most development environment:

Activity diagram

Component diagram

Collaboration diagram

Deployment diagram

Flow chart

Object model diagram

Sequence diagram

Statechart

Structure diagram

Use case diagram

More importantly, Rational Rhapsody also assists in designing additional specialized diagrams that include:

Block definition diagram

Requirements diagram

Parametric diagram

Internal block diagram

To enhance greater understanding of the operation procedure of Rational Rhapsody, the study uses the strategy the Rational Rhapsody used to create activity diagrams:

In the Rational Rhapsody package, it is possible to stimulate the activity diagram to test the new features. For example, the package contains the sample of activity diagram in the following Rational Rhapsody installation folder:

"SamplesSystemSamplesActivitiesDiagramSimulation."

The activity diagram could be created automatically, stimulated and run as class activities.

Procedure

Start Rational Rhapsody software,

Navigate to the Packages, Use cases, blocks or Operations, to the activity diagram,

Right-click the component of the package, or operation to add the activity diagram to, select Add New > Diagrams > Activity Diagram,

Alternatively, click the Activity Diagram icon located at the top of the window.

The diagram below reveals the operations of the activity diagram discussed.

Fig: Activity Diagram

From: IBM (2009). Creating activity diagrams. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rhaphlp/v7r6/index.jsp?topic=%2Fcom.ibm.rhp.sysml.doc%2Ftopics%2Frhp_t_dev_creating_activity_dgrms_sysml.html

Results

Based on the above operation, the following result is automatically generated:

Fig: Result

From: IBM (2009). Java Tutorial for Rational Rhapsody. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rsdp/v1r0m0/topic/com.ibm.help.download.rhapsody.doc/pdf75/tutorialj.pdf

Apart from assisting system designer, system engineer, or information architect to create a dynamic UML diagram, Rational Rhapsody also assists in code generation. The study discusses the operational procedure in the code generation strategy using Rational Rhapsody.

Rational Rhapsody Java Code Generation

The study reveals the strategy to generate code from the Dishwater project.

To create a Dishwater project, it is essential to provide the analysis of the Dishwasher system.

Dishwasher System Analysis

The thesis attempts to answer the following questions through the analysis Dishwater:

Who are going to use the system?

How they are going to use it?

What are the more important actions of the system?

When do these actions going to occur?

What are the relationships, differences or similarities between the actions?

What are standard behaviors?

What are the actions that can go wrong?

Based on the questions specified above the following specified answers are considered:

The system actors or users would include "service and "user" person.

The system rinses, washes, and then dries dishes.

The "user" will load the dishes into the dishwasher. Then start the dishwasher, and finally remove dishes after they are washed.

The system might fail to rinse, wash, or dry the dishes and will require additional service.

Thus, three types of actors are identified:

System's users,

External components responsible to provide information to the system,

External components that are receiving information from the system

The next step is to create a Use Case Diagram for the dishwasher system revealing the interaction of the system with the external actors considering interacting with the Dishwater. The diagram below reveals the Use Case Diagram of the Dishwater.

Fig: Use Case Diagram for Dishwasher

From: IBM (2009). Java Tutorial for Rational Rhapsody. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rsdp/v1r0m0/topic/com.ibm.help.download.rhapsody.doc/pdf75/tutorialj.pdf

Creating a Statechart

Statecharts for Dishwater project defines the life cycle behaviors of reactive classes and include various states that cause transition between one another. The diagram below reveals the use case diagram for the Dishwater diagram.

Fig: Use Case Diagram for the Dishwater

From: IBM (2009). Java Tutorial for Rational Rhapsody. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rsdp/v1r0m0/topic/com.ibm.help.download.rhapsody.doc/pdf75/tutorialj.pdf

Object Model Diagram

Building the Object model diagram reveals the type of the objects in the system, and operations.

Creating Object model diagrams (OMDs)

The next step is to create the Object model diagrams that:

specify the attributes, the type of object in the system, operations belonging to those objects, the static relationship that could exist between types of classes and, the constraints that might apply.

From the OMD, the Rational Rhapsody generates code that translates OMD model into Java source code.

The diagram below reveals the Object model diagram for the Dishwater project.

Fig: Object Model Diagram for the Dishwater Project

From: IBM (2009). Java Tutorial for Rational Rhapsody. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rsdp/v1r0m0/topic/com.ibm.help.download.rhapsody.doc/pdf75/tutorialj.pdf

Generating Code

The code generator of the Rational Rhapsody translates the element of model into OMD source code. The Java code for the Dishwater project is presented in the figure below.

Fig: Java Code for the Dishwater Project

From: IBM (2009). Java Tutorial for Rational Rhapsody. IBM Corporation.USA. Retrieved February 20, 2013, from http://publib.boulder.ibm.com/infocenter/rsdp/v1r0m0/topic/com.ibm.help.download.rhapsody.doc/pdf75/tutorialj.pdf

Transformation outcome of Rational Rhapsody

The transformation outcome is the results of the model at the same and different level of abstraction. The transformation outcome is also based on the roles of the model in delivering a quality system design. This includes:

Easy of use

Ability to deliver program

Ability to implement a program in a logical choice.

However, the study uses the quality of transformation language to evaluate the transformation outcome of the Rational Rhapsody. The findings of the study reveal that Rational Rhapsody is the only transformation tools that satisfy all the requirements of the transformation tools, which include:

Requirements

Rational Rhapsody

Discussions

Commonly used language

Yes

Rhapsody was released 17 years ago in 1996 and since the period, it has a gained massive attention among software developers globally. Typically, Rhapsody has well established tool that delivers high usefulness for developers.

Inheritance

Yes

Rhapsody has ability to make a quicker new transformation as well as making changes relevant to many transformations.

Graphical notation

Yes

Rhapsody has ability to specify transformation Graphical. The model also uses UML-to-UML transformations to make graphical models. Typically, the graphical models deliver a higher-level view, which enhances the communication of the lexical counterpart.

Lexical notation

Yes

Rhapsody is also a language that could specify the transformation lexically. It has ability to handle complex graphical notations having a scalability problem.

Declarative

Yes

Rational Rhapsody is able to support statements that the transformation could do. The importance of declarative is that it does not operate on the computer system. Moreover, declarative does not allow a programmer to alter the value of a declaration and a variable. The features make the declarative language to be side-effect free and making errors in the written code to be reduced.

Bidirectional

Yes

Rational Rhapsody is able to support bio-directional language by supporting transformation in two-ways. The advantage is that bio-directional language is easier to maintain and specification is easier.

XML support

Yes

Rhapsody is also a XML support by providing a built-in support to produce or consume XML, which include ability to support general XML, attributes, elements, and namespaces.

This requirement is very important for the text-to-UML and UML to-text due to widespread usage of data formats and XML specifications.

Text-to-XML

Yes

With reference to Text-to-UML, Rational Rhapsody has ability to specify reverse-engineering, transformations from a code/text to UML models. Using this language, a graphical UML models could improve documentation and a model-driven setting.

UML-to-UML

Yes

Moreover, the Rational Rhapsody has ability to transfer transformations from a UML model into another UML model. The benefit derived from this feature is to transform platform independent models into platform-specific models.

UML-to-TEXT

Yes

With the UML-to-TEXT language, Rational Rhapsody has ability to specify transformations from a UML model to text format. The benefit derived from this feature is to achieve a code generation and use the feature for a documentation purpose.

UML tool Independence

Yes

Rational Rhapsody could use UML tool independence to support transformation of models into several UML tools. This requirement is desirable to derive a solution into a single UML tool.

No Proprietary Intermediate Structures

Yes

Rational Rhapsody has been able to use this feature to reduce a complexity for a transformation architect.

Traceability

Yes

Rational Rhapsody has ability to provide explicit traces on every target element. The feature assists a developer to understand the transformation, the source model and modification of the transformation to get better results from software system.

MOF-based / Metamodel

Yes

Rational Rhapsody uses MOF-based / Metamodel to get a better results on to the transformation specification. Using the Metamodel-based language, a developer could be able achieve a correct transformation as well as checking whether the metamodel follow the explicit transformation rule.

From: Gronmo, R. (2001). An empirical study of the UML model transformation tool

(UMT). SINTEF: Norway. Retrieved February 20, 2013, from http://heim.ifi.uio.no/~roygr/INTEROP-ESA-2005.pdf

Comparative analysis of all tools reveals that it is only Rational Rhapsody that could only deliver operational and transformational outcome be effective for developer. Oldevik, & Gronmo, (2003) argues that the quality of the transformation languages is critical in the producing effective and efficient software development.

The model requirements identified in the table above is desirable for a complete transformation tool. Typically, a transformation or information architect requires many technologies to succeed in model driven development. A developer requires good model to succeed in the design environment. While some transformation tools delivers a ready-made code generation templates that are difficult to customize, Rational Rhapsody an effective transformation that could assist software developers to customize codes based on developer's specifications.

Typically, the Rational Rhapsody assists developers to delivers a robust set of modeling to assists in deliver high quality code to meet stakeholder's requirements Typically, Rational Rhapsody assists in achieving:

Stimulation, model verification, and execution capabilities,

Static model checking that assists a developer to verify the completeness and consistence of models, the support for object based, functional, or object-oriented paradigms.

the integrated requirements modeling that assist a developer to design software that meets stakeholder's requirements.

the ability to integrate an external code within the modeling environment,

Domain-specific language to enhance support for AUTOSAR, graphical C, Modeling, Embedded (MARTE) systems, Analysis of Real-Time.

Automatic diagram creation that assists in visualizing the existing code. (IBM, 2009).

MOLA

Analysis of MOLA reveals that MOLA is a model transformation language using a simple procedural control structures. Typically, MOLA uses a graphical loop concept to achieve its designing function. Using a set of graphical editors, MOLA could support graphical diagram building system. Typically, MOLA has been used for some large scale project and one of the projects is the "6-th Framework IST project ReDSeeDS" used the MDA guidelines.

"Non-trivial transformations are used to obtain the initial version of Architecture model (in a rich subset of UML) from the Requirements model. Similarly, the Architecture model can be transformed to a Detailed Design model (an analogue to OMG PSM). The first versions of supporting MOLA transformations have already been built and tested in practice. Here the JGraLab repository is used, since some other tools in ReDSeeDS also use this repository." (Kalnins, Sostaks, Kalnina, et al. 2009 P. 4).

Despite the benefits derived from the operation of MOLA, the MOLA language is not a commonly used language because it well-known for academic purpose. Moreover, MOLA does not have an inheritance features that could be used to make a quicker new transformation. Moreover, MOLA does not possess other transformational requirements such as lexical notation, declarative features, bidirectional and XML support.

BOTL

BOTL uses a formal foundation, compressible, precise, and graphical notation to achieve a transformation objective. Analysis of BOTL reveals it is not a commonly used language. Typically, BOLT uses a mathematical foundation and graphical description techniques to achieve a set of mapping rules transformation mechanisms to deliver a transformation (Braun, & Marschall, 2003). However, the shortcoming of BOTL is that it is not commonly used language and it does not have an inheritance feature to make a quicker transformation. The table below reveals the operational ability and transformation outcomes of other transformation tools.

Chapter 5: Discussion

This chapter discusses the analysis of the tools in the comparative approach. The study also delivers the evaluation of the transformation tools. The evaluation process will involve analysis of the tools in a comparative approach. The evaluation process will enhance greater understanding of the strategy to improve on them for the business applications.

Analysis of the transformation tools discussed in this project reveals that they base their design methodology on Unified Modeling Language, which is a standard graphical notation and language to specify, visualize, document and construct the artifacts of software systems.

"The UML represents a collection of best engineering practices that have proven successful in the modeling of large and complex systems. The UML is a very important part of developing objects oriented software and the software development process. The UML uses mostly graphical notations to express the design of software projects." (Wang, 2005 P. 16).

The UML assists a developer to communicate, explore and validate a software architectural design. More important, UML provides an abstract language to describe a graphical notation of software systems. (Wang, 2005). Based on the importance of UML, the study evaluates each of the transformation tools to enhance greater understanding of their strengths and their weaknesses. Gronmo et al. (2005) uses different criteria in evaluating the language tools:

"Is it possible to identify a set of fairly objective and easily checkable requirements that measures the quality of a model-driven transformation tool"?

"Tool-dependant vs. language-dependant testing"

"Ease-of-use? Robustness? Pricing?" etc.

"Narrowed model scope in this study": (Gronmo et al. 2005 P. 2).

Based on evaluation of the language tools in the Table below, it is revealed that UMT provides a significant contribution to the development of language tools. The model transformation tools deliver benefits such as code generation, reverse engineering, and model-to-model. A transformation architect could use one of these tools to design a dynamic software system. Analysis of all the transformation tools discussed in this study reveals that Rational Rhapsody has high quality features compared to other transformation tools. In the present business environment, companies are increasingly demanding for an advanced software product that could deliver latest technology. More importantly, the increased in the design complexity, shrinking design cycles, and limited financial resources have created challenges in the design environment. The IBM Rational Rhapsody delivers a MDD (model-driven development) that could assist a developer to automate software development process as well as identifying designing error and defect in the development lifecycle. Unlike other transformation tool, the Rational Rhapsody assists software developer or system engineer to deliver innovative and high quality software design.

Typically, Rational Rhapsody has embedded features that deliver the following quality software environment:

Harmonizing software development and systems engineering with SysML and UML modeling,

Ability to generate Java, C, C++, and Ada applications as well as behavioral and architectural views,

Providing a model-level debugging via model execution that generates real-time sequence diagrams and highlights state charts during execution,

Includes a requirements traceability capabilities and a robust set of modeling to enhance effective software delivery system,

Integrating real time operating system as well as integration of industry-leading IDE.

(IBM, 2009).

Similarly, XSLT is a commonly used language similar to Rational Rhapsody. Typically, UMT is also generally written in XSLT since XSLT is a declarative language specialized in input in XML.

Similarly, UMLX uses a standard UML diagram to generate information schema, as well as using class diagram to define inter-schema transformation. Similar to Rational Rhapsody, UMLX has ability to generate Java or C++ code.

BOTL (Bi-directional Object oriented Transformation Language) Tool

Vendor and Version

ArgoUML4BOTL: BOLT is from Editor for BOTL Meta rules and models. BOLT also produces BOTLXML specifications.

Installation Procedure

The process of installation is to download the software from its home page: http://www4.in.tum.de/~marschal/botl/download.htm.

Run download jar file.

Main Features

BOTL is based upon a formal, precise, graphical and a comprehensible notation.

BOTL comes with techniques to allow a developer to verify whether a BOTL specification could be used to produce models conforming to a given meta model.

BOTL's specifications are bijective.

The prototypical model transformation of BOTL tool is based on ArgoUML.

Test and Evaluation

Category

The category of BOTL is as follows:

"BOTL is PIM to PSM Transformation Tool,"

"PIM to code Transformation Tool,"

"PSM to code Transformation Tool,"

Tunable Transformation Tool,

Transformation Definition Tool.

The following criteria deliver the transformation tools features of BOTL:

Self-containing: Many documents are available in BOTL and BOTL introduces concept in the documents.

Scalability: It is not possible for user to freely decide the dimension of the transformation.

Simplicity: Transformations are designed automatically for users.

Bi-directional mappings: Theoretically possible because the works on bijective is currently still under construction.

Ease of Adoption: the mechanisms rules for BOTL is well defined, could be used as transformation tool set in the other projects.

Rich Conditions: BOLT does not support View/Query/Transformation

Abstract syntax language: BOLT does not support abstract syntax for the transformation language.

Adopt common terminology: BOLT document is understandable because it is written in English.

Reuse and Support composition: BOLT does not support repository.

BOLT supports complex transformation scenarios.

Provide complete examples: BOLT provides many examples of class diagrams.

Robust transformation executions: A robust transformation executions is not yet supported

Tooling aspect: BOTL does not a tooling aspect.

Transformation Example

Input format: Botl file, XMI, Object Diagram (XMI), XML,

Output format: Botl file, XML, java file.

In the figure below, the XML is input into the Java code.

Gronmo, R. & Oldevik, K.(2005). An Empirical Study of the UML Model Transformation Tool (UMT). First International Conference on Interoperability of EnterpriseSoftware and Applications Retrieved February 20, 2013, from http://www.big.tuwien.ac.at/system/theses/61/papers.pdf?1298558494

Despite the benefits derived from the BOLT application, BOLT has some shortcomings. BOLT has not been able to fulfill the requirements defined within the MOF 2.0, QVT. Moreover, BOLT is still only concentrating on class diagrams in the Object oriented design. The input of BOLT is only in Java, and its XMI is still under construction.

On the other hand, ATL is a hybrid language, which is a mix of imperative and declarative constructions specially designed to express transformation model being required by the MDA approach. Similar to BOLT, and Rational Rhapsody, ATL employs the graphical notation to express the transformation rules. One central principle of ATL is that the transformation is modeled and treated as an input of transform engine. More importantly, ATL framework handles different technological space such as Java program, DBMS artifacts, XML documents etc. Similar to other transformation language such as BOLT and Rational Rhapsody, ETL also has a simplicity feature where ATL transformation could be made automatically for the user. However, ATL is not as scalable as Rational Rhapsody because a user could not freely decide the dimension of transformation. Similar to XLTS, and Rational Rhapsody, the ATL is very easy to adopt because it is well defined and could be used as transformation language tool for other project.

More importantly, the ATL posses a rich condition because ATL fully support View/Query Transformation. Similar to all transformation tools discussed in this project, ATL is written English and understandable. With reference to the tooling aspect, traceability is supported in ATL; however, the transformation execution is not yet supported in ATL engine. The weakness identified within the ATL transformation tool reveals that ATL is not a commonly used language compared to XSLT and Rational Rhapsody. Contrary to other transformation language such as MOLA, BOTL, VMT, UMLX and Rational Rhapsody, the ATL does not use the graphical notation to design a system. Moreover, ATL is not XML support, contrary to XSLT and Rational Rhapsody that are XML support. Unlike, Rational Rhapsody and XSLT, ATL is not yet a matured transformation language because it does not support many features such as

Text-to-UML

Traceability

XML

Declarative

Bidirectional

Despite the shortcomings identified within the ATL, the ATL still remains a very strong QVT-based transformation language because ATL tries to comply with the MOF/QVT (Queries /

Views / Transformation) OMG recommendation. The future of ATL will be in the industrial application.

Similar to Rational Rhapsody, XSLT is also a commonly used language. The XSLT has become a flexible and powerful language that assists developers to design quality software. The performances of XSLT depend on the XSLT processor and the code generation is increasingly common with XSLT. The XSLT processors use optimization technique to deliver effective and efficient results. More importantly, the XSLT stylesheet is affected by the XSLT code, which delivers big results during the implementation. Similar to Rational Rhapsody, XSTL has become a very popular language for a wide range of application. It is also commonly used to integrate back-end software. XSTL has ability to transform XML document into other XML document, HTML document or text document. The XSLT processor could operate on XML and it could work directly from a database as well as sharing XPath and XQuery. Similar to other transformation language such as YATL, VMT, and Rational Rhapsody, XSTL supports the lexical notation, Text-to-UML, UML-to-UML, UML-tool-Independence and declarative. Despite the benefits that developers could derive XSLT, the shortcomings of XSLT is that it does not use graphical notation for system design. Typically, this feature is a major shortcoming of the XSLT because graphical notation has become a powerful tool that enhances a visual presentation of a system before a developer generates code for system design. (Freire, & Fortes, 2005).

Despite the shortcomings identified within the XSLT, the XSLT has become a powerful transformation to produce a dynamic webpage. Web developers always use the features of XSLT to separate the layouts of a webpage to deliver multiple interfaces.

MOLA is a graphical transformation language similar to BOTL, UMLX and Rational Rhapsody. MOLA uses the traditional concept of transformation language to combine the imperative with the declarative style in the programming pattern. (Kalnina, Kalnins, Celms, et al. 2010). More importantly, MOLA has important features by supporting Text-to-UML, and UML-to-UML. However, MOLA is not as strong as the transformation tools such as Rational Rhapsody, and XSLT because the MOLA does not support many important applications such as Lexical notation, ML-to-TEXT, XML support, UML tool independence, Declarative, and Bidirectional. Typically, MOLA is not a commonly used language such as Rational Rhapsody and XSLT because MOLA does not support complex transformation scenario and does not support many dynamic application that could make it to be universally acceptable by developers.