Catálogo de publicaciones - libros

Composition of algorithms has dominated software composition since the inception of programming. The ubiquitous subroutine call acts as the primary composition operator in virtually all programming models and paradigms, appearing in various guises such as function call, method invocation, remote procedure call, etc. The inadequacies of the tight coupling imposed by such composition mechanisms and the need for more flexible alternatives have become clearer along the evolution through object-oriented to component-based, and now, service oriented computing.

We address in this article the description and usage of component protocols viewed as specific services. In addition to inter-component service composition, our Kmelia component model supports vertical structuring mechanisms that allow service composition inside a component. The structuring mechanisms (namely state annotation and transition annotation) are then used to describe protocols which are considered here as component usage guides. These structuring mechanisms are integrated in the support language of our component model and are implemented in our COSTO toolbox. We show how protocol analysis is performed in order to detect some inconsistencies that may be introduced by the component designers.

Abadi and Lamport established a general theorem for composing specifications [1] . Based on an assume-guarantee principle, it enables one to prove the specification of a composite system from the ones of its components. But the general application of this theorem to software composition is not that straightforward because the resulting abstract specification of the composite depends upon the hidden guarantees of its subcomponents. In this paper, we investigate how this result can be exploited without blurring responsibilities between the different participants. Our contributions leverage an existing contracting framework for hierarchical software components [7] , in which contracts are first-class objects during configuration and run times. This framework already associates specifications and responsibilities to software components, within the traditional form of composition. We show here how the one can be made operational using the theorem as a sound formal basis. The resulting composite contracts make possible not only to detect violations, but also to determine and exploit precisely responsibilities upon them, related to both forms of composition.

In the context of Service Oriented Computing, contracts are descriptions of the externally observable behaviour of services. Given a group of collaborating services, their contracts can be used to verify whether their composition is sound, i.e., the services are compliant. In this paper, we relate the theory of contracts with the notion of choreography conformance, used to check whether an aggregation of services correctly behaves according to a high level specification of their possible conversations. The main result of this paper is the definition of an effective procedure that can be used to verify whether a service with a given contract can correctly play a specific role within a choreography. This procedure is achieved via composition of choreography projection and contract refinement.

This paper describes a process-algebraic approach to specification and refinement of workflow processes. In particular, we model both specification and implementation of workflows as CSP processes. CSP’s behavioural models and their respective refinement relations not only enable us to prove correctness properties of an individual workflow process against its behavioural specification but also allows us to design and develop workflow processes compositionally. Moreover, coupled with CSP is an industrial strength automated model checker FDR, which allows behavioural properties of workflow models to be proved automatically. This paper details some CSP models of van der Aalst et al.’s control flow workflow patterns, and illustrates behavioural specification and refinement of workflow systems with a business process scenario.

Bridging problem domain and solution in product line engineering is a time-consuming and error-prone process. Since both domains are structured differently (features vs. artifacts), there is no natural way to map one to the other. Using an explicit and formal mapping creates opportunities for consistency checking and automation. This way both the configuration and the composition of product instances can be more robust, support more product variants and be performed more often.

Software system construction based on the reuse of software components has to be done with flexibility enough to control the desired behavior of the resulting assemblies. Applications created by component composition usually depend on a strict method of construction in which COTS or in-house components are only integrated with great difficulty. Actually, reliable assemblies result from being able to observe the inner workings of components and from getting an in-depth understanding of them. The need for fine-grained tailoring and adequate setups is also therefore essential. To enhance the usability, the interoperability and the runtime adaptability of components, composition management interfaces are proposed. They aim at preparing and guiding composition by exposing information about components’ inners (states and transitions), which in turn allow for the making of rules that formalize appropriate composition conditions. Finally, state-based expressions for composition are built on a set of primitives discussed in the paper.

In Service-Oriented Architectures (SOA) composed services provide functionalities with certain non-functional properties that depend on the properties of the basic services. Models that represent dependencies among these properties are necessary to analyze non-functional properties of composed services. In this paper we focus on the reliability of a SOA. Most reliability models for software that is assembled from basic elements (e.g. objects, components or services) assume that the elements are independent, namely they do not take into account the dependencies that may exist between basic elements. We relax this assumption here and propose a reliability model for a SOA that embeds the “error propagation” property. We present a path-based model that generates the possible execution paths within a SOA from a set of scenarios. The reliability of the whole system is then obtained as a combination of the reliability of all generated paths. On the basis of our model, we show on an example that the error propagation analysis may be a key factor for a trustworthy prediction of the reliability of a SOA. Such a reliability model for a SOA may support, during the system development, the allocation of testing effort among services and, at run time, the selection of functionally equivalent services offered by different providers.

Traditional component models and frameworks simplified software system development by enabling developers to break software systems into independent pieces with well-defined interfaces. This approach led to looser coupling among the system pieces and enhanced possibilities for reuse. While the component-based approach led to advancements in the software development process, it still has its limitations. In particular, after a component-based application is developed and deployed it typically is a monolithic and static configuration of components. The advent of service-oriented component (SOC), the rise in popularity of consumer devices, and the ubiquity of connectivity have fostered a growing interest in applications that react dynamically to changes in the availability of various services. To simplify the creation of such dynamic software systems, it is possible to borrow concepts from SOC and include them into a component model, resulting in a service-oriented component model that specifically supports dynamically adaptable applications. This paper presents iPOJO, a service-oriented component framework to help developers implement dynamically adaptable software systems.

This paper explores service composition in pervasive environments with a focus on dynamic service selection. Service orientation offers the dynamism and loose coupling needed in pervasive applications. However, context-aware service composition is still a great challenge in pervasive computing. Service selection has to deal with dynamic contextual information to enable context-aware behaviors to emerge from the environment. This paper describes how to add dynamic contextual service ranking mechanisms to the service-oriented OSGi framework and further discusses service re-composition decisions.