In commercial software development, components are mainly used to reduce time to market. While some effort has been spent on formal aspects of components, most of this was done in the context of integration into programming languages or operating system frameworks. As a consequence, increased reliability of composed systems is merely regarded as a side effect of a more rigid testing of pre-fabricated components. In contrast to this, Design for Verification (D4V) puts the focus on component-specific property guarantees, which are used to design systems with high reliability requirements. D4V components are domain specific design pattern instances with well-defined property guarantees and usage rules, which are suitable for automatic verification. The guaranteed properties are explicitly used to select components according to key system requirements. The D4V hypothesis is that the same general architecture and design principles leading to good modularity, extensibility and complexity/functionality ratio can be adapted to overcome some of the limitations of conventional reliability assurance methods, such as too large a state space or too many execution paths. 1.

This article discusses how artificial intelligence (AI) planning techniques can be used to enable automatic composition of Web Services. Particulary, the paper discusses how standard Web Service descriptions can be annotated and converted into proper formats like PDDL to enable reasoning with modern AI planning tools. 1

Abstract not found

Vol. 4, No. 2, March-April 2005 It is common agreement that software engineering can meet its challenges only if disciplined reuse and composition mechanisms can be established in both theory and practice. In this paper we provide a thorough analysis of the percolation pattern and three alternatives to it. As result of this analysis we get that each of these alternative checking strategies ensures behavioral subtyping and therefore good reuse properties. However, none of them allows for modular reasoning due to missing success or failure conformance over class hierarchies. 1

Abstract—The greater and greater quantity of services that are available over the web causes a growing attention to techniques that facilitate their reuse. A web service specification can be quite complex, including various operations and message exchange patterns. In this work, we give a declarative representation of services, and in particular of WSDL operations, that enables the application of techniques for reasoning about actions and change. By means of these techniques it becomes possible to reason on the specification of choreography roles and on possible role players, as a basis for selecting services which match in a flexible way with the specifications. Flexible match is, indeed, fundamental in order to enable web service reuse but it does not guarantee the preservation of the goals, that can be proved over the role specification itself. We show how to enrich various kinds of match proposed in the literature so to produce substitutions that preserve goals. I.

The REBOUND adaptation framework organizes a collection of adaptation tactics in a way that they can be selected based on the components available for adaptation. Adaptation tactics are specified formally in terms of the relationship between the component to be adapted and the resulting adapted component. The tactic specifications are used as matching conditions for specification-based component retrieval, creating a ``retrieval for adaptation' ' scenario. The results of specification matching are used to guide component adaptation. Several examples illustrate how the framework guides component and tactic selection and how basic tactics are composed to form more powerful tactics.

The focus of this paper is reusable components organised around a hierarchical faceted classification scheme in a metaCASE environment repository. Defining and design a faceted component search tool in a metaCASE environment is analysed based on an overview of current information retrieval techniques and a study of specific features of the components in a metaCASE environment. The suggested design effectively supports query specification and component search. It further guides users to exploit component resources for reuse. Keywords: component, search, reuse, faceted classification 1. Introduction Component reuse has become increasingly important as the demand for cost-effective software rises. Observers predict that most application software would be built of reusable components by next decade. With the enhancement of reuse, development speed and quality will increase, and time-to-market and maintenance costs will shrink dramatically. MetaCASE forms an environment supporting method ...

Effective application of AI techniques requires an understanding of how the representation vs. reasoning tradeoffs impact the domain of interest. In this paper we evaluate these tradeoffs for the software engineering problem of automatically retrieving components from a library. We generalize our experience in building several automated component retrieval and automated program synthesis systems. We then develop a framework in which we can compare the tradeoffs taken in the various approaches and speculate as to how to effectively combine aspects of the approaches for future applications.

apport de recherche

Abstract—Searching for code is a common task among programmers, with the ultimate goal of finding and reusing code or getting ideas for implementation. While the process of searching for code – issuing a query and selecting a relevant match – is straightforward, several costs must be balanced, including the costs of specifying the query, examining the results to find desired code, and not finding a relevant result. For the popular syntactic searches the query cost is quite low, but the results are often vague or irrelevant, so the examination cost is high and matches may not be found. Semantic searches may return more relevant results, but current techniques that involve writing complex specifications or executing code against test cases are costly to the developer, and close matches cannot be easily identified. In this work, we address these limitations and propose an approach for semantic search in which developers specify lightweight, incomplete specifications and an SMT solver automatically identifies programs from a repository that match the specifications. The program repository is automatically encoded as constraints offline so the search for programs is efficient. The program encodings cover various levels of abstraction to enable partial matches when no, or few, exact matches exists. We present empirical evidence showing the lightweight specifications can be accurately defined by developers, instantiate this approach on a subset of the Yahoo! Pipes mashup language, and outline extensions to other programming languages. I.