HCM-L: Domain-Specific Modeling for Active and Assisted Living

General-purpose modeling languages are inadequate to model and visualize business processes precisely. An enterprise has its own vocabulary for modeling processes and its specific tasks may have attached data that define the tasks precisely. We propose using Domain Specific Modeling (DSM) languages to model business processes, such that an enterprise can define its own DSM language(s) capturing its vocabulary and data requirement. We suggest using UML profiles and UML activity diagrams as the semantic base for these DSM languages and present tools that are able to create a DSM language and tool support for a given domain. One tool, called ADSpecializer, can generate a UML profile and its tool support of a given application domain. The other tool, ADModeler, is used to create UML activity diagrams within such a domain-specific UML profile. The two tools enable an enterprise to efficiently define and utilize their own DSM language.

Compared to General Purpose Modeling Languages (GPMLs), Domain Specific Modeling Languages (DSMLs) have brought increasing expressivity and conciseness through the use of concepts and notations, which are customized by the characteristics of a specific problem domain. However, the creation of completely new languages can significantly increase software development costs. An alternative approach to creating new DSMLs refers to a customization of existing modeling languages. The DSML creation process through a customization of existing languages is a special case of Language Embedding. The embedding provides customization of an inherited infrastructure to a given domain. This paper elaborates a Domain-Specific Modeling environment for embedding an arbitrary DSML into an arbitrary GPML. The environment enables uniform development of DSMLs in the form of a lightweight extension of existing modeling languages.

The subject of the research is machine learning models and methods for generating legal contracts with limited resources and performance evaluation benchmarks. The goal of the work is to analyse approaches of domain-specific Large Language Models development and to find the optimal method of creating independent specialized systems that can generate contracts in different languages and legal systems. The article addresses the following tasks: identification of existing companies and solutions in this area, exploring approaches to create texts in natural language, analysis of evaluation and comparison methods of such systems, inspecting limitations and shortcomings of existing solutions and approaches, finding the optimal method of developing systems with limited resources. The following results were obtained: approaches of natural language generation and their features were investigated; the "Transformer" architecture was defined as a modern standard in the field of text information generation; different model types which are based on this architecture were considered; data sources for training were analysed; methods of adapting models in specialized areas were considered; model evaluating benchmarks for various tasks were reviewed; shortcomings of the existing specialized language models and the incompleteness of existing benchmarks for contract generation task evaluation were revealed. As a result of the analytical experiment, it was determined that the Retrieval-Augmented Generation method is the most optimal for solving the given task under the given conditions. The conducted experiment and its results can be used as a basis for further research of domain-specific language models development with limited resources. Conclusions: the article provides an overview of natural language generation methods using modern machine learning techniques, considers their advantages and disadvantages for small companies and scientific institutions that have limited resources. The work examinates a specialized legal domain and the problem of contract generation and determines the most optimal method to solve it.

The International Workshop on Non-functional System Properties in Domain Specific Modeling Languages (NFPinDSML) series traditionally takes place as part of the Satellite Events of the ACM/IEEE International Conference on Model Driven Engineering Languages and Systems (MODELS). Traditionally, NFPinDSML gathers researchers and practitioners interested in the estimation and evaluation of system quality and their integration in Domain Specific Modeling Languages and Model Driven Engineering in general. This paper is the summary of the fourth NFPinDSML workshop which was affiliated with MODELS 2012.

Domain-specific modelling langugages, which are tailored to the requirements of their users, can significantly increase the acceptance of formal (or at least semi-formal) modelling in scenarios where informal diagrams and natural language descriptions are predominant today. We show in this article how the Resource Description Framework (RDF), which is a standard for the fundamental data structures of the Semantic Web, and algebraic graph transformations on these data structures can be used to realise and modify the abstract syntax of models in such domain-specific languages. We examine a small domain-specific modelling language for IT infrastructures--inspired by real-world requirements from a banking environment--as an application scenario. From this scenario, we derive four key requirements for a domain-specific modelling framework: (1) distributed modelling, (2) evolution of language definitions, (3) migration of legacy models and (4) integration of modelling languages. RDF and transformation rules are then used to provide a solution which meets these requirements simultaneously, where all kinds of modifications--from simple editing steps via model migration to language integration--are realised in an integrated manner by the single, declarative formalism of algebraic graph transformation.

Software development processes are collaborative in nature. Neglecting the key role of end-users leads to software unlikely to satisfy their needs. This collaboration becomes specially important when creating Domain-Specific Modeling Languages (DSMLs), which are (modeling) languages specifically designed to carry out the tasks of a particular domain. While end-users are actually the experts of the domain for which a DSML is developed, their participation in the DSML specification process is still rather limited nowadays. In this paper, we propose a more community-aware language development process by enabling the active participation of all community members (both developers and end-users of the DSML) from the very beginning. Our proposal is based on a DSML itself, called Collaboro, which allows representing change proposals on the DSML design and discussing (and tracing back) possible solutions, comments and decisions arisen during the collaboration. Collaboro also incorporates a metric-based recommender system to help community members to define high-quality notations for the DSMLs. We also show how Collaboro can be used at the model-level to facilitate the collaborative specification of software models.

The paper is devoted to the convergence of critical and non-critical IT in the area of Business Analysis and Requirements Engineering. We consider Domain Specific Modelling (DSM) and Domain Specific Language (DSL) as promising points to improve Requirements Engineering maturity and quality in a safety-critical and security-critical domain. The paper presents a DSM-based procedure of knowledge management that can be implemented in a software engineering company to support the reuse of domain knowledge and technical solutions. Afterward, we select Gherkin language as a sample of DSL-based requirements elicitation, analysis, documentation, and validation in a frame of Behavior Driven Development. To provide a DSM&DSL-based Requirements Engineering technique we analyzed Gherkin's applicability for different kinds and levels of critical requirements.

ADELFE is a French acronym that means “Toolkit for Designing Software with Emergent Functionalities” (“Atelier de DEveloppement de Logiciels à Fonctionnalité Emergente” in French). ADELFE methodology is dedicated to applications characterized by openness and the need of the system adaptation to an environment. Its main goal is to help and guide any designer during the development of an Adaptive Multi-agent System (AMAS). An AMAS is characterized by the following points: it is plunged into an environment and composed of interdependent agents, each agent carries out a partial function and the agents, organization during runtime makes the system realize an emergent function. Actually, an agent is locally cooperative, i.e. it is able to recognize cooperation failures called Non-cooperative Situations (NCS, which could be related to exceptions in classical programs) and treat them.ADELFE includes five Work Definitions that were initially inspired from the Rational Unified Process (RUP) and gathers 21 activities, producing or refining 12 work products. These products are aggregating modelling diagrams or structured or free text. ADELFE, which is a Model-Driven (model-centred) development method, is not hardly dependent on Domain Specific Modelling Languages (DSML) but currently the recommendation is to use UML2 for general activities and to use AMASML (AMAS Modelling Language) and SpeADL (Species-based Modelling Language) for specific activities appearing in Analysis, Design or Implementation phases.KeywordsAdaptive Multi-agent Systems (AMAS)Domain-specific Modeling Languages (DSML)AMAS ApproachAMAS TheoryManagement Studies ConferenceThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Domain specific modeling languages are of increasing importance for the development of software and other systems. Meta tools are needed to support rapid development of domain-specific solutions. Using the Eclipse Graphical Modeling Framework (GMF), modeling languages are defined by providing a meta model using the MOF/EMF approach. Up to now, GMF provides basic editing commands only. It does not support the definition of complex editing commands which would allow e.g. to insert a complex structure into a diagram in one step. As practical tool support for the design and generation of visual editors with complex editing operations based on graph transformation, an extended version of GMF has been developed and is presented in this paper.

The increasing use of model-driven software development has renewed emphasis on using domain-specific models during application development. More specifically, there has been emphasis on using domain-specific modeling languages (DSMLs) to capture user-specified requirements when creating applications. The current approach to realizing these applications is to translate DSML models into source code using several model-to-model and model-to-code transformations. This approach is still dependent on the underlying source code representation and only raises the level of abstraction during development. Experience has shown that developers will many times be required to manually modify the generated source code, which can be error-prone and time consuming. An alternative to the aforementioned approach involves using an interpreted domain-specific modeling language (i-DSML) whose models can be directly executed using a Domain Specific Virtual Machine (DSVM). Direct execution of i-DSML models require a semantically rich platform that reduces the gap between the application models and the underlying services required to realize the application. One layer in this platform is the domain-specific middleware that is responsible for the management and delivery of services in the specific domain. In this dissertation, we investigated the problem of designing the domain-specific middleware of the DSVM to facilitate the bifurcation of the semantics of the domain and the model of execution (MoE) while supporting runtime adaptation and validation. We approached our investigation by seeking solutions to the following sub-problems: (1) How can the domain-specific knowledge (DSK) semantics be separated from the MoE for a given domain? (2) How do we define a generic model of execution (GMoE) of the middleware so that it is adaptable and realizes DSK operations to support delivery of services? (3) How do we validate the realization of DSK operations at runtime? Our research into the domain-specific middleware was done using an i-DSML for the user-centric communication domain, Communication Modeling Language (CML), and for microgrid energy management domain, Microgrid Modeling Language (MGridML). We have successfully developed a methodology to separate the DSK and GMoE of the middleware of a DSVM that supports specialization for a given domain, and is able to perform adaptation and validation at runtime.

In order to assist domain experts, several tools exist for the definition of graphical or textual domain specific modeling languages (DSMLs). The resulting models are useful, but not sufficient, for an overall understanding of the system, especially when formal methods are being applied. Indeed, formal methods failures often result from misunderstandings of the requirements, even if the system is entirely proved. This is confirmed by several industrial experiments which showed that the poor readability of the formal notations is not convenient for communication with domain experts and hence the validation activity is often tedious, time consuming and complex. In order to circumvent this shortcoming, we propose to make domain specific models provable and also executable thanks to the animation of their expected behaviour directly in a dedicated DSML tool. Our approach starts from an intuitive description of the system’s operational semantics thanks to high-level Petri-nets which abstract away structural constraints and focus on safety-critical behaviours. Then we take benefit of the B method in order to refine and prove these operational semantics on the one hand, and to merge them with the static semantics of a given DSML, on the other hand. This work is applied to the design of ERTMS/ETCS 3 which is an emergent solution for railway system management.

Educational games are serious games that specifically used for education yet it is fun to play. There are numbers of domain specific modeling languages for educational games focus in various aspect and theories of learning. By having domain specific modeling language which applies a visual diagramming language, it helps in represent design ideas and logic. This paper analyzes existing modelling languages to assess the coverage of strategy genre and transfer learning concepts. The results show that existing modelling languages covers important strategy genre concepts but cover very little of the transfer learning concepts. The authors conclude that the existing modelling languages can be used to model small strategy games but will have trouble to scale to large strategy games, and will not be able to model games that guarantee students learning.

A considerable portion of software systems today are adopted in the embedded control domain. Embedded control software deals with controlling a physical system, and as such models of physical characteristics become part of the embedded control software. In current practices, usually general-purpose languages (GPL), such as C/C++ are used for embedded systems development. Although a GPL is suitable for expressing general-purpose computation, it falls short in expressing the models of physical characteristics as desired. This reduces not only the readability of the code but also hampers reuse due to the lack of dedicated abstractions and composition operators. Moreover, domain-specific static and dynamic checks may not be applied effectively. There exist domain-specific modeling languages (DSML) and tools to specify models of physical characteristics. Although they are commonly used for simulation and documentation of physical systems, they are often not used to implement embedded control software. This is due to the fact that these DSMLs are not suitable to express the general-purpose computation and they cannot be easily composed with other software modules that are implemented in GPL. This paper presents a novel approach to combine a DSML to model physical characteristics and a GPL to implement general-purpose computation. The composition filters model is used to compose models specified in the DSML with modules specified in the GPL at the abstraction level of both languages. As such, this approach combines the benefits of using a DSML to model physical characteristics with the freedom of a GPL to implement general-purpose computation. The approach is illustrated using two industrial case studies from the printing systems domain.

The development and use of Domain Specific Languages emerged as a way to cope with complex problems using concepts closer to the problem domain. By leveraging the principles proposed by Model-Driven Development (MDD), like the separation of concerns and the use of model transformations, this approach became popular and caused the emergence of a variety of languages, known as Domain Specific Modeling Languages (DSMLs). Moreover, the use of DSMLs with graphical notations abstracts even more the problem domain, either by using extensions of UML or directly using metamodeling languages. The definition and use of DSMLs is only possible through specific tools, known as languages workbenches. This paper discusses the analysis and comparison of three of these tools (namely Papyrus, Enterprise Architect and Sirius) that were used to create the XIS-Mobile language, a non-trivial DSML defined as a UML profile for modeling mobile applications in a platform-independent way. These tools were evaluated considering a set of key criteria (namely learnability, usability, graphical completeness, validation support, transformation support, evolvability and interoperability) which show their suitability to develop non-trivial languages.

The use of domain-specific modeling languages (DSMLs) results in higher productivity during the development process. This is accomplished by raising the level of abstraction during design and focusing on domain concepts rather than low-level implementation details. Unlike other development paradigms, little work has been done in determining and measuring the claimed benefits of using DSMLs.In this paper, we propose a new approach to determine the effort involved in creating and using DSML models to develop applications and to manage the behavior of applications at runtime. The approach involves a classification of the effort involved, and definition of relevant metrics to measure the effort for each category. A case study is presented that shows how we applied the proposed metrics during the development and execution of an application using three different DSMLs.