19 research outputs found
Towards Systematic Mutations for and with ATL Model Transformations
Model transformation is a key technique to automate
software engineering tasks, such as generating implementations
of software systems from higher-level models. To enable
this automation, transformation engines are used to synthesize
various types of software artifacts from models, where the rules
according to which these artifacts are generated are implemented
by means of dedicated model transformation languages. Hence,
the quality of the generated software artifacts depends on the
quality of the transformation rules applied to generate them.
Thus, there is the need for approaches to certify their behavior
for a selected set of test models. As mutation analysis has proven
useful as a practical testing approach, we propose a set of
mutation operators for the ATLAS Transformation Language
(ATL) derived by a comprehensive language-centric synthesis
approach. We describe the rationale behind each of the mutation
operators and propose an automated process to generate mutants
for ATL transformations based on a combination of generic
mutation operators and higher-order transformations. Finally,
we describe a cost-effective solution for executing the obtained
mutants.European Commission ICT Policy Support Programme 317859Ministerio de Ciencia e Innovación TIN2011-2379
UML-based Cloud Application Modeling with Libraries, Profiles, and Templates
Recently, several cloud modeling approaches have emerged. They address
the diversity of cloud environments by introducing a considerable set of
modeling concepts in terms of novel domain-specific languages. At the same
time, general-purpose languages, such as UML, provide modeling concepts to
represent software, platform and infrastructure artifacts from different viewpoints
where the deployment view is of particular relevance for specifying the distribution
of application components on the targeted cloud environments. However, the
generic nature of UML’s deployment language calls for a cloud-specific extension
to capture the plethora of cloud provider offerings at the modeling level. In
this paper, we propose the Cloud Application Modeling Language (CAML) to facilitate
expressing cloud-based deployments directly in UML, which is especially
beneficial for migration scenarios where reverse-engineered UML models are tailored
towards a selected cloud environment. We discuss CAML’s realization as a
UML internal language that is based on a model library for expressing deployment
topologies and a set of profiles for wiring them with cloud provider offerings.
Finally, we report on the use of UML templates to contribute application
deployments as reusable blueprints and identify conceptual mappings between
CAML and the recently standardized TOSCA.European Commission ICT Policy Support Programme 31785
XMLText: From XML Schema to Xtext
A multitude of Domain-Specific Languages (DSLs) have
been implemented with XML Schemas. While such DSLs
are well adopted and flexible, they miss modern DSL editor
functionality. Moreover, since XML is primarily designed as
a machine-processible format, artifacts defined with XMLbased
DSLs lack comprehensibility and, therefore, maintainability.
In order to tackle these shortcomings, we propose
a bridge between the XML Schema Definition (XSD) language
and text-based metamodeling languages. This bridge
exploits existing seams between the technical spaces XMLware,
modelware, and grammarware as well as closes identified
gaps. The resulting approach is able to generate Xtextbased
editors from XSDs providing powerful editor functionality,
customization options for the textual concrete syntax
style, and round-trip transformations enabling the exchange
of data between the involved technical spaces.
We evaluate our approach by a case study on TOSCA,
which is an XML-based standard for defining Cloud deployments.
The results show that our approach enables bridging
XMLware with modelware and grammarware in several
ways going beyond existing approaches and allows the automated
generation of editors that are at least equivalent to
editors manually built for XML-based languages.European Commission ICT Policy Support Programme 31785
fREX: fUML-based Reverse Engineering of Executable Behavior for Software Dynamic Analysis
International audienceReverse engineering is still a challenging process, notably because of the growing number, heterogeneity, complexity, and size of software applications. While the analysis of their structural elements has been intensively investigated, there is much less work covering the reverse engineering of their behavioral aspects. To further stimulate research on this topic, we propose fREX as an open framework for reverse engineering of executable behaviors from existing software code bases. fREX currently provides model discovery support for behavior embedded in Java code, employs the OMG's fUML standard language as executable pivot format for dynamic analysis, and uses model transformations to bridge Java and fUML. Thus, fREX also aims at contributing to explore the relationship between programming languages (e.g., Java) and executable mod-eling languages (e.g., fUML). In this paper, we describe the proposed fREX framework and its current reverse engineering support covering some core Java features. In addition we discuss how the framework can be used for performing different kinds of dynamic analysis on existing software, as well as how it could be extended in the future
SLO-ML:A Language for Service Level Objective Modelling in Multi-cloud applications
Cloud modelling languages (CMLs) are designed to assist customers in tackling the diversity of services in the current cloud market. While many CMLs have been proposed in the literature, they lack practical support for automating the selection of services based on the specific service level objectives of a customer's application. We put forward SLO-ML, a novel and generative CML to capture service level requirements. Subsequently, SLO-ML selects the services to honour the customer's requirements and generates the deployment code appropriate to these services. We present the architectural design of SLO-ML and the associated broker that realises the deployment operations. We evaluate SLO-ML using an experimental case study with a group of researchers and developers using a real-world cloud application. We also assess SLO-ML's overheads through empirical scalability tests. We express the promises of SLO-ML in terms of gained productivity and experienced usability, and we highlight its limitations by analysing it as application requirements grow
Cloud Modeling Languages by Example
Recently, several proposals towards a cloud modeling language have emerged. As they address the diversity of cloud environments, it is not surprising that these modeling languages support different scenarios. Using a by-example approach based on the scenario of software migration, we demonstrate their representational capabilities and review them according to characteristics common to all modeling languages as well as specific to the cloud computing domain. We report on our findings and present research guidelines for future efforts towards a better alignment of the different cloud modeling languages
UML Profile Generation for Annotation-based Modeling
The capability of UML profiles to serve as annotation mechanism has been recognized in both industry and research. With JUMP, we have presented a fully automatic approach to generate profiles from annotation-based Java libraries. We have demonstrated the practical value of JUMP by contributing profiles that facilitate reverse-engineering and forward-engineering scenarios for the Java platform. Its evaluation shows that automatically generated profiles are equal or even improved in quality compared to profiles currently used in practice
Bridging Java Annotations and UML Profiles with JUMP
UML profiles support annotations at the modeling level. However, current modeling tools lack the capabilities to generate such annotations required for the programming level, which is desirable for reverse engineering and for- ward engineering scenarios. To overcome this shortcoming, we defined an effec- tive conceptual mapping between Java annotations and UML profiles as a basis for implementing the JUMP tool. It automates the generation of profiles from annotation-based libraries and their application to generate profiled UML mod- els. In this demonstration, we (i) compare our mapping with the different rep- resentational capabilities of current UML modeling tools, (ii) apply our tool to a model-based software modernization scenario, and (iii) evaluate its scalability with real-world libraries and applications.publishe