Results 1 -
6 of
6
Higher-order rewriting of model-to-text templates for integrating domain-specific modeling languages
- in Proc. 1st Int. Conf. Model-Driven
, 2013
"... Abstract: Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML wo ..."
Abstract
-
Cited by 6 (6 self)
- Add to MetaCart
(Show Context)
Abstract: Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML would yield a number of benefits, such as, a reduced testing and maintenance effort. However, in order to reuse the original templates for an integrated DSML, potential syntactical mismatches between the templates and the integrated metamodel must be solved. This paper proposes a technology-independent approach to template rewriting based on higher-order model transformations to address such mismatches in an automated manner. By considering M2T generator templates as first-class models and by reusing transformation traces, our approach enables syntactical template rewriting. To demonstrate the feasibility of this rewriting technique, we built a prototype for Eclipse EMF and Epsilon. 1
Requirements-driven Testing of Domain-specific Core Language Models using Scenarios
"... Abstract—In this paper, we present an approach for the scenario-based testing of the core language models of domainspecific modeling languages (DSML). The core language model is a crucial artifact in DSML development, because it captures all relevant domain abstractions and specifies the relations b ..."
Abstract
-
Cited by 5 (4 self)
- Add to MetaCart
(Show Context)
Abstract—In this paper, we present an approach for the scenario-based testing of the core language models of domainspecific modeling languages (DSML). The core language model is a crucial artifact in DSML development, because it captures all relevant domain abstractions and specifies the relations between these abstractions. In software engineering, scenarios are used to explore and to define (actual or intended) system behavior as well as to specify user requirements. The different steps in a requirements-level scenario can then be refined through detailed scenarios. In our approach, we use scenarios as a primary design artifact. Non-executable, human-understandable scenario descriptions can be refined into executable test scenarios. To demonstrate the applicability of our approach, we implemented a scenario-based testing framework based on the Eclipse Modeling Framework (EMF) and the Epsilon model-management toolkit. Keywords—Domain-specific modeling, scenario-based testing, language engineering, metamodel testing I.
Natural-Language Scenario Descriptions for Testing Core Language Models of Domain-specific Languages
"... Abstract: The core language model is a central artifact of domain-specific modeling languages (DSMLs) as it captures all relevant domain abstractions and their relations. Natural-language scenarios are a means to capture require-ments in a way that can be understood by technical as well as non-techn ..."
Abstract
-
Cited by 2 (2 self)
- Add to MetaCart
(Show Context)
Abstract: The core language model is a central artifact of domain-specific modeling languages (DSMLs) as it captures all relevant domain abstractions and their relations. Natural-language scenarios are a means to capture require-ments in a way that can be understood by technical as well as non-technical stakeholders. In this paper, we use scenarios for the testing of structural properties of DSML core language models. In our approach, domain experts and DSML engineers specify requirements via structured natural-language scenarios. These scenario descriptions are then automatically transformed into executable test scenarios providing forward and backward traceability of domain requirements. To demonstrate the feasibility of our approach, we used Eclipse Xtext to implement a requirements language for the definition of semi-structured scenarios. Transformation specifica-tions generate executable test scenarios that run in our test platform which is built on the Eclipse Modeling Framework and the Epsilon language family. 1
Towards testing the integration of MOF/UML-based domainspecific modeling languages
- in Proc. 8th IASTED Int. Conf. Advances in Computer Science
, 2013
"... Domain-specific modeling languages (DSMLs) are com-monly employed in the model-driven development (MDD) of software systems. As DSMLs are tailored for a narrow application domain, a software system needs to integrate multiple DSMLs for its complete specification. In this pa-per, we review the suitab ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
(Show Context)
Domain-specific modeling languages (DSMLs) are com-monly employed in the model-driven development (MDD) of software systems. As DSMLs are tailored for a narrow application domain, a software system needs to integrate multiple DSMLs for its complete specification. In this pa-per, we review the suitability of selected testing techniques for each phase of an MOF/UML-based DSML integration process. We exemplify every test technique by providing a motivating example of its application to the composition of existing, security-related DSMLs. As for evaluation, we provide for prototypical software implementations. KEYWORDS Domain-specific modeling language, language composi-
Framework, Epsilon
"... Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML would yield ..."
Abstract
- Add to MetaCart
(Show Context)
Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML would yield a number of benefits, such as, a reduced testing and maintenance effort. However, in order to reuse the original templates for an integrated DSML, potential syntactical mismatches between the templates and the integrated metamodel must be solved. This paper proposes a technology-independent approach to template rewriting based on higher-order model transformations to address such mismatches in an automated manner. By considering M2T generator templates as first-class models and by reusing transformation traces, our approach enables syntactical template rewriting. To demonstrate the feasibility of this rewriting technique, we built a prototype for Eclipse EMF and Epsilon. 1
Towards Benchmarking Evolution Support in Model-to-Text Transformation Systems
"... In model-driven development, an evolving metamodel as part of a changing software system requires the adaptation of interrelated ar-tifacts, such as, model-to-text (M2T) transformation specifications. In this paper, we propose a definition for a standard problem to evalu-ate the evolution support in ..."
Abstract
- Add to MetaCart
In model-driven development, an evolving metamodel as part of a changing software system requires the adaptation of interrelated ar-tifacts, such as, model-to-text (M2T) transformation specifications. In this paper, we propose a definition for a standard problem to evalu-ate the evolution support in M2T transformation systems. The objec-tive of the standard problem is to allow for benchmarking of multiple evolution-support techniques for M2T transformations. For this, we se-lected an existing, real-world software application acting as the basis for the standard-problem definition, describe a metamodel-evolution sce-nario (migration), and define a measurement plan to benchmark differ-ent implementations (thus, making them comparable). The applicabil-ity of the standard problem definition is exemplified by benchmarking an approach of higher-order rewriting M2T generator templates. 1
