Using iterative refinement to find reusable software

Component libraries are the dominant paradigm for software reuse, but they suffer from a lack of tools that support the problem-solving process of locating relevant components. Most retrieval tools assume that retrieval is a simple matter of matching well-formed queries to a repository. But forming queries can be difficult. A designer's understanding of the problem evolves while searching for a component, and large repositories often use an esoteric vocabulary. CodeFinder is a retrieval system that combines retrieval by reformulation (which supports incremental query construction) and spreading activation (which retrieves items related to the query) to help users find information. I designed it to investigate the hypothesis that this design makes for a more effective retrieval system. My study confirmed that it was more helpful to users seeking relevant information with ill-defined tasks and vocabulary mismatches than other query systems. The study supports the hypothesis that combining techniques effectively satisfies the kind of information needs typically encountered in software design     

Reusing software: issues and research directions

Software productivity has been steadily increasing over the past 30 years, but not enough to close the gap between the demands placed on the software industry and what the state of the practice can deliver; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but software reuse as the (only) realistic approach to bring about the gains of productivity and quality that the software industry needs. In this paper, we discuss the implications of reuse on the production, with an emphasis on the technical challenges. Software reuse involves building software that is reusable by design and building with reusable software. Software reuse includes reusing both the products of previous software projects and the processes deployed to produce them, leading to a wide spectrum of reuse approaches, from the building blocks (reusing products) approach, on one hand, to the generative or reusable processor (reusing processes), on the other. We discuss the implication of such approaches on the organization, control, and method of software development and discuss proposed models for their economic analysis. Software reuse benefits from methodologies and tools to: (1) build more readily reusable software and (2) locate, evaluate, and tailor reusable software, the last being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and OO development for the first and a thorough discussion of retrieval techniques for software components, component composition (or bottom-up design), and transformational systems for the second. We conclude by highlighting areas that, in our opinion, are worthy of further investigation     

An experiment in software component retrieval

Our research centers around exploring methodologies for developing reusable software, and developing methods and tools for building inter-enterprise information systems with reusable components. In this paper, we focus on an experiment in which different component indexing and retrieval methods were tested. The results are surprising. Earlier work had often shown that controlled vocabulary indexing and retrieval performed better than full-text indexing and retrieval [IEEE Trans. Software Engng (1994) 1, IEEE Trans. Software Engng 17 (1991) 800], but the differences in performance were often so small that some questioned whether those differences were worth the much greater cost of controlled vocabulary indexing and retrieval [Commun. Assoc. Comput. Mach. 28 (1985) 289, Commun. Assoc. Comput. Mach. 29 (1986) 648]. In our experiment, we found that full-text indexing and retrieval of software components provided comparable precision but much better recall than controlled vocabulary indexing and retrieval of components. There are a number of explanations for this somewhat counter-intuitive result, including the nature of software artifacts, and the notion of relevance that was used in our experiment. We bring to the fore some fundamental questions related to reuse repositories.     

一个支持构件库动态演变的构件检索系统

在基于构件的软件开发CBD(component－based Software development)中,随着可重用构件库的不断增长,构件的分类和检索技术一直是软件重用组织十分关注的问题.文章提出了一个支持构件库动态演变的构件检索系统;为了改进该系统的检索性能,还采用了多种构件检索方法.     

The REBOOT approach to software reuse

Although some companies have been successful in software reuse, many research projects on reuse have had little industrial penetration. Often the proposed technology has been too ambitious or exotic, or did not scale up. REBOOT emphasizes industrial applicability of the proposed technology in a holistic perspective: a validated method through a Methodology Handbook, a stabilized tool set around a reuse library, a training package, and initial software repositories of reusable components extracted from company-specific projects. This article presents the REBOOT approach to software reuse, covering both organizational and technical aspects and the experiences so far from the applications.     

基于刻面描述的构件查询匹配模型及算法研究

在软件复用研究不断深入的情况下，软件构件库的管理研究得到了产业界与学术界越来越多的重视．作为构件库管理的两个核心技术，构件的表示与检索技术已经成为研究热点，其中基于刻面描述的构件相关应用得到了广泛研究，针对构件查询的特点，结合模式分析中的树匹配思想，提出了新颖的构件树路径包含匹配模型及其相应的构件查询匹配算法，该算法可以在保持构件查准率的前提下，有效提高构件的查全率，算法的时间复杂度和空间复杂度是线性的，实验表明具有良好的查询效率．     

基于刻面描述的构件查询匹配模型及算法研究

在软件复用研究不断深入的情况下，软件构件库的管理研究得到了产业界与学术界越来越多的重视。作为构件库管理的两个核心技术，构件的表示与检索技术已经成为研究热点，其中基于刻面描达的构件相关应用得到了广泛研究，针对构件查询的特点，结合模式分析申的树匹配思想，本文提出了一种新颖的构件树路径包含匹配模型及其相应的构件查询匹配算法，该算法可以在保持构件查准率的前提下，有效提高构件的查全率，算法的时间复杂度和空间复杂度是线性的，试验表明具有良好的查询效率。     

Graph-based traceability: a comprehensive approach

In recent years, traceability has been globally accepted as being a key success factor of software development projects. However, the multitude of different, poorly integrated taxonomies, approaches and technologies impedes the application of traceability techniques in practice. This paper presents a comprehensive view on traceability, pertaining to the whole software development process. Based on the state of the art, the field is structured according to six specific activities related to traceability as follows: definition, recording, identification, maintenance, retrieval, and utilization. Using graph technology, a comprehensive and seamless approach for supporting these activities is derived, combining them in one single conceptual framework. This approach supports the definition of metamodels for traceability information, recording of traceability information in graph-based repositories, identification and maintenance of traceability relationships using transformations, as well as retrieval and utilization of traceability information using a graph query language. The approach presented here is applied in the context of the ReDSeeDS project (Requirements Driven Software Development System) that aims at requirements-based software reuse. ReDSeeDS makes use of traceability information to determine potentially reusable architectures, design, or code artifacts based on a given set of reusable requirements. The project provides case studies from different domains for the validation of the approach.     

刻面分类构件的匹配模型

随着软件复用实践的深入和软件构件库规模的扩大,对软件构件的表示与检索的研究正得到越来越多的重视.针对基于刻面描述的软件构件,结合模式分析中的树匹配思想,并根据构件刻面描述的特点,提出了一个包含3个层次,5种匹配类型的刻面匹配模型.给出了该匹配模型的泛型算法并对具化情况下的算法实现与时间复杂度进行了讨论.同时,通过理论和实践的结果证明了该匹配模型在构件检索上的可行性与有效性.     

An information retrieval approach for automatically constructingsoftware libraries

A technology for automatically assembling large software libraries which promote software reuse by helping the user locate the components closest to her/his needs is described. Software libraries are automatically assembled from a set of unorganized components by using information retrieval techniques. The construction of the library is done in two steps. First, attributes are automatically extracted from natural language documentation by using an indexing scheme based on the notions of lexical affinities and quantity of information. Then a hierarchy for browsing is automatically generated using a clustering technique which draws only on the information provided by the attributes. Due to the free-text indexing scheme, tools following this approach can accept free-style natural language queries     

基于语义与句法的Java类库检索方法与系统

提出了一个支持系统化、大规模软件复用的基于语义与句法的可复用模块的检索方法，并介绍了基于此方法支持Jwa类库的实用检索系统。软件开发者既可以使用自然语言直接描述待开发软件的功能语义并用此查询类库中的相关模块，也可以通过对输入输出数据类型的描述对Java类库进行快速地查询，还可以同时使用两者的组合来提高可复用库模块查询的精度。     

Software quality through domain-;driven certification

Software reuse is being pursued in an attempt to improve programmer productivity. The concept of reuse is to permit various work products of software development to be used on more than one project in order to amortize their development costs. Productivity is not the only advantage of reuse although it is the most widely publicized. By incorporating reusable components into a new product, the components bring with them whatever qualities they possess, and these can contribute to the quality of the new product. This suggests that reuse might be exploited for achieving quality as an entirely separate goal from improving productivity. If useful properties pertaining to quality could be shown to be present in products as a direct result of software development based on reuse, this might be a cost-;effective way of achieving those qualities irrespective of the productivity advantages. The adjective certified is sometimes used to describe components that have been tested in some way prior to entry into a library but the term certified is not formally defined in the reuse literature. In this paper, we address the issue of certifying reusable components. We advocate the development of software by reuse with the specific intent of establishing as many of the required properties in the final product as possible by depending upon properties present in the reusable components. For this goal to succeed, a precise definition of certification of reusable components is required and such a definition is presented. The benefits of the definition and the way in which it supports the goal are explored.     

Generic components for petascale adaptive unstructured mesh-based simulations

In the traditional programming paradigm, data structures and algorithms are developed for specific data types and requirements. This leads to code redundancy and inflexibility, thus not allowing effective code reuse for similar applications. One effective approach to increase code reuse is generic programming, which focuses on the development of efficient, reusable software libraries through suitable abstractions for the common requirements. In this paper, we present how we applied generic programming to an ongoing effort for mesh-based adaptive simulations on massively parallel computers. Three generic components, iterator, set and tag, were developed using design pattern, C++ template programming and the standard template library. The scaling studies on petascale supercomputers demonstrate the efficiency of the reusable, generic components which do not sacrifice the performance of the previous tools developed in the traditional object-oriented programming paradigm.     

SPARTACAS: automating component reuse and adaptation

A continuing challenge for software designers is to develop efficient and cost-effective software implementations. Many see software reuse as a potential solution; however, the cost of reuse tends to outweigh the potential benefits. The costs of software reuse include establishing and maintaining a library of reusable components, searching for applicable components to be reused in a design, as well as adapting components toward a proper implementation. We introduce SPARTACAS, a framework for automating specification-based component retrieval and adaptation that has been successfully applied to synthesis of software for embedded and digital signal processing systems. Using specifications to abstractly represent implementations allows automated theorem-provers to formally verify logical reusability relationships between specifications. These logical relationships are used to evaluate the feasibility of reusing the implementations of components to implement a problem. Retrieving a component that is a complete match to a problem is rare. It is more common to retrieve a component that partially satisfies the requirements of a problem. Such components have to be adapted. Rather than adapting components at the code level, SPARTACAS adapts the behavior of partial matches by imposing interactions with other components at the architecture level. A subproblem is synthesized that specifies the missing functionality required to complete the problem; the subproblem is used to query the library for components to adapt the partial match. The framework was implemented and evaluated empirically, the results suggest that automated adaptation using architectures successfully promotes software reuse, and hierarchically organizes a solution to a design problem.     

Rascal: A Recommender Agent for Agile Reuse

As software organisations mature, their repositories of reusable software components from previous projects will also grow considerably. Remaining conversant with all components in such a repository presents a significant challenge to developers. Indeed the retrieval of a particular component in this large search space may prove problematic. Further to this, the reuse of components developed in an Agile environment is likely to be hampered by the existence of little or no support materials. We propose to infer the need for a component and proactively recommend that component to the developer using a technique which is consistent with the principles of Agile methodologies. Our RASCAL recommender agent tracks usage histories of a group of developers to recommend to an individual developer components that are expected to be needed by that developer. Unlike many traditional recommender systems, we may recommend items that the developer has actually employed previously. We introduce a content-based filtering technique for ordering the set of recommended software components and present a comparative analysis of applying this technique to a number of collaborative filtering algorithms. We also investigate the relationship between the number of usage histories collected and recommendation accuracy. Our overall results indicate that RASCAL is a very promising tool for allowing developers discover reusable components at no additional cost     

Design reuse oriented partial retrieval of CAD models

As a huge number of 3D CAD models is generated each year, retrieval of 3D CAD models is becoming more and more important for achieving design reuse. However, the existing methods for partial retrieval of 3D CAD models are very few and far from the requirements of design reuse. In this paper, we present an approach to partial retrieval of 3D CAD models for design reuse. The criteria for determining whether a subpart of 3D CAD models is reusable for design is defined first. Based on the criteria defined, all the design reusable subparts involved in the 3D CAD models in the library are automatically extracted and stored in the library as reference models. Moreover, each design reusable subpart in the library is represented by all its local matching regions in a hierarchical way so as to support multi-mode partial retrieval. In our approach, three partial retrieval modes including normal retrieval, exact retrieval and relaxed retrieval are defined to meet various partial retrieval requirements of design reuse such as the incomplete and vague queries during the early design stage. And the multi-mode partial retrieval is achieved by performing multi-mode matching and similarity assessment between the query and the design reusable subparts in the library indexed by bitmap. Experimental results are presented to demonstrate the effectiveness of the approach.     

Supporting search for reusable software objects

Prior research has shown that achieving high levels of software reuse in the presence of repository and object-based computer-aided software engineering (CASE) development methods presents interesting human, managerial and technical challenges. This article presents research that seeks to enhanced software development performance through reuse. We propose automated support for developers who search large repositories for the appropriate reusable software objects. We characterize search for repository objects in terms of a multistage model involving screening, identification, and the subsequent choice between new object construction or reusable object implementation. We propose automated support tools, including ORCA, a software Object Reuse Classification Analyzer, and AMHYRST, an Automated HYpertext-based Reuse Search Tool, that are based on this model. ORCA utilizes a faceted classification approach that can be implemented using hypertext. We also describe an aspect of AMHYRST's architecture which can automatically create hypertext networks that represent and link objects in terms of a number of distinguishing features. We illustrate our approach with an example drawn from a real world object repository     

The Draco Approach to Constructing Software from Reusable Components

This paper discusses an approach called Draco to the construction of software systems from reusable software parts. In particular we are concerned with the reuse of analysis and design information in addition to programming language code. The goal of the work on Draco has been to increase the productivity of software specialists in the construction of similar systems. The particular approach we have taken is to organize reusable software components by problem area or domain. Statements of programs in these specialized domains are then optimized by source-to-source program transformations and refined into other domains. The problems of maintaining the representational consistency of the developing program and producing efficient practical programs are discussed. Some examples from a prototype system are also given.     

关于软件标本重用技术的研究

文中阐述了具有类Ａｄａ风格的软件标本重用的技术，阐明了标本重用的基本概念，途径及实现方法，提出将杯本作为重用库中的可重用单元，其重用途径是将部件作为重用参数，标本作为一种模板，实现重用的关键策略是通过预处理生成标本实例，同时，提出了重用库中的单元组成标准的建议。