This paper presents the development of a robotic system for the rehabilitation and quality of life improvement of children with cerebral palsy (CP). The system consists of four modules and is based on a virtual humanoid robot that is meant to motivate and encourage children in their rehabilitation programs. The efficiency of the developed system was tested on two children with CP. The effect of using the robot is an increase in the number of exercise repetitions, as well as the time spent on therapy, developing and strengthening the child’s musculature. Additionally, the children are able to produce socially acceptable gestures in the context of non-verbal communication for socialization. The main advantages of this system are its flexibility and ease of use. Besides the proposed use in CP rehabilitation, this system can be used in the rehabilitation of people recovering from surgery or injuries. Use of the proposed system significantly decreases the work load of the therapist who would be conducting the repetitive motion, allowing the therapist to see an increased number of patients. In the future, the number of different movements the robot is able to perform will be increased by way of domain-specific modelling and language.

Constructing languages and tools for modeling is an intellectual effort that addresses challenges related to linguistic theory. It requires a high level of creativity and understanding between software engineers and language and domain experts. It is important to consider the context of language application, or the main goal of the work, at the beginning of the language construction process. A new language is not created instantaneously, but rather through a process of iteratively refining the definition of its elements in interaction with the real-world context in which it will be applied. From a pragmatic standpoint, the best way to ensure the correctness of a language's semantics is to verify it using a reference implementation, although different approaches may be used to describe the semantics of the language. In this paper, we share our experience in developing new and extending the existing functionalities of tools for visual domain-specific modeling to simplify reference implementation. We demonstrate how the code generator language, with minor extensions, can be used for it. Visual modeling tools in MDSD and DSM pay more attention to the graphical representation of objects, and less to relations, roles, and properties. In our platform, objects, roles, and relations are all derived from the same base class, which allows us to distinguish between fifteen different model representation types, ranging from view on the model topology to complex 3D views.

Using domain-specific modeling tools for conceptual modeling in automation can significantly improve not only quality and productivity in the development and maintenance of software, but can also influence the expected functional features related to applied electronics and mechanics. When specifying control logic in contemporary automation, engineers predominantly use general-purpose languages, like PLC code function block diagrams. The levels of abstraction and representation of the real environment and operations performed by various devices are generally low. Therefore, it is difficult to satisfy requirements and expectations of users, domain experts and software engineers and present complete control logic using a single language understandable to every one of them. This paper describes one way of evolving from the use of general-purpose to the use of domain-specific languages, which offers some practical benefits. The evolutionary path is illustrated by examples from the automotive. Special attention is paid to automated refinement of modeling languages and full application of the “model execution” paradigm to model views. The automated language refinement is achieved by means of modifiers and action reports, as an extension to code generator languages.

This paper presents an approach to handling frequent variations of modeling languages and models. The approach is based on Domain-Specific Modeling and linking of modeling tools with adaptive Run-Time Systems. The applicability of our solution is illustrated on an example of domain-specific languages for robot control. Special attention was given to the following problems: 1) model-level debugging; 2) performing fast transformation of models to native code for various hardware platforms and operating systems; and 3) specification of views and view-based generation of applications for validation of meta-models, models, and generated code. The feedback for automated refinement of models and meta-models is provided by a custom adaptive Run-Time System. For the purpose of synchronizing models, meta-models, and the target Run-Time System, we introduce action reports, which allow model-level debugging. In order to simplify handling of frequent model variations, we have introduced the linguistic concept of a modifier.

Contemporary tools aimed at information system (IS) development often use models to generate system implementation. Starting from an IS model, these tools commonly generate database implementation schema as well as code for generic CRUD operations of business applications. On the other hand, at the level of platform-independent models (PIMs) there is a lack of support for specification of more complex functionalities associated with events. In this paper, we present an approach aimed at specification of events at the level of PIMs. We introduce new concepts to describe context in which an event may occur, while we use our IIS*CFuncLang language to define event business logic. We also developed adequate transformations to generate executable program code from these specifications.

We present an approach and tools implemented for model-driven development of robotics using Domain-specific Modeling (DSM). Special attention is paid to the automatic generation of robot control logic, and facilitation of the validation and certification of software components. We describe the approach using practical examples on how to construct and use domain-specific languages for modeling (1) topological properties of a robot arm, (2) robot controllers, (3) robot actions and activities as well as (4) generating and verifying end-user applications from the models. Additionally, we describe on how to build DSM tools for visual debugging and how to include generation of documents in a model-level debugging scenario. Using fast code generators and adaptive run-time systems our tool chain supports generation, incremental update and execution of native code for various hardware platforms and operating systems "on hot". Our approach is applicable to both industrial and human-like robots and is verified by developing practical robot applications.

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.

Metamodels can be used to specify languages that capture the concepts and constraints of an area of interest. We describe a case and experiences on applying metamodeling for the development of medical devices. Metamodels are used to define Domain-Specific Modeling languages raising the level of abstraction in models close to the problem domain and producing formal specifications. Generators then read the models and produce executable code running in medical devices. The novel part of our approach, and particularly useful for device development, is extending the generation approach to model debugging and synchronization between a state of a model and a state of a program executed in a target runtime-system. This enables quick iterative feedback from the running code back to models, supports verification of the developed control logic, and helps to optimize the use of hardware resources.

Models have been widely used in the information system development process. Models are not just means for system analysis and documentation. They may be also transformed into system implementation, primarily program code. Generated program code of screen forms and transaction programs mainly implements generic functionalities that can be expressed by simple retrieval, insertion, update, or deletion operations over database records. Besides the program code of generic functionalities, each application usually includes program code for specific business logic that represents application-specific functionalities, which may include complex calculations, as well as a series of database operations. There is a lack of domain-specific and tool-supported techniques for specification of such application-specific functionalities at the level of platform-independent models (PIMs). In this paper, we propose an approach and a domain-specific language (DSL), named IIS⁎CFuncLang, aimed at enabling a complete specification of application-specific functionalities at the PIM level. We have developed algorithms for transformation of IIS⁎CFuncLang specifications into executable program code, such as PL/SQL program code. In order to support specification of application-specific functionalities using IIS⁎CFuncLang, we have also developed appropriate tree-based and textual editors. The language, editors, and the transformations are embedded into a Model-Driven Software Development tool, named Integrated Information Systems CASE (IIS⁎Case). IIS⁎Case supports platform-independent design and automated prototyping of information systems, which allows us to verify and test our approach in practice.

In this paper, we present an approach to development and application of domain-specific modeling (DSM) tools in the model-based management of business processes. The level of Model-to-Text (M2T) transformations in the standard architecture for domain-specific modeling solutions is extended with action reports, which allow synchronization between models, generated code, and target interpreters. The basic idea behind the approach is to use M2T transformation languages to construct submodels, client application components, and operations on target interpreters. In this manner, M2T transformations may be employed to support not only generation of target platform code from domain-specific graphical language (DSGL) models but also straightforward use of models and appropriate DSM tools as client applications. The applicability of action reports is demonstrated by examples from document engineering, and measurement and control systems.

In this position paper, we argue in favour of three points related to document-centric modelling of information systems: (i) information systems of some organizations may be understood in terms of documents, actions, actors, and document flow; (ii) modelling document flow may be a central step in modelling an information system; and (iii) as an approach to information system modelling, document flow modelling may be coupled with the form-based approach to information system development that is featured in IIS*Case, a model-driven development tool, because the form concept is semantically close to the document concept. With respect to these claims, we formulate a document-centric and model-driven approach to information system development, explain its particularities, and present a plan of activities that should lead to its implementation. By relying on domain-specific languages, the proposed approach should allow generation of information systems supporting document manipulation within a document flow and process mining.

In this paper, we present an approach to testing of models and generated code as well as of target interpreters that relies on the use of modeling tools and model transformation languages. When compared to the existing Model Driven Development (MDD) approaches and tools supporting Domain Specific Modeling (DSM), contributions of our research include: (i) introduction of action reports, which allow semantic actions on elements of a graphical interface for modeling; (ii) creation of recommendations and of the interface for integrating modeling tools with applications; and (iii) construction of a language for the description of the structure of user controls as well as construction of a component for embedding such controls into modeling and meta-modeling tools. The basic idea behind the approach is to use a transformation language to construct complex objects and applications as well as specify operations on complex objects and the interface. In this manner, we not only generate the target platform code from the select domain-specific graphical language (DSGL) models but also directly use these models and appropriate tools as client applications. The applicability of action reports is demonstrated in the examples concerning validation of document models and their generators.

Tutorial describes Domain-Specific Modeling (DSM) approach and demonstrates the practical benefits of applying DSM to modeling business / automation processes where documents are used.