ADM tutorial
The last week we attended to the JISBD spanish conference, where we presented some of our work on MDD in the main spanish workshop about MDD and we also presented a tutorial about ADM in the JISBD conference.
ADM is the OMG’s initiative for software modernization. One of the main objectives of this initiative is to promote the interoperability between modernization tools, and for this purpose the OMG defines a set of standard metamodels. There are planned seven metamodels, although at the moment, only three of them are available: version 1.1 of Knowledge Discovering Metamodel (KDM) and beta versions of Abstract Syntax Tree Metamodel (ASTM) and Software Measurement Metamodel (SMM). The others are under development (Analysis Program, Visualization, Refactoring and Transformation).
ASTM and KDM complement each other in modeling the syntax and semantics of software systems. Whereas ASTM allows us to represent mainly the syntax of the source code by using abstract syntax trees (ASTs), KDM allows us to represent semantic information about a software system, ranging from source code to higher-level abstractions such as GUI events, platforms or business rules. On the other hand, SMM is a metamodel which allows us to represent both metrics and measurements. You can find more information about ADM and the metamodels in the ADM website.
We began to work on ADM in the end of 2008, we first used KDM for representing the source code. Although such metamodel is complete enough to represent the source code from a semantic level, it is very difficult to obtain KDM models directly from the code. It is necessary to use an intermediate representation to achieve the KDM world. Thus, we began to use ASTM and we defined an ADM-based process where ASTM models were first obtained and such models were then transformed into KDM models. At the end of 2009, we had defined a process where KDM models represent the source software system and we could use them to perform a reengineering or modernization process. The following figure illustrates such a process:
We used this ADM-based process in an Oracle Forms application migration scenario, which is a case study that is being developed in the Modelum research group. In this scenario, a code-to-model transformation is first defined to obtain ASTM models from the PL/SQL source code of the Oracle Forms application and then a model-to-model transformation is in charge of transform such ASTM models into KDM models. The c2m transformation is performed by using the Gra2MoL language, which I hope to tell something about it in this blog. On the other hand, the m2m transformation is performed by using the RubyTL language, which I suppose that Jesus Sánchez will tell about it in this blog too.
Once we have the KDM models, we can apply any modernization process. In our case, we used such models for calculating some metrics. The first version of this approach was published in the IEEE Software journal, where we used an own metric representation. We then used the SMM metamodel defined in the ADM initiative by building a SMM engine called Medea for executing SMM measure models and obtaining SMM measurement models. Moreover, since the SMM specification only defines the SMM abstract syntax, we defined a textual concrete syntax to facilitate the definition of SMM measure models. Thus, the obtained KDM model were input of the Medea engine, which generated a SMM measurement model. Finally, such measurement model was transformed into a CSV file to be visualized by applying a model-to-code transformation in Textplate. The complete process is illustrated in the following figure:
The tutorial which we presented in the JISBD conference was based on this experiencie. In the tutorial, we presented the main metamodels of the ADM initiative (KDM, ASTM and SMM) and a modernization process where the ADM metamodel are used. Finally, we commented the Oracle Forms case study described previously.
The content used in this tutorial can be downloaded from this website, where you can find both the presentation (in english and spanish) and the Eclipse projects used in the modernization process. You will also find a brochure which includes an example of each ADM metamodel. It is important to say that the Eclipse projects are actually two projects. The former obtains the KDM models and the latter takes the KDM models to calculate some metrics defined in SMM.
For further information, please, do not hesitate to contact us. It is quite difficult to summarize the motivation and content of the tutorial in just one post.
See you!
Starting post
Well, hello to everyone. Before starting to write about my problems and paranoias, I am going to introduce myself shortly. My name is Javier Canovas, I joined to Modelum in 2006 as hired and then I got a grant in 2007 to do my PhD. The PhD grants in Spain lasts four years, so I am in my third year and I have one more for finishing it.
My research area is focused on model-driven modernization. In 2006, we identified some work in this area when we colaborated with a company to build wrappers for PL/SQL automatically. In that moment, we realized the necessity of providing a DSL for extracting models from source code in software modernization and that was my first real research task.
The new language was called Gra2MoL (Grammar to Model language) and we are now using it for performing model harvesting in software modernization processes. One year ago, I created the ScheMoL language in collaboration with the Onekin research group, such language is intended to extract models from databases. Now, I am doing a predoctoral stay in Nantes, in the Atlanmod research team, and my main work in focused on the definition of a new DSL (also suffixed by “MoL” 
) for using in other modernizing contexts. As you can see, my research line is mainly focused on bridging different technical spaces to modelware.
I am also working on the ADM world (ASTM, KDM, SMM… metamodels) since they are directly related to my application domain. They offer a standard way for representing software system and we have defined a process for extracting KDM models. In such process, we first obtain ASTM models by using Gra2MoL and then these models are transformed into KDM models by using RubyTL.
For those reasons I am very fond of the “MoL” prefix. In almost three years I have created a set of sibling DSLs. They set up the “the MoL family”, which is specially aimed to brigde technical spaces. I suppose that they will be the main topic of my posts in this blog along with some dissertations about model-driven modernization. I will try to show some problems that I have to face, news about the tools and other ideas. I hope it was interesting to you.
See you!
Hello world!
Welcome to our new blog about model-driven development.
The blog has been born to post the advances and thoughts about our work. We are the Modelum team, a young research team which work on model-driven development. Our research lines are related to the main areas of model-driven development. We will try to discuss our problems and present our work here.
See you!