Powered by
Conference Publishing Consulting

Workshop on Domain-Specific Modeling (DSM 2015), October 27, 2015, Pittsburgh, PA, USA

DSM 2015 – Proceedings

Contents - Abstracts - Authors


Title Page

Domain-Specific Modeling (DSM) languages provide a viable and time-tested solution for continuing to raise the level of abstraction, and thus productivity, beyond coding, making systems development faster and easier. When accompanied with suitable automated modeling tools and generators it delivers to the promises of continuous delivery and devops.

Language Engineering Experiences

Domain Specific Modelling for Clinical Research
Jim Davies, Jeremy Gibbons, Adam Milward, David Milward, Seyyed Shah, Monika Solanki, and James Welch
(University of Oxford, UK)
The value of integrated data relies upon common data points having an accessible, consistent interpretation; to achieve this at scale requires appropriate informatics support. This paper explains how a model-driven approach to software engineering and data management, in which software artefacts are generated automatically from data models, and models are used as metadata, can achieve this. It introduces a simple data modelling language, consistent with standard object modelling notations, together with a set of tools for model creation,maintenance, and deployment. It reports upon the application of this approach in the provision of informatics support for two large-scale clinical research initiatives.
Publisher's Version Article Search
CHARIOT: A Domain Specific Language for Extensible Cyber-Physical Systems
Subhav M. Pradhan, Abhishek Dubey, Aniruddha Gokhale, and Martin Lehofer
(Vanderbilt University, USA; Siemens, USA)
Wider adoption, availability and ubiquity of wireless networking technologies, integrated sensors, actuators, and edge computing devices is facilitating a paradigm shift by allowing us to transition from traditional statically configured vertical silos of Cyber-Physical Systems (CPS) to next generation CPS that are more open, dynamic and extensible. Fractionated spacecraft, smart cities computing architectures, Unmanned Aerial Vehicle (UAV) clusters are all examples of extensible CPS wherein extensibility is implied by the dynamic aggregation of physical resources, affect of physical dynamics on availability of computing resources, and various multi-domain applications hosted on these systems. However, realization of extensible CPS requires resolving design-time and runtime challenges emanating from properties specific to these systems. In this paper, we first describe different properties of extensible CPS - dynamism, extensibility, remote deployment, security, heterogeneity and resilience. Then we identify different design-time challenges stemming from heterogeneity and resilience requirements. We particularly focus on software heterogeneity arising from availability of various communication middleware. We then present appropriate solutions in the context of a novel domain specific language and describe how this language and its features have evolved from our past work.
Publisher's Version Article Search
Experience Report: Constraint-Based Modeling of Autonomous Vehicle Trajectories
Kennon McKeever, Yegeta Zeleke, Matt Bunting, and Jonathan Sprinkle
(University of Arizona, USA; University of California at Santa Cruz, USA)
Autonomous vehicles and other robotics systems are frequently implemented using a general-purpose programming language such as C++, and prototyped using domain-specific tool such as MATLAB/Simulink, and LabVIEW. Such an approach is not efficient when programming primitive motions of autonomous vehicles when considering important safety constraints, and when promoting the broad access to robotic systems through involvement of students and aspiring students who do not know conventional low-level programming languages. Aside from general-purpose programming languages, there are languages that are specifically designed to model autonomous vehicles, such as SHIFT, but these languages are typically for simulation purposes only. This experience report discusses the creation of a domain-specific language that allows for faster programming of autonomous vehicles while ensuring valid constraints will be met. This language generates code for multiple controllers that will operate alternatively to allow for fast and effective programming of vehicle trajectories using primitive motions. In addition to improving coding efficiency and reducing the number of programming errors, the language adds a level of abstraction so that autonomous vehicle behaviors may be generated by people with little knowledge of low-level details of the car's operation. Furthermore, this language ensures safe operation of the vehicle by enforcing a set of user-definable constraints on the output path. A main set of constraints that are applied to every generated path have been specifically chosen to enforce safe switching between controllers and prevent the planning of unsafe actions. A novel application of the language is its ability to permit users to add specific constraints for a particular path; these constraints are checked for validity after the main constraint check is performed.
Publisher's Version Article Search

Code Generation

Adaptable Symbol Table Management by Meta Modeling and Generation of Symbol Table Infrastructures
Katrin Hölldobler, Pedram Mir Seyed Nazari, and Bernhard Rumpe
(RWTH Aachen University, Germany)
Many textual software languages share common concepts such as defining and referencing elements, hierarchical structures constraining the visibility of names, and allowing for identical names for different element kinds. Symbol tables are useful to handle those reference and visibility concepts. However, developing a symbol table can be a tedious task that leads to an additional effort for the language engineer. This paper presents a symbol table meta model usable to define language-specific symbol tables. Furthermore, we integrate this symbol table meta model with a meta model of a grammar-based language definition. This enables the language engineer to switch between the model structure and the symbol table as needed. Finally, based on a grammar annotation mechanism, our approach is able to generate a symbol table infrastructure that can be used as is or serve as a basis for custom symbol tables.
Publisher's Version Article Search
Automating Engineering with a Domain-Specific Language and a Code Generator
Al Niessner, Oh-Ig Kwoun, Belinda Randolph, and Honghanh Nguyen
(Jet Propulsion Laboratory, USA)
The following is an industry experience on using well established concepts, domain-specific language and code generation, to automate the engineering process of sub-system interactions. A domain-specific language was used to improve the communication efficiency among several teams of engineers. A code generator transforms the models formed for communicating into executables that process data. While, the savings in terms of man-effort and schedule-time were high, the single point of failure is end-user adoption. Adoption failure was attributed to two factors: One, the distance between the end-user and the realized benefit. Two, the amount the end-user had to change (become proficient in skills outside of their discipline). In our experience, the lack of an appropriate editor was the dominate cause to both factors in adoption failure.
Publisher's Version Article Search
Management of Guided and Unguided Code Generator Customizations by Using a Symbol Table
Pedram Mir Seyed Nazari, Alexander Roth, and Bernhard Rumpe
(RWTH Aachen University, Germany)
An essential part of model-driven development to systematically generate concrete source code from abstract input models are code generators. Regardless of their importance, abstract input models are not always suited to describe the output in a concise and precise way. Hence, customizations and adaptations of the code generator and the generated products are needed. Existing approaches mainly regard the code generation process as their primary concern and require the set up of an additional infrastructure in order to manage the customizations and adaptations. Thus, the goal of this paper is to propose an extension for template-based code generators to enable customizations and adaptations within a code generator that also respects referential integrity and reuses existing data structures for efficient management. First, we present a classification of common code generator customization and adaptation approaches (guided and unguided approaches) to identify the main concepts and elements of the approaches. Then, using the derived information relevant to manage guided and unguided approaches, we reuse the existing data structure (symbol table) to manage the customizations and adaptations. We achieve this by associating all relevant information directly with a template. This approach enables dynamic management of customizations and adaptations at run-time of the code generator and allow for statically checking before code generation. Our main contribution is an approach to combine guided and unguided customization approaches with a symbol table for efficient management.
Publisher's Version Article Search
Mixed Generative and Handcoded Development of Adaptable Data-Centric Business Applications
Pedram Mir Seyed Nazari, Alexander Roth, and Bernhard Rumpe
(RWTH Aachen University, Germany)
Consistent management of structured information is the goal of data-centric business applications. Model-driven development helps to automatically generate such applications. Current approaches target full or one shot generation of business applications and often neglect simplicity and adaptability of the code generator and the generated code. Inspection of the generated code is required to add functionality. Thus, here we discuss mechanisms for a code generator to generate a lightweight and highly customizable data-centric business application that is targeted for a variety of users including generated application users, tool developers, and product developers. We achieve simplicity by reducing the mapping of the input model to the generated code to a minimal core of easily understandable concepts. High customizability is achieved by providing a variety of mechanisms to extend the generator and the generated code. These include template overriding and hook points to extend the code generator; and hot spots and additional manual extensions to extend the generated code. It is even possible to fully control the code generator and the entire generation process via a scripting language.
Publisher's Version Article Search

Language Evolution and Reuse

Reusing Legacy DSLs with Melange
Thomas Degueule, Benoit Combemale, Arnaud Blouin, and Olivier Barais
(INRIA, France; INSA, France; University of Rennes 1, France)
The proliferation of independently-developed and constantly-evolving domain-specific languages (DSLs) in many domains raises new challenges for the software language engineering community. Instead of starting the definition of new DSLs from scratch, language designers would benefit from the reuse of previously defined DSLs. While the support for engineering isolated DSLs is getting more and more mature, there is still little support in language workbenches for importing, assembling, and customizing legacy languages to form new ones. Melange is a new language workbench where new DSLs are built by assembling pieces of syntax and semantics. These pieces can be imported and subsequently extended, restricted, or customized to fit specific requirements. The demonstration will introduce the audience to the main features of Melange through the definition of an executable DSL for the design and execution of Internet of Things systems. Specifically, we will show how such a language can be obtained from the assembly of other popular languages while maintaining the compatibility with their tools and transformations.
Publisher's Version Article Search
Supporting Users to Manage Breaking and Unresolvable Changes in Coupled Evolution
Juri Di Rocco, Davide Di Ruscio, Alfonso Pierantonio, and Ludovico Iovino
(University of L'Aquila, Italy; Gran Sasso Science Institute, Italy)
In Model-Driven Engineering (MDE) metamodels play a key role since they underpin the specification of different kinds of modeling artifacts, and the development of a wide range of model management tools. Consequently, when a metamodel is changed modelers and developers have to deal with the induced coupled evolutions i.e., adapting all those artifacts that might have been affected by the operated metamodel changes. Over the last years, several approaches have been proposed to deal with the coupled evolution problem, even though the treatment of changes is still a time consuming and error-prone activity. In this paper we propose an approach supporting users during the adaptation steps that cannot be fully automated.~The approach has been implemented by extending the EMFMigrate language and by exploiting the user input facility of the Epsilon Object Language. The approach has been applied to cope with the coupled evolution of metamodels and model-to-text transformations
Publisher's Version Article Search

Language Engineering Perspectives

Towards Improving Software Security using Language Engineering and mbeddr C
Markus Voelter, Zaur Molotnikov, and Bernd Kolb
(itemis, Germany; fortiss, Germany)
This paper explores the use of domain-specific languages for improving software security, which deals with developing software in a way that is not maliciously exploitable. Specifically we demonstrate how modular extension of the C programming language can help with technical and process-related aspects of software security. Some of these examples are already implemented, some are analytical extrapolations from related work we have done in the past; a detailed empirical evaluation has not yet been done. We rely on mbeddr, an extensible version of C developed with the JetBrains MPS language workbench. We conclude the paper with a discussion of the potential drawbacks of the approach and how these can be addressed in the future.
Publisher's Version Article Search
Extensible Visual Constraint Language
Brian Broll and Ákos Lédeczi
(Vanderbilt University, USA)
The paper presents a visual, imperative language for the specification of constraints corresponding to domain-specific modeling languages (DSML) in the new WebGME modeling environment. The language is based on the visual notation introduced by Scratch. The novel feature of the approach is that the constraint language is just another DSML defined through UML class diagram-based metamodels. As such, it is easily extensible via metamodel inheritance. The visual constraint programs are automatically translated into asynchronous JavaScript code that utilizes the native WebGME APIs for evaluation.
Publisher's Version Article Search
Systematic Evaluation of Three Data Marshalling Approaches for Distributed Software Systems
Hugo Andrade, Federico Giaimo, Christian Berger, and Ivica Crnkovic
(Chalmers University of Technology, Sweden; University of Gothenburg, Sweden)
Cyber-physical systems like robots and self-driving vehicles comprise complex software systems. Their software is typically realized as distributed agents that are responsible for dedicated tasks like sensor data handling, sensor data fusion, or action planning. The modular design allows a flexible deployment as well as algorithm encapsulation to exchange software modules where needed. The distributed software exchanges data using a data marshalling layer to serialize and deserialize data structures between a sending and receiving entity. In this article, we are systematically evaluating Google Protobuf, LCM, and our self-adaptive delta marshalling approach by using a generic description language, of which instances are composed at runtime. Our results show that Google Protobuf performs well for small messages composed mainly by integral field types; the self-adaptive data marshalling approach is efficient if four or more fields of type double are present, and LCM outperforms both when a mix of many integral and double fields is used.
Publisher's Version Article Search

proc time: 0.05