Antonio Vallecillo

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.

Towards a consistent terminology for software measurement

Although software measurement plays an increasingly important role in Software Engineering, there is no consensus yet on many of the concepts and terminology used in this field. Even worse, vocabulary conflicts and inconsistencies can be frequently found amongst the many sources and references commonly used by software measurement researchers and practitioners. This article presents an analysis of the current situation, and provides a comparison framework that can be used to identify and address the discrepancies, gaps, and terminology conflicts that current software measurement proposals present. A basic software measurement ontology is introduced, that aims at contributing to the harmonization of the different software measurement proposals and standards, by providing a coherent set of common concepts used in software measurement. The ontology is also aligned with the metrology vocabulary used in other more mature measurement engineering disciplines.

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.

Formal and Tool Support for Model Driven Engineering with Maude

Models and metamodels play a cornerstone role in Model-Driven Software Development. Although several notations have been proposed to specify them, the kind of formal and tool support they provide is quite limited. In this paper we explore the use of Maude as a formal notation for describing models and metamodels. Maude is an executable rewriting logic language specially well suited for the specification of object-oriented open and distributed systems. We show how Maude oers a simple, natural, and accurate way of specifying models and metamodels, and oers good tool support for reasoning about them. In particular, we show how some basic operations on models, such as model subtyping, type inference, and metric evaluation, can be easily specified and implemented in Maude, and made available in development environments such as Eclipse.

Tractable model transformation testing

Model transformation (MT) testing is gaining interest as the size and complexity of MTs grows. In general it is very difficult and expensive (time and computational complexity-wise) to validate in full the correctness of a MT. This paper presents a MT testing approach based on the concept of Tract, which is a generalization of the concept of Model Transformation Contract. A Tract defines a set of constraints on the source and target metamodels, a set of source-target constraints, and a tract test suite, i.e., a collection of source models satisfying the source constraints. We automatically generate input test suite models, which are then transformed into output models by the transformation under test, and the results checked with the USE tool (UML-based Specification Environment) against the constraints defined for the transformation. We show the different kinds of tests that can be conducted over a MT using this automated process, and the kinds of problems it can help uncovering.

Component-Based Software Quality

The last decade marked the first real attempt to turn software development into engineering through the concepts of ComponentBased Software Development (CBSD) and Commercial Off-The-Shelf (COTS) components. The idea is to create high-quality parts and join them together to form a functioning system. The problem is that the combination of such parts does not necessarily result in a high-quality system. It is clear that CBSD affects software quality in several ways, ranging from introducing new methods for selecting COTS components, to defining a wide scope of testing principles and measurements. Today, software quality staff must rethink the way software is assessed, including all life-cycle phases—from requirements to evolution. Based on cumulated research efforts, the goal of this chapter is to introduce the best practices of current Component-Based Software Assessment (CBSA). We will develop and describe in detail the concepts involved in CBSA and its constituent elements, providing a basis for discussing the different approaches presented later in this book.

Analyzing Rule-Based Behavioral Semantics of Visual Modeling Languages with Maude

There is a growing need to explicitly represent the behavioral semantics of Modeling Languages in a precise way, something especially important in industrial environments in which simulation and verification are critical issues. Graph transformation provides one way to specify the semantics of Domain Specific Visual Languages (DSVLs), with the advantage of being intuitive and easy to use for the system designer. Even though its theory has been extensively developed during the last 30 years, it has some limitations concerning specific analysis capabilities. On the contrary, Maude is a rewriting logic-based language with very good formal analysis support, but which requires specialized knowledge. In this paper we show how a mapping between graph transformation-based specifications of DSVL semantics and Maude is possible. This allows performing simulation, reachability and model-checking analysis on the models, using the tools and techniques that Maude provides.

A Trading Service for COTS Components

Component-based software development (CBSD) has gained recognition as one of the key technologies for the construction of high-quality, evolvable, large complex systems in a timely and affordable manner. In CBSD, the development effort becomes one of gradual discovery about the components, their capabilities and the incompatibilities that arise when they are used in concert. Thus, trading becomes one of the cornerstones of CBSD. However, most of the existing methods for CBSD do not make effective use of traders. In this paper, we analyze the required features for commercial off-the-shelf (COTS) components traders, and introduce COTStrader ,a n Internet-based trader for COTS components. In addition, we discuss how the COTStrader can be integrated into a spiral methodology for CBSD, providing partially automated support for building COTS-based systems.

A Rewriting Logic Semantics for ATL

As the complexity of model transformation (MT) grows, the need to rely on formal semantics of MT languages becomes a critical issue. Formal semantics provide precise specications of the expected behavior of transformations, allowing users to understand them and to use them properly, and MT tool builders to develop correct MT engines, compilers, etc. In addition, formal semantics allow modelers to reason about the MTs and to prove their correctness, something specially important in case of large and complex MTs (with, e.g., hundreds or thousands of rules) for which manual debugging is no longer possible. In this paper we give a formal semantics of the ATL 3.0 model transformation language using rewriting logic and Maude, which allows addressing these issues. Such formalization provides additional benets, such as enabling the simulation of the specications or giving access to the Maude toolkit to reason about them.

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.