OCL 2015 Ottawa

15th International Workshop on
OCL and Textual Modeling

co-located with
Models 2015 Ottawa

Program Overview

Proceedings at CEUR-WS
Workshop Room: Panorama

09:00 - 09:15 Introduction / Welcome

    09:15 - 10:15 Session 1: Challenges of Constraint Languages

    Chair: Frédéric Tuong

    10:15 - 10:45 Coffee Break

      10:45 - 12:00 Session 2: Evaluation

      Chair: Marc Pantel
      • 10:45 - 11:15
        On the Use of Active Operations for Incremental Bidirectional Evaluation of OCL
        abstract paper slide
        Speaker: Frédéric Jouault
        Frédéric Jouault and Olivier Beaudoux
        Groupe ESEO Groupe ESEO
        France France
      • 11:15 - 11:45
        Lazy Evaluation for OCL
        abstract paper slide
        Speaker: Massimo Tisi
        Massimo Tisi , Rémi Douence and Dennis Wagelaar
        AtlanMod team (Inria, Mines Nantes, LINA) Ascola team (Inria, Mines Nantes, LINA) HealthConnect NV
        France France Belgium

      12:00 - 13:00 Lunch

        13:00 - 15:00 Session 3: Tools and Emerging Ideas

        Chair: Frédéric Jouault
        • 13:00 - 13:30
          An Adaptable Tool Environment for High-level Differencing of Textual Models
          abstract paper slide demo
          Speaker: Daniel Strüber
          Timo Kehrer , Christopher Pietsch , Udo Kelter , Daniel Strüber and Steffen Vaupel
          Universität Siegen Universität Siegen Universität Siegen Philipps-Universität Marburg Philipps-Universität Marburg
          Germany Germany Germany Germany Germany
        • 13:30 - 14:00
          Recursion and Iteration Support in USE Validator with AnATLyzer
          abstract paper slide
          Speaker: Jesús Sánchez Cuadrado
          Jesús Sánchez Cuadrado
          Modelling and Software Engineering Research Group, Universidad Autónoma de Madrid
        • 14:00 - 14:30
          Safe Navigation in OCL
          abstract paper slide
          Speaker: Edward D. Willink
          Edward D. Willink
          Willink Transformations Ltd
        • 14:30 - 15:00
          Tool Paper: A Lightweight Formal Encoding of a Constraint Language for DSMLs
          abstract paper slide
          Speaker: Marc Pantel
          Arnaud Dieumegard , Marc Pantel , Guillaume Babin and Martin Carton
          IRIT ENSEEIHT, Université de Toulouse IRIT ENSEEIHT, Université de Toulouse IRIT ENSEEIHT, Université de Toulouse IRIT ENSEEIHT, Université de Toulouse
          France France France France

        15:00 - 15:30 Coffee Break

          15:30 - 17:00 Session 4: Extending OCL and Panel Discussion

          Chair: Martin Gogolla
          • 15:30 - 16:00
            Tool Paper: Combining Alf and UML in Modeling Tools - An Example with Papyrus -
            abstract paper slide
            Speaker: Ed Seidewitz
            Ed Seidewitz and Jérémie Tatibouet
            Model Driven Solutions CEA, LIST, Laboratory of Model Driven Engineering for Embedded Systems
            USA France
          • 16:00 - 17:00
            Panel Discussion, e.g., on tools for textual modelling


          Session 1: Challenges of Constraint Languages
          09:15 - 09:45
          Opportunities and Challenges for Deep Constraint Languages
          Structural models are often augmented with additional well-formedness constraints to rule out unwanted configurations of instances. These constraints are usually written in dedicated constraint languages specifically tailored to the conceptual framework of the host modeling language, the most well-known example being the OCL constraint language for the UML. Many multi-level modeling languages, however, have no such associated constraint language. Simply adopting the OCL for such multi-level languages is not a complete strategy, though, as the OCL was designed to support the UML’s two-level class/instance dichotomy, i.e., it can only define constraints which restrict the properties of the immediate instances of classes, but not beyond. The OCL would consequently not be able to support the definition of deep constraints that target remote or even multiple classification levels. In fact, no existing constraint language can address the full range of concerns that may occur in deep modeling using the Orthogonal Classification Architecture (OCA) as an infrastructure. In this paper we consider what these concerns might be and discuss the syntactical and pragmatic issues involved in providing full support for them in deep modeling environments.

          09:45 - 10:15
          An OCL-based Bridge from Concrete to Abstract Syntax
          The problem of converting human readable programming languages into executable machine representations is an old one. EBNF and Attribute grammars provide solutions, but unfortunately they have failed to contribute effectively to model-based Object Management Group (OMG) specifications. Consequently the OCL and QVT specifications provide examples of specifications with significant errors and omissions. We describe an OCL-based internal domain specific language (DSL) with which we can re-formulate the problematic parts of the specifications as complete, checkable, re-useable models.

          Session 2: Evaluation
          10:45 - 11:15
          On the Use of Active Operations for Incremental Bidirectional Evaluation of OCL
          Many relations between model elements are expressed in OCL. However, tool support to enable synchronization of elements based on OCL-expressed relations is lacking. In this paper, we propose to use active operations in order to achieve incremental execution of some OCL expressions. Moreover, bidirectionality can also be achieved in non-trivial cases.

          11:15 - 11:45
          Lazy Evaluation for OCL
          The Object Constraint Language (OCL) is a central component in modeling and transformation languages such as the Unified Modeling Language (UML), the Meta Object Facility (MOF), and Query View Transformation (QVT). OCL is standardized as a strict functional language. In this article, we propose a lazy evaluation strategy for OCL. We argue that a lazy evaluation semantics is beneficial in some model-driven engineering scenarios for: i) lowering evaluation times on very large models; ii) simplifying expressions on models by using infinite data structures (e.g., infinite models); iii) increasing the reusability of OCL libraries. We implement the approach on the ATL virtual machine EMFTVM.

          Session 3: Tools and Emerging Ideas
          13:00 - 13:30
          An Adaptable Tool Environment for High-level Differencing of Textual Models
          The use of textual domain-specific modeling languages is an important trend in model-driven software engineering. Just like any other primary development artifact, textual models are subject to continuous change and evolve heavily over time. Consequently, MDE tool chain developers and integrators are faced with the task to select and provide appropriate tools supporting the versioning of textual models. In this paper, we present an adaptable tool environment for high-level differencing of textual models which builds on our previous work on structural model versioning. The approach has been implemented within the SiLift framework and is fully integrated with the Xtext language development framework. We illustrate the adaptability and practicability of the tool environment using a case study which is based on a textual modeling language for simple web applications.

          13:30 - 14:00
          Recursion and Iteration Support in USE Validator with AnATLyzer
          Model finders enable numerous verification approaches based on searching the existence of models satisfying certain properties of interest. One of such approaches is anATLyzer, a static analysis tool for ATL transformations, which relies on USE Validator to provide fine grained analysis based on finding witness models that satisfy the OCL path conditions associated to particular errors. However it is limited by the fact that USE Validator does not include built-in support for analysing recursive operations and the iterate collection operator.
          This paper reports our approach to allow USE Validator to analyse OCL path conditions containing recursive operations and iterate, with the aim of widening the amount of actual transformations that can be processed by anATLyzer. We present our approach, based on unfolding recursion into a finite number of steps, and we discuss how to take into account practical aspects such as inheritance and details about the implementation.

          14:00 - 14:30
          Safe Navigation in OCL
          The null object has been useful and troublesome ever since it was introduced. The problems have been mitigated by references in C++, annotations in Java or safe navigation in Groovy, Python and Xbase. Introduction of a safe navigation operator to OCL has some rather unpleasant consequences. We examine these consequences and identify further OCL refinements that are needed to make safe navigation useable.

          14:30 - 15:00
          Tool Paper: A Lightweight Formal Encoding of a Constraint Language for DSMLs
          Domain Specific Modeling Languages (DSMLS) plays a key role in the development of Safety Critical Systems to model system requirements and implementation. They often need to integrate property and query sub-languages. As a standardized modeling language, OCL can play a key role in their definition as they can rely both on its concepts and textual syntax which are well known in the Model Driven Engineering community. For example, most DSMLS are defined using MOF for their abstract syntax and OCL for their static semantics as a metamodeling DSML. OCLinEcore in the Eclipse platform is an example of such a metamodeling DSML integrating OCL as a language component in order to benefit from its property and query facilities. DSMLS for Safety Critical Systems usually provide formal model verification activities for checking models completeness or consistency, and implementation correctness with respect to requirements. This contribution describes a framework to ease the definition of such formal verification tools by relying on a common translation from a subset of OCL to the Why3 verification toolset. This subset was selected to ease efficient automated verification. This framework is illustrated using a block specification language for data flow languages where a subset of OCL is used as a component language.

          Session 4: Extending OCL and Panel Discussion
          15:30 - 16:00
          Tool Paper: Combining Alf and UML in Modeling Tools - An Example with Papyrus -
          The Unified Modeling Language has been used largely in the software community to draw pictures for designing and documenting software written in other languages. The real executable semantics of a program are determined by the programming language, while the UML models themselves do not have a precise enough meaning to fully specify the executable functionality of the system being developed. Recently, however, there has been a great deal of work toward the standardization of precise, executable semantics for UML models - the "meaning" behind the pictures: Foundational UML (fUML) adopted by the Object Management Group in 2008, the Action Language for fUML (Alf) adopted in 2010, the recently completed Precise Semantics for UML Composite Structures (PSCS) and the Precise Semantics for UML State Machines (PSSM), now in progress. Together, these standards effectively provide a new combined graphical and textual language for precise, executable modeling. In particular, the Alf language goes beyond simply providing a textual "action language" for detailed behavioral code within graphical models, by including textual notation for fUML structural object-oriented modeling constructs (e.g., packages, classes, associations, etc.). This opens up the possibility of tooling allowing various parts of a UML model to be represented both graphically and textually (while preserving the same semantic level), with bidirectional synchronization between the two representations. This paper presents the achievement of an initial integration of UML and Alf in the context of the Papyrus tool for the specification of executable models.