Search

Chatbots provide a novel form of user interface, and Web API (Application Programming Interface) technology is rapidly expanding to encompass a wide range of applications. The integration of Chatbots with APIs facilitates access to a wide range of data and functionalities; however, existing tools for the development of a conversational Chatbot user interface can be exceedingly complex. This paper presents a semi-automatic system based on the concept of MDE (Model-Driven Engineering) by which to generate a Chatbot user interface for a specific Web API in accordance with the proposed BotSwagger specifications. The devised BO-1-EN system allows developers to integrate APIs with Chatbots seamlessly. It also enables end users to input parameters, access APIs. and obtain comprehensible responses promptly in a conversational wa>·. In experiments, the proposed system proved highly effective in integrating APIs with Chatbots. It makes it possible for users to input required parameters sequentially via an interactive dialogue to use Web APIs. The proposed system simplifies the process of creating Chatbots with API services, while largely eliminating the need for API-specific knowledge. Besides, the proposed LLMbased coordination mechanism (LLM: Large Language Model) also facilitates the creation of large-scale applications comprising multiple Chatbots. [ABSTRACT FROM AUTHOR]

Background and Goal: Health information systems are increasingly sophisticated and developing them is a challenge for software developers. Software engineers usually make use of UML as a standard model language that allows defining health information system entities and their relations. However, working with health system requires learning HL7 standards, that defines and manages standards related to health information systems. HL7 standards are varied, however this work focusses on v2 and v3 since these are the most used one on the area that this work is being conducted. This works aims to allow modeling HL7 standard by using UML.Methods: Several techniques based on the MDE (Model-Driven Engineering) paradigm have been used to cope with it.Results: A useful reference framework, reducing final users learning curve and allowing modeling maintainable and easy-going health information systems.Conclusions: By using this approach, a software engineer without any previous knowledge about HL7 would be able to solve the problem of modeling HL7-based health information systems. Reducing the learning curve when working in projects that need HL7 standards. [ABSTRACT FROM AUTHOR]

Software models describe structures, relationships and features of the software. Modern software development methodologies such as MDE (Model Driven Engineering) use models as core elements. In MDE, the code is automatically generated from the model and model errors can implicitly shift into the code, which are difficult to find and fix. Model verification is a promising solution to this problem. However, coverage of all facets of model verification is a painful job and existing formal/semi-formal verification methods are greatly inspired by mathematics and difficult to understand by the software practitioners. This work considers particularly UML Class/OCL (Unified Modeling Language Class/Object Constraint Language) model and presents an ontology-based verification method. In the proposed method, a class diagram is transformed into ontology specified in OWL (Web Ontology Language) and constraints into SPARQL NAF (Negation as Failure) queries. This work tries to demonstrate that the proposed approach can efficiently cover all aspects of UML Class/OCL model verification. [ABSTRACT FROM AUTHOR]

This systematic literature review examines the effectiveness of automated test case generation, optimization, and prioritization methods based on Unified Modeling Language (UML) diagrams. The review summarizes the methods, main contributions, and limitations, and suggests areas for future research. This paper examines various optimization algorithms, model-based testing methods, and UML diagram validation methods to determine how well they perform. The review highlights some issues with the current situation, such as the fact that it only examines a few types of UML diagrams and does not go into great detail about how they work or compare to other diagrams. However, it also suggests ways in which these issues could be addressed in future research. Some of the suggested directions include researching different modeling languages and devising solutions to handle the complexity of system models. Model-based testing should also be combined with optimization and prioritization methods to increase the flexibility and usefulness of research in this field. This article makes no direct comparisons to UML diagrams, but it does provide a thorough discussion of the current state of the art and a list of strategic priorities to advance the field of automated test case generation, optimization, and prioritization. These reviews are useful for both researchers and practitioners because they demonstrate how things are currently done and how they should be done in the future. [ABSTRACT FROM AUTHOR]

Purpose: This paper introduces the problematic of the SBP modeling. Our objective is to provide a conceptual analysis related to the concept of SBP. This facilitates, on the one hand, easier understanding by business analysts and end-users, and one the other hand, the integration of the new specific concepts relating to the SBP/BPM-KM domains into the BPMN meta-model (OMG, 2013). Design/methodology/approach: We propose a rigorous characterization of SBP (Sensitive Business Processes) (which distinguishes it from classic, structured and conventional BPs). Secondly, we propose a multidimensional classification of SBP modeling aspects and requirements to develop expressive, comprehensive and rigorous models. Besides, we present an in-depth study of the different modeling approaches and languages, in order to analyze their expressiveness and their abil-ity to perfectly and explicitly represent the new specific requirements of SBP modeling. In this study, we choose the better one positioned nowadays, BPMN 2.0, as the best suited standard for SBP representation. Finally, we propose a semantically rich conceptualization of a SBP organized in core ontology. Findings: We defined a rigorous conceptual specification for this type of BP, organized in a multi-perspective formal ontology, the Core Ontology of Sensitive Business Processes (COSBP). This reference ontology will be used to define a generic BP meta-model (BPM4KI) further specifying SBPs. The objective is to obtain an enriched consensus modeling covering all generic concepts, semantic relationships and properties needed for the exploitation of SBPs, known as core modeling. Originality/value: This paper introduces the problem of conceptual analysis of SBPs for (crucial) knowledge identification and management. These processes are highly complex and knowledge-intensive. The originality of this contribution lies in the multi-dimensional approach we have adopted for SBP modeling as well as the definition of a Core Ontology of Sensitive Business Processes (COSBP) which is very useful to extend the BPMN notation for knowledge management. [ABSTRACT FROM AUTHOR]

MDE (Model Driven Engineering) is an emerging software engineering paradigm that relies on models as primary artifacts to build complex software and hardware systems. It basically aims at overcoming the inability of third-generation languages to alleviate the complexity of platforms and express domain concepts effectively. One particular vision of MDE was proposed by OMG (Object Management Group) under the name of MDA (Model Driven Architecture). MDA consists of a set of standardized rules and practices to promote good modeling and fully exploit the models in order to gain in sustainability, consideration of execution platforms and productivity. To achieve these objectives, the models to be used within an MDA approach should be consistent (i.e., complete, free of ambiguities, free of contradictions and anomalies, etc.). In this paper, we identify and describe possible inconsistencies that can be encountered in UML models while applying MDA, propose a new taxonomy for such inconsistencies and precise those supported by the most known verification approaches found in literature. Simple examples are used throughout the paper to illustrate our contribution. [ABSTRACT FROM AUTHOR]

The main concern of this research work is to analyse and model supply chains (SCs) in the particular context of small and medium enterprises (SMEs) in the field of mechatronic. The study is based on the analysis of the organisational features, the actors' behaviour, and performance considerations. The development of the model relies on an iterative framework that progressively integrates different aspects into the model. This framework is the ArchMDE process, which is based on MDE (Model Driven Engineering). A major feature of this work lies in its contribution to two different areas of research. The first contribution of the work is to propose a generic metamodel for SCs. Based on a literature review, an incremental framework is proposed for the modelling of SCs in terms of concepts, structure and relationships. The application of the framework to the studied context is described and its result is a domain-metamodel for SCs. The second contribution of this work lies in the formalisation of the dynamic behaviour of the concepts in the metamodel. This formalisation is based on the multi-agent approach. An agentification of the metamodel is thus drawn, thanks to the natural links between multiagent theory and SC reality. This step leads to an agentified-domain-metamodel which also includes the monitoring of the SC and synchronisation protocols. By adding relationships and dynamic behavior aspects, we obtain a metamodel of the domain that can be implemented, with its static and dynamic aspects. To validate this model, an industrial case study is detailed and has been instantiated and encoded in JAVA. [ABSTRACT FROM AUTHOR]

Since several years, the Object Constraint Language (OCL) is a central component in modeling and transformation languages like the Unified Modeling Language, the Meta Object Facility, and Query View Transformation. Consequently, approaches MDE (Model-Driven Engineering) depend on this language. OCL is present not only in areas influenced by the OMG but also in the Eclipse Modeling Framework (EMF). Thus the quality of OCL and its realization in tools seems to be crucial for the success of model-driven development. Surprisingly, up to now a benchmark for OCL to measure quality properties has not been proposed. This paper puts forward in the first part the concepts of a comprehensive OCL benchmark. Our benchmark covers (1) OCL engine accuracy (e.g., for the handling of the undefined value, the use of variables and the implementation of OCL standard operations), (2) OCL engine determinateness properties (e.g., for the collection operations 'any' and 'flatten'), and (3) OCL engine efficiency (for data type and user-defined operations). In the second part, this paper empirically evaluates the proposed benchmark concepts by examining several OCL tools. The paper clarifies a number of differences in handling particular language features and under specifications in the OCL standard. [ABSTRACT FROM AUTHOR]

Resumen: Hoy en día, los robots manipuladores están presentes en todas las instalaciones de producción moderna industriales. Por ello, a la robótica manipuladora se la considera una disciplina decisiva en el sector industrial. Además, en un futuro no muy lejano los robots manipuladores pasarán a ser también esenciales en la vida cotidiana de la sociedad. Así, existe una demanda creciente de aplicaciones con robots manipuladores con requisitos software como son la reutilización, flexibilidad y adaptabilidad. Lamentablemente, en la actualidad hay una falta de estandarización de plataformas hardware y software, por lo que es extremadamente complicado satisfacer estos requisitos. Así, se contempla, por lo tanto, una necesidad de definir una metodología que proporcione unas pautas y guíe en el diseño, implementación y en la ejecución de sistemas software para este tipo de aplicaciones. Este trabajo explora las ventajas proporcionadas por la Ingeniería Dirigida por Modelos (MDE- Model Driven Engineering) en el diseño y desarrollo de tareas realizadas por robots manipuladores. En concreto se propone una aproximación basada en un sub-conjunto de diagramas UML (diagrama de componentes y diagrama de despliegue) para el diseño de este tipo de aplicaciones. Además, se identifican y definen los pasos a realizar para la generación automática de código que se ejecutará sobre los middlewares (MW) de comunicación más utilizados en esta disciplina. Para ello, se hará uso de las técnicas Model-To-Model y Model-To-Text nuevamente de MDE. Este trabajo, detalla la generación del código para OROCOS (el MW basado en componentes más extendido) y ROS. Finalmente, se presentan dos casos de estudio, el primero de ellos consiste en una aplicación industrial para el ensamblado de faro de vehículos que se ejecuta sobre OROCOS. El segundo caso de estudio es una aplicación de robótica de servicios en la que un robot manipulador antropomórfico realiza la tarea de seguimiento de un objeto en movimiento. Este segundo caso de estudio se ejecuta sobre ROS. Abstract: Today, robotics manipulator is a crucial discipline in modern production industrial facilities and in a near future; it will also be decisive in the human quotidian society. Consequently, currently there is a growing demand of applications with arm-based robots with requirements such as: reutilization, flexibility and adaptability. Unfortunately, there is a lack of standardization of hardware and software platforms, so the satisfaction of these requirements is too difficult. In this sense, there is a necessity of a methodology that guides along application design, implementation as well as the execution of the software systems. This work, explores the advantages of Model Driven Engineering (MDE) for the design and development of applications performed by manipulator robots. In fact, an UML based approach is proposed that supports the design of robotic tasks and an automatic code generation for the most spread robotic communication Middlewares has been also developed. More specifically, the target code generation for OROCOS and ROS communication Middlewares has been detailed. Finally, two case studies have been presented one for industrial field and the other for service sector. The former runs on OROCOS and the latter on ROS. Palabras clave: Robots manipuladores, UML, MDE-Model Driven Engineering, ROS-Robotic Operating System-, OROCOS â Open Robot Control Software-, Keywords: Manipulator robots, UML-Unified Modeling Language, MDE-Model Driven Engineering, ROS-Robotic Operating System, OROCOS- Open Robot Control Software

Simulation facilitates the understanding and improvement of complex systems. Conceptual modelling is a key step in simulation studies. It has gained recognition because it may both increase engagement with stakeholders and decrease the time to implement a simulation. This scoping review's objective is to highlight approaches and platforms for electronically representing models from 1999 to 2020. The motivation is that electronic representations facilitate the sharing of conceptual models. The contribution from the review to the research of conceptual modelling and simulation is to show that conceptual models are electronically represented by broadly speaking either General-Purpose or Domain-Specific Modelling Languages. There is a slight trend towards the latter in order to better deal with application specificities and improve unambiguity in model representations, though. Thus, we identify modelling approaches, platforms, and features for electronically representing conceptual models with the potential to fill the gap between conceptual models and their corresponding simulation implementations. [ABSTRACT FROM AUTHOR]

Model‐Driven Development (MDD) is one of the important approaches to develop complex software systems. This approach tries to model a system in high‐abstraction level. Then through applying multiple transformations step by step, the model abstraction level is reduced and finally yields to executable code. As a result, Model transformation (MT) plays a pivotal role on the realization of MDD goals. Due to the increasing complexity of software systems, MTs naturally become more complex. Hence, qualitative technical issues may be overlooked or forgotten in these model transformations. To alleviate these issues in terms of technical debts/code smells in MTs, we can apply MT patterns. A main drawback on applying patterns is that most of them are cataloged in informal language. Additionally, construction of a conceptual framework to help MT designers through applying patterns requires a precise specification of the underlying MT patterns. With a formal basis, this paper is trying to realize the proposed framework. Hence, some of the existing well‐known MT patterns are formalized. Then based on the identified common technical debts/code smells in MTs, a designer can be directed to apply the appropriate patterns and resolve the detected problems iteratively. For the applicability and functionality of the proposed framework, several examples of problematic model transformations in terms of quality flaws were considered and resolved using the appropriate patterns. We consider the Epsilon Transformation Language (ETL) cases of model transformations in this paper, and other similar MT languages could be treated using the same measures and patterns as well. [ABSTRACT FROM AUTHOR]

Cyber-Physical Systems (CPS) are physical systems whose operations are coordinated, monitored, and controlled by computing and communication functions. These systems are typically heterogeneous, including Internet of Things and information technology subsystems, and can present a myriad of implementation details, making them very complex systems. An important type of CPS is a maritime container terminal (cargo port), which is a facility where cargo containers are transported between ships and land vehicles for onward transportation and vice versa. A cargo port performs four basic functions: receiving, storing, staging, and loading for both import and export containers. We present here process patterns that describe the functional aspects of cargo ports and a pattern that describes their structural properties (patterns are encapsulated solutions to recurrent problems). These patterns describe semantic aspects found in any cargo port and can be adapted to describe other CPSs. We decompose these process patterns into use cases that describe their interactions with the system. We then integrate the process patterns with structural patterns to assemble a partial reference architecture (RA) that shows the interactions of all the patterns while also indicating the typical stakeholders found in all ports. We validate the proposed reference architecture, highlighting its theoretical and practical value. Software and system designers of cargo ports need to start from a conceptual and abstract view that is subsequently refined to add more details. The use of reference architectures and patterns is an effective way to organize and describe the functional and non-functional aspects of a system, as well as to unify the design of all its aspects. This is, until now, the only published RA for cargo ports, and it can be a useful guideline for the designers of any type of cargo port. [ABSTRACT FROM AUTHOR]

The increasing essential complexity of software systems makes current software engineering methods and practices fall short in many occasions. Software assistants have the ability to help humans achieve a variety of tasks, including the development of software. Such assistants, which show human‐like competences such as autonomy and intelligence, help software engineers do their job by empowering them with new knowledge. This article investigates the research efforts that have been conducted on the creation of assistants for software design, construction and maintenance paying special attention to the user‐assistant interactions. To this end, we followed the standard systematic mapping study method to identify and classify relevant works in the state of the art. Out of the 7580 articles resulting from the automatic search, we identified 112 primary studies that present works which qualify as software assistants. We provide all the resources needed to reproduce our study. We report on the trends and goals of the assistants, the tasks they perform, how they interact with users, the technologies and mechanisms they exploit to embed intelligence and provide knowledge, and their level of automation. We propose a classification of software assistants based on interactions and present an analysis of the different automation patterns. As outcomes of our study, we provide a classification of software assistants dealing with the design, construction and maintenance phases of software development, we discuss the results, identify open lines of work and challenges and call for new innovative and rigorous research efforts in this field. [ABSTRACT FROM AUTHOR]

Employing Modeling and Simulation (M&S) extensively to analyze and develop complex systems is the norm today. The use of robust M&S formalisms and rigorous methodologies is essential to deal with complexity. Among them, the Discrete Event System Specification (DEVS) provides a solid framework for modeling structural, behavior and information aspects of any complex system. This gives several advantages to analyze and design complex systems: completeness, verifiability, extensibility, and maintainability. DEVS formalism has been implemented in many programming languages and executable on multiple platforms. In this paper, we describe the features of an M&S framework called xDEVS that builds upon the prevalent DEVS Application Programming Interface (API) for both modeling and simulation layers, promoting interoperability between the existing platform‐specific (C++, Java, Python) DEVS implementations. Additionally, the framework can simulate the same model using sequential, parallel, or distributed architectures. The M&S engine has been reinforced with several strategies to improve performance, as well as tools to perform model analysis and verification. Finally, xDEVS also facilitates systems engineers to apply the vision of model‐based systems engineering (MBSE), model‐driven engineering (MDE), and model‐driven systems engineering (MDSE) paradigms. We highlight the features of the proposed xDEVS framework with multiple examples and case studies illustrating the rigor and diversity of application domains it can support. [ABSTRACT FROM AUTHOR]

Incremental model transformation (IMT) tools have been proposed to improve performances of model transformations by updating only the parts of a model that need to be changed when another model on which it depends has been changed. Yet, the question is how these tools are suitable for modeling large and complex systems with rich modeling languages as used in industry. In this paper, we report the results of a benchmark of the most mature IMT tools. Particularly, we benchmark MoTE, eMoflon, VIATRA and YAMTL to evaluate their usability, maintainability and runtime performances. Our benchmark is based on a model transformation of an industrial case study using the standard architecture description language AADL. We propose a reusable evaluation framework, available for tool developers and users. Besides the capability to process large models, our benchmark also assesses IMT tool performances according to the different kinds of complex structures that typically exist in models of rich languages, as well as the complexity of the transformation specifications. Our results show the promising potential of some tools to specify sophisticated specifications and transform large models with good performance, but their use still requires the help of their developers, especially to solve serious problems with their runtime performance. [ABSTRACT FROM AUTHOR]

The evolution of Cloud Computing into a service utility, along with the pervasive adoption of the IoT paradigm, has promoted a significant growth in the need of computational and storage services. The traditional use of cloud services, focused on the consumption of one provider, is not valid anymore due to different shortcomings being the risk of vendor lock-in a critical. We are assisting to a change of paradigm, from the usage of a single cloud provider to the combination of multiple cloud service types, affecting the way in which applications are designed, developed, deployed and operated over such heterogeneous ecosystems. The result is an effective heterogeneity of architectures, methods, tools, and frameworks, copying with the multi-cloud application concept. The goal of this study is manifold. Firstly, it aims to characterize the multi-cloud concept from the application development perspective by reviewing existing definitions of multi-cloud native applications in the literature. Secondly, we set up the basis for the architectural characterization of these kind of applications. Finally, we highlight several open research issues drawn up from the analysis carried out. To achieve that, we have conducted a systematic literature review (SLR), where, a large set of primary studies published between 2011 and 2021 have been studied and classified. The in-depth analysis has revealed five main research trends for the improvement of the development and operation DevOps lifecycle of "multi-cloud native applications". The paper finishes with directions for future work and research challenges to be addressed by the software community. [ABSTRACT FROM AUTHOR]

HL7 (Health Level 7) International is an organization that defines health information standards. Most HL7 domain information models have been designed according to a proprietary graphic language whose domain models are based on the HL7 metamodel. Many researchers have considered using HL7 in the MDE (Model-Driven Engineering) context. A limitation has been identified: all MDE tools support UML (Unified Modeling Language), which is a standard model language, but most do not support the HL7 proprietary model language. We want to support software engineers without HL7 experience, thus real-world problems would be modeled by them by defining system requirements in UML that are compliant with HL7 domain models transparently. The objective of the present research is to connect HL7 with software analysis using a generic model-based approach. This paper introduces a first approach to an HL7 MDE solution that considers the MIF (Model Interchange Format) metamodel proposed by HL7 by making use of a plug-in developed in the EA (Enterprise Architect) tool. [ABSTRACT FROM AUTHOR]

Increasingly, the model driven engineering (MDE) community is paying more attention to the techniques offered by the machine learning (ML) community. This has led to the application of ML techniques to MDE related tasks in hope of increasing the current benefits of MDE. Nevertheless, there is a lack of empirical experiments that evaluate the benefits that ML brings to MDE. In this work, we evaluate the benefits of empowering model engineers of model‐driven development (MDD) with an ML classifier. To do this, we tackled how to embed the ML classifier as part of the MDD. Then, this was evaluated using two different real industrial cases. Our results show that despite the ML part takes an extra effort, the use of the ML classifier pays off in terms of the quality results, the perceived usefulness, and intention to use. [ABSTRACT FROM AUTHOR]

The variety feature of Big Data, represented by multi-model data, has brought a new dimension of complexity to all aspects of data management. The need to process a set of distinct but interlinked data models is a challenging task. In this paper, we focus on the problem of inference of a schema, i.e., the description of the structure of data. While several verified approaches exist in the single-model world, their application for multi-model data is not straightforward. We introduce an approach that ensures inference of a common schema of multi-model data capturing their specifics. It can infer local integrity constraints as well as intra- and inter-model references. Following the standard features of Big Data, it can cope with overlapping models, i.e., data redundancy, and it is designed to process efficiently significant amounts of data.To the best of our knowledge, ours is the first approach addressing schema inference in the world of multi-model databases. [ABSTRACT FROM AUTHOR]

For model-driven engineering (MDE) to become more Agile, the community needs to embrace development and operations (DevOps) practices. One of the core practices of DevOps is the use of pipelines to enable CI/CD to make teams more Agile and break down the barriers between development and operations with faster deployments. Current MDE tooling is not designed at its core to participate in DevOps pipelines. Consequently this makes the adoption of MDE in industry more difficult. In this article, we cover an industrial experience report describing how we enabled our pipelines using DevOps and MDE. [ABSTRACT FROM AUTHOR]

Microservice architecture (MSA) is a paradigm to design and develop scalable distributed applications using loosely coupled, highly cohesive components that can be deployed independently. The applications that realize the MSA may contain thousands of services that together form the overall system. Microservices interact with each other by producing and consuming data. Deploying frequently communicating services to the same physical resource would reduce network utilization, which is vital for reducing costs and improving scalability. Since the physical resources have limited capacity, it is not always possible to deploy communicating services to the same resource. Therefore, automated efficient deployment alternatives need to be generated for MSA in the design phase. To address this problem, we proposed an algorithmic approach to generate efficient microservice deployment configurations to available cloud resources in our previous study. In this study, a tool (Micro‐IDE) has been proposed to realize and evaluate this approach. The Micro‐IDE tool has been validated using a case study inspired by the Spotify application. [ABSTRACT FROM AUTHOR]

Abstract: The progress in FPGA technology has enabled FPGA-based reconfigurable systems to target increasingly sophisticated applications, which has led to a high control design complexity, resulting in longer design cycles. In this paper, we propose a control design approach for FPGA-based reconfigurable systems aiming at increasing design productivity. This approach is based on a semi-distributed control model that splits different control concerns (monitoring, decision-making and reconfiguration) between autonomous modular controllers and makes use of formalism-oriented design, to decrease the control design complexity and facilitate design verification, reuse and scalability. This model is composed of distributed controllers handling the self-adaptivity of the system reconfigurable regions and a coordinator to respect the system global constraints. To enhance design productivity, the proposed control model is generated automatically using a high-level modeling approach. This approach is based on MDE (Model-Driven Engineering) and the MARTE (Modeling and Analysis of Real-Time and Embedded Systems) standard, allowing to make low-level technical details transparent to designers and to automate code generation from high-level models. Experiments on the generated control systems showed that the proposed semi-distributed control model is more flexible, reusable and scalable than the centralized one, at the cost of a slight increase in required hardware resources. [Copyright &y& Elsevier]

In November 2000, the OMG made public the MDA™initiative, a particular variant of a new global trend called MDE (Model Driven Engineering). The basic ideas of MDA are germane to many other approaches such as generative programming, domain specific languages, model-integrated computing, generic model management, software factories, etc. MDA may be defined as the realization of MDE principles around a set of OMG standards like MOF, XMI, OCL, UML, CWM, SPEM, etc. MDE is presently making several promises about the potential benefits that could be reaped from a move from code-centric to model-based practices. When we observe these claims, we may wonder when they may be satisfied: on the short, medium or long term or even never perhaps for some of them. This paper tries to propose a vision of the development of MDE based on some lessons learnt in the past 30 years in the development of object technology. The main message is that a basic principle (“ Everything is an object”) was most helpful in driving the technology in the direction of simplicity, generality and power of integration. Similarly in MDE, the basic principle that “ Everything is a model” has many interesting properties, among others the capacity to generate a realistic research agenda. We postulate here that two core relations ( representation and conformance) are associated to this principle, as inheritance and instantiation were associated to the object unification principle in the class-based languages of the 80’s. We suggest that this may be most useful in understanding many questions about MDE in general and the MDA approach in particular. We provide some illustrative examples. The personal position taken in this paper would be useful if it could generate a critical debate on the research directions in MDE. [ABSTRACT FROM AUTHOR]

Unlike conventional software, robotic software suffers from a lack of methods and processes that could systematize and facilitate development. Thus, the application of software engineering techniques is at the heart of current issues in robotics. The work presented in this paper aims to facilitate the development of robotic software and to facilitate communication between experts in the field through the use of software engineering techniques and methods. It proposes RsaML (Robotic Software Architecture Modeling Language), a Domain Specific Modeling Language (DSML) dedicated to robotics, which takes into account the different categories of robotic software architectures and makes it possible to describe the latter independently from the implementation platform. The conceptual model defining the terminology and the hierarchy of concepts used for the description and representation of robotic software architectures in RsaML are presented in this article. RsaML is defined through a meta-model which represents the abstract syntax of the language. The real-time properties of robotic software architectures are identified and included in the meta-model. The use of RsaML is illustrated through several experimental scenarios of the language: the definition of a robotic system and the description of its software architecture, the verification of the semantics of a robotic software architecture, and the modeling of a robotic system whose software architecture does not belong to the usual categories. The support tool used for implementations and experimentation is Eclipse Modeling Framework (EMF). The results of experimentation showed good working of the proposed solution and made it possible to validate the main concepts of the RsaML language. [ABSTRACT FROM AUTHOR]

Summary: Feature location (FL) is performed to find the relationships between domain concepts and other software artifacts. One major problem in maintaining a software system is to understand how many functional features exist in a system and how these features are implemented. Also, poor security is the prime problem in the FL system. However, the existing recent FL techniques use a textual and dynamic approach, which is not found to be secure, keeping in view the changes in the description of security attacks. To overcome this drawback, this work proposed a novel secure approach for FL utilizing data fusion as well as data mining for the internet of things environment. Firstly, the repeated test cases (TC) are eradicated as of the labeled TC. Next, important attributes are selected using the artificial flora optimization algorithm from the removed labeled TC. Then, association rule mining is performed to ascertain closed attributes. Subsequently, encrypt the closed attributes utilizing Caesar Cipher‐Rivest, Shamirs, as well as Adelman algorithm. After that, the score value of the closed attributes counts was found utilizing entropy calculation. Finally, the score value is given as input to the normalized‐K‐Means (N‐[K‐Means]) algorithm, where the score value is normalized utilizing min‐max normalization and then grouped utilizing K‐Means algorithm (KMA). It proffers better results for FL in the source code. The proposed N‐(K‐Means) performance is found better in comparison to the KMA and latent semantic indexing methods. The proposed system proffered better FL results in comparison to the other prevailing methods. [ABSTRACT FROM AUTHOR]

Security policies constrain the behavior of all users of an information system. In any non-trivial system, these security policies go beyond simple access control rules and must cover more complex and dynamic scenarios while providing, at the same time, a fine-grained level decision-making ability. The Usage Control model (UCON) was created for this purpose but so far integration of UCON in mainstream software engineering processes has been very limited, hampering its usefulness and popularity among the software and information systems communities. In this sense, this paper proposes a Domain-Specific Language to facilitate the modeling of UCON policies and their integration in (model-based) development processes. Together with the language, an exploratory approach for policy evaluation and enforcement of the modeled policies via model transformations has been introduced. These contributions have been defined on top of the Eclipse Modeling Framework, the de-facto standard MDE (Model-Driven Engineering) framework making them freely available and ready-to-use for any software designer interested in using UCON for the definition of security policies in their new development projects. • A domain-specific language for UCON policies is defined. • The domain-specific language is validated with a complex, running example. • Policy evaluation and enforcement are introduced by means of a model transformation framework. [ABSTRACT FROM AUTHOR]

Contemporary complex systems often exhibit dynamic structures and behaviors, several components/systems involved, and multiple interoperability links. Those systems have been exposed to fragilities of traditional software specification languages (e.g. UML and SySML), since such languages were designed to document single (not multiple interoperating) systems. Those limitations can potentially further compromise the quality of the final software product. In this context, Executable Models (ExM) technology, such as simulation models, models@runtime and executable UML, satisfy the aforementioned requirements by supporting engineers with visualization of the system structures (still at design-time) and the ability to exercise their behaviors and interactions. In our prior study, we presented the results of an exploratory study on the perceptions of those professionals (from both industry and academia) regarding the use of ExM to solve problems in their current practice. We exposed 58 professionals (researchers and practitioners) to situations to solve problems using a specific type of ExM (DEVS simulation models), based on survey research. Responses were quantitatively and qualitatively analyzed. In this article, we extended the obtained results by analyzing and compiling a list of strategies to improve ExM notations to better address the needs of software engineering professionals. Later, we assessed those strategies with software engineering researchers to confirm the importance of the proposed strategies. Results revealed that executable languages still require advances to bring them even closer to the current software engineering practice and towards a more significant adoption in the future. The proposed strategies focus on improvements on the robustness of the ExM notations, visual representation of the models, the usability of the models, and user support. [ABSTRACT FROM AUTHOR]

The final objective of smart cities is to optimize services and improve the quality of life of their citizens, who can play important roles due to the information they can provide. This information can be used in order to enhance many sectors involved in city activity such as transport, energy or health. Crowd-sourcing initiatives focus their efforts on making cities safer places that are adapted to the population size they host. In this way, citizens are able to report the issues they identify to the relevant body so that they can be fixed and, at the same time, they can provide useful information to other citizens. There are several projects aimed at reporting incidents in a smart city context. In this paper, we propose the use of model-driven engineering by designing a graphical domain-specific language to abstract and improve the incident-reporting process. With the use of a domain-specific language, we can obtain several benefits in our research for users and cities. For instance, we can shorten the time for reporting the events by users and, at the same time, we gain an expressive power compared to other methodologies for incident reporting. In addition, it can be reused and is centered in this specific domain after being studied. Furthermore, we have evaluated the DSL with different users, obtaining a high satisfaction percentage. [ABSTRACT FROM AUTHOR]

The modern world greatly depends on information systems and the software that governs them. The software architecture defines and designs the holistic structure that the software will have, its components, the interaction between them and all the development is done around it. The purpose of this systematic literature review (SLR) is to analyse the software architectures used in educational websites, methodologies, technological components and empirical results. The search of the SLR yielded 23 studies from the most significant academic sources in education and software engineering. The results of the SLR show that the analysed educational websites were proposing a software architecture, developing a system, proposing a model, assessing of a platform, proposing a Folksonomy‐Based Ontology Maintenance, reviewing smart home design, and proposing a Web‐based platform to aid parallel, distributed and high‐performance computing education. Of the 23 selected studies, 13 carried out an evaluation of their research with either students, teachers, professionals or a combination of these. In conclusion, the selected studies present narrated experiments of projects or individuals that seek to improve collaborative learning in the educational area. Finally, an important finding is that the proposed software architectures do not contemplate laws or quality standards for universal access. [ABSTRACT FROM AUTHOR]

Model Driven Engineering (MDE) plays a very important role in improving the development of complex systems. It focuses more on modeling than on classical programming. In this sense, model transformation is at the heart of the Model Driven Architecture (MDA) approach which advocates the use of models throughout the software development cycle on two levels. The first being the transformation of Computing Independent Model (CIM) into Platform Independent Model (PIM) and the second concerning the transformation of PIM into Platform Specific Model (PSM). The latter has been dealt with in the majority of research works while the transformation from CIM to PIM which represents the highest level is rarely discussed in research topics. It is for this reason and in the spirit of improving the process of transforming the CIM model into PIM according to the MDA approach, that we have developed this research work in order to propose a new method and new transformation rules for optimization of the business process "COVID-19 patient management". Our contribution consists of the semi-automatic transformation of the CIM model presented by the BPMN (Business Process Model and Notation) source model into a PIM target model presented by a class diagram by using a set of transformation and correspondence rules that we performed manually using the language ATL (Atlas Transformation Language). This automatic transformation of the two source and target models is provided by the Eclipse Modeling Framework (EMF) which executes the transformation rules described manually in ATL and generates the PIM target model as an XMI (XML Metadata Interchange) file representing the target class diagram. [ABSTRACT FROM AUTHOR]

Software models describe structures, relationships and features of the software. Modern software development methodologies such as MDE (Model Driven Engineering) use models as core elements. In MDE, the code is automatically generated from the model and model errors can implicitly shift into the code, which are difficult to find and fix. Model verification is a promising solution to this problem. However, coverage of all facets of model verification is a painful job and existing formal/semi-formal verification methods are greatly inspired by mathematics and difficult to understand by the software practitioners. This work considers particularly UML Class/OCL (Unified Modeling Language Class/Object Constraint Language) model and presents an ontology-based verification method. In the proposed method, a class diagram is transformed into ontology specified in OWL (Web Ontology Language) and constraints into SPARQL NAF (Negation as Failure) queries. This work tries to demonstrate that the proposed approach can efficiently cover all aspects of UML Class/OCL model verification.

The use of distribution middleware facilitates the programming of heterogeneous real-time distributed systems, and it can also facilitate the automatic generation of source code when integrated as a part of a general MDE (Model-Driven Engineering) strategy. However, the complexity usually associated with distribution middleware puts a burden on the development of applications with hard real-time requirements or high levels of criticality. This paper gathers a set of previous works to present an overview on how a data-centric distribution middleware (DDS, Data Distribution Service) could be used in distributed applications with mixed criticality and real-time requirements.

The development and maintenance of complex software systems, with ever-changing requirements has benefited from the implementation of design patterns, which ensure a higher degree of maintainability. The present article illustrates the essential role of design patterns in sketching the software architecture for an electric vehicle charging management platform. We have integrated a series of design patterns to create a solid base structure for the API (Application Programming Interface). Furthermore, we have explored cloud design patterns in the deployment process to ensure a proper multi-tenant cloud application with the best possible tenant isolation for the cost. The aim of this paper is to offer readers an introduction in the case study theme, to describe a complex platform development through design patterns. With proper examples from real projects debated in the industry. The paper demonstrates the design patterns applicability from software level to cloud resources plan and advocates for a high-quality solution in every segment of project development. In conclusion, the results are promising, and the functionality of the established methods on this type of platforms will be evaluated during the implementation period. Overall, design patterns have proven to be essential in the development process, ensuring effective team communication and the delivery of qualitative software solutions. [ABSTRACT FROM AUTHOR]

This manuscript focuses on issues related to the implementation of the Future Multiband Multiwaveform Modular Tactical Radio (FM3TR) waveform on two different SCA platforms with similar hardware but different SCA development and deployment environments. Our experimental results showed that a SCA standardization based on technologies such as CORBA, XML, IDL, is not enough to ensure the portability of the waveform. Indeed, the files generated by SCA 2.2.2 environments (ZCE, SCA Architect, http://nordiasoft.com/products/scari-software-suite/sca-architect/) may often use a specific non-standard IDL interface to generate software components. To corroborate our statement, specific examples of SCA components are considered. The portability of the waveform depends on the waveform software used by the porting team. Three classic cases can be observed during the development of a waveform according to a standard specification: The first case is related to waveform development from scratch, the second case is observed when a static library is used to carry the golden code of the waveform and the third one occurs when only platform specific codes are available to the porting process. Finally, a general discussion about portability is provided. [ABSTRACT FROM AUTHOR]

Formal methods have provided approaches for investigating software engineering fundamentals and also have high potential to improve current practices in dependability assurance. In this article, we summarise known strengths and weaknesses of formal methods. From the perspective of the assurance of robots and autonomous systems (RAS), we highlight new opportunities for integrated formal methods and identify threats to the adoption of such methods. Based on these opportunities and threats, we develop an agenda for fundamental and empirical research on integrated formal methods and for successful transfer of validated research to RAS assurance. Furthermore, we outline our expectations on useful outcomes of such an agenda. [ABSTRACT FROM AUTHOR]

Scalability in modeling has many facets, including the ability to build larger models and domain-specific languages (DSLs) efficiently. With the aim of tackling some of the most prominent scalability challenges in model-based engineering (MBE), the MONDO EU project developed the theoretical foundations and open-source implementation of a platform for scalable modeling and model management. The platform includes facilities for building large graphical DSLs, for splitting large models into sets of smaller interrelated fragments, to index large collections of models to speed-up their querying, and to enable the collaborative construction and refinement of complex models, among other features. This paper reports on the tools provided by MONDO that Ikerlan, a medium-sized technology center which in the last decade has embraced the MBE paradigm, adopted in order to improve their processes. This experience produced as a result a set of model editors and related technologies that fostered collaboration and scalability in the development of wind turbine control applications. In order to evaluate the benefits obtained, an on-site evaluation of the tools was performed. This evaluation shows that scalable MBE technologies give new growth opportunities to small- and medium-sized organizations. [ABSTRACT FROM AUTHOR]

Domain-specific languages (DSL) are programming or modeling languages devoted to a given application domain. There are many tools used to support the implementation of a DSL, making hard the decision-making process for one or another. In this sense, identifying and mapping their features is relevant for decision-making by academic and industrial initiative on DSL development. Objective: The goal of this work is to identify and map the tools, Language Workbenches (LW), or frameworks that were proposed to develop DSLs discussed and referenced in publications between 2012 and 2019. Method: A Systematic Mapping Study (SMS) of the literature scoping tools for DSL development. Results: We identified 59 tools, including 9 under a commercial license and 41 with non-commercial licenses, and analyzed their features from 230 papers. Conclusion: There is a substantial amount of tools that cover a large number of features. Furthermore, we observed that usually, the developer adopts one type of notation to implement the DSL: textual or graphical. We also discuss research gaps, such as a lack of tools that allow meta-meta model transformations and that support modeling tools interoperability. [ABSTRACT FROM AUTHOR]

The aerospace industry needs to be provided with system solutions to technologically challenging and mission-critical problems. Based on the industrial control point of view, development engineers must take costs and existing standards into account in order to effectively design, implement, and deploy control systems with reasonable costs. The customization and reusability are important factors associated with the production of new applications in order to reduce their costs, resources, and development time. In this work, the Model-Driven Architecture (MDA)/Model-Based Systems Engineering (MBSE) approach combined with the real-time Unified Modeling Language (UML)/Systems Modeling Language (SysML), Unscented Kalman Filter (UKF) algorithm, and hybrid automata is specialized to obtain a hybrid control model in order to conveniently deploy controllers of Quadrotor Unmanned Aerial Vehicles (Q-UAVs). This hybrid control model also provides a real-time capsule pattern, which allows the designed elements to be customizable and reusable in new applications of various multirotor UAVs of the Vertical Take-Off and Landing (VTOL) type. The Q-UAV dynamics and control architecture are combined with the MDA/MBSE specialization as follows: the Computation Independent Model (CIM) is defined by specifying the use-case model together with the UKF algorithm and hybrid automata to intensively gather the control requirements. The Platform Independent Model (PIM) is then designed by specializing the real-time UML/SysML's features to obtain the main control capsules, ports, and protocols, together with their dynamic evolution. The detailed PIM is subsequently transformed into the PSM by open-source platforms to rapidly implement and deploy the Q-UAV controller. The paper ends with trial flights and deployment results that show good feasibility to be used for a trajectory-tracking controller of a low-cost Q-UAV. In this case study, the Q-UAV controller is implemented with the simulation model in the OpenModelica tool. The obtained simulation results then allow the main control elements and their properties to be defined, as well as building the implementation libraries in the Arduino environment based on C++ language to quickly perform the realization model in the ATMEGA32-U2 and STM32 Cortex-M4 microcontrollers. [ABSTRACT FROM AUTHOR]

Model comparison has been widely used to support many tasks in model-driven software development. For this reason, many techniques of comparing them have been proposed in the last few decades. However, academia and industry have overlooked a classification of currently available approaches to the comparison of design models. Hence, a thorough understanding of state-of-the-art techniques remains limited and inconclusive. This article, therefore, focuses on providing a classification and a thematic analysis of studies on the comparison of software designmodels. We carried out a systematic mapping study following well-established guidelines to answer nine research questions. In total, 56 primary studies (out of 4,132) were selected from 10 widely recognized electronic databases after a careful filtering process. Themain results are that amajority of the primary studies (1) provide coarse-grained techniques of the comparison of general-purpose diagrams, (2) adopt graphs as principal data structure and compare software design models considering structural properties only, (3) pinpoint commonalities and differences between software design models rather than assess their similarity, and (4) propose new techniques while neglecting the production of empirical knowledge from experimental studies. Finally, this article highlights some challenges and directions that can be explored in upcoming studies. [ABSTRACT FROM AUTHOR]

The aim of this work is propose and describe ImagIngDev, a new approach for developing automatic cross-platform mobile applications using image processing techniques. As proof of concept, we presented ImagIng Tool and compared its performance with respect to similar cross-platform application development tools. Our main contribution to software development is ImagingDev, a new, intuitive and agile approach aimed at novice developers for automatically developing cross-platform mobile applications. Our proof of concept, ImagIng Tool, can generate mobile applications on four different software platforms: Android™, Windows Phone™, iOS™ and FirefoxOS™. Also, it relies on image processing techniques to recognize user interface design patterns (UIDPs) inside user interfaces, and generates the source code for cross-platform and multi-device applications. As proof of concept, we developed ImagIng Tool for automatic generation of cross-platform mobile applications by using image processing techniques. Results from the evaluation demonstrated that ImagIng Tool has attractive benefits if compared to similar cross-platform application development tools. Such benefits include higher learnability and usability. ImagIngDev and ImagIng Tool can effectively solve current problems in mobile applications development, such as automatic code generation for cross-platform mobile applications, since they allow users to generate cross-platform and multi-device mobile applications in an easy and intuitive way. [ABSTRACT FROM AUTHOR]

Since web technologies are constantly evolving, the adaptation of legacy web applications (WAs) to new paradigms such as rich internet applications (RIAs) has become a necessity. In such tendencies, it has been noticed that several web leaders have already migrated there WAs to RIAs. However, they face many challenges due to the variety of frameworks. Nevertheless, in order to facilitate the process of migration, it would be ideal to use tools that could automatically help generate or ease the generation of UML (Unified Modeling Language) models from legacy WAs. In this context, novel methodology used for migration process such as Architecture-Driven Modernization (ADM), were transformed to describe specifications and promote industry accord on the modernization of existing applications. In this paper, we propose a process to migrating a Struts WA into UML model using the toolkit MODISCO. Then, we present a case study as an example that illustrates the different steps of the proposed process. Finally, we validate the proposition within EMF (Eclipse Modeling Framework) since a number of its tools and run-time environments are conforming to ADM standards. [ABSTRACT FROM AUTHOR]

Cloud computing offers a flexible pay-as-you-go model for provisioning application resources, which enables applications to scale on-demand based on the current workload. In many cases, though, users face the single vendor lock-in effect, missing opportunities for optimal and adaptive application deployment across multiple clouds. Several cloud modelling languages have been developed to support multi-cloud resource management, but still they lack holistic cloud management of all aspects and phases. This work defines the Cloud Application Modelling and Execution Language (CAMEL), which (i) allows users to specify the full set of design time aspects for multi-cloud applications, and (ii) supports the models@runtime paradigm that enables capturing an application's current state facilitating its adaptive provisioning. CAMEL has been already used in many projects, domains and use cases due to its wide coverage of cloud management features. Finally, CAMEL has been positively evaluated in this work in terms of its usability and applicability in several domains (e.g., data farming, flight scheduling, financial services) based on the technology acceptance model (TAM). [ABSTRACT FROM AUTHOR]

Copyright of Revista Espacios is the property of Talleres de Impresos Oma and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Education is key to a just and progressive society. It is specially provided by schools and reflects on various areas of our lives. The importance of education has led to new schemes in the development of educational applications. The goal of this research is to propose the design of an architecture for educational application development that relies on a set of user interface design patterns (UIDPs) to facilitate the laborious, time-consuming task of application development. To this end, this article presents the EduGene as the proof of concept. Applications generated with EduGene are compatible with four operating systems, Android™, Firefox® OS, macOS®, and Windows Phone®, and with the Web. Furthermore, EduGene is compatible with three types of devices: mobile (smartphones and tablets), desktop, and television. The evaluation results prove that EduGene is a user-friendly educational application generator, since it provides an intuitive interface that facilitates user interaction. The e-learning tools selected to perform EduGene's comparative evaluation are Moodle, Sakai, and ATutor. It is important to mention that the goal of the evaluation was only to highlight the benefits of EduGene as an educational app development tool. [ABSTRACT FROM AUTHOR]