Software Development Tools in Model-Driven ...

Download PDF
2 downloads 0 Views 385KB Size Report
Comment
Alexandra Corral. Departamento de Eléctrica y ...... [12] J. L. C. Izquierdo, J. Cabot, J. J. López-Fernández, J. S.. Cuadrado, E. Guerra, and J. De Lara, "Engaging ...
2017 2017 5th International Conference in Software Engineering Research and Innovation

Software Development Tools in Model-Driven Engineering Santiago P. Jácome-Guerrero

Juan M. Ferreira

Departamento de Eléctrica y Electrónica Universidad de las Fuerzas Armadas ESPE Sangolquí, Ecuador [email protected]

Facultad Politécnica Universidad Nacional de Asunción San Lorenzo, Paraguay [email protected]

Alexandra Corral Departamento de Eléctrica y Electrónica Universidad de las Fuerzas Armadas ESPE Sangolquí, Ecuador [email protected] obtain it are practically obsolete and do not reflect the changing reality of the software. MDE is a paradigm of software development that more closely connects the model to the application. In this way, the models not only encapsulate the design of the application, but are actively used to simulate, test, verify and generate the implementation of the system to build [2]. An MDE approach has to specify the modeling languages, the models, the translations between the models, the languages used for the effect, and the process used to coordinate the construction and evolution of the models. So, to ensure the benefits of using models to develop software requires the support of powerful tools [3]. Currently there are two MDE trends. The one through the use of the principles of Model-Driven Architecture (MDA) proposed by the OMG (Object Management Group) and the other through the use of DSLs that will be referenced in this article as MDE/DSL approach. There are several studies that point out the reasons why this technology is not used massively, among them: the lack of knowledge of its potential to self-qualify tasks in software development, the lack of knowledge about the existence and use of tools and the processes of development. In order to support the MDE initiative, this paper makes a categorization of the main tools that are used with this paradigm of software development. The article provides an overview of each of them, however, the URL is specified if a more detailed description is required. The process of developing a DSL to handle basic state machines is also described, using some of the tools pointed out. The rest of the article is organized as follows. Section 2 describes the use of MDE in the industry and the drawbacks of its use. Section 3 outlines the fundamentals of MDE/DSL. In section 4 an analysis of the technological space of MDE is realized, in which a categorization and

Abstract—Model-Driven Engineering (MDE) is a software development approach that considers the systematic use of models to develop software rather than using general purpose programming languages. The development of MDE based on Domain-Specific Languages (DSLs) covers two stages. The first, the creation of a set of artifacts such as DSLs, model transformation mechanisms, code generators. A second stage, where people do not necessarily with computer training using the artifacts created, develop applications simply because of the high level of abstraction allowed by technology. However, there are several obstacles that need to be overcome in order for this new approach to software development to be widely used. One of them, the lack of knowledge of tools and the development process with MDE. In order to minimize this problem, in the present work a categorization and description of the main environments and tools used in MDE are carried out. Using some of the tools analyzed also points out the process of creating a DSL. keywords-Model-Driven Engineering; software development tools, models; MDE; DSL

I.

INTRODUCTION

During software development, a large variety of models are used to represent different views of the architecture of a software system. You can have models to represent the constituent elements of a system such as data, processes, events and interfaces. You can choose to build models with a certain degree of freedom such as using boxes drawn by hand on paper [1] or with some degree of sophistication like using complex UML diagrams, produced with automatic modeling tool. Once the code of the computer system has been developed, the code is subjected to a continuous maintenance process and the models that were used to

0-7695-6342-2/17/31.00 ©2017 IEEE DOI 10.1109/CONISOFT.2017.00024

140

It is determined that to achieve the necessary conditions, it requires, among others: a stable and mature base, useful and robust tools, qualified professionals, and fundamentally that companies become aware of the benefits of the new technology. A number of actions are suggested for MDE to be adopted, including more research and development to overcome technical challenges, to include MDE in curricula of educational institutions, to develop technology transfer projects aimed at increasing knowledge in the industry to provide developers with a new approach to software development.

general description of some of the tools is defined. Section 5 shows an example of developing a DSL to handle state machines. Section 6 presents related work, and section 7 with conclusions and future work. II.

USE OF MDE IN THE INDUSRY

Following are several research papers that refer to the experience of using MDE in the industry. It also notes some of the work that has focused on the description of the technology and tools used. Kulkarni and Reddy [4] point out that the learning curve for adopting MDE in development is steep and that a high initial investment in the creation of the development environment is required. They consider these factors as the main impediment for software development with this approach to be employed in companies. Sánchez et al. [5] present the experience of technology transfer in two companies. They consider that although MDE is gaining more and more acceptance, its adoption in the industry is very limited. There are companies that have successfully applied MDE, but their use by industry remains an exception rather than the norm. The empirical research study carried out by Hutchinson et al. in [6] in a period of one year, determines the perception of MDE in the industry. They point out that there are many examples of success stories, but there are also many cases of failure. They consider that MDE has several benefits, mainly gain in productivity, portability, ease of maintenance and interoperability. But it also has several drawbacks, such as the cultural aspect of companies that are reluctant to change, in which it is considered that MDE is an approach that still has high risks of adoption due to people do not know the technology, the use of expensive tools, and the lack of a formal development process. Mohagheghi et al. in [7] notes that MDE is still at an early stage of adoption in industry, cites one case of success and one of failure. He believes that this paradigm must demonstrate its superiority over other paradigms of development based on the support of a rich ecosystem of stable, compatible and standardized tools. The study of the literature carried out by Mohagheghi and Dehlen [8] makes a compilation of evidence of the benefits and limitations of MDE in some companies. They consider that the MDE approach has promoted the premise that the software development with this paradigm increases productivity due to the automation of several of the work tasks, it increases the quality due to the reduction of errors mainly in the codification and it allows to handle the complexity of software development by raising the level of abstraction by handling specific domain models and languages. Whence, in Sánchez et al. [5] it is pointed out that the adoption of innovation (use of a new technology) is a process that takes time. Its use is not immediate, but covers a considerable period of time.

III.

MDE/DSL FUNDAMENTALS

When talking about software development with the MDE /DSL approach, two stages must be covered: the first is the creation of a set of MDE artifacts, mainly DSLs, model transformation mechanisms, code generators, and a second stage where people not necessarily with computer training can develop applications using MDE artifacts created in a quick and simple way, due to the high level of abstraction allowed by technology [9]. A model must be specified through a well-defined DSL with precise syntax and semantics. The abstract syntax is usually defined by a meta-model, the concrete syntax by means of a textual or graphic representation, while its semantics is related to what one wants to represent with the models. Abstract syntax defines the different elements of the language and the rules that establish how they can be combined. The concrete syntax defines how the elements of the language appear in a textual or graphical notation, usable by the people. Semantics defines the meaning of language. In Fig. 1, the structure of a DSL is shown. represent

Real world

subject to

Model

Transformation (M2T – M2M)

code in a programming language

DSL Meta-model (Abstract syntax )

Notation (Concrete syntax )

Figure 1. Structure of a DSL

A. Abstract syntax To define the abstract syntax of a DSL has two techniques: meta-modeling (Modelware) and grammars free of context (Grammarware) [10]. In the case of using grammars, BNF extensions (Backus-Naur Form) are used, whereas meta-modeling considers the development of a meta-model which in turn is a model that defines a language

141

are applied to high-level models that describe a system. A particular type of transformations is the M2T transformations, also known as "code generators". These languages usually share a number of common characteristics, such as: describing generation rules and templates, iterating over the model, incremental consistency when the generated code is modified. In essence, the model-based code generator interprets the model in the light of proper design decisions and architectural strategies to generate code on a specific technology platform [15].

to express models, i.e. the meta-model sets the structure of the model. Since a meta-model is also a model, a metamodel is a model of models. A model is according by its meta-model in the same way that a computer program is made up of the grammar of the programming language in which it is written. A meta-model is represented by a language called "meta-modeling language". To complete the specification of the models we use the Object Constraint Language (OCL) [11].

B. Concret syntax Once the abstract syntax is generally expressed in a class diagram, the specific syntax of the DSL has to be established, the concrete syntax performs a representation of the abstract syntax (meta-model), either graphically (e.g. an electronic circuit), textual (e.g. an SQL query), or a combination of both. Graphic or textual editors are constructed from the meta-model. It is advisable to use textual and graphic elements with which the end users are familiar [12]. In the case of constructing a graphic editor, it is usual for the designer to define a series of models with information about: 1) the graphic elements that will be shown in the diagrams; 2) the editor's tool palette; and 3) the relationship between the two previous models and the starting metamodel.

IV.

MDE TECHNOLOGICAL SPACE

Table 1 shows the main development tools used in the MDE/DSL environment. There follows an overview of some of them (the more general considerations [2]). If an extension is required on a particular subject, the URL is specified. TABLE I. DEVELOPMENT TOOLS Development environment OMG Architecture Eclipse/EMF Architecture MetaCase/MetaEdit+ Microsoft DSL Tools Project TCS Proprietary Editors (Concrete syntax) Graphic editors GMF, EuGENia, Graphiti, Spray, Sirius, DiaGen, Microsoft DSL Tools, MetaEdit+, Devil, Concrete, AToM3 Textual editors

C. Transformtion of models Any MDE proposal involves working with several related models, which requires a lot of effort to address the complexity involved in the different tasks related to model management, such as refining, validating, refactoring, etc. In fact, one of the main challenges that must be addressed in order to enhance the role of models in software engineering is to automate such tasks in order to reduce the associated complexity, and the way to automate is nothing more than to develop transformations of models that support them. Tratt [13] Considers that a model transformation is a program that mutates one model into another, in other words, something like a compiler. Therefore, it can be understood to the transformation of models as the manipulation of models to cover different levels of abstraction of a software application [14]. Modelto-Model (M2M), Model-to-Text (M2T) transformations can be performed or in-place transformations that change a model, restructure or optimize it. Therefore, a source model and target model is required, the transformation is done based on the definition of transformation rules. For example, a class model can be transformed into a relational database with ODBC or JDBC access-level code [15].

Meta-modeling platform (Abstract syntax) MOF Ecore/OCL GOPRR Domain Model KM3 MetaDepth Transformation Code generation of models ATL, QVT, RubAcceleo, JET, yTL MOFScript, Xpand, Mof2Text

Xtext, EMFText, TCS

A. Development environments OMG meta-modeling Achitecture: UML is a visual modeling software language whose meta-model is defined with the meta-model language MOF (Meta Object Facility). Since MOF and UML share all the constructs related to class modeling, we organized the definition of the UML meta-model in two packages in order to reuse elements: InfraStructure and SuperStructure. The first package includes the Core package with all elements common to UML and MOF (classes, properties, references) along with another package that defines an extension mechanism called profiles. The second package, in addition to completing the specification related to the class model, defines other elements and UML notation. URL: http://www.omg.org/gettingstarted/what_is_uml.htm

D. Code generators The MDE paradigm allows the automation of software development through the application of transformations that 142

define a series of models with information regarding: 1) the graphic elements to be shown in the diagrams, 2) the editor's tool palette, and 3) the relationship between the two models And the starting meta-model. URL: https://www.eclipse.org/modeling/gmp/

Eclipse/EMF meta-modeling Architecture: Modeling Project is the name of the Eclipse project intended to support the construction of MDE tools and solutions. All these projects are articulated around EMF (Eclipse Modeling Framework) that provides the basic mechanisms to handle meta-models, that is, it implements a metamodeling architecture [2]. URL: https://eclipse. org/modeling/emf/

Graphiti: it is a tool that uses GEF and Eclipse Draw2D to create highly sophisticated editors. It supports EMF on the domain side. The diagrams are written by a meta-model (Ecore) independent of the platform and the diagram of data is separated from the domain data. The Graphiti API is strictly usercentric and the creation of visual editors is done in Java. Publishers built with the framework are equipped with a standardized Look & Feel (designed in conjunction with usability experts) leading to a more consistent user interface in Eclipse-based tools. URL: https://eclipse.org/graphiti/

B. Meta-modeling platforms MOF: it is a particular platform that includes the part intended for the modeling of classes, along with some facilities related to the support of the reflection and the handling of identifiers. Because it was understood that MOF was complicated and that in most cases was enough with a small part of what was offered the language EMOF (Essential MOF) was defined. URL: http://www.omg.org/mof/

Sirius: it is an Eclipse project that allows you to easily create your own graphic modeling workbeach by leveraging Eclipse modeling technologies, including EMF and GMF. Provides a generic workbeach for model-based engineering. It can be easily adapted to any specific needs based on viewpoint approaches and is supported by the ISO/IEC42010 standard, which specifies that the same information can be represented in a synchronized way in diagrams, tables and trees. Sirius relies on Acceleo, and other projects, to facilitate the establishment of relationships between model data and its graphical representation. URL: https://wiki. eclipse.org/Sirius

Ecore/OCL: it is a part of the meta-modeling architecture of EMF [16] which provides Eclipse to create environments and tools intended to apply MDE. Ecore was designed as a subset of MOF with the basic constructs to construct meta-models. It was understood that MOF was complicated and that in most cases was enough with a small part of what it offered. Ecore is a meta-model language that provides object-oriented concepts for the creation of metamodels: classes, attributes and references; excludes partnerships. In a meta-model it is sometimes necessary to include rules that determine when a model is well formed, this is achieved with OCL rules. URL: http://www.eclipse.org/modeling/mft/search/concepts /subtopic.html

D. Concrete syntax (textual editors) Xtext: it is a framework aimed at the creation of textual modeling languages. It associates a textual representation to the concepts and relations of language specified in the metamodel. It provides the mechanisms that allow the editing and manipulation of textual models. Being an EMF-based Eclipse plug-in, it allows text templates created with Xtext editors to be used by other Eclipse plug-ins. It includes a language for designing grammars and a broad API for defining the different aspects of DSL. It allows to automatically generate the necessary components to work with the DSL: parser, static analyzer, code formatter, code generator, etc. URL: https://eclipse.org/Xtext/

MetaDepth: it is the main feature of MetaDepth is its support for an arbitrary number of ontological meta-levels. This makes MetaDepth especially useful for defining multilevel languages. That is, instead of adhering to the typical three layer meta-modeling architecture (model/metamodel/meta-meta-model), designers can define any number of meta-modeling levels. An example is the relationship between objects and classes in UML. One can think of object diagrams as instances of class diagrams. Therefore the class (diagrams+objects=clabject) can be considered as a multi-level language, and can be defined in MetaDepth through a single meta-model [17]. URL: http://metadepth.org/

EMFText: it is an Eclipse plug-in that allows defining a textual syntax for an Ecore meta-model. Among its main features are that the generated code does not contain EMFText dependencies. The whole code is fully customizable, allows automatic generation of default syntax (HUNT and Java-like), allows full analysis of syntax to warn of potential problems. URL: http://www.emftext.org /index.php/EMFText

C. Concrete syntax (graphic editors) Eclipse Graphical Modeling Framework (GMF): it is an Eclipse plug-in that supports the development of graphical model editors from meta-models. In order to construct these editors, GMF requires that the designer

143

classes represented in the UML model, with the names of the packages, corresponding attributes methods. URL: https://projects.eclipse.org/projects/modeling.m2t.jet

TCS: Textual Concrete Syntax is a component of Eclipse/GMT that allows the specification of a textual syntax of a DSLs attaching syntactic information to metamodels. With TCS it is possible to perform a DSL sentence analysis (T2M and M2T). TCS offers an Eclipse editor that features syntax highlighting, a schema, and hyperlinks per each DSL syntax that is represented in the DSL. URL: http://wiki.eclipse.org/TCS

Xpand: it can generate code based on DSL models defined with Xtext. It is a statically typed template language with invocation of polymorphic templates, aspect oriented programming, functional extensions, validation of models, etc. URL: https://eclipse.org/ modeling/m2t/?project=xpand

E. Transformation of models ATL: Atlas Transformation Language is a hybrid model transformation language that implements the declarative and imperative paradigms [18]. Its authors recommend the use of the declarative style, since it allows to express in a simple way the existing relations between the elements of the source and target model, while the imperative constructions facilitate the codification of complex transformations. An ATL transformation is made up of rules that define how the elements of the target model/s are created and initialized from elements of the source model. URL: http://www.eclipse. org/atl/

V.

DEVELOPMENT OF A DSL

The following describes the process of creating a DSL for the handling of basic state machines. To do this first, the corresponding meta-model representing the abstract DSL syntax is designed, using the EMF/Ecore platform. Once the meta-model has been defined and tested, its specific syntax must be created, for which a textual editor is developed using Xtext and a graphical editor using Sirius. Finally Acceleo is used to generate HTML code from a state machine model. A. DSL Requirements The state machine must allow to represent some types of states: initial state, final state, simple states, and compound states that can contain simple states; transitions that unite the different states, as well as the possibility of representing different resources that states can use.

QVT: OMG as creator of the MDA proposal in an attempt to unify the different proposals for the development of transformations, the end of 2008 was the standard for the same, Query/View/Transformations (QVT). This specification defines a family of languages for the definition of transformations: two end user languages (QVT Operational Mappings and QVT Relations), and a low level language that can be viewed as a byte-code of QVT (QVT Core). URL: http://www.omg.org/spec/QVT/

B. Abstrac syntax (meta-model) Based on the requirements established in the previous section, a meta-model is created that can be represented in different formats, such as class diagram (Fig. 2), XMI (XML Metadata Interchange), java code, tree-based. In this case the meta-model is represented Ecore. In order to design the meta-model, the Eclipse IDE is selected, within which the EMF framework is used. The process of designing the meta-model is as follows: 1) create an EMF project, for which Empty EMF Projec is selected, 2) give a name to the project, 3) in the model folder a Model Ecore, 4) put a name to the meta-model, 5) design the metamodel with the different constituent elements, such as EClass, EReferences, EAttributes, etc. To design the metamodel in graphical form you can use the Ecore Tools/Ecore Diagram utility.

F. Code generation lenguages Acceleo: it is an implementation of OMG's MOF-toText standard by Obeo, part of the Eclipse M2T project. It offers several advantages, among them: ease to carry out the process of code generation, high capacity of personalization, interoperability, management of the traceability. Acceleo uses the template mechanism for code generation (M2T transformation). The template is constructed to manipulate models that conform to a certain meta-model. The basic idea is to traverse the model by generating fixed text and leaving "holes" to be filled depending on the input model when the transformation is executed. URL: https://www.eclipse.org/acceleo/ JET: Java Emitter Templates is a tool to generate one or more output files from an input model using templates. In other words, it is part of a template (for example, the generic skeleton with the structure of a C++ class) and from the information contained in the input model of the transformation (for example a UML class model) Code of the C++

144

Figure 2. Meta-model represented as class diagrams

C. Concrete syntax (textual editor) To develop the programming language for representing state machines, Xtext was used because it offers a specific language for designing EBNF type grammars. The grammars are composed of a set of terminal and nonterminal rules. In addition, you can define syntactic predicates, hidden terminal symbols, and rules for enumerated values. Fig. 3 shows an extract of the grammar generated automatically by Xtext, which is derived from the metamodel (Fig. 2). The derivation of the grammar from the meta-model is established through the following rules: • • • • • •

Figure 3. Excerpt from the grammar of the language

Fig. 4 shows the textual editor that allows to write instructions in the new language of specific purpose. The source code of the program is registered in files with extension (*.statemachine).

From a meta-model package a new grammar is derived. From a class a rule of grammar is derived. Class attributes are derived from simple assignments of a rule. From a composition, multiple assignments are derived from a rule. From a class inheritance, a rule is derived with alternatives. In inheritance the de-factorization of attributes of the base class occurs on the subclass. Cardinality: exactly one: by default zero or one: ? zero or more: * one or more: +

Figure 4. Textual editor

D. Concreta syntax (graphic editor) Based on the meta-model of the state machine, we design the graphical form that will have each of the elements of the meta-model. Sirius was used because it allows the brief and simple specification of a modeling workbench in terms of "views" and that can take the form of graphical editors, tables or trees, with validation rules and actions using declarative descriptions. All the features and behaviors of the views can be easily configured with minimal technical knowledge. Fig. 5a shows the configuration environment of a view and Fig. 5b the environment for representing state machines graphically. It should be noted that each model of a state machine is an instance of the meta-model. Sirius uses AQL (Acceleo Query Language) as the recommended language (from Sirius 3.1) to access the elements of the meta-model (query execution). The process of creating a Sirius project considers the following activities: 1) creation a Viewpoint Specification Project, 2) specification a Viewpoint, 3) specification the type of representation (diagram, edition table, cross table, tree, sequence diagram), 3) mapping between the graphic elements of the diagram with the elements of the metamodel, 4) specification the actions to be performed when an

Assignment Operators simple : name = ID multiple: options += OPTION boolean: correct ? = 'Correct'

The process of creating an Xtext project considers the following activities: 1) creation an Xtext project from an existing meta-model, 2) specification the language name, 3) specification the name of the language extension , 4) modify the grammar created automatically if required, 5) create the Xtext artifacts from the grammar, 6) execute the MWE2 Workflow process, 7) use the textual editor to create programs with the new language of specific purpose .

145

event occurs, and 5) specification the elements of the editor toolbar (palette).

Figure 5a. Configuration of Viewpoint

Figure 6b. Template that generates code

Figure 5b. Graphic environment

E. Code generator In order to develop a code generator (M2T), Acceleo was used due to its ease of use and offers advantages such as high customization capacity, easy launch to generate a program in any programming language. Fig. 6a shows the configuration of the template to generate code from a model. Fig. 6b shows the generated HTML code. The process of creating an Acceleo project will consider the following activities: 1) creation of an Acceleo project, 2) selecting the meta-model from which to generate the project, 3) template configuration generates generate.mtl for take the data from a model (instantiation of the metamodel), 4) run an Acceleo application from the generate.mtl template, specify the input model and the location of the generated file (code source generated from the model).

Figure 6b. HTML code

VI.

RELATED WORK

The objective of the present work has been to present the foundations of the technology MDE, the main tools used, and the development process of a DSL as a key element of MDE, in a single document. Below are several papers that cover aspects of MDE independently. Muhanna and Pick in [19] focus on describing software development technology based on models, emphasizes thlevels of abstraction that is achieved with technology, explains what is a meta-model within a DSL and computa-

146

organize some of the possible elements. The research has made it possible to identify that there are several areas that in the future can be developed and improved in the MDE/DSL area, among them: the adoption of methodologies (formal software development processes) with this approach, the development of applications with artifacts MDE/DSL by the end user using software engineering criteria and usability principles.

tion tools that one has for its construction and administration. Kurtev et al. in [20] refers to the evolution of software engineering. It also presents a set of practices and a set of problems that could be solved with the MDE/DSL approach. In [21] Mernik et al. it shows how and when to develop domain-specific languages. Schmidt in [22] makes a description of the evolution of programming languages, always trying to raise the level of abstraction of its expression, that is, that its design is more adjusted to the solution space of the problem, as if it does MDE. In [23] Bézivin and Breton some advantages are presented of using the unification framework of model engineering to deal with the various facets of process engineering. Whittle et al. in [24] it is pointed out that one of the barriers to the adoption of (MDE) models is poor support of tools. Thus, the impact of the adoption of MDE tools and their use within a broader organizational context is analyzed. Den Haan [25] highlights “insufficient tools” as one of the eight reasons why MDE may fail. Staron [26] found that “technology maturity may not provide enough support for cost efficient adoption of MDE”. Kuhn et al. [27] identify five points of friction in MDE that introduce complexity; all relate to MDE tools. In a survey conducted by Tomassetti et al. [28] revealed that 30% of respondents see MDE tools as a barrier to adoption. It can be considered that the MDE tools play an important role in the adoption of MDE, however Hutchinson et al. in [29] it is considered that the barriers can also be social or organizational rather than purely technical or related to tools.

REFERENCES [1]

[2]

[3]

[4]

[5]

[6]

VII. CONCLUSIONS AND FUTURE WORK The development of software since its inception has been evolving, trying to make it increasingly easy and quick to generate applications. For some years now several proposals have appeared, one of them MDE, which deals with these models are represented with DSLs also called "modeling languages", a meta-model is used to formally represent a DSL, and that automation is normally achieved through the translation of models to code through model transformations. Despite the benefits of MDE as support for software development support, the efforts of a large community of researchers and some software development companies that drive this approach, there is still a long way to go before Possible users of this technology have enough confidence to start using it massively. For this reason and wanting to contribute with a grain of sand to this new software development initiative, this support and assistance guide was developed for people interested in adopting this approach to software development. There are many investigations in the area, each dealing with a particular topic, so somehow this work managed to

[7]

[8]

[9]

[10]

[11]

147

P. Mohagheghi and V. Dehlen, "A metamodel for specifying quality models in model-driven engineering," in Proc. The Nordic Workshop on Model Driven Engineering, 2008, pp. 51-65. J. García, F. García, V. Pelechano, A. Vallecillo, J. Vara, and C. Vicente-Chicote, Desarrollo de Software Dirigido por Modelos: Conceptos, Métodos y Herramientas, 1st ed., Ra-Ma, 2013, pp. 10-50. S. Kent, "Model driven engineering," in International Conference on Integrated Formal Methods, 2002, pp. 286298. V. Kulkarni and S. Reddy, "Model-driven development of enterprise applications," in International Conference on the Unified Modeling Language, 2004, pp. 118-128. J. S. Cuadrado, J. L. C. Izquierdo, and J. G. Molina, "Applying model-driven engineering in small software enterprises," Science of Computer Programming, vol. 89, pp. 176-198, 2014. J. Hutchinson, J. Whittle, M. Rouncefield, and S. Kristoffersen, "Empirical assessment of MDE in industry," in Software Engineering (ICSE), 2011 33rd International Conference on, 2011, pp. 471-480. P. Mohagheghi, M. A. Fernandez, J. A. Martell, M. Fritzsche, and W. Gilani, "MDE adoption in industry: challenges and success criteria," in International Conference on Model Driven Engineering Languages and Systems, 2008, pp. 54-59. P. Mohagheghi and V. Dehlen, "Where is the proof?-A review of experiences from applying MDE in industry," in European Conference on Model Driven ArchitectureFoundations and Applications, 2008, pp. 432-443. S. Jácome Guerrero, "Descripción de las actividades de una propuesta de Metodología de Desarrollo de Software Dirigida por Modelos", Master's thesis. Universidad Autónoma de Madris, 2013. M. Wimmer and G. Kramler, "Bridging grammarware and modelware," in International Conference on Model Driven Engineering Languages and Systems, 2005, pp. 159-168. M. Richters and M. Gogolla, "On formalizing the UML object constraint language OCL," in International Conference on Conceptual Modeling, 1998, pp. 449-464.

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22] [23]

[24]

[25]

[26]

J. L. C. Izquierdo, J. Cabot, J. J. López-Fernández, J. S. Cuadrado, E. Guerra, and J. De Lara, "Engaging end-users in the collaborative development of domain-specific modelling languages," in International Conference on Cooperative Design, Visualization and Engineering, 2013, pp. 101-110. L. Tratt, "Model transformations and tool integration," Software and Systems Modeling, vol. 4, pp. 112-122, 2005. C. E. Montenegro Marín, G. García, P. Alonso, J. Cueva Lovelle, and Ó. Sanjuán Martínez, "Application of modeldriven engineering (MDA) for the construction of a tool for domain-specific modeling (DSM) and the creation of modules in learning management systems (LMS) platform independent," Dyna, vol. 78, pp. 43-52, 2011. V. Kulkarni, S. Barat, and U. Ramteerthkar, "Early experience with agile methodology in a model-driven approach," in International Conference on Model Driven Engineering Languages and Systems, 2011, pp. 578-590. J. Haan, "The Entrerprise Architect: Building an Agile Enterprise," Blog para divulgaçao de pesquisas e soluçoes tecnológicas que envolvem MDE, MDA e DSL. Disponıvel em: http://www.theenterprisearchitect. eu/Acesso em, vol. 21, 2010. J. De Lara and E. Guerra, "Deep meta-modelling with metadepth," in International Conference on Modelling Techniques and Tools for Computer Performance Evaluation, 2010, pp. 1-20. F. Jouault, F. Allilaire, J. Bézivin, and I. Kurtev, "ATL: A model transformation tool," Science of Computer Programming, vol. 72, pp. 31-39, 2008. W. A. Muhanna and R. A. Pick, "Meta-modeling concepts and tools for model management: a systems approach," Management Science, vol. 40, pp. 1093-1123, 1994. I. Kurtev, J. Bézivin, F. Jouault, and P. Valduriez, "Modelbased DSL frameworks," in Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications, 2006, pp. 602-616. M. Mernik, J. Heering, and A. M. Sloane, "When and how to develop domain-specific languages," ACM computing surveys (CSUR), vol. 37, pp. 316-344, 2005. D. C. Schmidt, "Model-driven engineering," COMPUTERIEEE COMPUTER SOCIETY-, vol. 39, p. 25, 2006. J. Bézivin and E. Breton, "Applying the basic principles of model engineering to the field of process engineering," UPGRADE: European Journal for the Informatics Professional, vol. 5, pp. 27-33, 2004. J. Whittle, J. Hutchinson, M. Rouncefield, H. Burden, and R. Heldal, "Industrial adoption of model-driven engineering: Are the tools really the problem?," in International Conference on Model Driven Engineering Languages and Systems, 2013, pp. 1-17. J. Den Haan. (2008). Available: https://www.infoq. com/articles/8-reasons-why-MDE-fails

[27]

[28]

[29]

148

M. Staron, "Adopting model driven software development in industry-a case study at two companies," in MoDELS, 2006, pp. 57-72. A. Kuhn, G. C. Murphy, and C. A. Thompson, "An exploratory study of forces and frictions affecting largescale model-driven development," in International Conference on Model Driven Engineering Languages and Systems, 2012, pp. 352-367. F. Tomassetti, M. Torchiano, A. Tiso, F. Ricca, and G. Reggio, "Maturity of software modelling and model driven engineering: A survey in the Italian industry," 2012. J. Hutchinson, M. Rouncefield, and J. Whittle, "Modeldriven engineering practices in industry," in Proceedings of the 33rd International Conference on Software Engineering, 2011, pp. 633-642.