Search

Domain-specific languages (DSLs) become more useful the more specific they are to a particular domain. The resulting need for developing a substantial number of DSLs can only be satisfied if DSL development can be made as efficient as possible. One way in which to address this challenge is by enabling the reuse of (partial) DSLs in the construction of new DSLs. Reuse of DSLs builds on two foundations: a notion of DSL composition and theoretical results ensuring the safeness of composing DSLs with respect to the semantics of the component DSLs. Given a graph-grammar formalisation of DSLs, in this paper, we build on graph transformation system morphisms to define parameterised DSLs and their instantiation by an amalgamation construction. Results on the protection of the behaviour along the induced morphisms allow us to safely reuse and combine definitions of DSLs to build more complex ones. We illustrate our proposal in e-Motions for a DSL for production-line systems and three independent DSLs for describing non-functional properties, namely response time, throughput, and failure rate.

A reliable, accurate, and yet simple dynamic model is important to analyze, design and control hybrid rigid-continuum robots.Such models should be fast, as simple as possible and user-friendly to be widely accepted by the ever-growing robotics research community.In this study, we introduce two new modeling methods for continuum manipulators: a general reduced-order model (ROM) and a discretized model with absolute states and Euler-Bernoulli beam segments (EBA).Additionally, a new formulation is presented for a recently introduced discretized model based on Euler-Bernoulli beam segments and relative states (EBR).We implement these models to a Matlab software package, named $TMTDyn$, to develop a modeling tool for hybrid rigid-continuum systems.The package features a new High-Level Language (HLL) text-based interface, a CAD-file import module, automatic formation of the system Equation of Motion (EOM) for different modeling and control tasks, implementing Matlab C-mex functionality for improved performance, and modules for static and linear modal analysis of a hybrid system.The underlying theory and software package are validated for modeling experimental results for (i) dynamics of a continuum appendage, and (ii) general deformation of a fabric sleeve worn by a rigid link pendulum.A comparison shows higher simulation accuracy (8-14\% normalized error) and numerical robustness of the ROM model for a system with small number of states, and computational efficiency of the EBA model with near real-time performances that makes it suitable for large systems.The challenges and necessary modules to further automate the design and analysis of hybrid systems with a large number of states are briefly discussed in the end.

Hybrid rigid-continuum robot design addresses a range of challenges associated with using soft robots in application areas such as robotic surgery. Design of such robots poses challenges beyond standard rigid-body robots. A fast, reliable, accurate yet simple dynamic model is important to support the design, analysis, and control of hybrid rigid-continuum robots. In our previous work, we developed a modeling package for hybrid rigid-continuum systems, named TMTDyn. In this paper, we focus on how we developed an internal domain-specific language (DSL) using Matlab's OO capabilities and the concept of fluent interfaces to improve validation, understandability, and maintainability of the models constructed using TMTDyn. We present the language implementation, and discuss some of the benefits and challenges of building a Matlab-internal DSL.

Recently there has been increased interest in combining the fields of Model-Driven Engineering (MDE) and Search-Based Software Engineering (SBSE). Such approaches use meta-heuristic search guided by search operators (model mutators and sometimes breeders) implemented as model transformations. The design of these operators can substantially impact the effectiveness and efficiency of the meta-heuristic search. Currently, designing search operators is left to the person specifying the optimisation problem. However, developing consistent and efficient search-operator rules requires not only domain expertise but also in-depth knowledge about optimisation, which makes the use of model-based meta-heuristic search challenging and expensive. In this paper, we propose a generalised approach to automatically generate atomic consistency preserving search operators (aCPSOs) for a given optimisation problem. This reduces the effort required to specify an optimisation problem and shields optimisation users from the complexity of implementing efficient meta-heuristic search mutation operators. We evaluate our approach with a set of case studies, and show that the automatically generated rules are comparable to, and in some cases better than, manually created rules at guiding evolutionary search towards near-optimal solutions. This paper is an extended version of the paper with the same title published in the proceedings of the 22nd International Conference on Model Driven Engineering Languages and Systems (MODELS '19)., Comment: Technical report version of the MODELS 2019 paper with the same title

We argue for a general-purpose source code analysis tool that is aware of aspects.We present the logic program querying tool GASR, the first such tool.We discuss its implementation along with its library of logical predicates.We show how it can automatically verify previously published aspectual assumptions. Aspect-oriented programming languages extend existing languages with new features for supporting modularization of crosscutting concerns. These features however make existing source code analysis tools unable to reason over this code. Consequently, all code analysis efforts of aspect-oriented code that we are aware of have either built limited analysis tools or were performed manually. Given the significant complexity of building them or manual analysis, a lot of duplication of effort could have been avoided by using a general-purpose tool. To address this, in this paper we present Gasr: a source code analysis tool that reasons over AspectJ source code, which may contain metadata in the form of annotations. GASR provides multiple kinds of analyses that are general enough such that they are reusable, tailorable and can reason over annotations. We demonstrate the use of GASR in two ways: we first automate the recognition of previously identified aspectual source code assumptions. Second, we turn implicit assumptions into explicit assumptions through annotations and automate their verification. In both uses GASR performs detection and verification of aspect assumptions on two well-known case studies that were manually investigated in earlier work. GASR finds already known aspect assumptions and adds instances that had been previously overlooked.

Model Driven Engineering (MDE) is a methodology that aims to simplify the process of designing complex systems, by using models as an abstract representation of the underlying system.This methodology allows domain experts to more easily focus on system design, where their knowledge is more useful, without having to work with the system implementation complexities. Search Based Model Engineering applies MDE concepts to optimisation problems. The goal is to simplify the process of solving optimisation problems for domain experts, by abstracting the complexity of solving optimisation problems and allowing them to focus on the domain level issues..In this tool demostration we present MDEOptimiser (MDEO), a tool for specifying and solving optimisation problems using MDE. With MDEO the user can specify optimisation problems using a simple DSL. The tool can run evolutionary optimisation algorithms that use models as an encoding for population members and model transformations as search operators. We showcase the functionality of the tool using a number of case studies. We aim to show that with MDEO, specifying optimisation problems becomes a less complex task compared to custom implementations.

Over recent years, optimisation and evolutionary search have seen substantial interest in the MDE research community. Many of these techniques require the specification of an optimisation problem to include a set of model transformations for deriving new solution candidates from existing ones. For some problems—for example, planning problems, where the domain only allows specific actions to be taken—this is an appropriate form of problem specification. However, for many optimisation problems there is no such domain constraint. In these cases providing the transformation rules over-specifies the problem. The choice of rules has a substantial impact on the efficiency of the search, and may even cause the search to get stuck in local optima.

Teaching systematic object-oriented software development to undergraduate students is difficult: Students need to develop a lot of complex skills. These include technical skills in object-oriented software development, but also social skills-for example, how to collaborate with other developers as part of a team working towards a large and complex software system. To acquire these skills, students need hands-on development experiences-for example, through team-oriented project courses. Designing such project courses is a challenge in itself: They must be both sufficiently challenging and achievable within the limited time available. In our special situation (large numbers of students supervised by small numbers of staff) an important further requirement is scalability: Different projects should be easily comparable while allowing for different tasks for different teams to reduce the risk of plagiarism. The solution that in our experience satisfies all these requirements is to use an application framework for an everyday application domain-for example, the business domain. Since 1997, we have been using Salespoint, a Java-based framework for creating business applications, that has been jointly developed and maintained in Dresden and Munich. In this paper, we briefly recollect the educational background and aims of the courses and present in some detail Salespoint (and its most recent revision, Salespoint2010): central notions like catalogs and stocks, the functionality it offers to users (application control, data management, and much more), a technical overview of its architecture, an example application built with Salespoint, and some lessons learned so far.

Context: Domain-Specific Visual Languages (DSVLs) play a crucial role in Model-Driven Engineering (MDE). Most DSVLs already allow the specification of the structure and behavior of systems. However, there is also an increasing need to model, simulate and reason about their non-functional properties. In particular, QoS usage and management constraints (performance, reliability, etc.) are essential characteristics of any non-trivial system. Objective: Very few DSVLs currently offer support for modeling these kinds of properties. And those which do, tend to require skilled knowledge of specialized notations, which clashes with the intuitive nature of DSVLs. In this paper we present an alternative approach to specify QoS properties in a high-level and platform-independent manner. Method: We propose the use of special objects (observers) that can be added to the graphical specification of a system for describing and monitoring some of its non-functional properties. Results: Observers allow extending the global state of the system with the variables that the designer wants to analyze, being able to capture the performance properties of interest. A performance evaluation tool has also been developed as a proof of concept for the proposal. Conclusion: The results show how non-functional properties can be specified in DSVLs using observers, and how the performance of systems specified in this way can be evaluated in a flexible and effective way.

The quality of a software system can be measured by the extent to which it possesses a desired combination of quality attributes (QAs). While some QAs are achieved implicitly through the interaction of various functional components of the system, others (e.g., security) can be encapsulated in dedicated software components. These QAs are known as functional quality attributes (FQAs). As applications may require different FQAs, and each FQA can be composed of many concerns (e.g., access control and authentication), integrating FQAs is very complex and requires dedicated expertise. Software architects are required to manually define FQA components, identify appropriate points in their architecture where to weave them, and verify that the composition of these FQA components with the other components is correct. This is a complex and error prone process. In our previous work we defined reusable FQAs by encapsulating them as aspectual architecture models that can be woven into a base architecture. So far, the joinpoints for weaving had to be identified manually. This made it difficult for software architects to verify that they have woven all the necessary FQAs into all the right places. In this paper, we address this problem by introducing a notion of contract for FQAs so that the correct application of an FQA (or one of its concerns) can be checked or, alternatively, appropriate binding points can be identified and proposed to the software architect automatically. Ministerio de Economía y Competitividad TIN2012-34840 Junta de Andalucía MAGIC P12-TIC1814

As model transformations become more complex and more central to software development, reuse mechanisms become more important to enable effective and efficient development of high-quality transformations. A number of transformation-reuse mechanisms have been proposed, but so far there have been no effective attempts at evaluating the quality of reuse that can be achieved by these approaches. In this paper, we build on our earlier work on transformation intents and propose a systematic approach for analyzing the soundness and completeness of a given transformation reuse mechanism with respect to the preservation of transformation intent. We apply this approach to analyze transformation-reuse mechanisms currently proposed in the literature and show that these mechanisms are not sound or complete. We show why providing sound transformation reuse mechanisms is a hard problem, but provide some evidence that by limiting ourselves to specific families of transformations and modeling languages the problem can be simplified. As a result of our exploration, we propose a new research agenda into the development of sound (and possibly complete) transformation reuse mechanisms.

Model transformations are an essential part of model-based development approaches, such as Model-driven Architecture (MDA) and Model-driven Development (MDD). Model transformations are used to refine and abstract models, to re-express models in a new modelling language, and to analyse, refactor, compare and improve models. Therefore, the correctness of model transformations is critically important for successful application of model-based development: software developers should be able to rely upon the correct processing of their models by transformations in the same way that they rely upon compilers to produce correct executable versions of their programs. In this paper, we address this problem by defining standard structures for model transformation specifications and implementations, which serve as patterns and strategies for constructing a wide range of model transformations. These are incorporated into a tool-supported process which automatically synthesises implementations of model transformations from their specifications, these implementations are correct-by-construction with respect to their specifications.

Model-driven engineering (MDE) involves the construction and manipulation of many models of different kinds in an engineering process. In principle, models can be used in the product engineering lifecycle in an end-to-end manner for representing requirements, designs and implementations, and assisting in deployment and maintenance. The manipulations applied to models may be manual, but they can also be automated--for example, using model transformations, code generation, and validation. To enhance automated analysis, consistency and coherence of models used in an MDE process, it is useful to identify, establish and maintain trace-links between models. However, the breadth and scope of trace-links that can be used in MDE is substantial, and managing trace-link information can be very complex. In this paper, we contribute to managing the complexity of traceability information in MDE in two ways: firstly, we demonstrate how to identify the different kinds of trace-links that may appear in an end-to-end MDE process; secondly, we describe a rigorous approach to defining semantically rich trace-links between models, where the models themselves may be constructed using diverse modelling languages. The definition of rich trace-links allows us to use tools to maintain and analyse traceability relationships.

The Modeling in Software Engineering (MiSE) workshop series provides a forum for discussing the challenges associated with modeling software and with incorporating modeling practices into the software development process. The main goal of the series is to further promote cross-fertilization between the modeling communities (e.g., MODELS) and software-engineering communities. In particular, the workshop provides a medium to exchange innovative technical ideas and experiences related to modeling. The 2009 MiSE workshop provided a venue for presentation and discussion of eleven papers in the five areas of model evolution, domain specific languages, verification and validation, model transformation and state-of-the-art modeling usage in software development. These papers represent a 44% acceptance rate to the workshop. Three posters were also accepted. This report summarizes the discussions and conclusions of the workshop.

Component-based software engineering (CBSE) is viewed as an opportunity to deal with the increasing complexity of modern-day software. Along with CBSE comes the notion of component markets, where more or less generic pieces of software are traded, to be combined into applications by third-party application developers. For such a component market to work successfully, all relevant properties of components must be precisely and formally described. This is especially true for non-functional properties, such as performance, memory foot print, or security. While the specification of functional properties is well understood, non-functional properties are only beginning to become a research focus. This paper discusses semantic concepts for the specification of non-functional properties, taking into account the specific needs of a component market. Based on these semantic concepts, we present a new specification language QML/CS that can be used to model non-functional product properties of components and component-based software systems.

International audience; The RELATE Initial Training Network (ITN), funded by the EU in the Marie Curie Actions programme, is a multidisci- plinary training network of European academic and indus- trial partners working together to train academic researchers and next generation experts in the area of engineering and provisioning of service-based Cloud applications. In this pa- per, we present the up-to-date goals and strategy of the RE- LATE project and give an overview of the ongoing research activities within the training network.

Provenance awareness adds a new dimension to SOC systems' design allowing them to answer different kinds of questions about the system's history processing by recording information during system execution. Incorporating provenance in SOC systems requires to carefully model and analyse provenance infrastructure requirements at system's design time in order to cope with the inherent complexity encapsulated into the SOC systems' execution cycle, considering the aspects of service discovery, selection and dynamic composition. Formally specifying provenance-infrastructure behavior assists in the design/analysis of the system's accountability by introducing provenance mechanisms to collect the respective provenance where the latter can be verified and revised beforehand the system's actual implementation. We have previously presented a data model to express the graph-based structure of the provenance data collected for composite services. In this paper we focus on a template provenance-infrastructure model specifying the behavior required in order to issue the respective provenance recording calls through the SOC execution cycle. We then bind the infrastructure design to specific SOC models in order to analyze whether this leads to actual recording of the provenance required for answering provenance queries. We accomplish this by proposing a generic algorithm that simulates the provenance-infrastructure behavior and generates sample provenance-data graphs.

We present enforceable component-based realtime contracts, the first extension of component-based software engineering technology that comprehensively supports adaptive realtime systems from specification all the way to the running system. To provide this support, we have extended component-based interface definition languages (IDLs) and component representations in repositories to express realtime requirements for components. The final software, which is assembled from the components, is then executed on a realtime operating system (RTOS) with the help of a component runtime system. RTOS resource managers and the IDL-extensions are based on the same mathematical foundation. Thus, the component runtime system can use information expressed in a component-oriented manner in the extended IDL to derive parameters for the task-based admission and scheduling in the RTOS. Once basic realtime properties can thus be guaranteed, runtime support can be extended to more elaborate schemes that also support adaptive applications (container-managed quality assurance). We claim that this study convincingly demonstrates how component-based software engineering can be extended to build systems with non-functional requirements.

Model driven architecture (MDA) views application development as a continuous transformation of models of the target system. We propose a methodology which extends this view to non-functional properties. In previous publications we have shown how we can use so-called context models to make the specification of non-functional measurements independent of their application in concrete system specifications. We have also shown how this allows us to distinguish two roles in the development process: the measurement designer and the application designer. In this paper we use the notion of context models to allow the measurement designer to provide measurement definitions at different levels of abstraction. A measurement in our terminology is a non-functional dimension that can be constrained to describe a non-functional property. Requiring the measurement designer to define transformations between context models, and applying them to measurement definitions, enables us to provide tool support for refinement of non-functional constraints to the application designer. The paper presents the concepts for such tool support as well as a prototype implementation.

Elasticity refers to the auto-scaling ability of clouds towards optimally matching their resources to actual demand conditions. An important problem facing the infrastructure and service providers is how to optimise their resource configurations online, to elastically serve time-varying demands. Most scaling methodologies provide resource reconfiguration decisions to maintain quality properties under environment changes. However, issues related to the timeliness of such reconfiguration decisions are often neglected. In this paper, we present a methodology for online optimisation of cloud configurations. We first employ a search-based approach to extract near-optimal configurations considering conflicting performance and business quality attributes. Towards reducing the burden of time-consuming evaluations of configurations' quality, we develop surrogate models to predict their quality based on history observations. Finally, we evaluate our technique using Cloud Sim-based cloud simulation. Our experimental results show that the use of surrogates can produce high quality configurations with lead time of seconds and prediction error within 6%.

An increasing number of organisations want to migrate their existing applications to cloud environments to benefit from the increased scalability, flexibility, and cost reduction. Additionally, systems migrated to cloud environments have to fulfil their functional requirements, satisfy their users' requirements, and meet the organisation's criteria for cloud migration. All these different dimensions driving the migration decision conflict with each other. Therefore, organisations trade them off for one another. Migrating applications to cloud environments becomes a complex decision process for which organisations need assistance. We provide a decision support system to assist organisations by taking into account the formal description of the parameters affecting the cloud migration and our proposed metrics for objective and subjective criteria. Our approach to cloud migration allows organisations to describe their cloud migration criteria, the architecture, properties, and requirements of their applications, and the available cloud service offerings. We semi-automate the migration decision with our transparent formalisations to quantify criteria and constraints.

Provenance awareness adds a new dimension to the engineering of service-based systems, enabling them to increase their accountability through answering questions about the provenance of any data produced. Provenance awareness can be achieved by recording provenance data during system execution. In our previous work we have proposed an overall research agenda towards a design and analysis framework for provenance awareness of composite services. A fundamental element of this framework is the provenance model, Service Provontology, capturing the structure of the provenance data collected which allows designers to query and reason over provenance data instances of composite services. With this paper we contribute an industrial case study exploring real-world provenance data from a service-based system (ORBI). In our study Service Prov becomes the tool for enabling representation and reasoning over ORB provenance data instances in order to answer specific provenance questions formalized as SPARQL expressions.

With the increasing popularity of model-driven engineering, reusability and compositionality of model-management operations, including model transformations, becomes more important. One way of addressing this problem is through generic typing mechanisms for the parameters and outputs of such operations---essentially, introducing operation-specific views. There are two competing proposals for such type mechanisms available in the literature. However, it is not clear how they compare, whether they are complete or if they are indeed correct.In this paper, I present a generalisation of the notion of a model type. I show how this notion can be used to define a type system for model-management operations and how the two existing proposals for generic model typing (model (sub-) typing and model concepts) can be encoded in the general notion. I believe that this general notion can provide the basis for a systematic study, comparison, and unification of the existing pragmatic proposals.

International audience; Infrastructure-less mobile ad hoc networks enable the development of collaborative pervasive applications. Within such dynamic networks, collaboration between devices can be realised through service-orientation by abstracting device resources as services. Recently, a framework for QoS-aware service composition has been introduced which takes into account a spectrum of orchestration patterns, and enables compositions of a better QoS than traditional centralised orchestration approaches. In this paper, we focus on the automated exploration of trade-off compositions within the search space de fined by this flexible composition model. For the studied problem, the evaluation of the fi tness functions guiding the search process is computationally expensive because it either involves a high- fidelity simulation or actually requires calling the composite service. To overcome this limitation, we have developed e fficient surrogate models for estimating the QoS metrics of a candidate solution during the search. Our experimental results show that the use of surrogates can produce solutions with good convergence and diversity properties at a much lower computational e ffort.

Provenance awareness adds a new dimension to the engineering of service-oriented systems, requiring them to be able to answer questions about the provenance of any data produced. This need is even more evident where atomic services are aggregated into added-value composite services to be delivered with certain non-functional characteristics. Prior work in the area of provenance for service-oriented systems has primarily focused on the collection and storage infrastructure required for answering provenance questions. In contrast, in this paper we study the structure of the data thus collected considering the service's infrastructure as a whole and how this affects provenance collection for answering different types of provenance questions. In particular, we define an extension of W3Cs PROV ontological model with concepts that can be used to express the provenance of how services were discovered, selected, aggregated and executed. We demonstrate the conceptual adequacy of our model by reasoning over provenance instances for a composite service scenario.

We address some of the limitations for extending and validating MDE-based implementations of NFP analysis tools by presenting a modular, model-based partial reimplementation of one well-known analysis framework, namely the Palladio Architecture Simulator. We specify the key DSLs from Palladio in the e-Motions system, describing the basic simulation semantics as a set of graph transformation rules. Di erent properties to be analysed are then encoded as separate, parametrised DSLs, independent of the de nition of Palladio. These can then be composed with the base Palladio DSL to generate speci c simulation environments. Models created in the Palladio IDE can be fed directly into this simulation environment for analysis. We demonstrate two main benefits of our approach: 1) The semantics of the simulation and the nonfunctional properties to be analysed are made explicit in the respective DSL speci cations, and 2) because of the compositional de nition, we can add de nitions of new non-functional properties and their analyses. Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech.

International audience; Service-oriented pervasive systems, composed of a large number of devices with heterogeneous capabilities where devices' resources are abstracted as software services, challenge the creation of high-quality composite applications. Resource heterogeneity, dynamic network connectivity, and a large number of highly distributed service providers complicate the process of creating applications with specific QoS requirements. Existing approaches to service composition control the QoS of an application solely by changing the set of participating concrete services which is not suitable for ad-hoc service-based systems characterized by high intermittent connectivity and resource heterogeneity. In this paper, we propose a flexible way of formulating composition configurations suitable for such service-based systems. Our formulation proposes the combined consideration of the following factors that affect the QoS of a composed service: (a) service selection, (b) orchestration partitioning, and (c) orchestrator node selection. We show that the proposed formulation enables the definition of service composition configurations with 49% lower response time, 28% lower network latency, 36% lower energy consumption, and 13% higher success ratio compared to those defined with the traditional approach.

In this paper, we address the problem of performance analysis in computer networks. We present a new meta-model designed for the performance modeling of network infrastructures in modern data centers. Instances of our metamodel can be automatically transformed into stochastic simulation models for performance prediction. We evaluate the approach in a case study of a road traffic monitoring system. We compare the performance prediction results against the real system and a benchmark. The presented results show that our approach, despite of introducing many modeling abstractions, delivers predictions with errors less than 32% and correctly detects bottlenecks in the modeled network.

International audience; Dynamic and heterogeneous service-oriented systems present challenges when developing composite applications that exhibit specified quality properties. Resource heterogeneity, mobility, and a large number of spatially distributed service providers complicate the process of composing complex applications with specified QoS requirements. This PhD project aims at enabling the efficient run-time generation of service compositions that share functionality, but differ in their trade-offs between multiple competing and conflicting quality objectives such as application response time, availability and consumption of resources. In this paper we present a research roadmap towards an approach for flexible service composition in dynamic and heterogeneous environments.

Specifying and analysing non-functional properties (NFPs) is essential for driving architectural decisions and validating composite service designs. Only where NFPs have been specified can we choose between services with similar functionality that would better satisfy our non-functional requirements. Meanwhile, incorporating provenance functionality into service-oriented systems' design is becoming crucial for users, allowing them to query the generation methods and origins of the data the system outputs. This need is particularly evident in compositions of services, where audits of individual services do not provide a connected picture of the composition's processing history. Making provenance awareness (ability to answer provenance queries) an explicit NFP in composite service specifications would enable composite service designers to analyse whether they meet provenance-related requirements. In this paper, we discuss a framework for designing and analysing provenance awareness for service compositions. We envision this as a basis for analysing the impact of provenance on other NFPs such as performance and storage.

In this work-in-progress paper, we present a new meta-model designed for the performance modeling of dynamic data center network infrastructures. Our approach models characteristic aspects of Cloud data centers which were not crucial in classical data centers. We present our meta-model and demonstrate its use for performance modeling and analysis through an example, including a transformation into OMNeT++ for performance simulation.

As the complexity of online services increases, there is a corresponding need for service-oriented systems to provide support for answering questions about how they have processed and produced data. This need is particularly evident in compositions of services, where audits of each individual service's use do not provide a connected picture of the composition's processing history. The provenance awareness of a system is its ability to answer questions about the history of its processing, through recording provenance data during execution. As the size and usage of a system increases, so can the size of the provenance data recorded, leading to increased demands on storage and decreased performance of the service. However, the exact impact of provenance recording depends on what details of the service execution are being documented. Our goal is to make provenance awareness accessible as an explicit non-functional property (NFP) in composite service specifications, as is common for performance or reliability properties. This would enable composite service designers to analyse the properties of their services to see whether they meet users' requirements based on the provenance questions they could ask about the service's outputs and the dependent performance, storage and other properties. We present a preliminary approach towards this end, focusing on the step of categorising potential provenance questions according to their effect on other NFPs, so that the provenance awareness of a service can be specified as the categories of questions it can answer.

International audience; Model-driven engineering (MDE) and, in particular, the notion of domain-specific modelling languages (DSMLs) is an increasingly popular approach to systems development. DSMLs are particularly interesting because they allow encoding domain-knowledge into a modelling language and enable full code generation and analysis based on high-level models. However, as a result of the domain-specificity of DSMLs, there is a need for many such languages. This means that their use only becomes economically viable if the development of new DSMLs can be made efficient. One way to achieve this is by reusing functionality across DSMLs. On this background, we are working on techniques for modularising DSMLs into reusable units. Specifically, we focus on DSMLs whose semantics are defined through in-place model transformations. In this paper, we present a formal framework of morphisms between graph-transformation systems (GTSs) that allow us to define a novel technique for conservative extensions of such DSMLs. In particular, we define different behaviour-aware GTS morphisms and prove that they can be used to define conservative extensions of a GTS.

Domain-specific languages (DSLs) are an important tool for effective system development. They provide concepts that are close to the problem domain and allow analysis as well as generation of full solution implementations. However, this comes at the cost of having to develop a new language for every new domain. To make their development efficient, we must be able to construct DSLs as much as possible from reusable building blocks. In this paper, we discuss how such building blocks can be constructed for the specification and analysis of a range of non-functional properties, such as, for example, throughput, response time, or reliability properties. We assume DSL semantics to be provided through a set of transformation rules, which enables a range of analyses based on model checking. We demonstrate new concepts for defining language modules for the specification of non-functional properties, show how these can be integrated with base DSL specifications, and provide a number of syntactic conditions that we prove maintain the semantics of the base DSL even in the presence of non-functional–property specifications. Ministerio de Ciencia e Innovación TIN2011-23795

Model-driven engineering, especially using domain-specific languages, allows constructing software from abstractions that are more closely fitted to the problem domain and that better hide technical details of the solution space. Code generation is used to produce executable code from these abstractions, which may result in individual concerns being scattered and tangled throughout the generated code. The challenge, then, becomes how to modularise the code-generator templates to avoid scattering and tangling of concerns within the templates themselves. This paper shows how symmetric, language-aware approaches to aspect orientation can be applied to code generation to improve modularisation support.

Aspect developers constantly make a range of assumptions about the context in which their aspects will be deployed; ranging from assumptions about other aspects deployed to assumptions about semantic properties of the base and the joinpoints at which an aspect is woven. Although it has been acknowledged that such assumptions need to be made explicit to validate aspects in the face of evolution (both of aspects and the base) and reuse as well as to mitigate the fragile-pointcut problem, so far no study exists that identifies the types of assumptions aspect developers make. In this paper, we present a retrospective study of three medium-sized open-source AspectJ projects and assumptions identified in these. This leads to an initial classification of assumptions that can form the basis for further research into how best to support each type of assumption.

This workshop will explore the contributions that software research can make to the challenge of tackling climate change. Software is a critical enabling technology in nearly all aspects of climate change, from the computational models used by climate scientists to improve our understanding of the impact of human activities on earth systems, through to the information and control systems needed to build an effective carbon-neutral society. The intent of the workshop is to explore how software research can contribute to this challenge, to build a community of researchers interested in responding to the challenge, and to map out a research agenda.

Modularisation can reduce the effort in designing and maintaining language specifications. Existing approaches to language modularisation are typically either focused on language syntax or on language semantics. In this paper, we propose a modularisation approach covering both syntax and semantics. We propose defining composition rules on the level of abstract syntax, making it the central artefact in a language module. To enable clean interfaces for such language modules—effectively making them language components—we use role-modelling at the metamodel level. We discuss how role-based metamodelling supports the aspectual modularisation of language semantics and can also be integrated with concrete syntax specifications to build self-contained language components. We present the implementation of our approach in the LanGems language compositions system and show how it can be used to provide a modularised definition of the Object Constraint Language.

Managing variability is a challenging issue in software-product-line engineering. A key part of variability management is the ability to express explicitly the relationship between variability models (expressing the variability in the problem space, for example using feature models) and other artefacts of the product line, for example, requirements models and architecture models. Once these relations have been made explicit, they can be used for a number of purposes, most importantly for product derivation, but also for the generation of trace links or for checking the consistency of a product-line architecture. This paper bootstraps techniques from product-line engineering to produce a family of languages for variability management for easing the creation of new members of the family of languages. We show that developing such language families is feasible and demonstrate the flexibility of our language family by applying it to the development of two variability-management languages.

Software product lines using feature models often require the relation between feature models in problem space and the models used to describe the details of the product line to be expressed explicitly. This is particularly important, where automatic product derivation is required. Different approaches for modelling this mapping have been proposed in the literature. However, a discussion of their relative benefits and drawbacks is currently missing. As a first step towards a better understanding of this field, this paper applies two of these approaches-- FeatureMapper as a representative of declarative approaches and VML* as a representative of operational approaches--to the case study. We show in detail how the case study can be expressed using these approaches and discuss strengths and weaknesses of the two approaches with regard to the case study.