Lot-size-one systems as well as plug and produce concepts imply (1) producing increased variety of products in a highly flexible and timely manner, and (2) making commissioning and maintenance more flexible. The speed with which manufacturers, in particular SMEs, can reconfigure the production to a new run and thus respond to clients and avoid costly machine downtime is critical to maintaining commercial success and profit margins. The manufacturing systems of tomorrow must offer a high degree of autonomy, be quickly re-planned to other operations, and cope with a wide variety of unforeseen situations, in a secure and safe manner. In this context, the Asset Administration Shell (AAS) is an emergent standard that leverages the digital twin approach and provides concepts for describing capabilities and skills of I4.0 components in order to automate the reconfiguration process. This article proposes a capability-based operation and engineering approach to tackle the syntactic and semantic interoperability problems in flexible production lines. We demonstrate the implementation of the AAS standard in the open source model-driven workbench Papyrus; then we assess its usability for modeling a production cell use case in order to implement a capability-based reconfiguration approach for flexible production lines.

The future intelligent manufacturing systems should possess a high degree of autonomy, which is able to monitor the entire production process, quickly re-plan operations, and respond to various unforeseen situations in a secure and safe manner. This can achieve rapid response to customers and avoid costly machine downtime, which is crucial to maintaining business success and profitability. The Asset Administration Shell (AAS) is an emerging standard in the I4.0 (Industry 4.0) domain. Based on the concept of digital twins, it provides concepts for describing the digital representation of I4.0 assets including their capabilities and skills. The AAS provides also responses to the challenge of syntactic and semantic interoperability that the flexible and autonomous production lines are facing. In this article, we propose a capability-based operation and engineering approach for flexible production lines. Our approach is relying on the AAS standard which is a very wide and rich specification. Consequently, we describe the subset of AAS modelling concepts necessary for our approach, we clarify their semantics and we show their usage through a production cell use case. Furthermore, we demonstrate how these modelling concepts were tooled as an extension of the open source model-driven workbench Papyrus.

Coordinating decisions in large-scale systems is acknowledged as one of the most challenging aspects of autonomic computing. If control theory is already pushed to its limits by the inevitable decentralised nature of such systems, going large-scale makes things even harder. In this paper, we propose a decentralised token-based scheme for coordinating shared resources allocation in large-scale autonomic systems. In this scheme, each token represents an exclusive access to a share of the resource. Tokens are used and exchanged among autonomic managers to limit their decisions to the resource capacity the tokens they hold at this moment represent. Our token based protocol is meant to provide statistical guarantees on the average total resource usage and the average lateness of node actions due to the coordination. It exposes a set of parameters which we have explored to characterise its fairness and global resource usage on a use case in geotracking. Experiments with the coordination of 10.000 autonomic managers have shown very good results for large spectrum of parameter values and system's regimes.

Continuously adjusting the horizontal scaling of applications hosted by data centers appears as a good candidate to automatic control approaches allocating resources in closed-loop given their current workload. Despite several attempts, real applications of these techniques in cloud computing infrastructures face some difficulties. Some of them essentially turn back to the core concepts of automatic control: controllability, inertia of the controlled system, gain and stability. In this paper, considering our recent work to build a management framework dedicated to automatic resource allocation in virtualized applications, we attempt to identify from experiments the sources of instabilities in the controlled systems. As examples, we analyze two types of policies: threshold-based and reinforcement learning techniques to dynamically scale resources. The experiments show that both approaches are tricky and that trying to implement a controller without looking at the way the controlled system reacts to actions, both in time and in amplitude, is doomed to fail. We discuss both lessons learned from the experiments in terms of simple yet key points to build good resource management policies, and longer term issues on which we are currently working to manage contracts and reinforcement learning efficiently in cloud controllers.

Computing has reached the time of distributed applications everywhere. Service-oriented architectures are more and more used to organize such complex and highly dynamic applications into business processes calling services discovered in registries at load-time. In this context, Quality of Service (QoS) and agility in business processes become key issues. Instead of binding business processes to services at load-time, this paper proposes to monitor sets of candidate services for their current QoS and to choose among them at call-time. This new form of late-binding paves the way to more agile and robust applications called adaptive business processes. Besides the conceptual background and implementation of this late-binding in an industrial-strength web service platform, this paper presents the LCP-net formalism introduced to provide programmers with a mean to express qualitatively their preferences among the different QoS properties of services, hence tackling the multi-criteria decision making arising from the run-time choice among candidate services given several unrelated QoS properties.

Business process modeling languages, such as BPMN, offer an abstract view to Web service composition, where business functionalities are decomposed into activities connected through high level control and possibly data flows. Closing the gap between abstract modeling and concrete business process execution requires to solve data mismatches between producer and consumer services with specific adapters. Automatically generating data adapters as well as selecting actual services such as to minimize mismatches are major barriers to this end. In this paper, we present some new pieces of framework providing an end-to-end solution to this problem, (1) first by evaluating the level of data mismatches between candidate producer and consumer services in a business process, (2) second by selecting services in such a way to globally minimize the overall data mismatches in a process, and (3) finally by generating transformations from output to input XML data everywhere needed in the data flow. Moreover, we extend this framework to cope with the failure of selected services at run-time by choosing a replacement service that locally minimizes the data mismatches with its providers and clients in the process. Our solution is implemented and performance evaluations show its feasibility since the cost of selecting a replacement service is typically less than the one of one call to a remote Web service.

Web services lack the possibility to exchange first-class objects as parameters and results. In current SOA practices, one has to give up years of experience in object-oriented programming, and return to procedural programming, passing as parameters XML data rather than objects. We propose to tackle this problem with our WS-object model which, by transmitting methods in XQuery, as well as data in XML, strives to combine Web service calls with the power of object-oriented programming. Our concept reinterprets the basics of objects, state and behavior, within the XML world, and is based on the use of interfaces and their implementation by classes generated at run-time to convert WS-objects into native language objects that can then be used by server- and client-side programs. WS-objects simplify decoupling, enhance the confidentiality of data and make Web services more stable and resistant to changes. This paper introduces the WS-object concept and illustrates it with a first implementation in Java.

International audience

The prototype-based programming model has always been difficult to characterize precisely. Its basic principle advocates concrete objects as the only mean to model concepts, yet current languages promote methodologies reintroducing abstract constructions to manage efficiently groups of similar objects. In this paper, we propose a rational reconstruction of delegation-based programming languages that identifies programming models going beyond traditional prototypes. We also introduce a new classification of delegation-based languages, which clarifies these models, and we discuss their relative merits. We finally bring to the fore the existence of more and more structured delegation-based languages forming a continuum between pure prototype-based languages and class-based ones.

Reflective programming languages are those where users' programs are allowed to customize in an organized way the behavior of the language to their own needs. For ten years now, most of the work on reflection revolved around the definition and the implementation of metaobject protocols which express this organization. No methodologies have been proposed for reflective programming per se. This paper proposes a first one aiming at the design of composable metaobjects. Given two independently developed reflective customizations, this methodology proposes principles to be observed in their design such that they can be composed using standard base-level aggregation or specialization. While this paper focuses on a simple MOP and illustrates the methodology on specific examples, this methodology can be generalized to other languages with different MOPs. For instance, we discuss how to adapt it to CLOS.

Prototype-based languages are currently proposed as a substitute to class-based languages for a higher flexibility in manipulating objects.These languages are all based on a similar set of basic principles: object-centered representation, dynamic addition (deletion) of slots, cloning and message delegation.But they all differ in the precise interpretation of these principles and nobody has yet considered the semantic issues raised by their combination.In this paper, we propose a new taxonomy of prototypebased languages, enhancing the Treaty of Orlando by now discussing issues associated with the different semantics of the identified prototype-based languages.From this taxonomy, we extract a constructive proposal for the design of a new prototype-based language.This proposal is the chief result of this paper; it suggests one set of primitives which is regarded as the best to provide a clean, useful and coherent prototype-based computational model.We finally describe an implementation of most interesting language alternatives in the form of a Smalltalk-platform.This platform establishes an operational semantics for the basic primitives andmore interesting -validates our previous taxonomy by implementing it as a class hierarchy.Obviously, this platform has been used to relate in the same formalism the semantics of different languages with each others.For instance, the programming models of existing languages, such as Self, ObjectLisp and Actra's examplars, are faithfully derived as subclasses in this hierarchy.

A numerical approach for computing optimal dynamic checkpointing strategies for general rollback and recovery systems is presented. The system is modeled as a Markov renewal decision process. General failure distributions, random checkpointing durations, and reprocessing-dependent recovery times are allowed. The aim is to find a dynamic decision rule to maximize the average system availability over an infinite time horizon. A computational approach to approximate such a rule is proposed. This approach is based on value-iteration stochastic dynamic programming with spline or finite-element approximation of the value and policy functions. Numerical illustrations are provided.>