EMF on Rails

Rosa L

opez-Landa

, Julieta Noguez

, Esther Guerra

and Juan de Lara

Computer Department, Tecnol

ogico de Monterrey, Mexico City Campus, Mexico City, Mexico

Computer Science Department, Universidad Aut

onoma de Madrid, Madrid, Spain

Keywords:

Model-driven Engineering, Spring Roo, Code Generation.

Abstract:

In this paper we propose leveraging existing frameworks for automated web application development, in the

style of Ruby on Rails, Grails and Spring Roo, for their use within a Model-Driven Engineering process. Our

approach automates the construction of domain-speciﬁc generators for web applications in particular domains.

These generators are able to synthesize web applications using Spring Roo, starting from annotated models.

In this way, designers of web applications do not need to be proﬁcient in web automation frameworks, but

they can beneﬁt from the use of domain-speciﬁc, intuitive models. We illustrate our approach by generating

an application to edit Eclipse Modelling Framework (EMF) models through the web.

1 INTRODUCTION

Web applications have become popular recently be-

cause, unlike standalone systems, they are distributed

and accessible to a large number of users. Struc-

turally, web applications are based on a client-server

architecture where clients make requests to one or

more service and resource providers. Rapid Applica-

tion Development (RAD) is a methodology that im-

proves the productivity of software development by

allowing the construction of new systems from ex-

isting components (Poulin, 1993). Reusing software

components eliminates the need of investing time and

effort in developing components that can be generated

automatically. This reduces development costs.

The rapid changes and the obvious results of the

globalization have forced web applications to adopt

new technologies, methodologies and approaches.

In this context, Model-Driven Engineering (MDE)

olter and Stahl, 2006) effectively helps in improv-

ing the overall maintenance of web applications and

promotes a better manageability of the technological

changes they may go through. MDE relies on model

abstractions of the applications rather than on imple-

mentation details. Developers are provided with cus-

tomized domain-speciﬁc languages, tailored to a spe-

ciﬁc concern, which promotes higher levels of pro-

ductivity. From these domain-speciﬁc models, the ﬁ-

nal application is generated, so that the developers do

not need to deal with low-level, accidental details of

the systems.

Recently, several frameworks for the automated

development of web applications have been pro-

posed, built on top of general-purpose languages like

Java (Spring Roo

), Ruby (Ruby on Rails

), Python

(Django

) and Groovy (Grails

). They accelerate web

development by using convention over conﬁguration

(i.e., using sensible defaults for every aspect of the ap-

plication), freeing the developer from repetitive tasks,

and by generating skeleton code from higher level

commands. However, they still require the developer

to be proﬁcient in the base language they are built

upon, and the different technologies used, in order to

complete the generated skeleton code.

To alleviate this situation, we propose leveraging

those powerful, but still low-level frameworks for its

use in combination with MDE. Our approach is to

use these frameworks (in particular Spring Roo) as

back-end for web application development. For this

purpose, we propose an MDE architecture that au-

tomates: (1) the model-based construction of code

generators for families of web applications, and (2)

the construction of web applications using the pre-

vious generators, starting from domain-speciﬁc mod-

els. The advantage of our approach is that it helps in

the construction of domain-speciﬁc code generators,

from which different web applications of a given do-

main can be easily generated from models. Instead,

http://www.springsource.org/spring-roo

http://rubyonrails.org

https://www.djangoproject.com

http://grails.org

273

López-Landa R., Noguez J., Guerra E. and de Lara J..

EMF on Rails.

DOI: 10.5220/0004123202730278

In Proceedings of the 7th International Conference on Software Paradigm Trends (ICSOFT-2012), pages 273-278

ISBN: 978-989-8565-19-8

 2012 SCITEPRESS (Science and Technology Publications, Lda.)

using web application frameworks like Spring Roo

eases the construction of one particular application,

but not families of applications for the same domain.

The rest of the paper is organized as follows. Sec-

tion 2 introduces MDE and Spring Roo. Next, sec-

tion 3 describes EMF on Rails, our MDE approach to

develop web applications. Section 4 presents a usage

example of this tool. In section 5, we discuss some

related work. Finally, section 6 concludes.

2 BACKGROUND

2.1 Model-driven Engineering

Model-Driven Engineering (MDE) is a software de-

velopment paradigm that promotes an active use of

models to conduct the different phases of software

projects. Hence, models are used to specify, anal-

yse, verify, test and generate code for the ﬁnal ap-

plications. In MDE, models are frequently built us-

ing Domain-Speciﬁc Languages (DSLs) that gather

abstractions and primitives of the domain. These

domain-speciﬁc models describe the systems from the

problem domain perspective, instead of focussing on

the technological solution space. The syntax of DSLs

is normally deﬁned through a model, called meta-

model, which describes the primitives, abstractions

and relations of the domain. The manipulation of

models, e.g., for simulation or optimization purposes,

is deﬁned using model transformation programming

languages. Moreover, DSLs are complemented with

code generators to produce most or all the code for

the ﬁnal application.

Similar to annotations for Java, models can be an-

notated with elements providing extra information,

conveying special semantics to particular elements.

Annotations are frequently used as a previous step to

code generation. They are deﬁned in so-called pro-

ﬁles, which can be seen as an extension mechanism

for models. Proﬁles have been widely used to an-

notate the UML language, and have been recently

proposed as an extension mechanism for DSLs as

well (Langer et al., 2011).

The Object Management Group (OMG) supports

a ﬂavour of MDE, called Model-Driven Architec-

ture (MDA) (Kleppe et al., 2003). MDA uses stan-

dards like the MetaObject Facility (MOF) for meta-

modelling, and the QVT (Query/View/Transforma-

tions) language (OMG, 2005) for model transfor-

mations. Widely used (partial) implementations of

the MOF exist, most notably the Eclipse Modeling

Framework (EMF) (Steinberg et al., 2008), which in-

deed is the de-facto standard meta-modelling frame-

work for MDE.

While EMF is very successful, there are currently

no widely adopted QVT implementations. Thus, in

this work, we use the Atlas Transformation Language

(ATL) (Jouault et al., 2008) as it is one of the most

popular transformation languages nowadays. ATL

is a rule-based declarative model transformation lan-

guage, where transformations are speciﬁed by map-

ping object patterns from the source model into pat-

terns of the target model.

2.2 Spring Roo

Spring Roo (Long, 2011; Rimple and Penchikala,

2012) is a Java productivity tool for building enter-

prise applications. This project provides a command-

line shell where special commands can be issued to

automatically create high quality web applications.

The importance of this project lies in its ability to fa-

cilitate the development of high quality web applica-

tions, based on a set of architecture patterns and best

practices, just in minutes.

The aim of Spring Roo is to improve Java devel-

oper productivity without compromising the integrity

or ﬂexibility of the solution (Spring Source Commu-

nity, 2012). Figure 1 depicts the Spring Roo ap-

proach, where developers type commands that shape

the web application (a). These commands are inter-

preted by the command-line shell (b) to produce a

Java web application (c) with a database (d). If there

are special requirements, such as securing the access

to the web application, developers need to use add-

ons. Spring Roo is based on a modular architecture

that supports the installation of third-party add-ons.

In this way, users can extend the capabilities of the

project (Spring Source Community, 2012). Each add-

on incorporates a set of commands and functions to

the shell of Spring Roo that allow building different

types of applications depending on the used modules.

If an application has special requirements for which

there is no add-on available, then developers must

create their own add-ons (e) and add their own com-

dǇƉĞ ƚŚĞ

ĐŽŵŵĂŶĚƐ

dǇƉĞ ƚŚĞ

ĐŽŵŵĂŶĚƐ

tĞď

ĂƉƉůŝĐĂƚŝŽŶ

tĞď

ĂƉƉůŝĐĂƚŝŽŶ

^ƉƌŝŶŐZŽŽ

ĐŽŵŵĂŶĚͲůŝŶĞƐŚĞůů

ĂƚĂďĂƐĞ

ĞǀĞůŽƉĞƌĞǀĞůŽƉĞƌ

ĞǀĞůŽƉ

ĂĚĚͲŽŶ

ĞǀĞůŽƉ

ĂĚĚͲŽŶ

ĂƚĂďĂƐĞ

Figure 1: Web application development with Spring Roo.

ICSOFT2012-7thInternationalConferenceonSoftwareParadigmTrends

274

Annotations

(Profile)

Add-on Model

Roo Add-on

(Skeleton)

Model

transformation

& code generation

Designer

of the

Customized

Web Generator

Meta-Model of

the Domain

Repository of

commands

Figure 2: Step 1: Building a customized web generator.

mands to the script of Spring Roo (f). Then, these

commands can be used to produce a web application

that takes into account the special requirements.

3 PROPOSED ARCHITECTURE

The aim of MDE is to develop software from mod-

els and model transformations, rather than by hand-

crafted code. Taking this into consideration, we pro-

pose EMF on Rails, an approach for web application

development that is integrated within the Spring Roo

project and the Eclipse Modeling Framework. In this

way, we consider the automated development of cus-

tomized environments and generators for families of

web applications (see Figure 2). Such generators are

then used to automatically generate web applications

for speciﬁc domains, as can be seen in Figure 4.

Figure 2 shows the envisioned architecture of our

proposal. In particular, the design of a customized

web generator comprises building a meta-model or

DSL of the domain (e.g., of an e-learning system), as

well as an add-on model with speciﬁc commands that

the code generation using Spring Roo will need. The

DSL (marked as (a) in the ﬁgure) will be used later

to build models from which the ﬁnal web application

will be generated. The add-on model (marked as (b)

in the ﬁgure) includes a description of the domain-

speciﬁc functionality (commands) used by the web

applications to be generated.

Figure 3 depicts the meta-model that permits

building add-on models. This is made of:

Addon. This class contains the metadata of the

Spring Roo add-on. It has a name which corre-

sponds to the add-on identiﬁer, the URI of the

Ecore meta-model of the domain that is being

used, and a set of commands.

Command. This class represents a command of the

Spring Roo shell. Each command has a name, a

category, a help message, an eObjectType and a

set of parameters. The name and the category de-

termine how the command will be typed on the

Figure 3: Meta-model for Spring Roo add-ons.

shell. The eObjectType stores the relationship be-

tween the command and an object from the meta-

model.

Param. This class represents a parameter of a com-

mand. Each parameter has a name, a type, a help

message and a boolean ﬂag to indicate if the pa-

rameter is required or not.

From the add-on model, we use an ATL transfor-

mation and a code generator to produce: a proﬁle that

will be used to automatically annotate the models de-

ﬁned by the user of the generator framework (see (c)

in Figure 2), and a set of Java classes with a skeleton

of the Roo add-on that will be used for code genera-

tion (see (d) in Figure 2). The generated Java classes

are skeletons that the designer needs to complete by

hand with the speciﬁc functionality. We foresee hav-

ing a repository of typical Roo commands that can be

reused when designing a new generative framework.

Such a repository is currently being developed.

Once the domain-speciﬁc generative framework is

built, it can be used to generate families of web appli-

cations within a particular domain, as Figure 4 shows.

The designer of the web application only needs to de-

scribe the application using a model, which is an in-

stance of the meta-model of the domain (see (a) in

Figure 4). Then, this model is automatically anno-

Roo Script

Final Application

User of

the Customized

Web Generator

Model of the Domain

User of

Web Application

Automatic

annotation

Automatic

code

generation

Spring Roo

generated

add-on

Annotated Model

Figure 4: Step 2: Using the customized web generator to

synthesize the ﬁnal web application.

EMFonRails

275

Figure 5: Add-on model of the EMF web editor. This model

is an instance of the meta-model shown in Figure 3.

tated using the proﬁle that was generated from the

add-on model (see (b) in the ﬁgure), and a Roo script

is subsequently generated based on these annotations

(see (c) in the ﬁgure). The Roo script utilizes the add-

on previously deﬁned, and is used to synthesize the

ﬁnal web application using Spring Roo (see step (d)

in the ﬁgure). The automatic annotation process and

the Spring Roo script generation are detailed on the

Model2Roo project (Castrej

on et al., 2011).

4 EXAMPLE

To test the EMF on Rails approach, we have devel-

oped an editor for building models through a web ap-

plication. The application allows the instantiation of

meta-models, as well as the serialization of models as

XMI ﬁles in the same way as it is done within Eclipse

using EMF. Additionally, the application stores mod-

els in a database, so that model objects can be easily

reused across different models. This has the advan-

tage that not only models, but also model fragments,

can be serialized into XMI ﬁles. Indeed, this func-

tionality goes beyond what is available in the standard

EMF model tree editor.

As explained in the previous section (Figure 2), to

develop this application we needed to deﬁne (a) the

meta-model of the domain and (b) the add-on model

of the EMF web editor. Step (a) was not necessary

in this case because we directly used the meta-meta-

model of EMF, so that the user of the customized web

generator can generate web applications from Ecore

meta-models (step (a) in Figure 4). For step (b), we

built an instance of the add-on meta-model shown in

Figure 3. Figure 5 shows this instance, which deﬁnes

(1) a command to generate the Java classes from an

Ecore meta-model; and (2) a command to serialize,

within the web application, instances of a meta-model

in XMI format.

Starting from the add-on model, we generated the

annotations proﬁle (see Figure 6) and the code skele-

tons of the two Spring Roo commands that make up

the add-on. Then, we added the code for the Java

classes of the Spring Roo add-on commands. With

these two steps, we were able to generate the cus-

tomized web generator for the family of web editors

Figure 6: Annotations from the EMF web editor.

for EMF models.

To test the web generator, we have developed

a meta-model for describing e-learning systems that

include an Intelligent Tutoring Systems (ITS) (Self,

1999; Devedzic and Harrer, 2005). This corresponds

to step (a) in Figure 4. Intelligent tutoring systems are

tools that incorporate artiﬁcial intelligence techniques

to help students gain knowledge during the teaching-

learning process. Figure 7 shows the most signiﬁcant

elements of our tutor, which is composed of learning

objects (such as lessons and tests) and Bayesian net-

works (Pearl, 1988; Jensen, 2001) to infer knowledge.

Once we had an initial version of the ITS meta-

model, it was automatically annotated using the anno-

tations generated previously. This step corresponds to

(b) in Figure 4. Finally, we executed the transforma-

tion that generates the Spring Roo script (step (c) in

Figure 4). The transformation transforms the annota-

tions into Spring Roo commands, including the com-

mands deﬁned in the EMF add-on model described

at the beginning of this section. Then, this script was

processed within the Spring Roo command-line shell

(step (d) in Figure 4) to produce the ﬁnal web appli-

cation shown in Figure 8. Altogether, each class of

Figure 7: Most signiﬁcant elements in the tutor model.

ICSOFT2012-7thInternationalConferenceonSoftwareParadigmTrends

276

Figure 8: Graphical user interface generated by Spring Roo.

the tutor model was transformed into an element of

the menu (1). Moreover, Spring Roo generated op-

erations to create (2), read (3), update (4) and delete

(5) objects. The layout of the generated web applica-

tion is the same for any application built with Spring

Roo. However, as a result of using the EMF add-on,

the generated web applications can generate XMI ﬁles

(6) from the data stored in the database.

Figure 9 shows an instance of the tutor meta-

model generated using the EMF web editor, which

comprises two learning objects. It can be seen that

our web editor is equivalent to use the EMF editor,

in the sense that both editors generate the same XMI

ﬁles. Nevertheless, with the database of the web ap-

plication generated with Spring Roo, users can easily

reuse object instances. Also, if the web application is

deployed on a web server (such as Tomcat, Glassﬁsh

or Jetty), users can edit it through mobile devices and

share model objects.

To summarise, once the generator is built, we can

use it to synthesize a customized web application for

any Ecore meta-model. It should be noted that the

generation of the web application from the tutor meta-

model shown in Figure 7 did not require any cod-

Figure 9: A tutor instance generated with the web editor and

shown through the EMF editor.

ing or developer intervention. Users of the generator

are only required to provide the model of the domain

(step (a) in Figure 4). In this way, EMF on Rails expe-

dites and facilitates the development of web applica-

tions providing signiﬁcant savings in time and effort

without requiring expertise in system development.

5 RELATED WORK

There has been a lot of supporting work for models

to source code transformations. Regarding web ap-

plication development, we can mention the work of

Hou et al (Hou et al., 2006), where a modelling ap-

proach for web applications models, based on UML

extensions, is proposed. We can also highlight the

work described by Abdella (Daissaoui, 2010) where

an approach based on the extension of UML class di-

agrams, and the use of the EMF framework to build

Java web applications, is proposed.

Several authors have proposed domain-speciﬁc

languages for web modelling, like WebML (Ceri

et al., 2000), WSDM (Troyer and Leune, 1998), OO-

METHOD (Pastor et al., 2001) or Labyrinth (D

ıaz

et al., 2001). Apart from the last proposal, the other

modelling languages include a dedicated language to

model the concepts of the domain, and follow model-

driven approaches to generate the ﬁnal application

from models describing different aspects of the ap-

plication, such as presentation and navigation.

Our work differs from the previous ones in that we

EMFonRails

277

support the automated construction of generators for

families of web applications, and not only single web

applications.

6 CONCLUSIONS

In this paper, we have proposed an approach that

combines MDE with automation frameworks for web

development like Spring Roo. Our approach auto-

mates the creation of code generators for families of

web applications. This enables the rapid generation

of domain-speciﬁc web applications from annotated

models by generating Spring Roo scripts. We have

illustrated our approach with the generation of a web

application for editing EMF models, thus enabling,

e.g., editing models through mobile devices. Simi-

larly we have shown that EMF on Rails provides sig-

niﬁcant savings in time and effort for web application

development.

EMF on Rails is currently in development. There-

fore, the future work includes (1) adding a command

library that facilitates the reuse of commands; (2) de-

veloping an add-on to propagate evidence and infer

knowledge in Bayesian networks; and (3) improving

the tutor model.

ACKNOWLEDGEMENTS

This work was supported by a grant provided by

CONACyT and Tecnol

ogico de Monterrey, Mexico

City Campus. This research is part of the project ”Dy-

namic Probabilistic Graphical Models and their Ap-

plications”, number 95185, funded by CONACyT and

the European Union through FONCICyT. This work

is also supported by the Spanish Ministry of Econ-

omy and Competitivity (TIN2011-24139) and the

R&D programme of the Madrid Region (S2009/TIC-

1650).

REFERENCES

Castrej

on, J. C., L

opez-Landa, R., and Lozano, R. (2011).

Model2Roo: A model driven approach for web ap-

plication development based on the Eclipse Modeling

Framework and Spring Roo. In CONIELECOMP’11,

pages 82 –87.

Ceri, S., Fraternali, P., and Bongio, A. (2000). Web model-

ing language (WebML): a modeling language for de-

signing web sites. Computer Networks, 33(1-6):137–

157.

Daissaoui, A. (2010). Applying the MDA approach for the

automatic generation of an MVC2 web application. In

RCIS’10, pages 681 – 688.

Devedzic, V. and Harrer, A. (2005). Software patterns in

ITS architectures. Int. J. Artif. Intell. Ed., 15(2):63 –

94.

ıaz, P., Aedo, I., and Panetsos, F. (2001). Modeling the

dynamic behavior of hypermedia applications. IEEE

Trans. Software Eng., 27(6):550–572.

Hou, J., Wan, J., and Yang, X. (2006). MDA-based model-

ing and transformation approach for web applications.

In ISDA’06, pages 867–874. IEEE CS.

Jensen, F. V. (2001). Bayesian Networks and Decision

Graphs. Springer-Verlag New York, Inc.

Jouault, F., Allilaire, F., B

ezivin, J., and Kurtev, I.

(2008). ATL: A model transformation tool.

Science of Computer Programming, 72(1-

2):31 – 39. See also http://www.emn.fr/z-

info/atlanmod/index.php/Main Page. Last accessed:

Nov. 2010.

Kleppe, A. G., Warmer, J., and Bast, W. (2003). MDA

Explained: The Model Driven Architecture: Practice

and Promise. Addison-Wesley Longman Publishing

Co., Inc.

Langer, P., Wieland, K., Wimmer, M., and Cabot, J. (2011).

From UML proﬁles to EMF proﬁles and beyond.

In TOOLS’11, volume 6705 of LNCS, pages 52–67.

Springer.

Long, J. (2011). Getting Started with Roo. O’Reilly.

OMG (2005). MOF QVT Final Adopted Speciﬁcation. Ob-

ject Modeling Group.

Pastor, O., G

omez, J., Insfr

an, E., and Pelechano, V. (2001).

The OO-method approach for information systems

modeling: from object-oriented conceptual modeling

to automated programming. Inf. Syst., 26(7):507–534.

Pearl, J. (1988). Probabilistic reasoning in intelligent sys-

tems: networks of plausible inference. Morgan Kauf-

mann Publishers Inc., San Mateo, California.

Poulin, J. S. (1993). Integrated support for software reuse

in computer-aided software engineering (case). SIG-

SOFT Softw. Eng. Notes, 18(4):75–82.

Rimple, K. and Penchikala, S. (2012). Spring Roo in Action.

Manning Publications.

Self, J. (1999). The deﬁning characteristics of intelligent

tutoring systems research: Itss care, precisely. Int. J.

Artif. Intell. Ed., 10:350 – 364.

Spring Source Community (2012). Spring roo project.

http://www.springsource.org/spring-roo/.

Steinberg, D., Budinsky, F., and Paternostro, M. (2008).

EMF: Eclipse Modeling Framework. The Eclipse Se-

ries. Addison-Wesley Professional, second edition.

Troyer, O. D. and Leune, C. J. (1998). WSDM: A user

centered design method for web sites. Computer Net-

works, 30(1-7):85–94.

olter, M. and Stahl, T. (2006). Model-driven software de-

velopment. Wiley.

ICSOFT2012-7thInternationalConferenceonSoftwareParadigmTrends

278