Search

Parallel scheduling of multiple real-time applications onto heterogeneous processors is needed in the emerging embedded systems such as self-driving cars, smart cameras, and smartphones. Assuming that an embedded application is specified as a synchronous dataflow (SDF) graph or its extension, we propose a novel parallel scheduling methodology based on an evolutionary algorithm where the mapping of tasks onto processors is evolved to optimize a given objective function in an iterative fashion. In each iteration, we use an existing worst-case response time (WCRT) analysis tool to check if all applications satisfy their real-time requirements by translating each SDF graph into a directed acyclic graph (DAG) that is assumed in the WCRT analysis tool. Since the WCRT analysis must be performed in each iteration of evolution, we propose a clustering technique to reduce drastically the analysis time that depends on the number of nodes and their dependency. We formally prove that the proposed clustering technique does not change the estimated WCRT of each application. The effectiveness of the proposed scheduling methodology with the clustering technique is verified with extensive experiments using real-life benchmarks, randomly generated graphs, and the comparison with the existing technique.

The ever-increasing number of mobile platforms constitutes a challenge for application developers, who must develop efficient mobile applications for multiple platforms. Recently, a specific interest is being taken in the Model Based User Interface Development (MBUID) by Software Engineering Community. In such paradigm, an application’s user interface is obtained by defining models and transformations of those models. This paper aim at adopting MBUID paradigm to address the problem of mobile application development. As such, we propose a new approach and its support system for the automatic generation of mobile user interfaces. The approach and the system are based on a set of standards and relevant technologies such as EMF, GMF, ATL, and Xpand. A case study is presented, in the paper, with the aim of verifying the usefulness of this approach.

In the early phases of the software development process, specifications are mostly written in a natural language rather than formal models, which is not supported by the Model Driven Architecture (MDA). For this reason, the Semantic of Business Vocabulary and Rules (SBVR) is proposed by the Object Management Group to represent the textual specifications in a language comprehensible by both of humans and machines, to facilitate its integration in the MDA lifecycle. However, businesspeople are usually not familiar with SBVR standard. In this paper we present an approach to automatically transform textual business rules to an SBVR model, to facilitate its integration in nowadays information technology infrastructures. Our approach is distinguished from existing works in that it uses an in-depth Natural Language Processing to extract a more comprehensible SBVR model that includes the semantic formulation of each business rule statement, coupled with a Terminological Dictionary of extracted concepts, to which we have added further specifications such as definitions and synonyms. The evaluation of our approach shows that for three sets of business rules statements taken from different domains, we could generate the correct meaning with an average of F1-score exceeding 87%.

Summary: Modeling and specifying correct software systems is a challenging task that can be supported by providing appropriate modeling abstractions. This article proposes an approach for graphical multiscale modeling of such systems using model transformation techniques. The approach is founded on a guided rule‐based iterative modeling process ensuring controlled transition from a coarse‐grained description to a fine‐grained description. It provides also user‐friendly graphical descriptions by extension of UML notations, hence preserving the common practices from software architectures design. The iterative design process is supported by a set of model transformation rules. The rules manage the refinement process (by adding or removing subsystems or by adding or removing details on a given subsystem) as a model transformation. Our approach is supported by a rule‐based generator that implements the automatic transformation of UML diagrams into Event‐B specifications allowing formal verification of their correctness properties, and relieving software architects of mastering formal techniques. To experiment and validate our approach, we consider a case study dedicated to the smart cities. [ABSTRACT FROM AUTHOR]

In the last years, mobile applications have gained a lot of importance in the software industry, since every day more people become users of mobile devices and companies create a lot of mobile applications to keep competitive in the market. Then, it has become necessary to adopt new strategies that help the industry produce applications that can be extensible, scalable, testable, and deployable effectively and efficiently. Based on this, several architectural approaches have been proposed to provide the required features in mobiles applications. In the paper, we propose an approach that uses concepts of modeldriven engineering and model-driven architecture to build a model to text transformation that allows generating Android applications using Clean Architecture. [ABSTRACT FROM AUTHOR]

Data integration is one of the core responsibilities of EDM (enterprise data management) and interoperability. It is essential for almost every digitalization project, e.g., during the migration from a legacy ERP (enterprise resource planning) software to a new system. One challenge is the incompatibility of data models, i.e., different software systems use specific or proprietary terminology, data structures, data formats, and semantics. Data need to be interchanged between software systems, and often complex data conversions or transformations are necessary. This paper presents an approach that allows software engineers or data experts to use models and patterns in order to specify data integration: it is based on data models such as ER (entity-relationship) diagrams or UML (unified modeling language) class models that are well-accepted and widely used in practice. Predefined data integration patterns are combined (applied) on the model level leading to formal, precise, and concise definitions of data transformations and conversions. Data integration definitions can then be executed (via code generation) so that a manual implementation is not necessary. The advantages are that existing data models can be reused, standardized data integration patterns lead to fast results, and data integration specifications are executable and can be easily maintained and extended. An example transformation of elements of a relational data model to object-oriented data structures shows the approach in practice. Its focus is on data mappings and relationships. [ABSTRACT FROM AUTHOR]

Healthcare processes have many particularities captured and described within standards for medical information exchange such as HL7 FHIR. BPMN is a widely used standard to create readily understandable processes models. We show an approach to integrate both these standards via an automated transformation mechanism. This will allow us to use the various tools available for BPMN to visualize and automate processes in the healthcare domain. In the future we plan to extend this approach to enable mining and analyzing executed processes. [ABSTRACT FROM AUTHOR]

Enterprise architecture has become an important driver to facilitate digital transformation in companies, since it allows to manage IT and business in a holistic and integrated manner by establishing connections among technology concerns and strategical/motivational ones. Enterprise architecture modelling is critical to accurately represent business and their IT assets in combination. This modelling is important when companies start to manage their enterprise architecture, but also when it is remodelled so that the enterprise architecture is realigned in a changing world. Enterprise architecture is commonly modelled by few experts in a manual way, which is error-prone and time-consuming and makes continuous realignment difficult. In contrast, other enterprise architecture modelling proposal automatically analyses some artefacts like source code, databases, services, etc. Previous automated modelling proposals focus on the analysis of individual artefacts with isolated transformations toward ArchiMate or other enterprise architecture notations and/or frameworks. We propose the usage of Knowledge Discovery Metamodel (KDM) to represent all the intermediate information retrieved from information systems' artefacts, which is then transformed into ArchiMate models. Thus, the core contribution of this paper is the model transformation between KDM and ArchiMate metamodels. The main implication of this proposal is that ArchiMate models are automatically generated from a common knowledge repository. Thereby, the relationships between different-nature artefacts can be exploited to get more complete and accurate enterprise architecture representations. [ABSTRACT FROM AUTHOR]

Models capture relevant properties of systems. During the models' life-cycle, they are subjected to manipulations with different goals such as managing software evolution, performing analysis, increasing developers' productivity, and reducing human errors. Typically, these manipulation operations are implemented as model transformations. Examples of these transformations are (i) model-to-model transformations for model evolution, model refactoring, model merging, model migration, model refinement, etc., (ii) model-to-text transformations for code generation and (iii) text-to-model ones for reverse engineering. These operations are usually manually implemented, using general-purpose languages such as Java, or domain-specific languages (DSLs) such as ATL or Acceleo. Even when using such DSLs, transformations are still time-consuming and error-prone. We propose using the advances in artificial intelligence techniques to learn these manipulation operations on models and automate the process, freeing the developer from building specific pieces of code. In particular, our proposal is a generic neural network architecture suitable for heterogeneous model transformations. Our architecture comprises an encoder–decoder long short-term memory with an attention mechanism. It is fed with pairs of input–output examples and, once trained, given an input, automatically produces the expected output. We present the architecture and illustrate the feasibility and potential of our approach through its application in two main operations on models: model-to-model transformations and code generation. The results confirm that neural networks are able to faithfully learn how to perform these tasks as long as enough data are provided and no contradictory examples are given. [ABSTRACT FROM AUTHOR]

Model transformations play an essential role in most model-driven software projects. As the size and complexity of model transformations increase, their reuse, evolution and maintenance become a challenge. This work further details the Model Transformation TEst Specification (MoTES) approach, which leverages contract-based model testing techniques to assist engineers in model transformation evolution and repairing. The main novelty of our approach is to use contract-based model transformation testing as a foundation to derive suggestions of concrete adaptation actions. MoTES uses contracts to specify the expected behaviour of the model transformation under test. These contracts are transformed into model transformations which act as oracles on input–output model pairs, previously generated by executing the transformation under test on provided input models. By further processing, the oracles' output model, precision and recall metrics are calculated for every output pattern (testing results). These metrics are then categorised to increase the user's ability to interpret and act on them. The MoTES approach defines 8 cases for precision and recall values classification (test result cases). As traceability information is retained from transformation rules to each output pattern, it is possible to classify each transformation rule involved according to its impact on the metrics, e.g. the number of true positives generated. The MoTES approach defines 37 cases for these classifications, with each one linked to a particular (abstract) action suggested on a rule, such as relaxation of the rules. A comprehensive evaluation of this approach is also presented, consisting of three case studies. Two previous case studies performed over two model transformations (UML2ER and E2M) are replicated to contrast MoTES with an existing model transformation fault localisation approach. An additional case study presents how MoTES helps with the evolution of an existing model transformation in the context of a reverse engineering project. Main evaluation results show that our approach can not only detect the errors introduced in the transformations but also localise the faulty rule and suggest the proper repair actions, which significantly reduce testers' effort. From a quantitative perspective, in the third case study, MoTES was able to indicate one faulty rule from 19 possibilities for each result case and suggest one or two repair actions from 6 possibilities for each faulty rule. [ABSTRACT FROM AUTHOR]

Model transformation has become an established field, and it is important to improve the quality of specifications written in transformation languages. Different transformation patterns have been introduced in the model‐driven engineering (MDE) community to improve the quality of transformation specifications. However, due to the different definitions of pattern concepts by different authors, it is difficult for practitioners to understand how to apply patterns in practice. Therefore, there is a need to unify transformation pattern concepts by presenting a generic metamodel and formalizing patterns in terms of this metamodel, to define the meaning of pattern application. In this research a general metamodel for definition of different design patterns in model transformation is provided. The metamodel presents clear description of common aspects of transformation patterns, which facilitates the application of patterns on model transformations by validating the application against the underlying formalism. Additionally, a unified and precise terminology for the application and verification of model transformation patterns by using a formal model of model transformation patterns in the Z notation is presented. To show the applicability of the proposed formalism, four well‐known model transformation patterns are specified. [ABSTRACT FROM AUTHOR]

Real‐time systems are complex and composed of time‐bounded events that must satisfy the real‐time constraints for their proper functioning. To cope with the complexity of real‐time systems, model‐driven approaches such as model‐driven architecture (MDA) can be followed, which uses the conceptual models for system representation. This paper presents an MDA‐based automated approach for an early stage performance evaluation and verification of a real‐time system using the Unified Modeling Language (UML)/Modeling and Analysis of Real‐Time and Embedded systems (MARTE) sequence diagram. A metamodel‐based model‐to‐model transformation technique is used for mapping the UML/MARTE sequence diagram into the generalized Petri Net Markup Language (PNML) representation of the timed Petri net model using Atlas Transformation Language (ATL). The derived PNML representation has the advantage to support the interoperability between different Petri net tools when compared over the existing methods that produce tool‐specific representation. The proposed approach enables the system designers to create and evaluate alternate system designs and predict their behavior, contributing to improving the system quality. The contribution of the proposed technique for identifying the optimal system design is analyzed using a real‐time embedded sensor application. The proposed transformation approach is also validated using a real‐time system from the manufacturing domain. [ABSTRACT FROM AUTHOR]

This paper deals with modeling and verification of software systems by combining UML diagrams and Pi-calculus. UML 2.0 Activity diagrams are used for modeling the behavior of software systems, while Pi-calculus is used for semantic and verification purposes. More precisely, UML is a semi-formal language and so it needs formal semantics for its constructs and lacks tools for verifying properties. To this end, we propose an approach and a tool called AD2PICALC for transforming UML 2.0 Activity diagrams to Pi-calculus processes using Eclipse Xpand and TGG tools. The obtained Pi-calculus processes are then used as input for Pi-calculus tools, like MWB, to verify some properties as deadlocks, safety, determinism, termination and livelock. We illustrate our contribution through an example from the literature and verify the property of deadlock using MWB tool. The main contribution of this paper lies in the automation of the transformation approach using TGG tools.

Software Architecture (SA) generally has a considerable influence on software quality attributes. Coordination of software architecture to the requirements of the stakeholders and avoiding common mistakes and faults in designing SA increases the chance of success of the project and satisfaction of the stakeholders. Making the wrong decisions at the architectural design phase usually proves very costly later on. Refactoring is a method which helps in detecting and avoiding complications, improving the internal characteristics of software, while keeping the external behavior intact. Various problems can undermine the architecture refactoring process. The existence of different requirements in different domains, the diversity of architecture description languages, and the difficulty of describing refactoring patterns lead to the difficulty of performing automatic and semi-automatic refactoring on the SA. In this study, we use model transformation as a way to overcome the above mentioned difficulties. In this regard, the first step is converting the SA to a pivot-model. Then, based on the refactoring patterns, the refactoring process is performed on the pivotmodel. And finally, the pivot-model is converted back to the original (source) model. In this paper, the requirements of the stakeholders are taken into account in the refactoring process by modeling them as refactoring goals. These goals show the importance of the quality attributes in the project and the process of refactoring. The applicability of the framework is demonstrated using a case study.

Evolution of software development process and increasing complexity of software systems calls for developers to pay great attention to the evolution of CASE tools for software development. This, in turn, causes explosion for appearance of a new wave (or new generation) of such CASE tools. The authors of the paper have been working on the development of the so-called two-hemisphere model-driven approach and its supporting BrainTool for the past 10 years. This paper is a step forward in the research on the ability to use the two-hemisphere model driven approach for system modelling at the problem domain level and to generate UML diagrams and software code from the two-hemisphere model. The paper discusses the usage of anemic domain model instead of rich domain model and offers the main principle of transformation of the two-hemisphere model into the first one.

AADL is widely used to depict the architecture and behavior of real-time safety-critical systems such as avionics and aerospace. The development of these systems has strict requirements for building fault-free systems. Formal verification is frequently applied to verify the critical properties of the systems, such as safety and liveness; however, the formal verification is not supported by AADL. Model transformation is commonly applied to provide formal semantics; hence, the AADL model can be verified by a language that supports formal verification in addition to the ability to cover all AADL model behavior. Event-B, with its proof obligation, is increasingly used to model and verify safety-critical systems. This paper presents the transformation of the AADL model into Event-B, which captures most AADL components and behavioral actions to be effective in the verification of current real-time systems models. Then, we define theorems and invariants of safety and liveness properties to be proven by using the RODIN platform. To demonstrate the efficacy of our method, we model the AADL of movement authority (MA) control of the Chinese Train Control System, transform the AADL model to Event-B and verify its crucial properties.

Model transformations and model-driven engineering (MDE) have been applied widely in service-oriented architecture based information systems. To support the development of such a service-oriented information system, it is necessary to guarantee the quality of model transformations. With the increasing complexity and scale of model transformations, debugging of model transformations becomes more and more time-consuming and difficult, there is an increasing need to rely on efficient and accurate fault localization approaches to help with debugging. Among the existing fault localization approaches, the spectrum-based fault localization (SBFL), as a dynamic analysis method, mainly used the coverage information and execution results of the rules of model transformation to estimate the probability of each rule may be faulty. However, there are many false-positive and false-negative results in the rule coverage information, the accuracy of the SBFL is not ideal, so we consider mining the impact of covered range in different test models to further improve the effectiveness of fault localization. In this paper, we propose an optimized strategy of fault localization based on the impact of the test model, according to the covered range of test models, weight values are assigned to different test models, and the statistical coverage information of rules are weighted and adjusted accordingly. We compare the proposed approach with the SBFL, the experimental results show that under the same techniques for computing the suspiciousness, our approach can help locate around 26% more faulty rules in the ranking Top-1 of the suspicious list than the SBFL, the effectiveness of fault localization techniques can be improved by 50.42% in the best case and 8.9% in the average case.

Connectors are powerful architectural elements that allow the specification of interactions between software components. Since the connectors do not include behavior in UML, the components include the behavior for coordinating the components, complicating the designs of components and decreasing their reusability. In this study, we propose the enrichment of UML connectors with behavioral specifications. The goal is to provide separation of concerns for the components so that they are freed from coordination duties. The reusability of the components will increase as a result of such exogenous coordination. Additionally, using the associated behaviors, we aim to resolve the ambiguities that arise when n-ary connectors are used. We use a series of QVTo transformations to transform UML models that include connector behaviors in ALF specifications into UML models which include fUML activities as connector behavior specifications. We present a set of example connectors specified using the proposed method. We execute the QVTo transformations on the example connectors to produce models that represent platform-independent definitions of the coordination behaviors. We also present and discuss cases from real-life large-scale avionics software projects in which using the proposed approach results in simpler and more flexible designs and increases component reusability.

Model transformation is an effective technique to produce target models from source models. Most transformation approaches focus on generating a single target model from a given source model. However, there are situations where a collection of possible target models is preferred over a single one. Such situations arise when some choices cannot be encoded in the transformation. Then, search techniques can be used to help find a target model having specific properties. In this paper, we present an approach that combines model transformation and constraint programming to generate explorable sets of models. We extend previous work by adding support for multiple solvers, as well as extending ATL, a declarative transformation language used to write such transformations. We evaluate our approach and language on a task scheduling case study including both scheduling constraints and schedule visualization. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Computer Engineering & Applications is the property of Beijing Journal of Computer Engineering & Applications Journal Co Ltd. 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.)