Carlos Canal

A formal approach to component adaptation

Component adaptation is widelyrecognised to be one of the crucial problems in Component-Based Software Engineering (CBSE). We present a formal methodologyfor adapting components with mismatching interaction behaviour. The three main ingredients of the methodologyare: (1) the inclusion of behaviour specifications in component interfaces, (2) a simple, high-level notation for expressing adaptor specifications, and (3) a fullyautomated procedure to derive concrete adaptors from given high-level specifications.

Formalizing Web Service Choreographies

Current Web service choreography proposals, such as BPEL4WS, BPSS, WSFL, WSCDL or WSCI, provide notations for describing the message flows in Web service collaborations. However, such proposals remain at the descriptive level, without providing any kind of reasoning mechanisms or tool support for checking the compatibility of Web services based on the proposed notations. In this paper we present the formalization of one of these Web service choreography proposals (WSCI), and discuss the benefits that can be obtained by such formalization. In particular, we show how to check whether two or more Web services are compatible to interoperate or not, and, if not, whether the specification of adaptors that mediate between them can be automatically generated ---hence enabling the communication of (a priori) incompatible Web services.

Model-Based Adaptation of Behavioral Mismatching Components

Component-Based Software Engineering focuses on the reuse of existing software components. In practice, most components cannot be integrated directly into an application-to-be, because they are incompatible. Software Adaptation aims at generating, as automatically as possible, adaptors to compensate mismatch between component interfaces, and is therefore a promising solution for the development of a real market of components promoting software reuse. In this article, we present our approach for software adaptation which relies on an abstract notation based on synchronous vectors and transition systems for governing adaptation rules. Our proposal is supported by dedicated algorithms that generate automatically adaptor protocols. These algorithms have been implemented in a tool, called Adaptor, that can be used through a user-friendly graphical interface.

Compatibility and inheritance in software architectures

The application of formal methods to the development of software depends on the availability of adequate models and formalisms for each of the stages of the development process. In this work, we focus on the level of design called Software Architecture. At this level, the system is described as a collection of interrelated components, and it is here where the properties derived from the system’s structure can be naturally analyzed. Our approach uses process algebras as a formal basis for the description and analysis of software architectures. Process algebras are widely accepted for the speci8cation of software systems. In particular, � -calculus addresses the description of systems with a dynamic or evolving topology, and permits their analysis for bisimilarity and other interesting properties. Though bisimilarity determines the equivalence of behavior, more :exible relations are needed in the context of Software Engineering, in order to support formally the notions of conformance and re8nement of behavior. In this paper we present a relation of compatibility in the context of � -calculus which formalizes the notion of conformance of behavior between software components. Our approach is enhanced with the de8nition of a relation of inheritance among processes. This relation preserves compatibility and indicates whether a process can be considered as a specialization or extension of another one. The suitability of our approach is shown by its application to the 8eld of Software Architecture. c 2001 Elsevier Science B.V. All rights reserved.

Specification and Refinement of Dynamic Software Architectures

Several notations and languages for software architectural specification have been recently proposed. However, some important aspects of composition, extension, and reuse deserve further research. These problems are particularly relevant in the context of open systems, where system structure can evolve dynamically, either by incorporating new components, or by replacing existing components with compatible ones. Our approach tries to address some of these open problems by combining the use of formal methods, particularly process algebras, with concepts coming from the object-oriented domain. In this paper we present LEDA, an Architecture Description Language for the specification, validation, prototyping and construction of dynamic software systems. Systems specified in LEDA can be checked for compatibility, ensuring that the behaviour of their components conforms to each other and that the systems can be safely composed. A notion of polymorphism of behaviour is used to extend and refine components while maintaining their compatibility, allowing the parameterisation of architectures, and encouraging reuse of architectural designs.

Adding roles to CORBA objects

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. Some of the existing proposals try to add protocol information to object interfaces, but most of them fail to do so in a modular way. In this paper we propose an extension of the CORBA IDL that uses a sugared subset of the polyadic /spl pi/-calculus for describing object service protocols, based on the concept of roles. Roles allow the modular specification of the observable behavior of CORBA objects, reducing the complexity of the compatibility tests. Our main aim is the automated checking of protocol interoperability between CORBA objects in open component-based environments, using similar techniques to those used in software architecture description and analysis. In addition, our proposal permits the study of substitutability between CORBA objects, as well as the realization of dynamic compatibility tests during their runtime execution.

ITACA: An integrated toolbox for the automatic composition and adaptation of Web services

Adaptation is of utmost importance in systems developed by assembling reusable software services accessed through their public interfaces. This process aims at solving, as automatically as possible, mismatch cases which may be given at the different interoperability levels among interfaces by synthesizing a mediating adaptor. In this paper, we present a toolbox that fully supports the adaptation process, including: (i) different methods to construct adaptation contracts involving several services; (ii) simulation and verification techniques which help to identify and correct erroneous behaviours or deadlocking executions; and (iii) techniques for the generation of centralized or distributed adaptor protocols based on the aforementioned contracts. Our toolbox relates our models with implementation platforms, starting with the automatic extraction of behavioural models from existing interface descriptions, until the final adaptor implementation is generated for the target platform.

Formalizing WSBPEL Business Processes Using Process Algebra

Industry standards for Web Service composition, such as WSBPEL, provide the notation and additional control mechanisms for the execution of business processes in Web Service collaborations. However, these standards do not provide support for checking interesting properties related to Web Service and process behaviour. In an attempt to fill this gap, we describe a formalization of WSBPEL business processes, that adds protocol information to the specifications of interacting Web Services, and uses a process algebra to model their dynamic behaviour - thus enabling their formal analysis and the inference of relevant properties of the systems being built.

A Model-Based Approach to the Verification and Adaptation of WF/.NET Components

This paper presents an approach which supports verification and model-based adaptation of software components and services implemented using Windows Workflow Foundation (WF). First, we propose an abstract description of WF workflows, and we formalise the extraction of Labelled Transition Systems from these workflows. Next, verification and adaptation are applied using respectively model-checking techniques and existing model-based adaptation approaches. Last, we explain how a WF workflow can be generated from an adaptor protocol.

Extending CORBA Interfaces with Protocols

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. In this paper we propose an extension of the Common Object Request Broker Architecture (CORBA) interface description language (IDL) that uses a sugared subset of the polyadic π-calculus for describing object service protocols, aimed at the automated checking of protocol interoperability between CORBA objects in open component-based environments. In addition, some advantages and disadvantages of our proposal are discussed, as well as some of the practical limitations encountered when trying to implement and use this sort of IDL extension in open systems.