Specification Matching of State-Based Modular Components

Retrieval of software components from a library relies on techniques for matching user requirements against library component interfaces. In this paper we introduce a number of techniques for matching formally specified, state-based modules. These techniques will form the basis for retrieval tool support. The techniques described in this paper build on existing specification matching methods, based on individual functions, specified using pre- and post-conditions. We begin by defining a basic module matching technique, based on matching the individual units within a module. We consider variations of this technique that take into account two important features of modules: the visibility of module entities; and the use of state invariants. An advanced technique, based on data refinement and the use of coupling invariants, is also described

Conducting Requirements Evolution by Replacing Components in the Current System

As new software components become available for an existing system, we can evolve not only the system itself but also its requirements based on the new components. In this paper, we propose a method to support requirements evolution by replacing a component with another component, and by changing the current requirements so as to adapt to the new component. To explore the possibilities of such a replacement, we use the technique of specification matching. To change the current requirements, we modify the structure by following the concept of Design by Contract.ArticleProceedings : sixth Asia-Pacific Software Engineering Conference. 224-227 (1999)conference pape

A case-based reasoning (CBR) approach to software reusability, 1994

Software reuse is an attractive approach to improving software development productivity. In this thesis, a Case-Based Reasoning (CBR) software reusability environment is developed, driven by object-oriented modelling techniques. This research discusses various aspects of the classification and retrieval mechanisms necessary to facilitate the reuse of software components. The facet classification scheme breaks down information into different categories, and this makes it possible to consider information about several different aspects or properties of the components. Facet represents the information most important with respect to reuse. Component specifications will be translated into a specification representing the facets in the classification scheme. The retrieval of software components is based on signature matching between the signatures of goal specifications and those of reusable components. The retrieval mechanism is supported by the CBR system ESTEEM

Matching Spec# Specifications

In this project, we develop a tool which compares two Spec# programs (C# code with specification contracts) for signature matching. The tool automatically identifies whether the two specifications are similar, and gives out a new Spec# program which needs to be verified. There are levels of standards to judge how similar these two Spec# programs’ specification is. This work contributes to the area of code reuse via match specifications: given a specification we aim to mark it to a similar specification and use its implementation to generate the implementation of the original specification. In this work we present the process of match specifications in detail for Spec# programs, we discuss how the method may be applied to other languages and indicate future work in this direction. We match specifications according to the work of Amy Moormann Zaremski and Jeannette M. Wing’s on "Match specifications of Software Components" [1]. This work proposes a lattice of possible technique for match specifications. Examples include Exact Pre/Post Match, Plug-In Match, Plug-In Post Match, Weak Post Match, Exact Predicate Match, Generalized Match and Specialized Match. We apply these definitions to Spec# programs, provide examples of verification matches and illustrate the level of matching that can be achieved automatically within the Spec# tools

Defining substitutability criteria for object oriented components

Component-Based Software Development (CBSD) promotes software reusability by allowing new functionalities to be added and existing functionalities to be removed or replaced easily. However, high reusability comes with its own cost, namely the difficulty in selecting suitable candidates for adaptation tasks. Even though research has been conducted toward identification of such components, current methods rely on an existing system specification, which is more often either not available or inconsistent with other artifacts such as implementation. In this dissertation, we complement current works by proposing a novel approach to compare software components at source code level independent on the existence, or otherwise, of the specification. We consider Open-Source Software (OSS) components written in Java at three levels of granularity, namely methods, types and packages. Consequently, we define substitutability criteria at three levels of abstraction and provide metrics indicating the degree of matching of two components. We provide automation and tool support through an Eclipse plug-in and we demonstrate our method through a case study. We expect our approach to be beneficial to maintainers during the selection of suitable candidate components

An ontology for software component matching

The Web is likely to be a central platform for software development in the future. We investigate how Semantic Web technologies, in particular ontologies, can be utilised to support software component development in a Web environment. We use description logics, which underlie Semantic Web ontology languages such as DAML+OIL, to develop an ontology for matching requested and provided components. A link between modal logic and description logics will prove invaluable for the provision of reasoning support for component and service behaviour

Multilevel Contracts for Trusted Components

This article contributes to the design and the verification of trusted components and services. The contracts are declined at several levels to cover then different facets, such as component consistency, compatibility or correctness. The article introduces multilevel contracts and a design+verification process for handling and analysing these contracts in component models. The approach is implemented with the COSTO platform that supports the Kmelia component model. A case study illustrates the overall approach.Comment: In Proceedings WCSI 2010, arXiv:1010.233

Organising the knowledge space for software components

Software development has become a distributed, collaborative process based on the assembly of off-the-shelf and purpose-built components. The selection of software components from component repositories and the development of components for these repositories requires an accessible information infrastructure that allows the description and comparison of these components. General knowledge relating to software development is equally important in this context as knowledge concerning the application domain of the software. Both form two pillars on which the structural and behavioural properties of software components can be addressed. Form, effect, and intention are the essential aspects of process-based knowledge representation with behaviour as a primary property. We investigate how this information space for software components can be organised in order to facilitate the required taxonomy, thesaurus, conceptual model, and logical framework functions. Focal point is an axiomatised ontology that, in addition to the usual static view on knowledge, also intrinsically addresses the dynamics, i.e. the behaviour of software. Modal logics are central here – providing a bridge between classical (static) knowledge representation approaches and behaviour and process description and classification. We relate our discussion to the Web context, looking at Web services as components and the Semantic Web as the knowledge representation framewor