Search

Interactive scientific visualization applications have been more and more used to observe, analyze and understand the complex phenomena studied in several scientific disciplines such as (nano-sciences, fluid simulations, etc.). To facilitate the coupling of the different computation, visualization and exploration codes, which are often heterogeneous and difficult to cooperate, scientists must be able to use and reuse the different parts of the applications already built in order to interchange and enrich certain parts without being experts. In this context, a middleware called FlowVR has been developed by the scientific community leading to make applications divided into set of components exchanging messages. Moreover, this middleware enables to encapsulate existing codes in components, interconnect them via data links, and deploy them on distributed computing resources. Nevertheless, FlowVR does not offer any capability to check the functional correctness of new developed component-based applications. This paper presents a framework called Model and Component-based framework for Scientific Applications (MCSA) based on a interplay of model-driven and component-based software engineering. On the one hand, we provide a domain specific language dedicated to physics/chemistry scientists in order to built their MCSA applications. This language also allows to capitalize efforts by proposing existing components that have been already developed. On the other hand, we propose a model transformation to check the correctness of instantiated models, for this, we use a new subclass of Petri net called strict Colored FIFO Nets (sCFN). Our approach has been backed by a case study relies on a molecular dynamics application. [ABSTRACT FROM AUTHOR]

Real-time collaboration in model-driven software engineering is gaining increasing attention from both the research and industrial community. This is due to its potential adverse effects on the efficiency of software modeling process. However, current approaches for real-time collaboration are tightly coupled to modeling platforms and language workbenches. To address this issue, we present BUMBLE-CE, the first extensible approach for cross-platform real-time collaborative modeling which is independent of both the modeling platforms and the domain-specific modeling language used by the modelers. One of the main characteristics of BUMBLE-CE is that it allows modelers to work on the head revision of their models as usual and, when necessary, they can start and terminate on-demand real-time collaborative modeling sessions. This paper reports on the requirements driving the design of BUMBLE-CE, its architecture and underlying design decisions, implementation of BUMBLE-CE using EMF.Cloud technologies and an example application of BUMBLE-CE to state machine models realized in Eclipse EMF and Jetbrains MPS.

Model-driven software engineering (MDSE) is an established approach for developing complex software systems. The unified modelling language (UML) is one of the most used model languages for applying the MDSE approach. UML has 14 diagram types that describe different perspectives of a software system under development. These diagrams are strongly dependent on each other and must be consistent with one another. The main objectives of this paper are as follows: (1) to understand (i) how aware experts are of model consistency issues and (ii) how relevant these issues are to experts, in order to understand model consistency in the MDSE/UML contexts, and more importantly, (2) to validate a set of 116 UML consistency rules that was systematically collected from the literature, so as to identify the rules that should always be enforced. We conducted a personal opinion survey with 106 experts in SE and MDSE, by means of an online questionnaire. The survey results describe an overview of how the topic of MDSE/UML consistency is handled by experts in the field. In addition, this survey identified a set of 52 UML consistency rules which should always be checked in every UML diagram. The majority of these 52 rules were understood by the majority of respondents and are general-purpose rules that are involved in the Design software development phase. This subset of 52 rules could be considered to be (1) added to the UML standard, (2) used as a reference to researchers who study UML/MDSE, and (3) used as a practical example for teaching purposes. [ABSTRACT FROM AUTHOR]

In this paper, we present a transition journey of automotive software architecture design from using legacy approaches and toolchains to employing new modeling capabilities in the recent releases of Matlab/Simulink (M/S). We present the seamless approach that we have employed for the software architecture modeling of a mixed-critical electric powertrain controller which runs on a multi-core hardware platform. With our approach, we can achieve bidirectional traceability along with a powerful authoring process, implement a detailed model-based software architecture design of AUTOSAR system including a detailed data dictionary, and carry out umpteen number of proof-of-concept studies, what-if scenario simulations and performance tuning of safety software. In this context, we discuss an industrial case study employing valuable lessons learned, our experience reports providing novel insights and best practices followed.

Models are used in both Software Engineering (SE) and Artificial Intelligence (AI). SE models may specify the architecture at different levels of abstraction and for addressing different concerns at various stages of the software development life-cycle, from early conceptualization and design, to verification, implementation, testing and evolution. However, AI models may provide smart capabilities, such as prediction and decision-making support. For instance, in Machine Learning (ML), which is currently the most popular sub-discipline of AI, mathematical models may learn useful patterns in the observed data and can become capable of making predictions. The goal of this work is to create synergy by bringing models in the said communities together and proposing a holistic approach to model-driven software development for intelligent systems that require ML. We illustrate how software models can become capable of creating and dealing with ML models in a seamless manner. The main focus is on the domain of the Internet of Things (IoT), where both ML and model-driven SE play a key role. In the context of the need to take a Cyber-Physical System-of-Systems perspective of the targeted architecture, an integrated design environment for both SE and ML sub-systems would best support the optimization and overall efficiency of the implementation of the resulting system. In particular, we implement the proposed approach, called ML-Quadrat, based on ThingML, and validate it using a case study from the IoT domain, as well as through an empirical user evaluation. It transpires that the proposed approach is not only feasible, but may also contribute to the performance leap of software development for smart Cyber-Physical Systems (CPS) which are connected to the IoT, as well as an enhanced user experience of the practitioners who use the proposed modeling solution. [ABSTRACT FROM AUTHOR]

Traceability links recovery (TLR) has been a topic of interest for many years. However, TLR approaches are based on the latent semantics of the software artifacts, and are not equipped to deal with software artifacts that lack those inherent semantics, such as BPMN models. The aim of this work is to enhance TLR approaches in BPMN models by incorporating the linguistic particularities of BPMN models into the TLR process. Our approach runs through a threefold contribution: (1) we identify the particularities of BPMN models; (2) we describe how to leverage the particularities; and (3) we build three variants of the best exploratory TLR approach which specifically cater to BPMN models. The approach is evaluated through both an academic case study and a real-world industrial case study. The results show that incorporating the particularities of BPMN into the TLR process leads the specific approach to improve the traceability results obtained by generalist approaches, maintaining precision levels and improving recall. The novel findings of this paper suggest that there is a benefit in researching and taking in account the particularities of the different kinds of models in order to optimize the results of TLR between requirements and models, instead of relying on generalist approaches. [ABSTRACT FROM AUTHOR]

This article reports on the Design Science engineering cycle for implementing a modeling method to support model-driven, process-centric API management. The BPMN standard was hereby enriched on semantic, syntactic and tool levels in order to provide a viable solution for integrating API requests with diagrammatic business process models in order to facilitate the documentation or testing of REST API calls directly in a modeling environment. The method can be implemented by stakeholders that need to map and manage their API ecosystem, thus gaining more API management agility and improving their software engineering productivity. By assimilating API ecosystem conceptualization in the modeling environment, the proposal differs from both RPA (which typically employs non-BPMN process diagramming e.g., in UIPath) and BPM Systems (which typically isolate all API-related semantics outside the process modeling language to keep the diagrammatic representation standard-compliant).

The increasing complexity of embedded systems renders software verification more complex, requiring monitoring and formal techniques, like model-checking. However, to use such techniques, system engineers usually need formal expertise to express the software requirements in a formal language. To facilitate the use of model-checking tools by system engineers, our approach uses a UML model interpreter through which the software requirements can directly be expressed in UML as well. Formal requirements are encoded as UML state machines with the transition guards written in a specific observation language, which expresses predicates on the execution of the system model. Each such executable UML specification can model either a Büchi automaton or an observer automaton, and is synchronously composed with the system, to follow its execution during model-checking. Formal verification can continue at runtime for all deterministic observer automata used during offline verification by deploying them on real embedded systems. Our approach has been evaluated on multiple case studies and is illustrated, in this paper, through the user interface model of a cruise-control system. The automata-based verification results are in line with the verification of the equivalent LTL properties. The runtime overhead during monitoring is proportional to the number of monitors. [ABSTRACT FROM AUTHOR]

In this paper, we present a transition journey of automotive software architecture design from using legacy approaches and toolchains to employing new modeling capabilities in the recent releases of Matlab/Simulink (M/S). We present the seamless approach that we have employed for the software architecture modeling of a mixed-critical electric powertrain controller which runs on a multi-core hardware platform. With our approach, we can achieve bidirectional traceability along with a powerful authoring process, implement a detailed model-based software architecture design of AUTOSAR system including a detailed data dictionary, and carry out umpteen number of proof-of-concept studies, what-if scenario simulations and performance tuning of safety software. In this context, we discuss an industrial case study employing valuable lessons learned, our experience reports providing novel insights and best practices followed. [ABSTRACT FROM AUTHOR]

Cloud Functions are a trend in cloud computing in which developers are allowed to install code in a Function-as-a-Service (FaaS) platform able to manage provisioning, execution, monitoring and automatic scaling. The underlying infrastructure in FaaS platforms is hidden from the developers and designers and, since the inuence of the infrastructure is unknown, this makes it di_cult to apply software performance engineering approaches on cloud functions, which could lead to wrong or inaccurate performance estimations. In this study, we explore the use of component-based modeling and simulation in order to generate performance estimations of an exemplar cloud function which was exercised using a variety of workloads. A cloud function was both implemented and instrumented to record performance datain a log _le, associated with its invocations; using the log _le as an input, we extracted a performance model in a Palladio Component Model format suitable for running simulations to validate whether the generated model could explain the runtime behavior of the function. Using this approach and further tunings in the model, we were able to validate that the simulations could explain more than 95% of the function's behavior and that component-based modeling and simulation can be considered a serious option when trying to explain the behavior of a cloud function.

In recent years, we have been witnessing a rapid increase of research on exergames—i.e., computer games that require users to move during gameplay as a form of physical activity and rehabilitation. Properly balancing the need to develop an effective exercise activity with the requirements for a smooth interaction with the software system and an engaging game experience is a challenge. Model-driven software engineering enables the fast prototyping of multiple system variants, which can be very useful for exergame development. In this paper, we propose a framework, PhyDSLK, which eases the development process of personalized and engaging Kinect-based exergames for rehabilitation purposes, providing high-level tools that abstract the technical details of using the Kinect sensor and allows developers to focus on the game design and user experience. The system relies on model-driven software engineering technologies and is made of two main components: (i) an authoring environment relying on a domain-specific language to define the exergame model encapsulating the gameplay that the exergame designer has envisioned and (ii) a code generator that transforms the exergame model into executable code. To validate our approach, we performed a preliminary empirical evaluation addressing development effort and usability of the PhyDSLK framework. The results are promising and provide evidence that people with no experience in game development are able to create exergames with different complexity levels in one hour, after a less-than-two-hour training on PhyDSLK. Also, they consider PhyDSLK usable regardless of the exergame complexity. [ABSTRACT FROM AUTHOR]

In recent years, we have been witnessing a rapid increase of research on exergames—i.e., computer games that require users to move during gameplay as a form of physical activity and rehabilitation. Properly balancing the need to develop an effective exercise activity with the requirements for a smooth interaction with the software system and an engaging game experience is a challenge. Model-driven software engineering enables the fast prototyping of multiple system variants, which can be very useful for exergame development. In this paper, we propose a framework, PhyDSLK, which eases the development process of personalized and engaging Kinect-based exergames for rehabilitation purposes, providing high-level tools that abstract the technical details of using the Kinect sensor and allows developers to focus on the game design and user experience. The system relies on model-driven software engineering technologies and is made of two main components: (i) an authoring environment relying on a domain-specific language to define the exergame model encapsulating the gameplay that the exergame designer has envisioned and (ii) a code generator that transforms the exergame model into executable code. To validate our approach, we performed a preliminary empirical evaluation addressing development effort and usability of the PhyDSLK framework. The results are promising and provide evidence that people with no experience in game development are able to create exergames with different complexity levels in one hour, after a less-than-two-hour training on PhyDSLK. Also, they consider PhyDSLK usable regardless of the exergame complexity. [ABSTRACT FROM AUTHOR]

In recent years, the number of smartphone users has increased dramatically. These users download millions of apps and use them for various services. Due to the significant demand for mobile apps, developers often seek faster development methods and more effective tools and techniques to generate these apps. Many of these apps are location-based apps in which users receive services based on their geographical location. In this paper, we propose a model-driven approach for the automatic generation of Android location-based mobile apps. Our framework, called ALBA, consists of a domain-specific modeling language, a modeling tool, and a plugin which includes model to code transformations. The modeling tool enables a novice designer to model a location-based app. The model is validated against the predefined constraints and the editor prevents creating invalid models. The designer uses the plugin to generate the Android code of the app. The evaluation of our work is two fold. First, to evaluate the generalizability of the ALBA framework, we conducted an experiment which includes the generation of four industrial location-based apps. Second, to evaluate the usability and quality of both the framework and the generated apps, we conducted a case study consists of three experiments. The results of the evaluation are promising both in terms of the applicability of the framework and the quality of the generated apps. [ABSTRACT FROM AUTHOR]

Model-Driven Software Engineering (MDSE) is a software development methodology that reduces the cost and production time of the final product by concentratingon a higher level of abstraction. The main focus of MDSE is to generate automated code by applying different types of transformations to high-level models. The effectiveness of MDSE has been proved in different domains for solving various types of problems. This research provides the bibliometric analysis of research in the field of MDSE. The population of the study consists of all MDSE articles indexed in the Web of Science database in ten years from 2010 to 2019. The work aims to identify the volume of scientific production, the most influential countries, universities, authors, and journals, the cooperation network among the countries, universities, and authors, keyword ranking, and Co-word analysis of keywords and titles of the articles. Keyword analysis revealed that Model Transformation and Model Checking are two very important clusters and topics of interest to researchers in this field. The results provide valuable insights that can be used as a guideline by both fresh and experienced researchers for the current state and future trend of MDSE research in different scientific disciplines to establish a baseline beforeinitiating an MDSE research project in the future. [ABSTRACT FROM AUTHOR]

Summary: Software development is a collaborative activity that requires teams of software engineers to cooperate and work in parallel on versions of models. However, model management techniques such as model differencing, merging, and versioning have turned out to be difficult challenges, due to the complexity of operations and graph‐like nature of models. Therefore, a well‐developed support for model merging process, as well as conflict management, is highly desired. This paper presents a novel process for model merging, called the Epsilon‐based Three‐way Merging Process (E3MP) process. Model merging is a significant problem where there are different versions of a system model amongst modeler teams. E3MP includes three components implemented into the Epsilon framework. First, modelers can define domain‐specific rules that customize the merging process. Second, E3MP enables an automated method for syntactic and semantic conflict detection amongst different versions of the system model. Third, E3MP puts forward a pattern‐based approach for conflict resolution. We applied two generic benchmarks to assess conflict detection and resolution capabilities of our approach and carried out an initial scalability evaluation for the model merge with large models and large change sets. The results of our experiments revealed that the proposed process allows generating consistent and semantically correct merged models. [ABSTRACT FROM AUTHOR]

The Class Responsibility Assignment (CRA) problem is one of the most important problems in Object-Oriented Software Engineering. It is a Search-based optimization problem to assign attributes and methods to a set of classes such that the related class diagram has maximum cohesion and minimum coupling. Due to the large and complex search space of the problem, finding an optimal solution is a costly and challenging task. In this regard, the use of optimization approaches can be promising. In this paper, the Particle Swarm Optimization (PSO) and Ant Colony Optimization (ACO) algorithms are implemented using Model-Driven Engineering (MDE) techniques for solving the CRA problem. To evaluate the proposed approach, the effectiveness of provided algorithms is presented using models with different scales. Additionally, the results are compared with existing solutions for the CRA problem in the community. The results indicated that for large-scale models the ACO algorithm could find a much better solution in less time compared to the PSO algorithm. [ABSTRACT FROM AUTHOR]

We report on our success stories in developing and using Model-Driven Engineering (MDE) tools for information systems on real-world projects within different application domains. It is necessary that we ensure the extensibility and adaptability of code generators if we want to reuse them for different domains. Up to now, research on reusing software has been mainly conducted in the software product line community but rarely discussed in the context of code generators. This paper introduces the generation framework MontiGem and shows how it has been used and evolved within five different research and industry projects in the domains of financial management, IoT, energy management, privacy policy, and wind turbine engineering. We have developed the code generator within the first project and further refined it with each of the following projects. This paper describes the projects, shows how MDE helped us in the software engineering process, and discusses the lessons we learned. These examples show how MDE techniques can be successfully applied to the development of information systems in practice, although further requirements have been met over time. [ABSTRACT FROM AUTHOR]

QVT Relations (QVT-R), a standard issued by the Object Management Group, is a language for the declarative specification of model transformations. This paper focuses on a particularly interesting feature of QVT-R: the declarative specification of bidirectional transformations. Rather than writing two unidirectional transformations separately, a transformation developer may provide a single relational specification which may be executed in both directions. This approach saves specification effort and ensures the consistency of forward and backward transformations. This paper explores QVT-R’s support for bidirectional model transformations through a spectrum of transformation cases. The transformation cases vary with respect to several factors such as the size of the transformation definition or the relationships between the metamodels for source and target models. The cases are solved in QVT-R, but may be applied to other bidirectional transformation languages, as well; thus, they may be used as a benchmark for comparing bidirectional transformation languages. In our work, we focus on the following research questions: functionality of bidirectional transformations in terms of relations between source and target models, solvability (which problems may be solved by a single relational specification of a bidirectional transformation), variability (does a bidirectional transformation contain varying elements, i.e., elements being specific to one direction), comprehensibility (referring to the ease of understanding and constructing QVT-R transformations), and the semantic soundness of bidirectional transformations written in QVT-R. [ABSTRACT FROM AUTHOR]

The (re-)development of industrial production systems has to deal with high flexibility due to customers’ demands as well as constraints such as the dimensions of the manufactory. Therefore, Intralogistics systems, which transport goods or products between machine tools in the production system, must also be flexibly assembled to fit into the given space. This presupposes that parts of the Intralogistics system, such as a belt conveyor, may be modified or exchanged by different ones and with less effort. Additionally, due to the different lifespans of mechanical, electrical and software components, often electrical devices need to be replaced by other ones during operation as a result of lacking availability thanks to shorter life cycles. Nowadays in industry, a manual adaptation of the control software is necessary after the exchange of an electrical/mechanical device with a newer one. In order to ease the software adaptation, in this paper an automatic analysis of the differences between incompatible software and an adaptation approach focusing on the functional behavior of the software is introduced. After identifying seven interaction points of the control software that need to be adapted, the approach is evaluated with an industrial case study and feedback from industrial experts to prove industrial scalability. [ABSTRACT FROM AUTHOR]