An empirical study of software reuse with special attention to Ada

Over the past several decades, numerous software technologies have been developed for overcoming the software crisis. Among these technologies, reuse has been recognized as one of the most important software technologies. Recently, it has gained substantial attention as a possible solution to the software crisis in Ada and other software communities. The purpose of this empirical study is to examine how organizations actually exploit reuse technologies and evaluates how reuse factors affect the rate of reuse in an organization. This study is an attempt to enhance the measurement of the rate of reuse and the effectiveness of reuse by establishing conceptual foundations in the literature for reuse and conducting an empirical investigation of organizations using Ada technology. This study differentiated software reuse into six criteria: domain, human, tool, organization, software metrics, and environment. The results of this study show that the rate of reuse significantly depends upon reuse capability, software development effort, object-oriented design capability, repository development effort, Ada technology capability, and domain capability     

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     

State restoration in Ada 95: a portable approach to supporting software fault tolerance

Studies indicate that techniques for tolerating hardware faults are so effective that software design errors are the leading cause of all faults encountered. To handle these unanticipated software faults, two main approaches have been proposed: N-version programming and recovery blocks. Both are based on the concept of design diversity: the assumption that different designs will exhibit different faults (if any) for the same inputs and will, therefore, provide alternatives for each other. Both approaches have advantages, but this paper focuses upon recovery blocks; specifically, the requirement to save and restore application state. Judicious saving of state has been described as “checkpointing” for over a decade. Using the object-oriented features of the revised Ada language (Ada 95) – a language widely used in this domain – we present three portable implementations of a checkpointing facility and discuss the trade-offs offered by each. Results of the implementation of these mechanisms are used to highlight both the strengths and weaknesses of some of the object-oriented features of Ada. We then show a reusable implementation of recovery blocks illustrating the checkpointing schemes. A performance analysis is made and measurements are presented in support of the analysis.     

Defining and validating measures for object-based high-level design

The availability of significant measures in the early phases of the software development life-cycle allows for better management of the later phases, and more effective quality assessment when quality can be more easily affected by preventive or corrective actions. We introduce and compare various high-level design measures for object-based software systems. The measures are derived based on an experimental goal, identifying fault-prone software parts, and several experimental hypotheses arising from the development of Ada systems for Flight Dynamics Software at the NASA Goddard Space Flight Center (NASA/GSFC). Specifically, we define a set of measures for cohesion and coupling, which satisfy a previously published set of mathematical properties that are necessary for any such measures to be valid. We then investigate the measures' relationship to fault-proneness on three large scale projects, to provide empirical support for their practical significance and usefulness     

Safety verification of Ada programs using software fault trees

The software fault-tree analysis technique is explained. It is then extended to allow its use on a more complex language involving such features as concurrency and exception handling. Ada is used as the example language because many safety-critical projects are using or planning to use Ada. It also contains complex, real-time programming facilities found in other languages used in these types of projects. Software fault-tree analysis uses failure-mode templates to generate the fault tree. The templates provided can be used to define the procedures for applying the technique to programs written in most other declarative languages. To explain the use of the templates an example Ada program, for a traffic-light-control system, is analyzed. The cost and practicality of the method and its implications for software reuse are assessed. The application of the safety analysis procedures to requirements modeling and specification languages is considered     

Automated object-oriented reusable component identification

An automated tool to assist in the understanding of legacy code can be useful both in the areas of software reuse and software maintenance. Most previous work in this area has concentrated on functionally-oriented code. Whereas object-oriented code has been shown to be inherently more reusable than functionally-oriented code, in many cases the eventual reuse of the object-oriented code was not considered during development. This paper describes an approach that makes preparing existing object-oriented code for reuse easier and more quantifiable. This problem includes two primary sub-problems: understanding the function of components, and applying an appropriate set of metrics to the components to quantify reusability.The research described in this paper addresses an approach to the automated understanding of object-oriented code. A knowledge-based system that implements the approach is described. This paper also briefly discusses the formulation of reusability metrics for object-oriented code.     

Cost models for future software life cycle processes: COCOMO 2.0

Current software cost estimation models, such as the 1981 Constructive Cost Model (COCOMO) for software cost estimation and its 1987 Ada COCOMO update, have been experiencing increasing difficulties in estimating the costs of software developed to new life cycle processes and capabilities. These include non-sequential and rapid-development process models; reuse-driven approaches involving commercial off-the-shelf (COTS) packages, re-engineering, applications composition, and applications generation capabilities; object-oriented approaches supported by distributed middleware; and software process maturity initiatives. This paper summarizes research in deriving a baseline COCOMO 2.0 model tailored to these new forms of software development, including rationale for the model decisions. The major new modeling capabilities of COCOMO 2.0 are a tailorable family of software sizing models, involving Object Points, Function Points, and Source Lines of Code; nonlinear models for software reuse and re-engineering; an exponentdriver approach for modeling relative software diseconomies of scale; and several additions, deletions and updates to previous COCOMO effort-multiplier cost drivers. This model is serving as a framework for an extensive current data collection and analysis effort to further refine and calibrate the model's estimation capabilities.     

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

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

Automating output size and reuse metrics in a repository-basedcomputer-aided software engineering (CASE) environment

Measurement of software development productivity is needed in order to control software costs, but it is discouragingly labor-intensive and expensive. Computer-aided software engineering (CASE) technologies-especially repository-based, integrated CASE-have the potential to support the automation of this measurement. We discuss the conceptual basis for the development of automated analyzers for function point and software reuse measurement for object-based CASE. Both analyzers take advantage of the existence of a representation of the application system that is stored within an object repository, and that contains the necessary information about the application system. We also discuss metrics for software reuse measurement, including reuse leverage, reuse value, and reuse classification that are motivated by managerial requirements and the efforts, within industry and the IEEE, to standardize measurement. The functionality and the analytical capabilities of state-of-the-art automated software metrics analyzers are illustrated in the context of an investment banking industry application that is similar to systems deployed at the New York City-based investment bank where these tools were developed and tested     

μC++: Concurrency in the object-oriented language C++

We present a design, including its motivation, for introducing concurrency into C++. The design work is based on a set of requirements and elementary execution properties that generate a corresponding set of programming language constructs needed to express concurrency. The new constructs continue to support object-oriented facilities such as inheritance and code reuse. Features that allow flexibility in accepting and subsequently postponing servicing of requests are provided. Currently, a major portion of the design is implemented, supporting concurrent programs on shared-memory uniprocessor and mulitprocessor computers.     

支持地球科学的软件复用(英文)

地球科学研究中数据的准备、分发、访问、处理和分析都依赖于计算机软件。科学结果的重复通常需要复用同样的软件。同样,科学数据的有效分发、访问或者分析也都需要进行软件复用。地球科学软件开发社区已经意识到了软件复用的价值,并且在社区内大力鼓励和培育软件复用。因此,他们成立了 NASA 地球科学数据系统( ESDS) 软件复用工作组( WG) 来支持社区成员之间的软件复用。工作组开发了软件复用门户来发布软件复用相关的信息、资源,并且提供培训来提高和改进整个社区的软件复用实践。工作组还开发了一个复用支持系统( RES) 原型系统来支持可复用软件的访问。此外, 工作组还制定了复用成熟度级别, 从而提高了评估和选择可复用软件的能力。     

关于Ada并发可重用软件包的设计

文中首先分析了一般Ａｄａ顺序可重用软件包在用于开发Ａｄａ并发软件时所存在的问题，然后给出了几种可以支持并发软件开发的Ａｄａ可重用软件包的实现方案，并同时指出了各种方案的不足及可取之处。     

Object-extending class transformations

Reorganisation and evolution of class hierarchies is important for object-oriented system development and has received considerable attention in the literature. The contributions of this paper are: (1) a formal study of a set of extension relations and transformations on class hierarchies; (2) a presentation of a small set of primitive transformations which form a minimal and complete basis for the extension relations; and (3) an analysis of the impact of these transformations at the object level.The study leads to a better understanding of evolution and reuse of object-oriented software and class hierarchies. It also provides a terminology and a means of classification for design reuse. The theory presented in this paper is based on the Demeter data model, which gives a concise mathematical foundation for classes and their inheritance and part-of relationships. Parts of the theory have been implemented in the Demeter System ^TM C++, a CASE tool for object-oriented design and programming.     

Beauty and the Beast: on the readability of object-oriented example programs

Some solutions to a programming problem are more elegant or more simple than others and thus more understandable for students. We review desirable properties of example programs from a cognitive and a measurement point of view. Certain cognitive aspects of example programs are captured by common software measures, but they are not sufficient to capture a key aspect of understandability: readability. We propose and discuss a simple readability measure for software, SRES, and apply it to object-oriented textbook examples. Our results show that readability measures correlate well with human perceptions of quality. Compared with other readability measures, SRES is less sensitive to commenting and whitespace. These results also have implications for software maintainability measures.     

DocLine: A method for software product lines documentation development

The DocLine method designed for developing documentation for software product lines is presented. The method makes it possible to reuse document fragments with adaptation to a particular usage context. The method provides the Documentation Reuse Language (DRL) that has a graphical part (for designing the structure of documentation packages) and a text part (for implementing the documentation). It also describes a process for developing documentation and a toolset architecture based on the DSM approach and Eclipse GMF technology.     

The impact of software evolution and reuse on software quality

This paper presents a case study of a software project in the maintenance phase. The case study was based on a sample of modules, representing about 1.3 million lines of code, from a very large telecommunications system. Software quality models were developed to predict the number of faults expected from the coding through operations phases. Since modules from the prior release were often reused to develop a new release, one model incorporated reuse data as additional independent variables. We compare this model's performance to a similar model without reuse data.Software quality models often have product metrics as the only input data for predicting quality. There is an implicit assumption that all the modules have had a similar development history, so that product attributes are the primary drivers of different quality levels. Reuse of software as components and software evolution do not fit this assumption very well, and consequently, traditional models for such environments may not have adequate accuracy. Focusing on the software maintenance phase, this study demonstrated that reuse data can significantly improve the predictive accuracy of software quality models.     

浅析软件复用技术

软件复用是将已有的软件及其有效成分用于构造新的软件或系统软件,是提高软件质量和生产效率的的基本途径。本文主要介绍软件复用的基本概念、分类,软件复用技术以及基于复用的软件开发过程。     

从源程序中获取可重用构件—对象和类

软件重用被广泛地认为是提高软件生产率和质量的关键。面向对象方法中的对象类是一种很好的可重用构件形式。为了快速获取和积累可重用构件，本文研究从源程序中获取对象类的问题，提出了一套较完整的从命令式语言程序中获取对象类的方法和规则。该方法能够从被分析的软件中提取尽可能多的可重用性较好的大粒度和小粒度的对象类。     

A case-based approach to software reuse

This software reuse system helps a user build programs by reusing modules stored in an existing library. The system, dubbed caesar (Case-basEd SoftwAre Reuse), is conceived in the case-based reasoning framework, where cases consist of program specifications and the corresponding C language code. The case base is initially seeded by decomposing relevant programs into functional slices using algorithms from dataflow analysis. caesar retrieves stored specifications from this base and specializes and/or generalizes them to match the user specification. Testing techniques are applied to the construct assembled by caesar through sequential composition to generate test data which exhibits the behavior of the code. For efficiency, inductive logic programming techniques are used to capture combinations of functions that frequently occur together in specifications. Such combinations may be stored as new functional slices.