Powered by
Conference Publishing Consulting

International Workshop on Domain-Specific Modeling (DSM 2016), October 30, 2016, Amsterdam, Netherlands

DSM 2016 – Proceedings

Contents - Abstracts - Authors

Frontmatter

Title Page

Message from the Chairs
Domain-Specific Modeling raises the level of abstraction beyond programming by specifying the solution directly using visual models to express domain concepts. In many cases, final products can be generated automatically from these high-level specifications. This automation is possible because both the language and generators fit the require-ments of only one domain. This paper introduces Domain-Specific Modeling and describes the related workshop that took place 30th October 2016.

Languages

Run-Time Code Generators for Model-Level Debugging in Domain-Specific Modeling
Verislav Djukić, Aleksandar Popović, and Zhenli Lu
(Djukic Software, Germany; University of Montenegro, Montenegro; Changshu Institute of Technology, China)
Code generators in the Domain-Specific Modeling (DSM) provide transformation from abstract models to specifica-tions that can be executed, interpreted, or compiled using a target language compiler. Modeling tools may include parsers assisting software engineers to perform an inverse task; i.e., to create a set of language concepts based on existing program code. Practical benefits from such a re-verse approach are limited, since source code cannot be used as an adequate base for creating language concepts on the high-abstraction level. Goal of application of the Model-Driven Development (MDD) approach, and DSM in particular, is to formally specify, using abstract models, a complete real system to the extent that models can be executed. In this paper we present an approach that completely achieve this goal. Model execution is implemented by the visual debugging of models, and submodels, which are dynamically created. In this approach, the most important role play performant code generators, so called run-time generators, and feedback that DSM tools get from run-time systems executing specifications.
Publisher's Version Article Search
A DSL-Based Approach for Elasticity Testing of Cloud Systems
Michel Albonico, Amine Benelallam, Jean-Marie Mottu, and Gerson Sunyé
(AtlanMod, France; Federal University of Technology Paraná, Brazil; École des Mines de Nantes, France; Université de Nantes, France)
One of the main features of cloud computing is elasticity, where resource is (de-)allocated on demand and at system's runtime. Since elasticity is not trivial, testing cloud-based systems (CBS) is laborious. Among others, testers must set up elasticity parameters on cloud computing infrastructure, specify a sequence of resource variations, and drive CBS through this sequence. In this paper, we propose a Domain-Specific Language (DSL) aiming at reducing the tester's effort in writing and executing CBS elasticity testing. Our DSL abstracts test case specification from different cloud provider's libraries, making it portable. Experiments with two different case studies, a MongoDB replica set and a distributed web application, shows that our approach reduces the effort (in number of words) to write test cases, compared to dedicated libraries. We also see a reduced effort when running the same test case on multiple cloud providers.
Publisher's Version Article Search
DesignScript: A Domain Specific Language for Architectural Computing
Robert Aish and Emmanuel Mendoza
(University College London, UK; ARM, UK)
DesignScript is a multi-paradigm domain-specific end-user language and modelling environment for architectural and engineering computation. DesignScript implements both visual data flow programming and imperative programming. The novice user initially develops his data flow program through the familiar visual programming environment. This environment is effectively an intuitive user interface masking the underlying DesignScript language. The DesignScript language and its related user interface addresses three issues: the domain specific requirements of architectural and engineering computing, the scalability issues encountered when visual data flow programming is applied to complex design scenarios and the abstraction barriers encountered when users transition from data flow to imperative programming.
Publisher's Version Article Search

Robotics and Safety

Model-Driven Separation of Concerns for Service Robotics
Kai Adam, Arvid Butting, Robert Heim, Oliver Kautz, Bernhard Rumpe, and Andreas Wortmann
(RWTH Aachen University, Germany)
Robotics currently adopts model-driven engineering focusing software modeling languages. This forces domain experts to employ these languages instead of enabling application of more appropriate DSLs. This ultimately produces monolithic, hardly reusable applications. We present an infrastructure for the development of service robotics applications employing DSLs aimed at domain experts and tailored to domain challenges. It facilitates separation of concerns of participating robotics, domain, and software engineering experts and integrates their models via a component & connector reference architecture and a combined code generation framework. The infrastructure was successfully deployed and evaluated with robotics manufacturers, caregivers, and software engineers in a German hospital. We believe that model-driven engineering with languages tailored to the various stakeholders’ needs can greatly facilitate robotic application engineering.
Publisher's Version Article Search
Improving Maintenance by Creating a DSL for Configuring a Fieldbus
Mathijs Schuts and Jozef Hooman
(Philips, Netherlands; TNO, Netherlands; Radboud University Nijmegen, Netherlands)
The high-tech industry produces complex devices in which software plays an important role. Since these devices have been developed for many decades, an increasing part of the software can be classified as legacy which is difficult to maintain and to extend. To improve the maintainability of legacy components, domain specific languages (DSLs) provide promising perspectives. We present a DSL for creating configuration files that describe the topology of a fieldbus. This DSL improves the maintainability and extensibility of a legacy component. Compared to the current way-of-working, the configuration files generated by the DSL are of higher quality due to the concise representation of DSL instances and additional validation checks. To raise the level of abstraction even more, we have created a second DSL which allows a concise description of system configurations and the generation of topologies.
Publisher's Version Article Search
CPAL: High-Level Abstractions for Safe Embedded Systems
Nicolas Navet and Loïc Fejoz
(University of Luxembourg, Luxembourg; RTaW, France)
Innovation in the field of embedded systems, and more broadly in cyber-physical systems, increasingly relies on software. The productivity gain in software development can hardly keep up with the demand for software despite the increasing adoption of Model-Driven Development (MDD). In this context, we believe that major productivity and quality improvements are still ahead of us through better programming languages and environments. CPAL, the Cyber-Physical Action Language, is a contribution in that direction with the objective to speed-up the development of embedded systems with dependability constraints. The objective of this paper is to present and illustrate the use-cases of the high-level abstractions offered to the developer in CPAL with respect to real-time scheduling, introspection mechanisms, native support of Finite State Machines (FSMs), abstracting the hardware and decoupling functional concerns from non-functional concerns.
Publisher's Version Article Search
A Safe Autonomous Vehicle Trajectory Domain Specific Modeling Language for Non-expert Development
Matt Bunting, Yegeta Zeleke, Kennon McKeever, and Jonathan Sprinkle
(University of Arizona, USA; University of California at Santa Cruz, USA)
Managing complexity while ensuring safely designed behaviors is important for cyber-physical systems as they are continually intro- duced to consumers, such as autonomous vehicles. Safety consid- erations are important as programming interfaces become open to experts and non experts of varying degrees. Autonomous vehicles are an example system where many domain experts must collab- orate together to ensure safe operation. Through the use of higher level abstraction, domain experts may provide verification tools to check dynamic behavioral constraints. Similarly, higher level mod- eling tools may generate lower level artifacts for a working system. With modeling and verification tools, smaller teams and potentially non-experts may program custom behaviors while ensuring a cor- rectly behaved system. A high level domain specific modeling language was created with a focus on non-domain experts. The domain consists of driving a vehicle through a set of known waypoints by connecting together multiple primitive motions in a sequence. Though constrained to simple motions, it is still possible to create a sequence to drive the vehicle unsafely. Model verification was implemented to check that the expected start and stop waypoints were correctly reached without driving the vehicle into unsafe regions. The language was then provided to a set of 4th year elementary school students to create unique paths. The models created by the students were then used to generate controller artifacts to operate a real autonomous vehicle on a soccer field.
Publisher's Version Article Search
Applying Test-Driven Development for Creating and Refining Domain-Specific Modeling Languages and Generators
Juha-Pekka Tolvanen
(MetaCase, Finland)
While creation of modeling languages and related code generators has become easier, their testing is perhaps now-adays the most time consuming part. This is particularly relevant for Domain-Specific Modeling (DSM) as it is common that the language and generators evolve frequently along with the domain it addresses. We demonstrate one solution that we have found practical when applying Test Driven Development for creating and maintaining modeling languages and generators along with tool support.
Publisher's Version Article Search
Instance Modeling Assisted by an Optional Meta Level
Riccardo Solmi
(Whole Factory, Italy)
We believe that programming is mainly a linguistic process concerning the development of the language abstractions better suited to deal with a given problem domain. The main responsibility of a linguistic system is to capture and incorporate the knowledge of domain experts, while trying to minimize the meta level efforts, thus allowing users to concentrate on modeling activities. While a meta level is necessary in order to write instances, it is possible to define a generic meta level capable of representing any specific entity. We introduce an instance modeling language, Entities, combining a rich graphical notation, an optionally typed structure, and composability with other domain specific languages. The visual expressivity is comparable to a mindmapping tool, and makes it best suited for knowledge representation domains. The optional typing enables an exploratory, bottom up approach to metamodeling. The composability with strictly typed languages makes modeling a much more flexible experience.
Publisher's Version Article Search

proc time: 0.11