The strategy design pattern is an essential behavioral design pattern.When developing software it is relied upon for the development of modular components.Given the constraints inherent to the inner workings of the Blockchain and features offered by Smart Contract languages, some of the design patterns commonly used in software systems development cannot be naively implemented.This paper explores a new pattern implementation of the mentioned pattern in a contract oriented language aimed at Smart-Contracts development, specifically the solidity language.The pattern's implementations discussed in this paper are intended to be deployed and run on the Ethereum Blockchain.

International audience

Machine learning approaches propose a promising solution for extracting and analyzing contextual information from different data sources. Especially, in the E-health field, the need for Improvement in risk prediction, early detection and prevention of disease remains an essential task for the well-being of patients at risk. In this paper, we aim to explore the added value of using machine learning based approach to predict contextual situations in context-aware systems, and more specifically the field of E-health.

Design of complex systems goes through a multiview paradigm in which separate teams, from different business viewpoints, build partial models describing the system. As they are expressed in different languages, these partial models are called heterogeneous models. To maintain the global system's consistency, we propose a collaborative approach that combines Group Decision Making (GDM) and Model-Based Engineering. This paper presents a metamodel for collaborative decision elaboration via a set of decision policies which are instances of GDM patterns. Our approach is illustrated with a hospital Emergency Department case study and is supported by a tool allowing models alignment through GDM based processes.

Design of complex systems implies various points of view expressed by stakeholders with different areas of expertise. Each stakeholder describes his model in a Domain Specific Language, according to his point of view. Ensuring the consistency of the global system and building a cross view is a challenging task. It requires the involvement of all stakeholders to produce intermodel correspondences that satisfy their concerns. In this paper, we first introduce a metamodel of collaboration that formalizes collaborative work, then we use this metamodel to define a collaborative process for heterogeneous design models matching. This approach establishes semantic links at metamodel level by following a group decision-making process, then it refines those links semi-automatically at model level by exploiting their semantics.

Models have always been adopted in trades implemented in Systems Engineering (SE). Those models go from concrete representations, such as reduced plans or models, to abstract ones like equations systems. In this context, SysML became an SE standard because of its capabilities of supporting the specification, analysis, design, verification and validation of a broad range of systems and systems-of-systems. However, SysML descriptive models are insufficient to perform system behavior verifications. This lack can be handled by simulation process that allows performing experiments on models to eliminate poor design alternatives, and ensures that a preferred alternative meets the stakeholders' objectives. As design process efficiency is considerably reduced by the fact that both system modeling and simulation tools are often used separately, several research works aim combining and integrating both approaches in a common framework. This paper proposes a study of common constructs, semantics and modeling methodologies of simulation tools on the basis of whom we define a modeling language that we name: Simulation Modeling Language. This latter is aimed to bridge the gap between SysML modeling and various simulation tools.

In system-level design, descriptive system models seem to be insufficient in order to perform a system verification which fulfils various stakeholders0 requirements. This fact is accentuated by the increasing complexity of system engineering projects and, as a consequence, the difficulties to deal with both their coordination and trace ability. Even if SysML (System Modeling Language) is considered as a flexible and standard tool for system engineering, using only descriptive models are insufficient for system behavior verifications. To deal with this concern, simulation environments (i.e. MATLAB/Simulink) allow verifying if the system preliminary design satisfies requirements or not. As a consequence, various research works have been centered on combining the potential of both SysML modeling and simulation tools. This paper proposes an integration approach based on metamodeling and model transformations to generate Simulink models from SysML diagrams. This approach is handled by models and modern techniques of MDE (Model-Driven Engineering).

Even if it is considered as an effective language for system modeling because of the descriptive aspect of its diagrams, SysML (System Modeling Language) is insufficient for verification of their behavior. This lack is accentuated by the increasing complexity of recent systems. In order to conduct behavior verifications, designers use simulation tools to realize experiments on the studied system. Thus, the efficiency of the engineering process is often reduced because of the separate and consecutive use of both SysML modeling and simulation tools. As a consequence, various research works focused on unifying the potential provided by the SysML language and simulation environments. We propose in this paper to study links taxonomy between SysML and various existing simulation environments. The ultimate goal of this study is to consider the most optimal passage from SysML to various simulation tools. A common environment based on models and modern techniques of model-based engineering will handle this transformation.

The current service discovery mechanisms are syntactic methods that often offer poor quality results. By researching this area we are able to identify issues that limit the quality of the result with these traditional service mechanisms. To overcome this issue we use ontologies to enable semantic matchmaking. By reasoning on concepts and relations, our approach can derive matches that syntactically would not match. Additionally, by introducing contextual information in the service discovery process, the quality of the service discovery result may improve. In this paper, we present an overview of the architecture for the discovery of context aware services by using ontologies, we also present our context aware semantic service by extending OWL-S with context properties.

The model composition provides support to build systems based on a set of less complex sub-models. This operation allows managing complexity while supporting the modularity and reusability tasks. Due to the increase number of the involving models, their composition becomes a tedious task. For that, the need for maintaining traceability information is raised to help managing the composition operation. We propose in this work a graph-based model transformations approach, which aims to keep track of the model composition operation. Our objective is to capture traces in an automatic and reusable manner. Finally, a composition scenario is given to demonstrate the feasibility of our proposal.

Building complex and trustworthy software systems in the shortest time-to-market remains the challenging objective that competitive companies are facing constantly, and mastering the development process is a key issue towards this objective. Companies need to be able to formalize their development processes in order to analyze them, to enact them, and to assess them for quality measurement and efficiency improvement. In the context of complex software and systems development, there are many actors involved in the development who use different tools and heterogeneous modeling languages. So we can say that resulting processes are highly collaborative and must be described and enacted as such.

ABSTRACT Collaboration in software engineering projects is usually intensive and requires adequate support by well‐integrated tools. However, process‐centered software engineering environments (PSEE) have traditionally been designed to exploit integration facilities in other tools, while offering themselves little to no such facilities. This is in line with the vision of the PSEE as the central orchestrator of project support tools. We argue that this view has hindered the widespread adoption of process‐based collaboration support tools by incurring too much adoption and switching costs. We propose a new process‐based collaboration support architecture, backed by a process metamodel, that can easily be integrated with existing tools. The proposed architecture revolves around the central concepts of ‘deep links’ and ‘hooks’. Our approach is validated by analyzing a collection of open‐source projects, and integration utilities based on the implemented process model server have been developed. Copyright © 2014 John Wiley & Sons, Ltd.

The rapid evolution of software paradigms, wireless technologies and mobile devices induced the emergence of new applications called context-aware services oriented applications. Such applications provide appropriate services or relevant information to the user or other applications to perform a specific task. An important challenge in such applications development process is context modeling and reasoning. Ontology based models presents the most promising instrument for context modeling and offers possibility of applying ontology reasoning techniques. the aim of context reasoning is converting low-level context to highlevel context in order to provide customized services to users. In this paper, we present an architecture for the development of context aware services based on ontologies. We also highlight our context metamodel and discuss about reasoning process for e-health systems.

This paper falls into the context of modeling complex systems according to various viewpoints. More precisely, it presents an iterative process of heterogeneous models consistency management - by taking into account various types of evolution - based on building a correspondence model. In the case of models evolution, this process is intended to capture changes in the models, to list modifications to be made in the impacted models and finally to update the correspondence model for a future iteration.

Model composition is one of the important activities in model driven engineering, because complex systems are built based on several viewpoints. The composition operation is a tedious task, however, traceability not only provides us with the tool to comprehend its effects, but also helps us to better manage the operation itself. This paper suggests a traceability framework for the model composition operation based on aspect oriented modeling and graph transformation. The generated trace models conform to a generic metamodel that allows representing nested trace links. A merge specification case study is presented to illustrate our contribution.

This work is situated in the context of the application of Model Driven Engineering to complex systems view-based modelling. In fact, view-based models - called also partial models - are manipulated by different actors (designers), and are thus generally heterogeneous, that is, described with different DSLs (Domain Specific Languages). Instead of building a single global model, which is not realistic, we propose to organize the different partial models as a network of related models, which provides a global view of the system through a correspondence model. As models are modelled separately by different designers, they also evolve separately that induces a problem of consistency. To solve it, we propose a semi-automatic process based on the correspondence model allowing detecting changes, calculating their impacts, and proposing modifications to maintain the consistency among them. The approach is supported by a tool chain and illustrated by the example of a Bug Tracking System.

Software engineering projects are highly collaborative. Existing tools designed to support collaboration usually provide some specific service, and integration with other tools using data and events. However, Process-Centered Software Engineering Environments have traditionally been designed with different assumptions. The process is usually considered as the central aspect of the software project, and used as a center of control. As a result, great emphasis has been placed on the ability of PSEEs to invoke other tools, or use data generated by other tools. However, the integration in the other direction, that is, the ability of other tools to query the data managed by PSEEs (the process model), and hook into their extensions points, has been largely ignored, as it is not compatible with the vision of the PSEE as the central orchestrator of project support tools. We argue that this view has hindered the widespread adoption of process-based collaboration support tools by incurring too much adoption and switching costs, and propose a new process-based collaboration support architecture, backed by a process metamodel, which can easily be integrated with existing tools.

In software engineering, as in any collective endeavor, understanding and supporting collaboration is a major concern. Unfortunately, the main concepts of popular process formalisms are not always adequate to describe collaboration. We extend the Software & System Process Engineering Meta-Model (SPEM) by introducing concepts needed to represent precise and dynamic collaboration setups that practitioners create to address ever-changing challenges. Our goal is to give practitioners the ability to express evolving understanding about collaboration in a formalism suited for easy representation and tool-provided assistance. Our work is based on a collaborative process metamodel we have developed. In this paper, we first present a meta-process for process modeling and enactment, which we apply to our collaborative process metamodel. Then we describe the implementation of a suitable process model editor, and a project plan generator from process models.

Several approaches adopted by the software engineering community rely on the principle of multi-modeling which allows to separate concerns and to model a system as a set of less complex sub-models. Model composition is a crucial activity in Model Driven Engineering (MDE). It is particularly useful when adopting a multi-modeling approach to analyze and design software systems. In previous work, we have defined a view-based UML profile called VUML. In this paper, we describe a formal approach for model composition in which we consider the composition as an algebraic operator on the set of UML-compliant models. We specify the semantics of our composition operator by means of graph transformations. Furthermore, we present a composition scheme interpreted by a two-steps composition process based on two strategies of correspondence and merging. To illustrate our approach, we apply it to the composition of UML class models diagrams into one VUML model class diagram.

The challenge in the development of complex systems is to cope with the dynamic nature of the user's profile, especially when such systems are exposed to the large public through the Internet. In Service oriented computing (SOC), a service may interact with several types of service clients. The central problem is, therefore, how to model the multidimensional aspect of service clients' needs and requirements. To tackle this problem, we propose in this paper the concept of the multiview service as a first class modeling entity that permits the representation of the needs and requirements of end-users by separating their concerns. Such adaptable services must carefully be analyzed and designed. However, current works on service oriented analysis and design (SOAD) largely focus on defining processes to develop business processes and services without considering user-aware variability. In the present paper we present an MDA framework for a muliview SOAD process for the development of highly adaptable services. We specify transformations as a collection of rules implemented in ATL. The proposal is illustrated by a simple example.

VUML is a view-based analysis/design method offering a formalism (UML profile) and a process to model software systems through objects and views. The main extension to UML is the multiview class whose goal is to store and deliver information according to the user's viewpoint. VUML supports the dynamic change of viewpoints and offers mechanisms to describe view dependencies. On the semantics side, the VUML meta-model extends the UML one with OCL rules. VUML proposes also a generic implementation pattern to generate the object code corresponding to a VUML class diagram. The proposed pattern uses delegation, handle technique and polymorphism to implement views. In this paper, we present a model driven implementation of this pattern, which integrates the multi-user aspect and supports Java language. We propose a code generation technique that respects the pattern and uses the MDA approach. We specify transformations as a collection of rules implemented in ATL. The proposal is illustrated by a simple example.

Model composition is considered as a crucial activity in model driven software development (MDSD). It is a common feature when adopting a multi-modeling approach to analyze and design software systems. Similar modular approaches are known under several names such as viewpoints, aspects, subjects, etc. In previous works, we proposed a view-based UML profile called VUML. In this paper, we describe a conceptual framework whose goal is to separate the generic composition part from the specific part dedicated to a given modeling domain. We apply our approach to the composition of UML class diagrams into one VUML class diagram.

One of the main challenges of our modern societies is the development of information systems accessible to every citizen with respect to his culture, rights, education etc. A number of such information systems (servers) are now provided on the Web in e-learning, tourism, environment, health, transport, etc. But the development and the maintenance of those systems are not guided by users' profile (viewpoints) and thus such systems are very difficult to adapt, reuse and maintain when a viewpoint must be added/removed/updated. To meet these requirements, we propose an extension of UML called VUML (View based Unified Modeling Language). VUML provides the concept of multiviews component whose goal is to store and deliver information according to users' viewpoints. A multiviews component consists of a default view and a set of specific views related to the base through an extension relation. This approach allows for dynamic change of viewpoints and offers mechanisms to describe views dependencies. To favor reuse and transition to coding, we propose an implementation generic pattern targeting object-oriented languages.