Re-engineering Eclipse MDT/OCL for Xtext

The current tooling used for the Eclipse OCL project uses an LALR parser generator. Enhancing the tooling to support editing motivated a migration to exploit the inherently model-driven characteristics of Xtext. This paper summarizes the experiences of that migration, identifies the many benefits and discusses a few changes in implementation approach that were required. Objective performance and size comparisons between the old LALR and new Xtext approach are provided

OCL Tools Report based on the IDE4OCL Feature Model

Previously we have developed the idea of an Integrated Development Environment for OCL (IDE4OCL). Based on the OCL community's feedback we have also designed and published an IDE4OCL feature model. Here we present a report on selected OCL tools developed by the authors and their teams. Each author gives an overview of their OCL tool, provides a top level architecture, and gives an evaluation of the tool features in a web framework. The framework can also be used by other potential OCL users and tool developers. For users it may serve as an aid to choose a suitable tool for their OCL use scenarios. For tool developers it provides a comparative view for further development of the OCL tools. Our plans are to maintain the collected data and extend this web framework by further OCL tools. Additionally, we would like to encourage sharing of OCL development resources

Integrating the AUTOSAR tool chain with Eclipse based model transformations

International audienceAUTOSAR is establishing itself as a prominent standard in automotive systems and is expected to significantly improve software architecture and the software development processes. However, the introduction of AUTOSAR also poses some challenges

Using an OCL Impact Analysis Algorithm for View-Based Textual Modelling

The Object Constraint Language (OCL) has become a vital part of many frameworks, tools and languages within model-driven engineering. One such application of OCL is the use for describing rules in concrete syntax definitions. Within the textual modeling framework FURCAS, OCL is extensively used for the definition of lookup and attribution rules. Based on these rules the model which is described by such a textual representation is created and updated accordingly. Changes on models over which such an expression is specified require the expression to be re-evaluated to keep the constructed model up-to-date. However, the effort for re-evaluating OCL expressions over a set of model elements grows with the  number of elements, the complexity of the expressions, and the number of model changes. Thus, having large models and/or complex expressions places considerable performance costs on OCL evaluation. Techniques to reduce this effort have been presented in previous work but do not cover the full range of OCL expressions, in particular calls to operations defined in OCL, including recursive operations. In this paper, we present an approach that is applicable to the full range of OCL expressions. We validated our approach based on a large set of models and complex expressions to evaluate the performance impact of our newly introduced techniques

Collaboration in Automotive - The Eclipse Automotive Industry Working Group

International audienceThe Automotive Industry is constantly introducing new and improved features based on advanced electronics and software. The use of these consumer electronics and software has required the automotive industry to define processes and tools that manage the interactions within an organization and within their extended supply chain. To address the growing complexity and time-to-market pressures , the automotive industry needs a common development tool-chain to support the development and testing of these new types of features. Today, many automotive companies use Eclipse to assist in the development of new features. However, a lack of integration between technology stacks, consistent use of tools throughout the supply chain and missing functionality has limited the effectiveness of create a complete development tool-chain. OEMs, 1st-tiers and consutling companies are founding the Eclipse Autmotive Industry Working Group to coordinate the activites within companies

Lightweight and static verification of UML executable models

Executable models play a key role in many software development methods by facilitating the (semi)automatic implementation/execution of the software system under development. This is possible because executable models promote a complete and fine-grained specification of the system behaviour. In this context, where models are the basis of the whole development process, the quality of the models has a high impact on the final quality of software systems derived from them. Therefore, the existence of methods to verify the correctness of executable models is crucial. Otherwise, the quality of the executable models (and in turn the quality of the final system generated from them) will be compromised. In this paper a lightweight and static verification method to assess the correctness of executable models is proposed. This method allows us to check whether the operations defined as part of the behavioural model are able to be executed without breaking the integrity of the structural model and returns a meaningful feedback that helps repairing the detected inconsistencies.Peer ReviewedPostprint (author's final draft

Teaching Model Driven Language Handling

Many universities teach computer language handling by mainly focussing on compiler theory, although MDD (model-driven development) and meta-modelling are increasingly important in the software industry as well as in computer science. In this article, we share some experiences from teaching a course in computer language handling where the focus is on MDD principles. We discuss the choice of tools and technologies used in demonstrations and exercises, and also give a brief glimpse of a prototype for a simple meta-model-based language handling tool that is currently being designed and considered for future use in teaching

Integration and Test of MOF/UML-based Domain-specific Modeling Languages

In model-driven development (MDD), domain-specific modeling languages (DSMLs) are used as tailor-made software languages targeting dedicated application domains. Due to the narrow domain coverage of DSMLs, demands to integrate their individual functionality into a consolidated DSML arise (e.g., developing a software product combining two or more pre-existing DSMLs). However, in order to realize the benefits of integrated DSMLs, it must be ensured that the integrated DSML is correctly implemented and behaves as specified. To support the integration and the test of DSMLs, this thesis presents an approach targeting the Meta Object Facility (MOF) and the Unified Modeling Language (UML)- a metamodeling infrastructure frequently employed for the MDD of software systems. The integration of DSMLs is based on a rewriting technique for model-to-text (M2T) transformations. This method allows for the reuse as well as for the automatic refactoring of M2T transformation templates to fix important syntactical mismatches between templates and the integrated DSML. To test an integrated DSML, scenarios are used to define domain requirements on an abstract level (via structured text descriptions). In a subsequent step, executable scenario tests are derived from the requirements-level scenarios. These executable scenario specifications are then employed to test the integrated DSML for compliance with corresponding domain requirements. Empirical evaluations of the approach (case studies, controlled experiment) demonstrate its successful application, collect evidence for its usefulness, and quantify its benefits. The integrated proof-of-concept implementations build on the Eclipse Modeling Framework (EMF), making use of and extending well-known Eclipse-based projects. All accompanying developments are placed into the public domain as free/libre open source software. Within the framework of this thesis, research results were originally published as individual contributions (workshop, conference, and journal articles). All research contributions are results of applying a design science research approach. (author's abstract

Auto-tooling to Bridge the Concrete and Abstract Syntax of Complex Textual Modeling Languages

This thesis contributes to improving support for complex textual modeling languages. This support refers to the automatic generation of tools for the end user -- e.g. parsers, editors, views, etc. -- and (parts of) the standard specifications defined to describe the languages -- e.g. the Object Management Group open specifications for varied modeling languages. The particular subset of languages considered in the thesis are textual, model-based and complex. They are considered textual when their concrete syntax is textual, in particular, defined by a grammar. They are considered model-based when their abstract syntax is defined by a meta-model. They are considered complex when there is a significant gap between the concrete and abstract syntax of the language; in other words, when the abstract syntax meta-model cannot directly be derived or inferred from the concrete syntax grammar. The contributions of this thesis address the problem of bridging the concrete and abstract syntax of complex textual modeling languages. In particular, the contributions include (a) a gap analysis of the limitations of related work; (b) a domain-specific transformation language for defining and executing concrete syntax to abstract syntax bridges; (c) an experimental evaluation of the proposed solution including studies to compare with related work. Existing related work presents different issues when working on complex textual modeling languages. Either sufficient automatic tooling generation is not provided (Gra2Mol), or model-based languages are not appropriately supported (Spoofax), or complex gaps between the concrete and abstract syntax cannot be bridged (Xtext). This thesis identifies the different concerns that arise when bridging the concrete and abstract syntax of complex textual modeling languages. In addition, some limitations of relevant related work are shown. With the aim of addressing these identified concerns a new approach is proposed, showing how these concerns are particularly addressed. Specifically, the proposed approach consists of complementing relevant related work (Xtext) with a novel domain-specific transformation language to declare bridges between the concrete syntax and abstract syntax of complex textual modeling languages. The domain-specific transformation language is the main contribution of this thesis and is evaluated by means of qualitative and quantitative studies. Subject to the presented examples, the conducted experiments show that the proposed approach brings measurable benefits -- in terms of size of specification artefacts and execution time of the underlying implementation -- when compared to the state-of-the-art