Jörn Guy Süß

Platform independent model transformation based on triple

Reuse is an important topic in software engineering as it promises advantages like faster time-to-market and cost reduction. Reuse of models on an abstract level is more beneficial than on the code level, because these models can be mapped into several technologies and can be adapted according to different requirements. Unfortunately, development tools only provide fixed mappings between abstract models described in a language such as UML and source code for a particular technology. These mappings are based on one-to-one relationships between elements of both levels. As a consequence, it is rarely possible to customize mappings according to specific user requirements.We aim to improve model reuse by providing a framework that generates customized mappings according to specified requirements. The framework is able to handle mappings aimed for several component technologies as it is based on an ADL. It is realized in Triple to represent components on different levels of abstraction and to perform the actual transformation. It uses feature models to describe mapping alternatives.

Robust Real-Time Synchronization between Textual and Graphical Editors

This paper is a pre-print of: Oskar van Rest, Guido Wachsmuth, Jim Steel, Jorn Guy Sus, Eelco Visser. Robust Real-Time Synchronization between Textual and Graphical Editors. In Keith Duddy, Gerti Kappel, editors, Theory and Practice of Model Transformations, Sixth International Conference, ICMT 2013, Budapest, Hungary, June 18-19, 2013. Proceedings. Lecture Notes in Computer Science, Springer Verlag 2013. In modern Integrated Development Environments (IDEs), textual editors are interactive and can handle intermediate, incomplete, or otherwise erroneous texts while still providing editor services such as syntax highlighting, error marking, outline views, and hover help. In this paper, we present an approach for the robust synchronization of interactive textual and graphical editors. The approach recovers from errors during parsing and text-to-model synchronization, preserves textual and graphical layout in the presence of erroneous texts and models, and provides synchronized editor services such as selection sharing and navigation between editors. It was implemented for synchronizing textual editors generated by the Spoofax language workbench and graphical editors generated by the Graphical Modeling Framework.

Analysis of compositional conflicts in component-based systems

Today, incompatibilities in component specifications make their composition hard to handle in practical terms. Incompatibilities can be classified into three conflict categories: type conflicts, behavioral conflicts, and property conflicts. This paper describes a framework for the identification of compositional conflicts in component-based systems that analyses conflicts of all three categories. Furthermore, the conflict analysis framework can be integrated into the software development process and handles component transformations between different abstraction levels.

Model-Centric Engineering with the Evolution and Validation Environment

Reuse is an important aspect of software engineering that promises advantages like faster time-to-market, cost reduction, better maintainability etc. The software industry focuses on components as commercials off-the-shelf in order to gain reusable assets. However, reuse on the design level usually is not addressed. If we come to perceive models as assets of the software process, then the design moves from the periphery of software engineering to the center. This implies several advantages, like an improved system’s overview and insight, because of greater abstraction and easier comprehension of the design concepts.

Model-Based Generation of Interlocking Controller Software from Control Tables

Railroad interlocking software drives specialised micro-devices, known as interlocking controllers. These controllers primarily actuate railroad points and change signal aspects in real-time, based on sensor and timer input. Due to their central function in railroad control, interlocking controllers and their firmware are safety-critical. The firmware programs, which mimic physical relays, are written in variants of domain-specific programming languages based on ladder logic. The programs have to comply with a more abstract specification of allowable states of sections of railroad track and equipment, known as a control table. The translation of a track layout and associated control tables into ladder logic-based code is manual, and hence subject to costly review and rework cycles. In this report, we describe a case study that uses a model-driven tool-chain as an automated alternative to the existing process. The two domain languages, control table and ladder logic, were modelled and transformations were implemented between the two models, and from model to program text. We report on implementation challenges, and describe the outlook and scalability of the approach in this application domain.

MDA-Based re-engineering with object-z

This paper describes a practical application of MDA and reverse engineering based on a domain-specific modelling language. A well defined metamodel of a domain-specific language is useful for verification and validation of associated tools. We apply this approach to SIFA, a security analysis tool. SIFA has evolved as requirements have changed, and it has no metamodel. Hence, testing SIFAs correctness is difficult. We introduce a formal metamodelling approach to develop a well-defined metamodel of the domain. Initially, we develop a domain model in EMF by reverse engineering the SIFA implementation. Then we transform EMF to Object-Z using model transformation. Finally, we complete the Object-Z model by specifying system behavior. The outcome is a well-defined metamodel that precisely describes the domain and the security properties that it analyses. It also provides a reliable basis for testing the current SIFA implementation and forward engineering its successor.

Architecture-Centric Model-Driven Web Engineering

To be adopted by architects, modelling approaches must provide a means to leverage the software patterns and architectural styles that are relevant to development practice, instead of those proscribed by black-box CASE tools. Architecture-Centric Model-Driven Software Development (AC-MDSD) is a modelling approach that provides architectural control of the generated application. However, AC-MDSD primarily focuses on generating infrastructure code. We apply AC-MDSD to web engineering and contribute a technique to define and generate system behaviour that goes beyond the create/read/update/delete infrastructure functionality. We use UML profiles augmented with OCL to specify the behaviour. We provide an example to illustrate the approach and outcomes.

Augmenting UML models for composition conflict analysis

Component reuse is inhibited by two factors: Lack of an adequate modeling representation of components and lack of a method to predict properties of a composition of application components. In this paper, we propose a framework for conflict identification. The framework is primarily based on a taxonomy describing communication and technology related properties. Conflict identification is based on inference rules. Furthermore, we aim to integrate conflict reasoning in the software development process. We will show that the Unified Modeling Language and the Resource Description Framework can be combined to provide a solution to the representation problems, without resorting to extension mechanisms, and without limiting to a specific component platform. As a real life example, we model the connection of an .Net Serviced Component to an Enterprise Java Bean as part of a mortgage banks enterprise architecture and prove its viability.

OCLPrime - Environment and Language for Model Query, Views and Transformations

UML, MOF, and MDA currently do not provide a standardized means to describe manipulation of model-elements in algorithms or rules. In order to define specific UML-based methods in a product-independent and portable way, this capability is essential. This paper discusses design and implementation of the hybrid language framework Prime and its derivative language OCLPrime in the light of the OMG Query / Views / Transformations RFP. Prime allows and coordinates the reuse of different languages for validation, selection, and projection in the Transformation of models. Its design follows the Composite, Visitor, and Interpreter patterns and coordinates the sub-languages in transactions. OCLPrime is a reference language implementation in Prime employing OCL expressions to select parts of a source model and SQL DML to project these into a target model. Preand Post-validations are performed by a UML Profile Validator.

Software Model Engineering and Reuse with the Evolution and Validation Environment

Reuse in software construction has been a core aspect of software engineering since the term was coined in late 70’s [2]. Strategies for reuse like high level languages, structuring and encapsulation have made valuable contributions. Today, the software industry produces components as reusable parts, which deliver advantages like faster time-to-market, cost reduction, better maintainability, configurability etc. While the reuse of code and components improves, one important contributing factor of the engineering process remains out of scope: Although design reuse is more effective and beneficial than code reuse [1] models of software systems still are not assets of the software process. As a result design reuse does not impact the actual software engineering process. The impediments and successes of bringing models to the heart of the software process are reflected in the history of the Unified Modeling Language (UML). We will retell this story below to pick up the motivation for our own project, the Evolution and Validation Environment (EVE), which has the potential to globally reuse and share know-how expressed in models and model services, independent of and complementary to existing modeling tools. We give an overview of EVE’s architecture and present an example of its application. Finally, we delve into the details of an EVE core component, the OCL profile validator service (MOCL), which is used to check UML models for compliance with profiles.