Andreas Wortmann

A new skill based robot programming language using UML/P Statecharts

This paper introduces the new robot programming language LightRocks(Light Weight Robot Coding for Skills), a domain specific language (DSL) for robot programming. The language offers three different level of abstraction for robot programming. On lowest level skills are coded by domain experts. On a more abstract level these skills are supposed to be combined by shop floor workers or technicians to define tasks. The language is designed to allow as much flexibility as necessary on the lowest level of abstraction and is kept as simple as possible with the more abstract layers. A Statechart like model is used to describe the different levels of detail. For this we apply the UML/P and the language workbench MontiCore. To this end we are able to generate code while hiding controller specific implementation details. In addition the development in LightRocks is supported by a generic graphical editor implemented as an Eclipse plugin.

Integration of heterogeneous modeling languages via extensible and composable language components

Effective model-driven engineering of complex systems requires to appropriately describe different specific system aspects. To this end, efficient integration of different heterogeneous modeling languages is essential. Modeling language integaration is onerous and requires in-depth conceptual and technical knowledge and effort. Traditional modeling lanugage integration approches require language engineers to compose monolithic language aggregates for a specific task or project. Adapting these aggregates to different contexts requires vast effort and makes these hardly reusable. This contribution presents a method for the engineering of grammar-based language components that can be independently developed, are syntactically composable, and ultimately reusable. To this end, it introduces the concepts of language aggregation, language embedding, and language inheritance, as well as their realization in the language workbench MontiCore. The result is a generalizable, systematic, and efficient syntax-oriented composition of languages that allows the agile employment of modeling languages efficiently tailored for individual software projects.

A comparison of mechanisms for integrating handwritten and generated code for object-oriented programming languages

Code generation from models is a core activity in model-driven development (MDD). For complex systems it is usually impossible to generate the entire software system from models alone. Thus, MDD requires mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects with many model and code artifacts, where a sound integration for generated and handwritten code is necessary. We provide an overview of mechanisms for integrating generated and handwritten code for object-oriented languages. In addition to that, we define and apply criteria to compare these mechanisms. The results are intended to help MDD tool developers in choosing an appropriate integration mechanism.

Composition of Heterogeneous Modeling Languages

Model-driven engineering aims at managing the complexity of large software systems by describing their various aspects through dedicated models. This approach requires to employ different modeling languages that are tailored to specific system aspects, yet can be interpreted together to form a coherent description of the total system. Traditionally, implementations of such integrated languages have been monolithic language projects with little modularization and reuse of language parts.

Modeling robot and world interfaces for reusable tasks

Robotics applications involve robots that perform tasks by interacting with specific worlds. Most applications are intertwined with and tied to fixed robots and worlds. Changes and evolution of a robot or world have an invasive and often unpredictable impact on the application software. We propose making the models of robots and worlds explicit in robotics applications and separate these by introducing application-specific and platform-independent interfaces. This separation allows modular model-driven development of robotics applications and enables the reuse and adaptation of models and applications without need for invasive modifications. We present a framework with a family of modeling languages for conceptual, platform-independent applications, tasks, robots, and worlds. The model-driven RoboTask framework integrates these languages with a runtime architecture to execute robotics tasks using a planner and mappings from conceptual models to actual platforms. This enables a separation of domain concerns from software development concerns and modification of applications without invasive impacts on their separated constituents. We believe that the enabled reuse and adaptation lead to more efficient development and higher quality software for robotics applications.

Systematic Language Extension Mechanisms for the MontiArc Architecture Description Language

Architecture description languages (ADLs) combine the benefits of component-based software engineering and model-driven development. Extending an ADL to domain-specific requirements is a major challenge for its successful application. Most ADLs focus on fixed features and do not consider domain-specific language extension. ADLs focusing on extensibility focus on syntactic augmentation only and neither consider semantics, nor the ADL’s tooling. We present a systematic extension method for the MontiArc component and connector ADL that enables extending its syntax and infrastructure. The MontiArc ADL is built on top of the MontiCore workbench for compositional modeling languages and leverages its powerful language integration facilities. Based on these, we conceived systematic extension activities and present their application to customizing MontiArc for three different domains. This application of software language engineering to ADLs reduces effort for their extension and the presented method guides developers in applying it to their domain. This ultimately fosters the application of ADLs to real-world domain-specific challenges.

Integration of Handwritten and Generated Object-Oriented Code

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete software system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integration of both forms of code is needed.

Teaching agile model-driven engineering for cyber-physical systems

Agile development methods, model-driven engineering, and cyber-physical systems are important topics in software engineering education. It is not obvious how to teach their combination while respecting individual challenges posed to students and educators. We have devised a software project class for teaching the agile MDE for CPS. The project class was held in three different semesters. In this paper, we report on the setup of our exploratory study and its goals for teaching. We base our evaluation and insights on interviews and questionnaires. Our results show the feasibility of combination of agile MDE for CPS but also the challenges this combination poses to students and educators.

A Systematic Mapping Study on Modeling for Industry 4.0

Industry 4.0 is a vision of manufacturing in which smart, interconnected production systems optimize the complete value-added chain to reduce cost and time-to-market. At the core of Industry 4.0 is the smart factory of the future, whose successful deployment requires solving challenges from many domains. Model-based systems engineering (MBSE) is a key enabler for such complex systems of systems as can be seen by the increased number of related publications in key conferences and journals. This paper aims to characterize the state of the art of MBSE for the smart factory through a systematic mapping study on this topic. Adopting a detailed search strategy, 1466 papers were initially identified. Of these, 222 papers were selected and categorized using a particular classification scheme. Hence, we present the concerns addressed by the modeling community for Industry 4.0, how these are investigated, where these are published, and by whom. The resulting research landscape can help to understand, guide, and compare research in this field. In particular, this paper identifies the Industry 4.0 challenges addressed by the modeling community, but also the challenges that seem to be less investigated.

Concern-Oriented Language Development (COLD): Fostering Reuse in Language Engineering

Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressive-ness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques. However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios. In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.