Model Driven Engineering (MDE) is a software engineering paradigm that advocates for the rigorous use of (software) models and model manipulation operations (known as model transformations) as the main artifacts in all software engineering activities. This comes from an industrial need to have a regular and homogeneous organization where different facets of a software system may be easily separated or combined when appropriate. The basic assumption of MDE is that models provide a better abstraction level than the classical programming code to manage the complexity of software development (and, in general, any other software-related task). When needed, executable code can be semi-automatically generated from (low-level) models of the system. Adoption of MDE increases productivity and quality of the software engineering process.
In this sense, AtlanMod is developing pioneering solutions to solve core research challenges in MDE and to ensure its successful application on relevant industrial problems. In particular, AtlanMod is focusing on three key challenges: evaluating the correctness of models and model transformations, ensuring the scalability of modeling techniques to deal with very large models and developing software modernization methods by means of the application of model-driven reverse engineering techniques on legacy software.
AtlanMod has significantly contributed to the evolution of MDE and to the progressive emergence of a scientific community in this field. The team has progressively developed a complete modeling framework that is now well accepted in the scientific community. This framework provides core MDE components (described in several research papers e.g., ) for (meta)model definition and manipulation.
The iterative definition of this conceptual framework has been validated by the construction of an MDE toolbox based on the conclusion that MDE is in fact a branch of language engineering. Models can be formally defined by means of metamodels, considered as the definition of the abstract syntax of a language in the same way grammars are used to define programming languages. Modeling languages are then the combination of a metamodel (abstract syntax), a notation (concrete syntax) plus a definition of the language semantics. In this sense, our toolbox can be regarded as a kind of language workbench offering the building blocks to define and manipulate models and metamodels. All these mutually interrelated tools are available under Eclipse.org (projects or components: M2M, ATL, AM3, AMW). They are currently in use in research, teaching, and industry and they have a broad user community.
Beyond the development of core MDE components, AtlanMod has also expressed a strong interest in the application and adaptation of these building blocks for specially relevant and challenging industrial problems. As an example, In this context, AtlanMod has been leading the MoDisco project
Jordi Cabot has successfully defended his HdR. Title of the habilitation thesis: MDE 2.0.: pragmatic model verification and other stories
Publication of the book Model-Driven Software Engineering in Practice (Morgan and Claypool) co-authored by Jordi Cabot. See also the popularization section.
MDE can be seen as a generalization and abstraction of object technology allowing to map more abstract organizations on class-based implementations. In MDE, (software) models are considered as the unifying concept .
Traditionally, models were often used as initial design sketches mainly aimed for communicating ideas among developers. On the contrary, MDE promotes models as the primary artifacts that drive all software engineering activities. Therefore, rigorous techniques for model definition and manipulation are the basis of any MDE framework.
The MDE community distinguishes three levels of models: (terminal) model, metamodel, and metametamodel. A terminal model is a (partial) representation of a system/domain that captures some of its characteristics (different models can provide different knowledge views on the domain and be combined later on to provide a global view). In MDE we are interested in terminal models expressed in precise modeling languages. The abstract syntax of a language, when expressed itself as a model, is called a metamodel. A complete language definition is given by an abstract syntax (a metamodel), one or more concrete syntaxes (the graphical or textual syntaxes that designers use to express models in that language) plus one or more definition of its semantics. The relation between a model expressed in a language and the metamodel of that language is called conformsTo. Metamodels are in turn expressed in a modeling language called metamodeling language. Similar to the model/metamodel relationship, the abstract syntax of a metamodeling language is called a metametamodel and metamodels defined using a given metamodeling language must conform to its metametamodel. Terminal models, metamodels, and metametamodel form a three-level architecture with levels respectively named M1, M2, and M3. A formal definition of these concepts is provided in and . MDE promotes unification by models, like object technology proposed in the eighties unification by objects . These MDE principles may be implemented in several standards. For example, OMG proposes a standard metametamodel called Meta Object Facility (MOF) while the most popular example of metamodel in the context of OMG standards is the UML metamodel.
In our view the main way to automate MDE is by providing model manipulation facilities in the form of model transformation operations that taking one or more models as input generate one or more models as output (where input and output models are not necessarily conforming to the same metamodel). More specifically, a model transformation Mt defines the production of a model
Another important idea is the fact that a model transformation is itself a model . This means that the transformation program
As MDE developed, it became apparent that this was a branch of language engineering . In particular, MDE offers an improved way to develop DSLs (Domain-Specific Languages). DSLs are programming or modeling languages that are tailored to solve specific kinds of problems in contrast with General Purpose Languages (GPLs) that aim to handle any kind of problem. Java is an example of a programming GPL and UML an example of a modeling GPL. DSLs are already widely used for certain kinds of programming; probably the best-known example is SQL, a language specifically designed for the manipulation of relational data in databases. The main benefit of DSLs is that they allow everybody to write programs/models using the concepts that actually make sense to their domain or to the problem they are trying to solve (for instance Matlab has matrices and lets the user express operations on them, Excel has cells, relations between cells, and formulas and allows the expression of simple computations in a visual declarative style, etc.). As well as making domain code programmers more productive, DSLs also tend to offer greater optimization opportunities. Programs written with these DSLs may be independent of the specific hardware they will eventually run on. Similar benefits are obtained when using modeling DSLs. In MDE, new DSLs can be easily specified by using the metamodel concept to define their abstract syntax. Models specified with those DSLs can then be manipulated by means of model transformations (with ATL for example ).
When following the previously described principles, one may take advantage of the uniformity of the MDE organization. Considering similarly models of the static architecture and models of the dynamic behavior of a system allows at the same time economy of concepts and economy of implementation. Considering models of products (e.g., software artifacts like UML) and models of processes (e.g., software processes like SPEM) may lead to a dual process/product organization. Considering transformation models, weaving models, and traceability models as special cases of correspondence models may also lead to simplicity and efficiency of implementations. These are some of the use cases that are being explored in the team.
By definition, MDE can be applied to any software domain. Core MDE techniques developed by the team have been successfully applied to a large variety of industrial domains from information systems to embedded systems. MDE is not even restricted to software engineering, but also applies to data engineering and to system engineering . There are a lot of problems in these application domains that may be addressed by means of modeling and model transformation techniques. For the core techniques, we are now focusing on solving the scalability problem to make sure they can be successfully adopted by our industrial partners in the context of large and complex software systems.
Nevertheless, the team has indeed selected a set of vertical and horizontal domains that AtlanMod finds specially interesting. In what follows we describe three of them.
One important and original domain that is being investigated by the AtlanMod team is the reverse engineering of existing IT systems. We do believe that efficiently dealing with such legacy systems is one of the main challenges in Software Engineering and related industry today. Having a better understanding of these systems in order to document, maintain, improve or migrate them is thus a key requirement for both academic and industrial actors in this area. However, it is not an easy task and it still raises interesting challenging issues to be explored .
We have shown how reverse engineering practices may be advantageously revisited with the help of the MDE approach and techniques, applying (as base principle) the systematic representation as models of the required information discovered from the legacy software artifacts (e.g.; source code, configuration files, documentation, metadata, etc). The rise in abstraction allowed by MDE can bring new hopes that reverse engineering is now able to move beyond more traditional ad-hoc practices. For instance, an ongoing industrial PhD in partnership with IBM France aims to investigate the possibilities of conceptualizing a generic framework enabling the extraction of business rules from a legacy application, as much as possible, independently of the language used to code it. Moreover, different pragmatic solutions for improving the overall scalability when dealing with large-scale legacy systems (handling huge data volumes) are intensively studied by the team.
In this context, AtlandMod has set up and is developing accordingly the open source Eclipse-MDT MoDisco project (see ). MoDisco is notably being referenced by the OMG ADM (Architecture Driven Modernization) normalization task force as the reference implementation for several of its standard metamodels.
We have also opened a novel research line focused on integration of APIs into MDE. In the application of reverse engineering processes while modernizing software system it is very common to face the need of integrating Application Programming Intefaces (APIs). Indeed, building any application usually involves managing a plethora of APIs to access different software assets such as: basic infrastructures (e.g., operating system, databases, or middleware), general-purpose or domain specific libraries, frameworks, software components, web services, and even other applications. Thus, to promote the interoperability between the API and model technical spaces, we have developed API2MoL, which is an approach aimed at automating the implementation of API-MDE bridges. This new language allows defining mappings between the artefacts of a given API (e.g., API classes in object-oriented APIs) and the elements of a metamodel that represents this API in the MDE technical space. A mapping definition provides the information which is necessary to build a bridge for a concrete API specification and metamodel. Thanks to the API-MDE bridges automatically created, developers are liberated from having to manually implement the tasks of obtaining models from API objects and generating such objects from models. Therefore, API2MoL may improve the productivity and quality of the part of the MDE application that deals with the APIs.
Several components are required to build up a system security architecture, such as firewalls, database user access control, intrusion detection systems, and VPN (Virtual Private Network) routers. These components must be properly configured to provide an appropriate degree of security to the system. The configuration process is highly complex and error-prone. In most organizations, security components are either manually configured based on security administrators expertise and flair; or simply recycled from existing configurations already deployed in other systems (even if they may not be appropriated for the current one). These practices put at risk the security of the whole organization.
We have started a Phd thesis in this domain intended to investigate the construction of a model-driven automatic reverse engineering mechanism (implemented as an extension of the MoDisco project) capable of analyzing deployed security aspects of components (e.g., concrete firewall configurations) to derive the abstract model (e.g., network security global policy) that is actually enforced over the system. Once the model is obtained, it can be reconciled with the expected security directives, to check its compliance, can be queried to test consistency or used in a process of forward engineering to generate validated security configurations.
As a first step we intend to apply model-driven techniques for the extraction of high level model representations of security policies enforced by firewalls. Firewalls, core components in network security systems, are generally configured by using very low level vendor specific rule-based languages, difficult to understand and to maintain. As a consequence, as the configuration files grow, understanding which security policy is being actually enforced or checking if inconsistencies has been introduced becomes a very complex and time consuming task. We propose to raise the level of abstraction so that the user can deal directly with the high level policies. Once a model representation of the enforced policy is available, model-driven techniques will ease some of the tasks we need to perform, like consistency checking, validation, querying and visualization. Easy migration between different firewall vendors will be also enabled.
As with any type of production, an essential part of software production is determining the quality of the software. The level of quality associated to a software product is inevitably tied to properties such as how well it was developed and how useful it is to its users. The AtlanMod team is considering software quality aspects in two areas that are described in the following paragraphs: formal verification of models and corpus-based domain-specific language (DSL) analysis.
In the context of MDE, models are expressions of a conceptualization (metamodel) of their respective domain. Therefore precise definitions of our metamodels are important to get the subsequent MDE activities right, such as testing, concrete syntax definition, model interchange, code generation, and any more. In this sense, metamodels establish a single point of truth. The Object Constraint Language (OCL) of the OMG is widely accepted as a standard language to provide such precise definitions.
However, precise metamodels are complex artifacts. To get them right, systematic approaches to quality assurance are required. As a solution to this problem, we propose formal checking of model satisfiability (can we express the desired things), and formal checking of unsatisfiability (does the metamodel not have models with undesirable properties). As both activities constitute NP-hard problems, they have to be put carefully into algorithms. The team maintains the tool EMFtoCSP which translates the problem into the domain of constrain logic programming (CLP) for which sophisticated decision procedures exist. The tool integrates the described functionality in the Eclipse Modeling Framework (EMF) and the Eclipse Modeling Tools (MDT), making the functionality available for MDE in practice.
In terms of DSLs, an equally important aspect of software language engineering other than the initial development process is the identification of quality characteristics of the language. We are currently investigating the use of corpus-based analysis to identify language characteristics. A corpus in this case consists of artifacts or models of the DSL that have been generated by its users. We aim to extract information based on the corpus of a DSL to identify various characteristics that can potentially prove useful for the language engineer in his or her efforts to improve the language. Such information can complement other quality measurements including the formal verification method described in the previous paragraph and user feedback-based evaluations. In addition to an initial investigation of cloning in DSLs, our corpus-based analysis is also investigating metamodel element instance and relationship analyses
URL: http://
With an eye on the normative work of the OMG (MOF, OCL, QVT, etc.), a new conceptual framework has been developed based on a second generation model transformation language called ATL. Although ATL influenced the OMG standard, the approach is more general as discussed in . In 2004 IBM gave an Eclipse innovation award to the ATL project. In 2007 Eclipse recognized ATL as one central solution for model transformation and promoted it to the M2M project (see Eclipse.org/m2m). There are more than 200 industrial and academic sites using ATL today, and several Ph.D. thesis in the world are based on this work.
In 2011 we started a new evolution phase for ATL. Our mid-term plan is making of ATL the leading solution for building autonomous reactive transformation systems, i.e. transformation networks that can autonomously manage a set of dataflows among the application models.
Following this line, we first implemented a new refinement mode for ATL, to support in-place transformations. This extension allows the dynamic manipulation of models while keeping them connected to runtime applications. Next, we presented a lazy execution algorithm for ATL. With it, the elements of the target model are generated only when and if they are accessed. This extension allows to build reactive transformation systems that react to requests of model elements, by triggering the necessary computation. Our lazy version of ATL enables also transformations that generate infinite target models, extending the application space of the model-transformation paradigm.
The latest (still ongoing) work in this direction is the development of a full reactive ATL engine, able to activate the minimal computation for responding to updates or request on the involved models. This engine is studied to scale up with large ATL networks. In this line we also introduced an algorithm for simplifying ATL transformation chains.
URL: http://
MoDisco is an open source Eclipse project that provides a generic and extensible framework dedicated to the elaboration of Model Driven Reverse Engineering (MDRE) solutions. Gathering contributions from both academics and industrials, the goal of the project is to federate common efforts in the model-based transformation of legacy software systems implemented using different technologies (e.g.; Java, COBOL, C). The first principle is to discover models out of legacy artifacts, representing appropriately all the relevant information, to be then used as part of reverse engineering processes for software understanding, evolution or modernization. Targeted scenarios include software (technical or architectural) migration of large legacy systems, but also retro-documentation, refactoring, quality assurance, etc. Within this context, MoDisco has collaborations with the OMG Architecture Driven Modernization (ADM) Task Force, for which the project provides several reference implementations of its standards: Knowledge Discovery Metamodel (KDM), Software Measurement Metamodel (SMM) and Abstract Syntax Tree Metamodel (ASTM).
The MoDisco framework is composed of a set of Eclipse plugins, and relies on the de-facto standard Eclipse Modeling Framework (EMF) for model handling. Thanks to its modular architecture, it allows completely covering the three steps of a standard MDRE approach: 1) Discovery (i.e. extracting a complete model of the source code), 2) Understanding (i.e. browsing and providing views on this model for a given purpose) and 3) Transformation (evolving the model towards a new technology, architecture, etc). More specifically, as part of its Infrastructure layer, MoDisco offers the set of generic (i.e.; legacy technology-independent) reusable components really useful to build the core of MDRE solutions: Discovery Manager and Workflow for MDRE task orchestration, Model Browser for advanced navigation in complex models, model extension and customization capabilities for understanding (e.g.; views definition), etc. As part of its Technologies layer, it provides an advanced support for the Java, JEE and XML technologies, including complete metamodels, corresponding model discoverers, transformations, code generators, customizations, query libraries, etc.
MoDisco (or some of its components) is being used by different partners including other academics, industrials (e.g.; Sodifrance on several of their real modernization projects for their customers) or Eclipse projects (e.g.; Eclipse-MDT Papyrus as developed by CEA). Moreover, the Eclipse-EMFT EMF Facet project has been initiated as a MoDisco spin-off, in order to externalize some features which are not actually specific to reverse engineering problems and thus may be reused in many different contexts (cf. corresponding EMF Facet section).
The initiative continues to be developed within the context of the European FP7-ICT project named ARTIST
URL: http://
Software development processes are collaborative in nature. Neglecting the key role of end-users leads to software that does not satisfy their needs. This collaboration becomes specially important when creating Domain-Specific Languages (DSLs), which are (modeling) languages specifically designed to carry out the tasks of a particular domain. While end-users are actually the experts of the domain for which a DSL is developed, their participation in the DSL specification process is still rather limited nowadays.
Thus, Collaboro is an approach to make language development processes more participative, meaning that both developers and users of the language can collaborate together to create and evolve it. The tool has been developed as an Eclipse plugin, whose features currently implemented are:
Version view to navigate through the Proposals of a version. For each Proposal, the solutions and comments are shown.
Collaboration view to show the data related to a Collaboration selected in the version view. This view also shows the changes to apply if the selected element is a Solution.
The user can login to the Collaboro system and create proposals, solutions and comments by right-clicking in the version view. The user can also vote for/against the collaborations.
Decision engine based on a total agreement (i.e., all the community users must vote for the collaboration). The decision engine can be launch by using the bar menu.
Notation engine and Notation view to render SVG snapshots of the DSL concrete syntax.
URL: http://
Virtual EMF is an Eclipse plugin built on top of EMF that enables the creation and manipulation of virtual models, i.e., models whose elements do not contain concrete data, but are rather proxies to elements contained in other models. The idea is related to that of model composition, as it aims capturing the (often overlapping) concepts as one single global model. This is a frequently faced problem as, in complex scenarios, modelers often have to deal with a large number of heterogeneous and interrelated models. Most times, the view a specific kind of user requires does not correspond to any of these models but is a combination of cross-domain information scattered among several ones.
Current composition techniques rely on the materialization of the composed model, an approach that poses some important limitations in terms of
Virtual EMF allows overcoming the limitations above. A virtual model provides to tools/users the illusion of working with a regular model whereas, in fact, all model access and manipulation requests are transparently redirected to its set of virtualized models. It serves as a centralized and transparent access point to a set of interconnected models, allowing users to easily compose, weave and link them. It provides the following beneficial properties:
Interoperability: it behaves as a normal model. Therefore, compatibility with existing EMF-based solutions/tools (e.g. models transformations, model editors, ...) is guaranteed;
Synchronization: changes are automatically and transparently propagated between virtual and original models;
Scalability: support for very big models;
low memory usage: no data duplication, direct access to original model elements;
faster generation time: no need for (time-consuming) information cloning operations (e.g. executing a model transformation);
Genericity: support for several types of inter-model relationships (e.g. merge, association, filter) and extension capabilities for their semantics.
Virtual EMF is available as an open source project on Eclipse Labs. It has been contributed by the AtlanMod team to the CESAR project.
The initiative continues to be developed within the context of the French FUI 13 project named TEAP [TODO Put ref to TEAP http://
URL: http://
EMFtoCSP is a tool for the verification of precisely defined
conceptual models and metamodels. For these models, the definition of the
general model structure (using UML or EMF) is supplemented by OCL
constraints. The Eclipse Modeling Development Tools
(MDT
However, an additional important task that is not supported by Eclipse MDT is the assurance of model quality. A systematical assessment of the correctness of such models is a key issue to ensure the quality of the final application. EMFtoCSP fills this gap by provided support for automated model verification in Eclipse.
Essentially, the EMFtoCSP is a sophisticated bounded model finder that yields instances of the model that conform not only to the structural definition of the model (e.g., the multiplicity constraints), but also to the OCL constraints. Based on this core, several correctness properties can be verified:
Satisfiability – is the model able to express our domain? For this check, the minimal number of instances and links can be specified to ensure non-trivial instances.
Unsatisfiability – is the model unable to express undesirable states? To verify this, we add further constraints to the model that state undesired conditions. Then we can check if is it impossible to instantiate the amended model.
Constraint subsumption – is one constraint already implied by others (and could therefore be removed)?
Constraint redundancy – do different constraints express the same fact (and could therefore be removed)?
To solve these search problems, EMFtoCSP translates the EMF/OCL
(resp. UML/OCL) model into a constraint satisfaction problem
and employs the Eclipse CLP solver
The tool is a continuation of the UMLtoCSP approach developed previously by Jordi Cabot, Robert Clarisó and Daniel Riera. It provides a generic plugin framework for Eclipse to solve OCL-annotated models using constraint logic programming. Apart from already supported Ecore and UML metamodels, further metamodels can be added easily in the future. Similarly, other constraint solving back-ends can be integrated. It is provided under the Eclipse Public License.
URL: http://
EMF Facet is an open source Eclipse project, under the Eclipse Public License (EPL), that provides a generic and extensible framework dedicated to the dynamic and non-intrusive extension of models. It can be used to extend already existing metamodels with additional concepts and properties, the corresponding models being then transparently augmented, reduced or modified accordingly at runtime. Such a metamodel extension is called a facet, and can be specified on top of any metamodel in EMF Ecore. The underlying mechanism is based on the runtime execution of queries on the models corresponding to the faceted metamodels. Facets are notably particularly relevant for obtaining different views on existing models without having to actually alter them with any extra data.
The EMF Facet framework is composed of several Eclipse plugins, and relies on the de-facto standard Eclipse Modeling Framework (EMF) for model handling. The facet definitions are stored as facet models, allowing them to be exchanged and reused in various contexts. The queries can be implemented using any suitable query language (e.g.; ATL, OCL, Java, XPath), as far as the corresponding adapters exist and are correctly registered within the framework. The proposed tooling includes dedicated editors for creating, editing and saving both facet and query definitions, the implemented support for Java, OCL and ATL queries, a Table Editor for visualizing query results. An advanced support for the model display customization (e.g.; icons, colors, fonts) is also provided as part of the framework.
EMF Facet is currently intensively used in MoDisco for extracting and displaying different specific views from large models of legacy systems. Its extension and customization capabilities are actually integrated into several MoDisco components, such as notably the MoDisco Model Browser. However, different other integration possibilities will be also explored in the future.
The initiative continues to be developed within the context of the European FP7-ICT project ARTIST.
Research labs, as a source of innovation, are potential key actors of the Software Engineering market. However, an important collaborative effort with the other players in the software industry is still needed in order to actually transfer the corresponding techniques or technologies from the research lab to a company. Based on the AtlanMod concrete experience with the previously mentioned open source tools/projects, we have extracted a pragmatic approach for transforming the results of scientific experimentation into practical industrial solutions.
While dealing with innovation, this approach is also innovation-driven itself, as the action is actually conducted by the research lab via a technology transfer. Three different partners are directly involved in this process, using open source as the medium for maintaining a constant interaction between all of them:
Use Case Provider. Usually a company big enough to have to face real complex industrial scenarios which need to be solved (at least partially) by applying new innovative principles and techniques;
Research Lab. Usually a group from a research institute (public or private) or university evaluating the scientific relevance of the problems, identifying the research challenges and prototyping possible solutions;
Technology Provider. Usually a small or medium company, with a particular technical expertise on the given domain or Software Engineering field, building and delivering the industrial version of the designed solutions;
From our past and current experience, three main characteristics of this industrialization business model can be highlighted:
Win-win situation. Each partner can actually focus on its core activity while also directly benefiting from the results obtained by the others (notably the research lab can continue to do research);
Application-driven context. The end-user need is at the origin of the process, which finally makes the developed solution actually relevant;
Iterative process. The fact of having three distinct partners requires different regular and consecutive exchanges between all of them.
AtlanMod has continued to improve the core model and model transformation technologies that are reused in the other more domain-oriented research lines of the team. Main results in this area have been:
Model-to-Model Transformation Refactorings. In object-oriented programming, continuous refactorings are used as the main mechanism to increase the maintainability of the code base. Unfortunately, in the field of model transformations, such refactoring support is so far missing. We have tackled this limitation by adapting the notion of refactorings to model-to-model (M2M) transformations. Particularly, in we present a dedicated catalogue of refactorings for improving the quality of M2M transformations. This catalogue is the result of analyzing existing ATL transformations; its scope is beyond ATL, covering other M2M transformation languages.
Reactive Model Transformations. Model-driven applications manipulate models by executing model transformations that are seen by host applications as black-box functions returning the computed target models. We propose a paradigm shift where a network of reactive transformations defines persistent data-flows among models. A reactive transformation engine takes care of activating only the strictly needed computation in response to updates or requests of model elements. Computation is updated when necessary, in an autonomous and optimized way. The application architecture results deeply changed, since the host application does not directly control the execution of the transformations anymore, but only accesses or updates the underlying models. We experiment this paradigm by implementing a reactive engine for ATL.
EMF Profiles. There are many situations in which one needs to extend or annotate a model with additional information. Nevertheless, changing the metamodel to include this new information is very costly (e.g. you'll need to recreate the modeling environment and, possibly, to migrate other existing models). As a solution, we have proposed the idea of EMF Profiles as a way to reuse the idea of UML Profiles for general EMF Models. UML profiles have been a key enabler for the success of UML by providing a lightweight language-inherent extension mechanism which is expressive enough to cover an important subset of adaptation scenarios. We believe a similar concept for DSMLs would provide an easier extension mechanism for EMF.
In the field of Domain-Specific Languages (DSLs), we have focused on the improvement of the DSLs definition process. During 2012 the new results in this area have been:
Software development processes are becoming more collaborative, trying to integrate end-users as much as possible. The idea is to advance towards a community-driven process where all actors (both technical and nontechnical) work together to ensure that the system-to-be will satisfy all expectations. This seems specially appropriate in the field of Domain-Specific Languages (DSLs) typically designed to facilitate the development of software for a particular domain. We have designed a collaborative infrastructure for the development of DSLs where end-users have a direct and active participation in the evolution of the language , . This infrastructure is based on Collaboro, a DSL to represent change proposals, possible solutions and comments arisen during the development and evolution of a language.
When developing DSLs, a number of design decisions must be made, such as those related to its concrete syntax, how the language semantics is going to be defined and in which form (interpreted or compiled), or whether there will be an underlying abstract syntax. However, deciding whether the DSL will be internal or external will have an impact on the other aspects of the language. Making an effective choice between these two options therefore requires a careful evaluation of the pros and cons of each alternative. Some important aspects that should be evaluated are the following, which are related to the three elements of a DSL: abstract and concrete syntaxes, and semantics (executability and optimizations), and to quality criteria (extensibility and efficiency) and DSL tooling (tools for developing DSL and tools for using DSL). In we presented the results of this work.
Guranteeing the correctness of models is a very important element of the MDE infrastructure. We made several contributions to the model verification field in 2012:
Automated verification of declarative, rule-based model transformations. Having sound transformations is essential, as they are the compilers in MDE. Because transformations are created frequently, e.g., on a per-project basis, it is important that we can check their correctness automatically. We have developed a novel, automatic proof technique based on Satisfiability Modulo Theories (SMT) solving for this, as well as a bounded-search verification approach using relational logic and Alloy . Both Yices and Z3 have been used as SMT solvers for this work.
Improving EMFtoCSP, the AtlanMod model finder. Model finding is a central, recurring task in MDE. It subsumes both metamodel consistency checking (i.e., metamodel verification) and metamodel instantiation (e.g., test case generation). Even when using a bounded search approach, the underlying research problem is computational hard and calls for flexibile solutions and heuristics. We have generalized and improved the EMFtoCSP model finder (formerly: UMLtoCSP), which is based on Constraint Logic Programming (CLP). It now supports both UML and Ecore (and OCL constraints) and is open for further modeling languages . As the first available MDE model finder, it now supports reasoning over string constraints. Such constraints are common in practical applications of MDE, but none of the existing model finding approaches could handle them. We have developed a flexible string constraint solver (based on multi-head constraint handling rules) that seamlessly integrates into EMTtoCSP .
White-box testing for model transformations is a technique that involves the extraction of knowledge embedded in the transformation code to generate test models. In , we manually extract such knowledge and we represent it in the form of partial models that can drive the generation of highly effective test models. In other works we go a step further and use static analysis to automatically extract testing knowledge from transformation code. We propose two tool-supported methodologies to automatically generate test cases using structural information from a model transformation. In we have developed an approach that optimizes the test coverage while testing rule-based model transformation languages like ATL. The approach is based on analyzing the dependencies among the OCL queries that are used within the transformation code. The methodology in makes use of the metamodel footprinting mechanism, generates partial models representing the testing intent and uses the ALLOY solver to create complete usable models. The experimental results show that a limited amount of white-box information on the model transformation (i.e., our footprints) can provide remarkable improvements on the efficiency of the generated tests.
Model Driven Reverse Engineering (MDRE), and its applications such as software modernization, is a discipline in which model-driven development (MDD) techniques are used to treat legacy systems. During 2012, Atlanmod has continued working actively on this research area. The main contributions are the following:
When existing software artifacts are treated in MDRE, they must be first transformed into models to apply MDD techniques such as model transformations. Since most scenarios involve dealing with code in general-purpose programming languages (GPL), the extraction of models from GPL code is an essential task. We designed Grammar-to-Model Transformation Language (Gra2MoL) as a domain-specific language (DSL) tailored to the extraction of models from GPL code. Gra2MoL aims to reduce the effort needed to implement grammarware-MDD bridges, since building dedicated parsers is a complex and time-consuming task. The language also provides a powerful query language which eases the retrieval of scattered information in syntax trees. Moreover, it incorporates extensibility and grammar reuse mechanisms. In , Gra2MoL is described in detail and a case study based on the application of the language in the extraction of models from Delphi code is included.
Software systems usually manage many Application Programming Interfaces (APIs) to access different software assets (e.g., databases, middleware, etc). A MDRE process therefore also normally involves extracting models from legacy artifacts using API. Thus, we devised API2MoL , a DSL which allows developers defining technological bridges between the model and the API technologies. API2MoL is, to the best of our knowledge, the first generic proposal to deal with the integration of MDE and APIs which automates the creation of the API-MDE bridge. Our proposal includes a complete prototype of a toolkit focused on Java APIs, although an adaptation of the approach to deal with APIs for other statically-typed object-oriented languages (such as C sharp) could be easily implemented.
Most companies information systems are composed by heterogeneous components responsible of hosting, creating or manipulating critical information for the day-to-day operation of the company. Securing this information is therefore one of their main concerns, more particularly specifying Access Control (AC) policies. However, the task of implementing an AC security policy (sometimes relying on several mechanisms) remains complex and error prone as it requires knowing low level and vendor-specific facilities. In this context, discovering and understanding which security policies are actually being enforced by the Information System (IS) becomes critical. Thus, the main challenge consists in bridging the gap between the vendor-dependent security features and a higher-level representation. This representation has to express the policies by abstracting from the specificities of the system components, allowing security experts to better understand the policy and to implement all related evolution, refactoring and manipulation operations in a reusable way. As a first result, in a method to extract AC policies from firewall configuration files is proposed.
In order to react to the ever-changing market, every organization needs to periodically reevaluate and evolve its company policies. These policies must be enforced by its Information System (IS) by means of a set of so-called business rules that drive the system behavior and data. Clearly, policies and rules must be aligned at all times but unfortunately this is a challenging task. In most ISs, the implementation of business rules is scattered among the code so appropriate techniques must be provided for the discovery and evolution of changing business rules. In , we describe a MDRE framework aiming at extracting business rules out of Java source code. The use of modeling techniques facilitate the representation of the rules at a higher-abstraction level which enables stakeholders to understand and manipulate them more easily.
Software modernization processes usually follow the well-known horse-shoe model, which provides a framework to integrate different abstraction levels and reverse engineering tools. The Architecture-Driven Modernization (ADM) is an OMG's initiative which aims at defining and standardizing techniques, methods and tools for software modernization. It incorporates the horse-shoe framework as its reference model and uses MDE techniques as the implementation foundation. Since ADM proposes applying the modernization process at the most abstract level, we believe that, to some extent, the ADM initiative has misinterpreted the original horse-shoe model .
The fast evolution of technologies (SOA, Cloud, mobile environments), ISs complexity and the growing need for agility require to be able to represent information systems as a whole. In this context, Enterprise Architecture (EA) approaches intend to address all the systems dimensions: software components, associated physical resources, relationships with the companies requirements and business processes, implied actors/roles/structures, etc. Within the TEAP FUI project (cf. corresponding section), we have started studying the reverse engineering capabilities required when dealing with such high-level views of an IS. More particularly, the focus has been put on features for allowing federating the relevant data coming from different existing sources, as well as for integrating them efficiently. To this intent, a prototype is currently being developed based on several technologies from the team (e.g. Virtual EMF, ATL, MoDisco).
A new line started this year was the evaluation of how software modeling techniques (and in general software engineering methods) are used in practice. As the first area of study, we have focused on how software architects deal with non-functional requirements. Based on a set of interviews with software architects, we have analyzed whether all the languages, patterns and methodologies proposed by researchers have had any impact on the way software architect choose the best architecture for a given system. Results of the study can be read in these publications .
Three technology transfer contracts with software companies were signed this year.
A first collaboration with Steria Ouest (located in Nantes) is resulting from the presentation of our activities during one of their regular Board of Architects meeting. The identified objective of this initial joint action was to guide and advice them to migrate an internal legacy application to model driven approach and related technologies, relying on our expertise about modeling and the Eclipse ecosystem. This has notably allowed us to get useful feedback on the benefits and drawbacks currently encountered when applying MDE and associated techniques in the context of real applications.
Since several years, AtlandMod and Mia-Software are actively collaborating around the topic of Model Driven Reverse Engineering (MDRE), i.e.; the combined use of different model-based techniques to solve real reverse engineering problems. This has resulted in the successful creation and development of two open source Eclipse projects, namely Eclipse-MDT MoDisco (providing a generic and extensible MDRE framework) and Eclipse-EMFT EMF Facet (providing a dynamic model extension framework), both reaching today an industrial maturity level.
However, for these technologies to be definitely adopted and deployed in the context of very large systems handling huge data volumes, some remaining scalability issues still have to be addressed. Thus, scalability of model-driven techniques is one of the main challenges MDE is facing right now. In this context, AtlanMod has joined forces with MIA-Software as part of an Inria technology transfer action. This initiative is devoted to the development of new generation MDE techniques, for model creation and general handling, that effectively scale up. Among the different research challenges behind the MDE scalability and performance improvement, the following ones have been explored in the context of this collaborative action:
Model random access. Advanced use of on-demand lazy loading techniques;
Model clustering and slicing. Advanced use of semantic grouping and partial loading techniques;
Model virtualization. Transparent and on-demand access to different views on a same model;
Lazy evaluation of model transformation. On-demand lazy execution of transformations;
Incremental model transformation. Partial model access and transformation execution;
Multi-threaded model transformation. Parallelization of both model accesses and rule executions.
AtlanMod has helped WebRatio and the University of Trento in the definition (to be provided as an answer to the corresponding OMG RFP) of IFML, a modeling language for designing user interaction flows (not limited to the Web). Such a language should be: Extremely compact (no useless overhead), Effective (allows to model exactly what users want), Efficient (grants high reusability of model fragments), Easy to learn (very low learning curve), Comprehensive (covers most of the user interaction needs), Open and extensible (for covering any ad-hoc logic) and Platform independent (addressing any type of user interface device).
For more information about IFML - Interaction Flow Modeling Language see
Program: Pays de la Loire regional funding. Call: Soutenir et accompagner la constitution et/ou l'implantation de nouvelles équipes sur des thématiques émergentes
Project title: AtlanMod New Team Creation
Duration: 2011 - 2014
Coordinator: AtlanMod
Other partners: None
Abstract: AtlanMod has been funded by the Pays de la Loire Regional Council new research teams program. This funding will mainly cover a PhD Student and two years of a postdoc to work on the quality of models research line.
Program: Pole de competitivite Images et Reseaux - Appel Projets PME 2011
Project title: StreamMaster
Duration: 2012 - 2014
Coordinator: Data Syscom
Other partners: Research and University (Universite de Nantes, Ecole de Design Nantes Atlantique, ESC Rennes) and Vendors and service providers (IMINFO)
Abstract: The purpose of the StreamMaster project is creating a universal software solution for the smart management of document streams, providing an added value over all the chain. StreamMaster will provide: an hybrid (local and remote) technological platform to allow user access, the possibility of connection to every information system and every input and output stream, the management of all the parameters of the document stream (cost, speed, delay, quality, environmental impact), security and reinforced document authentication mechanisms, non-falsifiable documents by means of invisible document tatooing, an innovative and multimodal HMI.
Program: ANR - ARPEGE program
Project acronym: Galaxy
Project title: Galaxy
Duration: 2010 - 2013
Coordinator: Airbus
Other partners: Industry (Airbus), Research and University (Armines -AtlanMod-, IRIT, LIP6) and Vendors and service providers (AKKA, Softeam)
Abstract: GALAXY (http://
Program: FUI - AAP 13
Project acronym: TEAP
Project title: TOGAF Entreprise Architecture Platform
Duration: 2012 - 2014
Coordinator: Obeo
Other partners: Industry (DCNS), Research and University (Inria AtlanMod) and Vendors and service providers (Obeo, Capgemini)
Abstract: The fast evolution of technologies (SOA, Cloud, mobile environments), the systems complexity and the growing need for agility require to be able to represent information systems as a whole. The high-level approach promoted by Enterprise Architecture (EA) is a key element in this context and intends to address all the systems dimensions: software components, associated physical resources, relationships with the companies requirements and business processes, implied actors/roles/structures, etc. The objective of the TEAP project is to specify and implement an EA platform based on the Open Group international standard named TOGAF and on the SmartEA technical solution. In addition to its base modeling capabilities, this platform will allow data federation from different existing sources (e.g. for reverse engineering purposes such as retro-cartography) as well as the definition of possible transformation chains (for governance and modernization). As part of this project, we are notably using in practice (and improving) some of our works such as Virtual EMF, ATL or some MoDisco components.
Title: Advanced software-based seRvice provisioning and migraTIon of legacy Software
Type: FP7, COOPERATION (ICT)
Defi: Cloud Computing, Internet of Services and Advanced Software engineering
Instrument: Integrated Project (IP)
Duration: October 2012 - September 2015
Coordinator: Atos Origin R&I (Spain)
Others partners: Tecnalia (Spain), Inria (France), Fraunhofer (Germany), TUWIEN (Austria), ENG (Italy), ICCS (Greece), SPARX (Austria), ATC (Greece), SPIKES (Belgium)
See also: http://
Abstract: Successful software has to evolve to keep it compatible and up to date. Up to 90% of software cost is spent on maintenance and of this 75% is spent on the development of new features for staying competitive. The industry progresses through periods of incremental development interlaced with true paradigm shifts. Accordingly, more and more traditional software vendors notice the need to transform their current business and technology model in order to remain competitive. Software-as-a-Service (SaaS) is seen as the most promising way to achieve this change. However, this transition from Software-off-the-shelf (often residing as legacy applications) to SaaS is a tremendous challenge comprising business, application and technical issues. Having an automated, vendor, technology and hardware independent way to migrate an application would permit the software to evolve easily even in case of transition to new paradigms. ARTIST proposes a software migration approach covering the premigration and postmigration phases. The premigration phase analyzes the technical and non-technical consequences of migrations, supporting the decision-making process on how a migration should be done. The migration phase itself is based on Model Driven Engineering techniques to automate the reverse engineering of the legacy applications to platform independent models. These models are the input for the forward engineering process to generate and deploy modernized applications and to support future migrations. In the postmigration phase, the modernized applications are certified with respect to the stated goals of the premigration phase. ARTIST will reduce the risk, time and cost of migrating legacy software. It will lower the barriers for companies (with existing software) wanting to take advantage of the latest technologies and business models, particularly when considering the current benefits of Cloud Computing and SaaS.
Title:Cost-Efficient methods and processes for SAfety Relevant embedded systems
Program: Artemis
Project acronym: CESAR
Duration: 2009 - 2012
Coordinator:
Other partners: More than 50 partners
Abstract: The three transportation domains, automotive, aerospace, and rail, as well as the automation domain share the need to develop ultra-reliable embedded systems to meet social demands for increased mobility and safety in a highly competitive global market.To maintain the European leading edge position in the transportation as well as automation market, CESAR aims to boost cost efficiency of embedded systems development and safety and certification processes by an order of magnitude. CESAR pursuits a multi-domain approach integrating large enterprises, suppliers, SME's and vendors of cross sectoral domains and cooperating with leading research organizations and innovative SME's.
In particular, we work on the Reference Technology Platform, which aims at tool integration. We propose to achieve tool integration by means of metamodeling and model transformations . In the context of this project we are developing VirtualEMF (http://
Title:Open Platform for the Engineering of Embedded Systems
Program: ITEA2
Project acronym: OPEES
Duration: 2009 - 2012
Coordinator: Obeo
Other partners: Many other research labs and companies. Our main partner was the Obeo company.
Abstract:OPEES (http://
Program: Leonardo da Vinci (LifeLong learning programme)
Project acronym: MDEExpertise
Project title:Exchanging knowledge, techniques and experiences around Model Driven Engineering education
Duration: 2010 - 2012
Coordinator: Lublin University of Technology
Other partners: Potecnico di Milano, Universidad de Alicante
Abstract: MDE Expertise (http://
The three main research partners of the team are:
Politecnico di Milano (Italy) - DB Group, specially with Marco Brambilla
TU Wien (Austria) - BiG Group, specially Manuel Wimmer
Politecnica de Catalunya (Spain) - GESSI Group, specially Xavier Franch
With all three teams we have published several papers and made research visits this year.
In 2012 the following visitors did a research stay with AtlanMod:
Ralf Lammel (University of Koblenz-Landau, Germany), February
Soichiro Hidaka (National Institute of Informatics (NII), Tokyo, Japan), September
David Ameller (Universitat Politècnica de Catalunya), June
Juan Manuel Dodero (University of Cádiz, Spain), June
Jokin García (University of Basque Country, Spain), May-August
In 2012, the AtlanMod team has coorganized the following events:
J. Cabot has coorganized the OCL and Textual Modeling Workshop (OCL'12)
J. Cabot has coorganized the CloudMDE workshop, the First International Workshop on Model-Driven Engineering on and for the Cloud, co-located with ECMFA 2012.
Participation in Steering Committees of Research Conferences:
Jordi Cabot: International Conference on Model Transformation
Participation to editorial boards of scientific journals:
Jordi Cabot: Journal of Object Technology, International Journal of Information System Modeling and Design
AtlanMod members have collaborated in the reviewing process for the following journals this year
Hugo Bruneliere: Elsevier Advances in Engineering Software (ADES)
Jordi Cabot: IEEE Software, IEEE Transactions on Software Engineering Journal, Journal of Systems and Software, Information and Software Technology Journal, Software and Systems Modeling Journal, Data and Knowledge Engineering Journal, Science of Computer Programming journal, Journal of Web Engineering journal
Javier Canovas: Software and Systems Modeling Journal.
Massimo Tisi: IEEE Software, Science of Computer Programming journal, Journal of Software: Practice and Experience, Information and Software Technology Journal, Software and Systems Modeling Journal, Journal of Object Technology.
Participation to conference program committees:
Fabian Buettner:
International: Workshop on the Analysis of Model Transformations (AMT), Model-Driven Security Workshop (MDSec).
Jordi Cabot:
International: World Wide Web Conference, International Conference on Model-Driven Engineering Language and Systems, Software Language Engineering conference, European Conference on modeling foundations and applications, International Conference on Web Engineering, Transformation Tool Contest, International Conference on Conceptual Modeling, International Conference on Advanced Information Systems Engineering, eXtreme Modeling workshop, Model-Driven Engineering for High Performance and CLoud computing workshop, Model Driven Web Engineering Workshop.
National: French national conference on MDE, Spanish national conference on MDE.
Javier Canovas:
International: International Workshop on Modeling Social Media.
National: French national conference on MDE, Spanish national conference on MDE.
Massimo Tisi:
International: International Conference on Engineering of Complex Computer Systems, International Conference on Current Trends in Theory and Practice of Computer Science, International Conference on Software Engineering and Advanced Applications, International Conference on Web Information Systems and Technologies, International Conference on Model Transformation, Transformation Tool Contest, Workshop on Domain-Specific Modeling, Extreme Modeling Workshop, Academics Modelling with Eclipse Workshop.
Jordi Cabot:Reviewer for Spanish CICYT Research Projects Call, Reviewer for the National Dutch Projects Call
The team got a price while participating in a hackathon organized as part of the SoTeSoLa 2012 Summer School. The objective was to perform useful reverse engineering tasks from a given base of legacy source code. The AtlanMod team (Hugo Bruneliere) and the Public Research Center Henri Tudor - Luxembourg (Jean-Sebastien Sottet, a former AtlanMod post-doc) worked together and proposed a model-based prototype using the MoDisco and ATL tools developed within the team. Javier Canovas got the best paper award in the National Spanish conference on MDE
Jordi Cabot gave an invited lecture in the 12th International School on Formal Methods for the Design of
Computer, Communication and Software Systems (http://
Teaching duties of AtlanMod members done in 2012 involved the following courses:
License: J. Cabot is in charge of a 24-hour course on MDE in the CS degree at the Ecole des Mines de Nantes .
Seminar: J. Canovas. Software modernization in Eclipse, 3h, Universidad de Cádiz, Spain.
Master: J. Canovas. Model-Driven Software Development, 2h, L1, Universidad Autónoma de Madrid, Spain
License: M. Tisi, Programmation Modulaire, 12h, L2, Ecole des Mines de Nantes
License: M. Tisi, Structures de Données, 15h, L3, Ecole des Mines de Nantes
License: M. Tisi, Interaction Homme-Machine, 15h, M1, Ecole des Mines de Nantes
License: M. Tisi, UML, 20h, M1, Ecole des Mines de Nantes
License: M. Tisi, Projet IPIPIP, 8h, L2, Ecole des Mines de Nantes
License: M. Tisi, Projet Integrateur PRIME, 12h, L3, Ecole des Mines de Nantes
License: M. Tisi, Programmation, 40h, L3, Ecole des Mines de Nantes
License: M. Tisi, Bases de Données, 33h, L3, Ecole des Mines de Nantes
License: M. Tisi, Interaction Homme-Machine, 14h, L3, Ecole des Mines de Nantes
HdR : Jordi Cabot, MDE 2.0 - Pragmatic Formal model verification and other challenges, ED-STIM Ecole des Mines de Nantes, 12/09/2012
PhD in progress : Carlos A. González, Pragmatic Model Verification, October 1st, 2011, Jordi Cabot
PhD in progress : Salvador Martínez Pérez, Automatic reconstruction and analysis of semantic network security policies from deployed security components, November 1st, 2011, Jordi cabot and Frédéric Cuppens
PhD in progress : Valerio Cosentino, Extraction and refactoring of Business Logic from Legacy Applications, December 1st, 2010, Jordi Cabot, Patrick Albert
Jordi Cabot was a member of the jury of the thesis of Thang Quyet Pham (Telecom Bretagne).
Jordi Cabot has co-written the book “Model-Driven Software Engineering in Practice” (published by Morgan and Claypool) , an introductory book to the domain of model driven engineering that discusses how approaches based on modeling can improve the daily practice of software professionals. The book is being used in more than 10 different universities as basic teaching material for MDE courses at the moment.
As part of our commitment to the Eclipse community (cf. next subsection), we co-organized again this year (together with the Obeo company) an Eclipse DemoCamp event in Nantes to promote the new Eclipse Juno version's release. The Eclipse DemoCamps are an opportunity to showcase all of the technology being built by local Eclipse community members, as well as an excellent opportunity to meet other Eclipse enthusiasts in the region (notably industrial actors) and present them some of the Eclipse-based technologies developed by the team in the context of our research works. This year, we have notably presented during the event our three latest prototypes: Collaboro, EMFtoCSP and Virtual EMF.
Also, we have been invited to present our team and its activities to the Board of Architects of Steria Ouest (premises located in Nantes). We described them our main research fields and experiments in term of modeling, and raised some real interest from their side. Concretely, this has resulted in a first successful collaboration with them that happened this year (cf. related subsection).
Since several years, the AtlandMod team is already very involved in the open source community, notably via its constant activity within the context of the Eclipse Foundation. This activity actually takes different forms: creation and leading/development of Eclipse projects (under Eclipse.org or Eclipse Labs), participation to the major worldwide community events (i.e.; EclipseCon North America and EclipseCon Europe), organization of events targeting the local community (i.e. Eclipse DemoCamps), etc.
This year again, the team has been active and visible in terms of concrete contributions to the community. The main remarkable items are the following ones:
Leading of the MDT MoDisco project (Hugo Bruneliere), the Eclipse reference project concerning model-driven reverse engineering;
Commitment to other projects directly under Eclipse.org: MMT ATL and EMFT EMF Facet (Hugo Bruneliere);
Commitment to other projects under EclipseLabs: EMFToCSP (Jordi Cabot, Carlos Gonzalez) and Virtual EMF (Caue Clasen, Jordi Cabot);
Creation and development of a new incubation project under Eclipse Labs: Collaboro (Javier Canovas);
Organization of an official Eclipse DemoCamp in Nantes, on the 28th of June 2012, for locally promoting the Eclipse Juno release including the MoDisco, ATL and EMF Facet team's projects (Hugo Bruneliere, in collaboration with the Obeo company);
Publication of a paper on MoDisco in the European ERCIM NEWS Journal 88, dedicated to Software Evolution (Hugo Bruneliere and Jordi Cabot, in collaboration with the Mia-Software company);
Presentation of talks during the two main Eclipse events (Hugo Bruneliere): at EclipseCon North America 2012 about EMF Facet, at EclipseCon Europe 2012 about Collaboro.
Generally, the team visible presence under Eclipse is also an efficient way to continue active collaborations with industrial partners, such as Mia-Software (Sodifrance) on MoDisco - EMF Facet, and Obeo on ATL.