Model-Driven Engineering Languages and Systems

Rapidly increasing numbers of applications and users make the development of mobile applications to one of the most promising fields in software engineering. Due to short time-to-market, differing platforms and fast emerging technologies, mobile application development faces typical challenges where model-driven development can help. We present a modeling language and an infrastructure for the model-driven development (MDD) of Android apps supporting the specification of different app variants according to user roles. For example, providing users may continuously configure and modify custom content with one app variant whereas end users are supposed to use provided content in their variant. Our approach allows a flexible app development on different abstraction levels: compact modeling of standard app elements, detailed modeling of individual elements, and separate provider models for specific custom needs. We demonstrate our MDD-approach at two apps: a phone book manager and a conference guide being configured by conference organizers for participants.

Cloud computing offers a flexible approach to elastically allocate computing resources for web applications without significant upfront hardware acquisition costs. Although a diverse collection of cloud resources is available, choosing the most optimized and cost-effective set of cloud resources to meet the QoS requirements is not a straightforward task. Manual load testing, monitoring of resource utilization, followed by bottleneck analysis is time consuming and complex due to limitations of the abstractions of load testing tools, challenges characterizing resource utilization, significant manual test orchestration effort, and complexity of selecting resource configurations to test. This paper introduces a model-based approach to simplify, optimize, and automate cloud resource allocation decisions to meet QoS goals for web applications. Given a high-level application description and QoS requirements, the model-based approach automatically tests the application under a variety of load and resources to derive the most cost-effective resource configuration to meet the QoS goals.

Society increasingly depends on web applications for business and pleasure. As the use of web applications continues to increase, the number of failures, some minor and some major, continues to grow. A significant problem is that we still have relatively weak abilities to test web applications. Traditional testing techniques do not adequately model or test these novel technologies. The atomic section model (ASM), models web applications to support design, analysis, and testing. This paper presents an empirical study to evaluate the effectiveness of the ASM. The model was implemented into a tool, WASP, which extracts the ASM from the implementation and supports various test criteria. We studied ten web applications, totaling 156 components and 11,829 lines of code. Using WASP, we generated 207 tests, which revealed 31 faults.Seventeen of those faults exposed internal information about the application and server.

Having multiple representations of the same instance is common in software language engineering: models can be visualised as graphs, edited as text, serialised as XML. When mappings between such representations are considered, terms “parsing” and “unparsing” are often used with incompatible meanings and varying sets of underlying assumptions. We investigate 12 classes of artefacts found in software language processing, present a case study demonstrating their implementations and state-of-the-art mappings among them, and systematically explore the technical research space of bidirectional mappings to build on top of the existing body of work and discover as of yet unused relationships.

Streaming model transformations represent a novel class of transformations dealing with models whose elements are continuously produced or modified by a background process [1]. Executing streaming transformations requires efficient techniques to recognize the activated transformation rules on a potentially infinite input stream. Detecting a series of events triggered by compound structural changes is especially challenging for a high volume of rapid modifications, a characteristic of an emerging class of applications built on runtime models.

In this paper, we propose a novel approach for streaming model transformations by combining incremental model query techniques with complex event processing (CEP) and reactive (event-driven) transformations. The event stream is automatically populated from elementary model changes by the incremental query engine, and the CEP engine is used to identify complex event combinations, which are used to trigger the execution of transformation rules. We demonstrate our approach in the context of automated gesture recognition over live models populated by

Kinect

sensor data.

Model-to-text (M2T) transformation is an important model management operation, used to implement code and documentation generation, model serialisation (enabling model interchange), and model visualisation and exploration. Despite the importance of M2T transformation, contemporary M2T transformation languages cannot be used to easily produce transformations that scale well as the size of the input model increases, which limits their applicability in practice. In this paper, we propose an extension to template-based M2T languages that adds support for signatures, lightweight and concise proxies for templates, which are used to reduce the time taken to re-execute a M2T transformation in response to changes to the input model. We report our initial results in applying signatures to two existing M2T transformations, which indicate a reduction of 33-47% in transformation execution time.

The paper explores a vision in modeling the behavior of complex systems by modular units hosting state machines arranged in part-whole hierarchies and communicating through event flows. Each modular unit plays at the same time the double role of part and whole, i.e. it is inspired by the philosophical idea of holon, providing both an interface and an implementation by which other component state machines may be controlled in order to achieve a global behavior. It is moreover observed that it is possible to assign a formal characterization to such state modules, due to their part-whole arrangement, since higher-level behaviors can derive formally their meaning from lower-level component behaviors. Such a way of arranging behavioral modules allows to establish directly correct-by-construction safety and liveness properties of state-based systems thus challenging the current approach by which state machines interact at the same level and have to be model-checked for ensuring correctness.

Identifying differences among models is a crucial prerequisite for several development and change management tasks in model-driven engineering. The majority of existing model differencing approaches focus on revealing syntactic differences which can only approximate semantic differences among models. Significant advances in semantic model differencing have been recently made by Maoz

et al

[16] who propose semantic diff operators for UML class and activity diagrams. In this paper, we present a generic semantic differencing approach which can be instantiated to realize semantic diff operators for specific modeling languages. Our approach utilizes the behavioral semantics specification of the considered modeling language, which enables to execute models and capture execution traces representing the models’ semantic interpretation. Based on this semantic interpretation, semantic differences can be revealed.

UML Profiles are not only sets of annotations. They have semantics. Executing a model on which a profile is applied requires semantics of this latter to be considered. The issue is that in practice semantics of profiles are mainly specified in prose. In this form it cannot be processed by tools enabling model execution. Although latest developments advocate for a standard way to formalize semantics of profiles, no such approach could be found in the literature. This paper addresses this issue with a systematic approach based on fUML to formalize the execution semantics of UML profiles. This approach is validated by formalizing the execution semantics of a subset of the MARTE profile. The proposal is compatible with any tool implementing UML and clearly identifies the mapping between stereotypes and semantic definitions.

UML is a comprehensive notation, offering a very large set of diagrams and constructs covering any possible modelling need. As consequence, on one hand, it is difficult and time consuming to master it, and on the other hand, people tend, naturally, to consider only a part of it. In practice, many UML diagrams/constructs seem scarcely used or even their existence is not known. By means of a study covering any possible source of information (e.g. UML books and tools), we started to assess which part of the UML is considered and used in practice. Here, we present some results about knowledge and usage of the UML diagrams by means of a personal opinion survey with 275 participants from both industry and academy, analysing also the influence of different factors: working environment (academia vs. industry), working role, seniority, education, and gender.

Model-Based Engineering (MBE) aims at increasing the effectiveness of engineering by using models as key artifacts in the development process. While empirical studies on the use and the effects of MBE in industry exist, there is only little work targeting the embedded systems domain. We contribute to the body of knowledge with a study on the use and the assessment of MBE in that particular domain. We collected quantitative data from 112 subjects, mostly professionals working with MBE, with the goal to assess the current State of Practice and the challenges the embedded systems domain is facing. Our main findings are that MBE is used by a majority of all participants in the embedded systems domain, mainly for simulation, code generation, and documentation. Reported positive effects of MBE are higher quality and improved reusability. Main shortcomings are interoperability difficulties between MBE tools, high training effort for developers and usability issues.

Although model-driven engineering (MDE) is now an established approach for developing complex software systems, it has not been universally adopted by the software industry. In order to better understand the reasons for this, as well as to identify future opportunities for MDE, we carried out a week-long design thinking experiment with 15 MDE experts. Participants were facilitated to identify the biggest problems with current MDE technologies, to identify grand challenges for society in the near future, and to identify ways that MDE could help to address these challenges. The outcome is a reflection of the current strengths of MDE, an outlook of the most pressing challenges for society at large over the next three decades, and an analysis of key future MDE research opportunities.

We present an approach, based on model-driven verifying compilation, to construct distributed applications that satisfy user-specified safety specifications, assuming a ”synchronous network” model of computation. Given a distributed application

P

d

and a safety specification

ϕ

in a domain specific language

dasl

(that we have developed), we first use a combination of sequentialization and software model checking to verify that

P

d

satisfies

ϕ

. If verification succeeds, we generate an implementation of

P

d

that uses a novel barrier-based synchronizer protocol (that we have also developed) to implement the synchronous network semantics. We present the syntax and semantics of

dasl

. We also present, and prove correctness of, two sequentialization algorithms, and the synchronizer protocol. Finally, we evaluate the two sequentializations on a collection of distributed applications with safety-critical requirements.

A contract splits the responsibilities between a component and its environment into a guarantee that expresses an intended property under the responsibility of the component, given that the environment fulfills the assumptions. Although current contract theories are limited to express contracts over interfaces of components, specifications that are not limited to interfaces are used in practice and are needed in order to properly express safety requirements. A framework is therefore presented, generalizing current contract theory to

environment-centric contracts

- contracts that are not limited to the interface of components. The framework includes revised definitions of properties of contracts, as well as theorems that specify exact conditions for when the properties hold. Furthermore, constraints are introduced, limiting the ports over which an environment-centric contract is expressed where the constraints constitute necessary conditions for the guarantee of the contract to hold in an architecture.

The emerging Model-driven Engineering approach puts models at the heart of the software development process. The Class Diagram language is central within the UML. Automated support for class diagrams involves identification and repair of

correctness

and

quality

problems.

This paper presents methods and rules for improving class diagram quality. The paper introduces formal semantics for class diagrams, which distinguishes between

existential

to

universal

constraints, and defines redundancy of existential constraints. It provides and analyzes algorithms for removing redundancy of multiplicity and generalization-set constraints in class diagrams with class hierarchy, qualifier, association class, aggregation/composition, and inter-association constraints, and presents inference rules for deducing element equivalence. All methods are under implementation in the

FiniteSatUSE

tool.

Models@run.time provides semantically rich reflection layers enabling intelligent systems to reason about themselves and their surrounding context. Most reasoning processes require not only to explore the current state, but also the past history to take sustainable decisions

e.g.

to avoid oscillating between states. Models@run.time and model-driven engineering in general lack native mechanisms to efficiently support the notion of history, and current approaches usually generate redundant data when versioning models, which reasoners need to navigate. Because of this limitation, models fail in providing suitable and sustainable abstractions to deal with domains relying on history-aware reasoning. This paper tackles this issue by considering history as a native concept for modeling foundations. Integrated, in conjunction with lazy load/storage techniques, into the Kevoree Modeling Framework, we demonstrate onto a smart grid case study, that this mechanisms enable a sustainable reasoning about massive historized models.

In order to develop appropriate adaptation policies for self-adaptive systems, developers usually have to accomplish two main tasks: (i) identify the application-level constraints that regulate the desired system states for the various contexts, and (ii) figure out how to transform the system to satisfy these constraints. The second task is challenging because typically there is complex interaction among constraints, and a significant gap between application domain expertice and state transition expertice. In this paper, we present a model-driven approach that relieves developers from this second task, allowing them to directly write domain-specific constraints as adaptation policies. We provide a language to model both the domain concepts and the application-level constraints. Our runtime engine transforms the model into a Satisfiability Modulo Theory problem, optimises it by pre-processing on the current system state at runtime, and computes required modifications according to the specified constraints using constraints solving. We evaluate the approach addressing a virtual machine placement problem in cloud computing.

Cloning a model is usually done by duplicating all its runtime objects into a new model. This approach leads to memory consumption problems for operations that create and manipulate large quantities of clones (e.g., design space exploration). We propose an original approach that exploits the fact that operations rarely modify a whole model. Given a set of immutable properties, our cloning approach determines the objects and fields that can be shared between the runtime representations of a model and its clones. Our generic cloning algorithm is parameterized with three strategies that establish a trade-off between memory savings and the ease of clone manipulation. We implemented the strategies within the Eclipse Modeling Framework (EMF) and evaluated memory footprints and computation overheads with 100 randomly generated metamodels and models. Results show a positive correlation between the proportion of shareable properties and memory savings, while the worst median overhead is 9,5% when manipulating the clones.

Large software product lines need to manage complex variability. A common approach is variability modeling—creating and maintaining models that abstract over the variabilities inherent in such systems. While many variability modeling techniques and notations have been proposed, little is known about industrial practices and how industry values or criticizes this class of modeling. We attempt to address this gap with an exploratory case study of three companies that apply variability modeling. Among others, our study shows that variability models are valued for their capability to organize knowledge and to achieve an overview understanding of codebases. We observe centralized model governance, pragmatic versioning, and surprisingly little constraint modeling, indicating that the effort of declaring and maintaining constraints does not always pay off.

When developing large-scale industrial software systems engineers need to instantiate, configure, and deploy diverse reusable components. The number of component instances required depends on customer requirements only known during configuration and is typically unknown when modeling the systems’ variability. Also, the hierarchy of dynamically created component instances leads to complex dependencies between configuration decisions. Dealing with component multiplicity and hierarchy thus requires an approach capable of expressing the dependencies among dynamically instantiated components and configuration decisions. Furthermore, users need tool support for navigating the complex decision space during configuration. In this experience paper we report on applying a decision-oriented modeling approach for defining component variability, multiplicity, and hierarchy. We further present a configuration tool that guides end users through the complex decision space. We report applications of the approach to industrial software systems and describe patterns and lessons learned.

In configuration processes with multiple stakeholders, conflicts are very likely because each decision maker has a different concerns and expectations about the product. They may not be aware of features selected by others or the restrictions that these selections impose. To help solve the conflicts, this paper introduces a new approach to provide

explanations

about their causes. Our approach is based on representing features from different concerns using different Feature Models (FMs), and relating them through Feature-Solution Graphs. An FSG contains dependency relationships between two FMs: one feature from the left side forces or prohibits the selection of features in the right side feature model. The strategy to detect and explain conflicts is based on propagation of constraints over the FSGs. We claim that our approach is more expressive and efficient than when using a single FM that contains all concerns and SAT solvers to detect conflicts.

We present the tools, metamodels and code generation techniques in use at Elettronica SpA for the development of communication adapters for software and firmware systems from heterogeneous models. The process start from a SysML system model, developed according to the platform-based design (PBD) paradigm, in which a functional model of the system is paired to a model of the execution platform. Subsystems are refined as Simulink models or hand coded in C++. In turn, Simulink models are implemented as software code or firmware on FPGA, and an automatic generation of the implementation is obtained. Based on the SysML system architecture specification, our framework drives the generation of Simulink models with consistent interfaces, allows the automatic generation of the communication code among all subsystems (including the HW-FW interface code).

To increase the performance of embedded devices, the current trend is to shift from serial to parallel and distributed computing with simultaneous instructions execution. The performance increase of parallel computing wouldn’t be possible without efficient transfers of data and control information via complex communication architectures. In UML/SysML/MARTE, different solutions exist to describe and map computations onto parallel and distributed systems. However, these languages lack expressiveness to clearly separate computation models from communication ones, thus strongly impacting models’ portability, especially when performing Design Space Exploration. As a solution to this issue, we present Communication Patterns, a novel UML modeling artifact and model-driven approach to assist system engineers in efficiently modeling and mapping communications for parallel and distributed system architectures. We illustrate the effectiveness of our approach with the design of a parallel signal processing algorithm mapped to a multi-processor platform with a hierarchical bus-based interconnect.

In order to handle complexity of software systems, component-based as well as model-driven approaches have become popular in the past. In a model-driven development process the problem arises that over time model and code may be not aligned. Thus, in order to avoid this steadily increasing distance between models and code, we propose the integration of (executable) models and code at the component level. Redundancy – the source of inconsistencies – is reduced by interpreting models directly. Moreover, variability and adaptivity can be achieved by querying and transforming the embedded models. As the basis for such Model-Integrating Components (MoCos), we introduce a component realization concept that is compatible with existing component technologies. We provide a reference implementation using Java, OSGi and TGraphs and apply it successfully in a feasibility study on Android

TM

.

The development of control systems for large telescopes is frequently challenged by the combination of research and industrial development processes, the bridging of astronomical and engineering domains, the long development and maintenance time-line, and the need to support multiple hardware and software platforms. This paper illustrates the application of a model driven engineering approach to mitigate some of these recurring issues. It describes the lessons learned from introducing a modeling language and creating model transformations for analysis, documentation, simulation, validation, and code generation.

We demonstrate the application of Model Driven Engineering techniques to support the development of research grant proposals. In particular, we report on using model-to-text transformation and model validation to enhance productivity and consistency in research proposal writing, and present unanticipated opportunities that were revealed after establishing an MDE infrastructure. We discuss the types of models and the technologies used, reflect on our experiences, and assess the productivity benefits of our MDE solution through automated analysis of data extracted from the version control repository of a successful grant proposal; our evaluation indicates that the use of MDE techniques improved productivity by at least 58%.

Model-driven engineering focuses on structuring systems as well as permitting domain experts to be directly involved in the software development. Agile methods aim for fast feedback and providing crucial knowledge early in the project. In our study, we have seen a successful combination of MDE and agile methods to support the development of complex, software-driven mechatronic systems. We have investigated how combining MDE and agile methods can reduce the number of issues caused by erroneous assumptions in the software of these mechatronic systems. Our results show that plant models to simulate mechanical systems are needed to enable agile MDE during the mechatronic development. They enable developers to run, verify, and validate models before the mechanical systems are delivered from suppliers. While two case studies conducted at Volvo Car Group confirm that combining MDE and agile works, there are still challenges e.g. how to optimize the development of plant models.

Many laws, e.g., those concerning taxes and social benefits, need to be operationalized and implemented into public administration procedures and eGovernment applications. Where such operationalization is warranted, the legal frameworks that interpret the underlying laws are typically

prescriptive

, providing

procedural rules

for ensuring legal compliance. We propose a UML-based approach for modeling procedural legal rules. With help from legal experts, we investigate actual legal texts, identifying both the information needs and sources of complexity in the formalization of procedural legal rules. Building on this study, we develop a UML profile that enables more precise modeling of such legal rules. To be able to use logic-based tools for compliance analysis, we automatically transform models of procedural legal rules into the Object Constraint Language (OCL). We report on an application of our approach to Luxembourg’s Income Tax Law providing initial evidence for the feasibility and usefulness of our approach.

The Common Variability Language (CVL) allows deriving new products in a software product line by substituting fragments (placement) in the base model. Relations between elements of different placement fragments are an issue. Substitutions involving interfering placements may give unexpected and unintended results. However, there is a pragmatic need to define and execute fragments with interference. The need emerges when several diagrams are views of a single model, such as a placement in one diagram and a placement in another diagram reference the same model elements. We handle the issue by 1) classifying interfering fragments, 2) finding criteria to detect them, and 3) suggesting solutions via transformations. We implement our findings in the tooling available for downloading.

Context-aware systems aim to improve the interaction between a computer and a human being by using contextual information about the system itself, the user, and their environment. The number of relevant contextual information is expected to grow rapidly within the next years which tends to result in a complex, error-prone and hence, expensive task of programming context-aware systems. Model-based development can overcome these issues. Current approaches do not allow to model calculation of reliabilities and do not offer options to handle multiple sources of contextual information.

In this paper, we present an approach of modeling contextual information of a context-aware system using the example of a context-aware in-car infotainment system. In particular, we show how developers of context-aware in-car infotainment systems can model reliability calculations of contextual information and handling of multiple sources of contextual information by using a hybrid, ontology-based modeling technique.

Feature modeling is a common way to present and manage variability of software and systems. As a prerequisite for effective variability management is comprehensible representation, the main aim of this paper is to investigate difficulties in understanding feature models. In particular, we focus on the comprehensibility of feature models as expressed in Common Variability Language (CVL), which was recommended for adoption as a standard by the Architectural Board of the Object Management Group. Using an experimental approach with participants familiar and unfamiliar with feature modeling, we analyzed comprehensibility in terms of comprehension score, time spent to complete tasks, and perceived difficulty of different feature modeling constructs. The results showed that familiarity with feature modeling did not influence the comprehension of mandatory, optional, and alternative features, although unfamiliar modelers perceived these elements more difficult than familiar modelers. OR relations were perceived as difficult regardless of the familiarity level, while constraints were significantly better understood by familiar modelers. The time spent to complete tasks was higher for familiar modelers.

Practical experience suggests that usage and understanding of UML diagrams is greatly affected by the quality of their layout. While existing research failed to provide conclusive evidence in support of this hypothesis, our own previous work provided substantial evidence to this effect. When studying different factors like diagram type and expertise level, it became apparent that diagram size plays an important role, too. Since we lack an adequate understanding of this notion, in this paper, we define diagram size metrics and study their impact to modeler performance. We find that there is a strong negative correlation between diagram size and modeler performance. Our results are highly significant. We utilize these results to derive a recommendation on diagram sizes that are optimal for model understanding.

The development of graphical editors for visual DSLs is far from being a trivial task. There are consequently several tools that provide technical support for this task. However, this paper shows that the analysis of the main characteristics of such tools leaves some space for improvement as regard the cognitive effectiveness of the visual notations produced with them. To deal with this issue, this work introduces CEViNEdit, a GMF-based framework for the development of visual DSLs which takes into account Moody’s principles for the development and evaluation of graphical notations. To that end, CEViNEdit eases the selection of values for the visual variables of which the notation is composed, computes a set of metrics to assess the appropriateness of these values and then automates the generation of the graphical editor.

The capability of UML profiles to serve as annotation mechanism has been recognized in both industry and research. Today’s modeling tools offer profiles specific to platforms, such as Java, as they facilitate model-based engineering approaches. However, the set of available profiles is considerably smaller compared to the number of existing Java libraries using annotations. This is because an effective mapping between Java and UML to generate profiles from annotation-based libraries is missing. In this paper, we present

JUMP

to overcome this limitation, thereby continuing existing mapping efforts by emphasizing on annotations and profiles. We demonstrate the practical value of

JUMP

by contributing profiles that facilitate reverse-engineering and forward-engineering scenarios for the Java platform. The evaluation of

JUMP

shows that profiles can be automatically generated from Java libraries exhibiting equal or even improved quality compared to profiles currently used in practice.

Model manipulation environments automate model operations such as model consistency checking and model transformation. A number of external model manipulation

Domain-Specific Languages

(DSL) have been proposed, in particular for the

Eclipse Modeling Framework

(EMF). While their higher levels of abstraction result in gains in expressiveness over general-purpose languages, their limitations in versatility, performance, and tool support together with the need to learn new languages may significantly contribute to accidental complexities.

In this paper, we present

Sigma

, a family of internal DSLs embedded in Scala for EMF model consistency checking, model-to-model and model-to-text transformations. It combines the benefits of external model manipulation DSLs with general-purpose programming taking full advantage of Scala versatility, performance and tool support. The DSLs are compared to the state-of-the-art Epsilon languages in non-trivial model manipulation tasks that resulted in 20% to 70% reduction in code size and significantly better performance.

We present a framework and methodology to benchmark NoSQL stores for large scale model persistence. NoSQL technologies potentially improve performance of some applications and provide schema-less data-structures, so are particularly suited to persisting large and heterogeneous models. Recent studies consider only a narrow set of NoSQL stores for large scale modelling. Benchmarking many technologies requires substantial effort due to the disparate interface each store provides. Our experiments compare a broad range of NoSQL stores in terms of processor time and disc space used. The framework and methodology is evaluated through a case study that involves persisting large reverse-engineered models of open source projects. The results give tool engineers and practitioners a basis for selecting a store to persist large models.

In Model-Driven Engineering (MDE) models are first-class entities that are manipulated by means of model transformations. The development of complex and large transformations can benefit from the reuse of smaller ones that can be composed according to user requirements. Composing transformations is a complex problem: typically smaller transformations are discovered and selected by developers from different and heterogeneous sources. Then the identified transformations are chained by means of manual and error-prone composition processes.

In this paper we propose an approach to automatically discover and compose transformations: developers provide the system with the source models and specify the target metamodel. By relying on a repository of model transformations, all the possible transformation chains are calculated. Importantly, in case of incompatible intermediate target and source metamodels, proper adapters are automatically generated in order to chain also transformations that otherwise would be discarded by limiting the reuse possibilities of available transformations.

While comparing different model transformation languages (MTLs), it is common to refer to their syntactic and semantic features and overlook their supporting tools’ performance. Performance is one of the aspects that can hamper the application of MDD to industrial scenarios. An highly declarative MTL might simply not scale well when using large models due to its supporting implementation. In this paper, we focus on the several pattern matching techniques (including optimization techniques) employed in the most popular transformation tools, and discuss their effectiveness w.r.t. the expressive power of the languages used. Because pattern matching is the most costly operation in a transformation execution, we present a classification of the existing model transformation tools according to the pattern matching optimization techniques they implement. Our classification complements existing ones that are more focused at syntactic and semantic features of the languages supported by those tools.

We propose an evolutionary approach that, in addition to learn model transformation rules from examples, allows to capture implicit and explicit control over the transformation rules. The derivation of both transformation and control knowledge is performed through a heuristic search, i.e., a genetic programming algorithm, guided by the conformance with examples of past transformations supplied as pairs of source and target models. Our approach is evaluated on four model transformation problems that require non-trivial control. The obtained results are convincing for three of the four studied problems.

Queries are the foundations of data intensive applications. In model-driven software engineering (MDE), model queries are core technologies of tools and transformations. As software models are rapidly increasing in size and complexity, traditional tools exhibit scalability issues that decrease productivity and increase costs [17]. While scalability is a hot topic in the database community and recent NoSQL efforts have partially addressed many shortcomings, this happened at the cost of sacrificing the ad-hoc query capabilities of SQL. Unfortunately, this is a critical problem for MDE applications due to their inherent workload complexity. In this paper, we aim to address both the scalability and ad-hoc querying challenges by adapting incremental graph search techniques – known from the

EMF-IncQuery

framework – to a distributed cloud infrastructure. We propose a novel architecture for distributed and incremental queries, and conduct experiments to demonstrate that

IncQuery-D

, our prototype system, can scale up from a single workstation to a cluster that can handle very large models and complex incremental queries efficiently.

Model-driven tools use model queries for many purposes, including validation of well-formedness rules and specification of derived features. The majority of declarative model query corpus available in industry appears to use the OCL language. Graph pattern based queries, however, would have a number of advantages due to their more abstract specification, such as performance improvements through advanced query evaluation techniques. As query performance can be a key issue with large models, evaluating graph patterns instead of OCL queries could be useful in practice.

The current paper presents an automatic mapping from a large sublanguage of OCL expressions to equivalent graph patterns in the dialect of

EMF-IncQuery

. Validation of benefits is carried out by performance measurements according to an existing benchmark.