An Enablement Detection Algorithm for Open Multiparty Interactions

Coordination axnongst an arbitrary number of entities has become an important issue in recent years m fields such as e-- commerce, web-based applications and so on. Traditionally, classical client/server primitives have been used to implement synchronisation and communication. But. when more than two entities need to coordinate hy means of those primitives, the coordination must be decomposed into a number of client/server hipaxty interactions, leading the programmer to the need of thinking in terms of the protocols needed to achieve properties like livenes, atomicity and so on. In this paper, we present an algorithm to perform enablement detection to implement open multiparty interactions. This primitive provides a high level of abstraction since the programmar can implement multiparty coordination without the need of thinking in terms of protocols

a framework for aspect–oriented multiparty coordination

Separation of concerns has been presented as a promising tool to tackle the design of complex systems in which cross–cutting properties that do no fit into the scope of a class must be satisfied. In this paper, we show that interaction amongst a number of objects can also be described separately from functionality by means of the CAL language, and present a framework that provides the needed infrastructure. It is innovative because it supports open multiparty interactions

An Order-Based, Distributed Algorithm for Implementing Multiparty Interactions

Multiparty interactions have been paid much attention in recent years because they provide the user with a useful mechanism for coordinating a number of entities that need to cooperate in order to achieve a common goal. In this paper, we present an algorithm for implementing them that is based on the idea of locking resources in a given order. It improves on previous results in that it can be used in a context in which the set of participants in an interaction cannot be known at compile time, and setting up communication links amongst interaction managers is costly or completely impossible

An Algorithm for Ensuring Fairness and Liveness in Non-deterministic Systems Based on Multiparty Interactions

Strong fairness is a notion we can use to ensure that an element that is enabled infinitely often in a non–deterministic programme, will eventually be selected for execution so that it can progress. Unfortunately, “eventually” is too weak to induce the intuitive idea of liveliness and leads to anomalies that are not desirable, namely fair finiteness and conspiracies. In this paper, we focus on non–deterministic programmes based on multiparty interactions and we present a new criteria for selecting interactions called strong k–fairness that improves on other proposals in that it addresses both anomalies simultaneously, and k may be set a priori to control its goodness. We also show our notion is feasible, and present an algorithm for scheduling interactions in a strongly k–fair manner using a theoretical framework to support the multiparty interaction model. Our algorithm does not require to transform the source code to the processes that compose the system; furthermore, it can deal with both terminating and non–terminating processes.Comisión Interministerial de Ciencia y Tecnología TIC 2000–1106–C02–0

An order-based algorithm for implementing multiparty synchronization

Multiparty interactions are a powerful mechanism for coordinating several entities that need to cooperate in order to achieve a common goal. In this paper, we present an algorithm for implementing them that improves on previous results in that it does not require the whole set of entities or interactions to be known at compile- or run-time, and it can deal with both terminating and non-terminating systems. We also present a comprehensive simulation analysis that shows how sensitive to changes our algorithm is, and compare the results with well-known proposals by other authors. This study proves that our algorithm still performs comparably to other proposals in which the set of entities and interactions is known beforehand, but outperforms them in some situations that are clearly identified. In addition, these results prove that our algorithm can be combined with a technique called synchrony loosening without having an effect on efficiency.Ministerio de Ciencia y Tecnología TIC 2003-02737-C02-0

Aspect-oriented interaction in multi-organisational web-based systems

Separation of concerns has been presented as a promising tool to tackle the design of complex systems in which cross-cutting properties that do not fit into the scope of a class must be satisfied. Unfortunately, current proposals assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse them in a context in which another interaction model is more suited, e.g., tuple spaces, multiparty meetings, ports, and so forth. In this paper, we show that functionality can be described separately from the interaction model used, which helps enhance reusability of functional code and coordination patterns. Our proposal is innovative in that it is the first that achieves a clear separation between functionality and interaction in an aspect-oriented manner. In order to show that it is feasible, we adapted the multiparty interaction model to the context of multiorganisational web-based systems and developed a class framework to build business objects whose performance rates comparably to handmade implementations; the development time, however, decreases significantly.Comisión Interministerial de Ciencia y Tecnología TIC2000-1106-C02-0

Implantations distribuées de modèles à base de composants communicants par interactions multiparties avec priorités : application au langage BIP

Distributed software is often required for new systems, because of efficiency and physical distribution and sensors and actuators. Ensuring correctness of a distributed implementation is hard due to the interleaving of actions belonging to distinct processes. This thesis proposes a method for generating a correct and efficient distributed implementation from a high-level model of an application. The input model is described as a set of components communicating through prioritized multiparty interactions. Such primitives change the state of all components involved in an interaction during a single atomic execution step. We assume that a distributed implementation is a set of processes communicating through asynchronous message-passing. The main challenge is to produce a correct and efficient distributed implementation of prioritized multiparty interactions, relying only on message-passing. The method relies on a rigorous design flow refining the high-level model of the application into a low-level model, from which code for a given platform is generated. All intermediate models appearing in the flow are expressed using the same semantics as the input model. Complex interactions are replaced with constructs using simpler interactions at each step of the design flow. In particular, the last model obtained before code generation contains only interactions modeling asynchronous message passing. The correctness of the implementation is obtained by construction. Using multiparty interaction reduces drastically the set of reachable states, compared to an equivalent model expressed with lower level primitives. Essential properties of the system are checked at this abstraction level. Each transformation of the design flow is simple enough to be fully formalized and proved by showing observational equivalence or trace equivalence between the input and output models. The obtained implementation is correct with respect to the original model, which avoids an expensive a posteriori verification. Performance can be optimized through adequate choice of the transformation parameters, or by augmenting the knowledge of components. The latter solution requires to analyze the original model to compute the knowledge, that is reused at subsequent steps of the decentralization. The various transformations and optimizations constituting the design flow have been implemented using the BIP framework. The implementation has been used to evaluate the different possibilities, as well the influence of parameters of the design flow, on several examples. The generated code uses either Unix sockets, MPI or pthreads primitives for communication between processes.Les nouveaux systèmes ont souvent recours à une implémentation distribuée du logiciel, pour des raisons d'efficacité et à cause de l'emplacement physique de certains capteurs et actuateurs. S'assurer de la correction d'un logiciel distribué est difficile car cela impose de considérer tous les enchevêtrements possibles des actions exécutées par des processus distincts. Cette thèse propose une méthode pour générer, à partir d'un modèle d'application haut niveau, une implémentation distribuée correcte et efficace. Le modèle de l'application comporte des composants communiquant au moyen d'interactions multiparties avec priorités. L'exécution d'une interaction multipartie, qui correspond à un pas de la sémantique, change de façon atomique l'état de tous les composants participant à l'interaction. On définit une implantation distribuée comme un ensemble de processus communiquant par envoi de message asynchrone. La principale difficulté est de produire une implémentation correcte et efficace des interactions multiparties avec priorités, en utilisant uniquement l'envoi de message comme primitive. La méthode se fonde sur un flot de conception rigoureux qui raffine progressivement le modèle haut niveau en un modèle bas niveau, à partir duquel le code pour une plateforme particulière est généré. Tous les modèles intermédiaires apparaissant dans le flot sont exprimés avec la même sémantique que le modèle original. À chaque étape du flot, les interactions complexes sont remplacés par des constructions utilisant des interactions plus simples. En particulier, le dernier modèle obtenu avant la génération du code ne contient que des interactions modélisant l'envoi de message. La correction de l'implémentation est obtenue par construction. L'utilisation des interactions multiparties comme primitives dans le modèle de l'application permet de réduire très significativement l'ensemble des états atteignables, par rapport à un modèle équivalent mais utilisant des primitives de communication plus simples. Les propriétés essentielles du système sont vérifiées à ce niveau d'abstraction. Chaque transformation constituante du flot de conception est suffisamment simple pour être complètement formalisée et prouvée, en termes d'équivalence observationelle ou d'équivalence de trace entre le modèles avant et après transformation. L'implémentation ainsi obtenue est correcte par rapport au modèle original, ce qui évite une coûteuse vérification a posteriori. Concernant l'efficacité, la performance de l'implémentation peut être optimisée en choisissant les paramètres adéquats pour les transformations, ou en augmentant la connaissance des composants. Cette dernière solution requiert une analyse du modèle de départ afin de calculer la connaissance qui est réutilisée pour les étapes ultérieures du flot de conception. Les différentes transformations et optimisations constituant le flot de conception ont été implémentées dans le cadre de BIP. Cette implémentation a permis d'évaluer les différentes possibilités ainsi que l'influence des différents paramètres, sur la performance de l'implémentation obtenue avec plusieurs exemples. Le code généré utilise les primitives fournies par les sockets POSIX, MPI ou les pthreads pour envoyer des messages entre les processus

Aspect Oriented Interaction in Environments Multi Organizational

Por desgracia, las propuestas actuales de separaci´on de aspectos asumen que los objetos interact´uan mediante invocaci´on de m´etodos, lo que implica que tienen que embeber las interacciones dentro del c´odigo funcional. Esto los hace dependientes de este modelo de interacci´on y hace dif´ıcil reutilizarlos en un contexto en el que otro modelo de interacci´on sea m´as adecuado. En este art´ıculo mostramos que la funcionalidad puede ser descrita de forma independiente al modelo de interacci´on usado, lo que mejora la facilidad de reutilizaci´on del c´odigo funcional y los patrones de coordinaci´on. Para demostrar que es viable, hemos adaptado el modelo de interacci´on entre m´ultiples participantes al contexto de los sistemas multiorganizacionales basados en la web y hemos desarrollado un framework de clases que permite construir objetos de negocio cuyo rendimiento es comparable al de una implementaci´on artesanal; el tiempo de desarrollo, por el contrario, se reduce de forma muy significativa.Unfortunately, current proposals that focus on separation of concerns assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse them in a context in which another interaction model is more suited. In this paper, we show that functionality can be described separately from the interaction model used, which helps enhance reusability of functional code and coordination patterns. In order to show that it is feasible, we adapted the multiparty interaction model to the context of Multi-Organisational Web-Based Systems and developed a class framework to build business objects whose performance rates comparably to a handmade implementation; the development time, however, decreases significantly

Interacción orientada a aspectos en entornos multiorganizacionales

Unfortunately, current proposals that focus on separation of concerns assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse them in a context in which another interaction model is more suited.Keywords: Aspect orientation, interaction models, multiparty interactions

A Comparative Analysis of Distributed Ledger Technology Platforms

Distributed Ledger Technology (DLT) has emerged as one of the most disruptive technologies in the last decade. It promises to change the way people do their business, track their products, and manage their personal data. Though the concept of DLT was first implemented in 2009 as Bitcoin, it has gained significant attention only in the past few years. During this time, different DLT enthusiasts and commercial companies have proposed and developed several DLT platforms. These platforms are usually categorized as public vs private, general-purpose vs application-specific and so on. As a growing number of people are interested to build DLT applications, it is important to understand their underlying architecture and capabilities in order to determine which DLT platform should be leveraged for a specific DLT application. In addition, the platforms need to be evaluated and critically analyzed to assess their applicability, resiliency and sustainability in the long run. In this paper, we have surveyed several leading DLT platforms and evaluated their capabilities based on a number of quantitative and qualitative criteria. The comparative analysis presented in this paper will help the DLT developers and architects to choose the best platform as per their requirement(s)