Success factors of systematic reuse

Systematic software reuse is a paradigm shift in software engineering from building single systems to building families of related systems. The goal of software reuse research is to discover systematic procedures for engineering new systems from existing assets. Implementing systematic reuse is risky. Not doing it is also risky. Trying systematic reuse unsuccessfully can cost precious time and resources and may make management sceptical of trying it again. But if your competitors do it successfully and you do not, you may lose market share and possibly an entire market. There is no cookbook solution-each organization must analyze its own needs, implement reuse measurements, define the key benefits it expects, identify and remove impediments, and manage risk. Reliable data on how much this costs and the benefits an organization will derive are insufficient. The article addresses issues from management, measurement, law, economics, libraries, and the design of reusable software     

A reuse business model

This paper summarizes the decision framework for forming reuse business models and offers the Expert Services Model as a preferred first application of that framework. The Expert Services Model is only one possible approach, but one that we found is a good starting point. The framework for setting up a reuse plan consists of four major steps: define reuse, populate a library of reusable assets, share reusable assets, and maintain reusable assets.     

以项目为中心的面向对象复用支持

现有的软件复用技术通常是围绕着库来组织利用标准的和通用的可复用资源.例如,面向对象编程环境中的类库和通用构件库.然而,这种以库为中心的复用方式在一定程度上忽略了可复用资源的项目相关信息,而项目相关信息记录了可复用资源的应用语境(Application Context).应用语境有利于可复用资源的理解和使用.为此,提出了一种围绕着一个项目的文档来组织和利用可复用资源的复用途径,即以项目为中心的文档复用,用以支持在相同应用领域中一族软件的开发.探讨了当前的面向对象方法在支持文档复用方面的一些局限性,提出了一种     

Towards a formal framework for software reuse

It is reasonable to expect that the use of formal methods in software reuse will help improve the practice of this discipline as well as enhance our understanding of its products and processes. We have identified the following technical activities that take place in software reuse as candidates for a formal modeling: representing reusable assets, representing reuse queries, defining matching criteria, defining a storage structure, deriving measures of distance and deriving a calculus of program modification. In this paper we discuss how a simple mathematical model based on set theory and relation theory allows us to capture these activities in a unified, coherent framework.     

Building enterprise reuse program

Reuse is viewed as a realistically effective approach to solving software crisis. For an organization that wants to build a reuse program, technical and non-technical issues must be considered in parallel. In this paper, a model-based approach to building systematic reuse program is presented. Component-based reuse is currently a dominant approach to software reuse. In this approach, building the right reusable component model is the first important step. In order to achieve systematic reuse, a set of component models should be built from different perspectives. Each of these models will give a specific view of the components so as to satisfy different needs of different persons involved in the enterprise reuse program. There already exist some component models for reuse from technical perspectives. But less attention is paid to the reusable components from a non-technical view, especially from the view of process and management. In our approach, a reusable component model—FLP model for reusable component—is introduced. This model describes components from three dimensions (Form, Level, and Presentation) and views components and their relationships from the perspective of process and management. It determines the sphere of reusable components, the time points of reusing components in the development process, and the needed means to present components in terms of the abstraction level, logic granularity and presentation media. Being the basis on which the management and technical decisions are made, our model will be used as the kernel model to initialize and normalize a systematic enterprise reuse program.     

Effects of reuse on quality, productivity, and economics

This article presents metrics from two Hewlett-Packard (HP) reuse programs that document the improved quality, increased productivity, shortened time-to-market, and enhanced economics resulting from reuse. Work products are the products or by-products of the software-development process: for example, code, design, and test plans. Reuse is the use of these work products without modification in the development of other software. Leveraged reuse is modifying existing work products to meet specific system requirements. A producer is a creator of reusable work products, and the consumer is someone who uses them to create other software. Time-to-market is the time it takes to deliver a product from the time it is conceived. Experience with reuse has been largely positive. Because work products are used multiple times, the accumulated defect fixes result in a higher quality work product. Because the work products have already been created, tested, and documented, productivity increases because consumers of reusable work products need to do less work. However, increased productivity from reuse does not necessarily shorten time-to-market. To reduce time-to-market, reuse must be used effectively on the critical path of a development project. Finally, we have found that reuse allows an organization to use personnel more effectively because it leverages expertise. However, software reuse is not free. It requires resources to create and maintain reusable work products, a reuse library, and reuse tools. To help evaluate the costs and benefits of reuse, we have developed an economic analysis method, which we have applied to multiple reuse programs at HP     

Toward an engineering discipline of software reuse

This article stems from a panel session at the 1997 Symposium on Software Reusability, and discusses open research issues, classified by goal and by approach. Software development cannot possibly become an engineering discipline so long as it has not perfected a technology for developing products from reusable assets in a routine manner, on an industrial scale. Software reuse cannot, in turn, achieve this status unless we make the following provisions: a sound scientific foundation that encompasses relevant design principles, widely acceptable engineering standards that compile these principles into working practical solutions, and coherent managerial standards that enable the deployment of these solutions under acceptable conditions of product quality and process maturity. Although successful software reuse experiments are increasingly common, success is not the norm, software reuse is not a matter of routine practice, the promises of software reuse remain for the most part unfulfilled, and a number of issues remain worthy of further research     

Building enterprise reuse program——A model-based approach

Reuse is viewed as a realistically effective approach to solving software crisis. For an organization that wants to build a reuse program, technical and non-technical issues must be considered in parallel. In this paper, a model-based approach to building systematic reuse program is presented. Component-based reuse is currently a dominant approach to software reuse. In this approach, building the right reusable component model is the first important step. In order to achieve systematic reuse, a set of component models should be built from different perspectives. Each of these models will give a specific view of the components so as to satisfy different needs of different persons involved in the enterprise reuse program. There already exist some component models for reuse from technical perspectives. But less attention is paid to the reusable components from a non-technical view, especially fromthe view of process and management. In our approach, a reusable component model--FLP modelfor reusable component     

Assessing the cost-effectiveness of software reuse: A model for planned reuse

Information systems development is typically acknowledged as an expensive and lengthy process, often producing code that is of uneven quality and difficult to maintain. Software reuse has been advocated as a means of revolutionizing this process. The claimed benefits from software reuse are reduction in development cost and time, improvement in software quality, increase in programmer productivity, and improvement in maintainability. Software reuse entails undeniable costs of creating, populating, and maintaining a library of reusable components. There is anecdotal evidence to suggest that some organizations benefit from reuse. However, many software developers practicing reuse claim these benefits without formal demonstration thereof. There is little research to suggest when the benefits are expected and to what extent they will be realized. For example, does a larger library of reusable components lead to increased savings? What is the impact of component size on the effectiveness of reuse? This research seeks to address some of these questions. It represents the first step in a series wherein the effects of software reuse on overall development effort and costs are modeled with a view to understanding when it is most effective.     

A multi-level analysis of factors affecting software developers’ intention to reuse software assets: An empirical investigation

Reuse of software assets in application development has held promise but faced challenges. In addressing these challenges, research has focused on organizational- and project-level factors while neglecting grass-root level adoption of reusable assets. Our research investigated factors associated with individual software developers’ intention to reuse software assets and integrated them in TAM. Towards that end, 13 project managers were interviewed and 207 software developers were surveyed in India. Results revealed that the technological-level (infrastructure), and individual-level factors (reuse-related experience and self-efficacy) were major determinants. Implications are discussed.     

A survey of software reuse libraries

The study of storage and retrieval methods of software assets in software libraries gives rise to a number of paradoxes: While this subject has been under investigation for nearly two decades, it still remains an active area of research in software reuse and software engineering; this can be explained by the observation that new technologies (such as the internet, the world wide web, object-;oriented programming) keep opening new opportunities for better asset packaging, better library organizations, and larger scale libraries – thereby posing new technical challenges. Also, while many sophisticated solutions have been proposed to this problem, the state of the practice in software reuse is characterized by the use of ad-;hoc, low-;tech methods; this can be explained by the observation that most existing solutions are either too ineffective to be useful or too intractable to be usable. Finally, while it is difficult to imagine a successful software reuse program without a sophisticated, well-;tuned, systematic procedure for software component storage and retrieval, it seems many successful software reuse experiments rely on trivial methods of component storage and retrieval; this can be explained by the observation that, in the current state of the practice, software libraries are not the bottleneck of the software reuse process. This paper presents a survey of methods of storage and retrieval of software assets in software libraries. In addition to a review of existing research efforts, the paper makes two contributions. First, a definition of (presumably) orthogonal attributes of storage and retrieval methods; these attributes are used, in turn, to classify existing methods into six broad classes. Second, a definition of (presumably) orthogonal assessment criteria, which include technical, managerial and human factors; these criteria afford us an exhaustive and uniform basis for assessing and comparing individual methods and classes of methods.     

Software reuse through re-engineering the legacy systems

Software reuse is widely considered to be a way to increase the productivity and improve the quality and reliability of new software systems. Identifying, extracting and re-engineering software components that implement abstractions within existing systems is a promising cost-effective way to create reusable assets and re-engineer legacy systems. This paper summarizes our experiences with using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. In this effort, we have developed an object-oriented architecture for the Janus Combat Simulation Subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the reuse of the software components of the legacy systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.     

Feature‐based approach to object‐oriented engineering of applications for reuse

Object‐oriented technology is gaining popularity among software engineers with the goal of building reusable and adaptable software. Unfortunately, however, most methods introduced so far are not domain‐oriented and do not address the issue of reuse directly. For these methods, software reuse is not the primary goal; it is only a by‐product. The feature‐oriented reuse method, FORM, is extended in this paper for improving the object‐oriented engineering of applications for reuse. FORM concentrates on analyzing and modeling commonalities and differences in the applications of a given domain in terms of capability, operating environment, domain technology, and implementation technique features. These features are used to systematically derive objects that are tied to the features, and to develop reusable and adaptable domain architectures. We found that FORM facilitates analysis of variability (and commonality) of software before engineering and implementation start, and with this understanding, adaptability and reusability can be built into software. Feature modeling has been found to be an effective method for identifying and modeling reusable objects. Copyright © 2000 John Wiley & Sons, Ltd.     

Saving reuse from the noose: reuse of analogous specifications through human involvement in reuse process

Analogy is proposed as an alternative paradigm for the reuse of specifications during requirements analysis. First, critical determinants of analogies between software engineering problems are discussed in relation to a specification retrieval mechanism. Second, the process of specification reuse is examined. Specification reuse by analogy is knowledge-intensive, hence an important role is proposed for the analyst during specification reuse: analyst involvement would appear necessary to categorize a new problem, select between candidate reusable specifications, and customize the selected specification to the new domain. Finally, a specification reuse tool is proposed that recognises the collaborative nature of reuse by analogy. This tool assists and advises the analyst during reuse founded on cognitive models of analyst behaviour during analogous reasoning and reuse. The prototype version of this intelligent reuse advisor (Ira) is outlined.     

Architecture-driven component reuse

The evolution of software reuse over the last 30 plus years is drawn upon to show current achievements, a stable model of components, an approach to reusing components based on architectures, an appreciation of human and organisational problems in reuse, accumulating evidence for the value of reuse approaches. The shortfalls of some current OO methods are pointed out. The significance and limitations of software reuse is indicated by situating it in the wider context of learning organisations and knowledge management, and by viewing architecture-driven reuse as routine design. The distinct role of patterns is indicated.     

面向复用的测试设计模型的研究与实现

本文讨论了测试复用的模型和方法．在对测试设计中的可复用资产及其可复用性进行了深入分析之后，提出了一种面向复用的软件测试设计模型ROTDM．该模型定义了测试的概念模型。抽象并提取了不同颗粒度的可复用测试资产，支持引用、组装和继承等测试复用方法．在此基础上，论文讨论了基于该模型的测试设计脚本以及基于XML的数据交换，并介绍了模型实现工具的设计与实现，最后给出了测试设计复用的实验结果．     

Module reuse by interface adaptation

This paper describes a language called Nimble that allows designers to declare how the actual parameters in a procedure call are to be transformed at run time. Normally, programmers must edit an application's source in order to adapt it for reuse in some new context where the interfaces fail to match exactly (e.g. the parameters may appear in a different order, data types may not exactly match, and some data may need to be either initialized or masked out when the reusable module is integrated within a new application.) But Nimble allows programmers to adapt the interfaces of existing software without having to operate on the source manually. As a result, existing software may be easily reused in a broader range of applications, and software libraries do not need to store many variants of a component that differ only in how the interfaces are used. Nimble has been implemented on a variety of Unix hosts, and is part of a broader reuse project at the University of Maryland. Our current system is suitable for use either in conjunction with existing module interconnection languages, or stand-alone with C, Pascal and Ada source programs.     

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

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