Ali Mili

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. >

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.

Architectural-level risk analysis using UML

Risk assessment is an essential part in managing software development. Performing risk assessment during the early development phases enhances resource allocation decisions. In order to improve the software development process and the quality of software products, we need to be able to build risk analysis models based on data that can be collected early in the development process. These models will help identify the high-risk components and connectors of the product architecture, so that remedial actions may be taken in order to control and optimize the development process and improve the quality of the product. In this paper, we present a risk assessment methodology which can be used in the early phases of the software life cycle. We use the Unified Modeling Language (UML) and commercial modeling environment Rational Rose Real Time (RoseRT) to obtain UML model statistics. First, for each component and connector in software architecture, a dynamic heuristic risk factor is obtained and severity is assessed based on hazard analysis. Then, a Markov model is constructed to obtain scenarios risk factors. The risk factors of use cases and the overall system risk factor are estimated using the scenarios risk factors. Within our methodology, we also identify critical components and connectors that would require careful analysis, design, implementation, and more testing effort. The risk assessment methodology is applied on a pacemaker case study.

On the lattice of specifications: Applications to a specification methodology

In this paper we investigate the lattice properties of the natural ordering between specifications, which expresses that a specification expresses a stronger requirement than another specification. The lattice-like structure that we uncover is used as a basis for a specification methodology.

Storing and retrieving software components: a refinement based system

Software reuse poses a number of challenges, ranging from managerial to technical - not least of these is the problem of storing and retrieving software components in a time efficient manner. This paper presents the design and implementation of an automated software repository, where software components can be automatically stored and retrieved. This repository is based on a formal representation of programs and their specifications, as well as a refinement ordering of these specifications.<<ETX>>

Error propagation in software architectures

The study of software architectures is emerging as an important discipline in software engineering, due to its emphasis on large scale composition of software products, and its support for emerging software engineering paradigms such as product line engineering, component based software engineering, and software evolution. Architectural attributes differ from code-level software attributes in that they focus on the level of components and connectors, and that they are meaningful for an architecture. In this paper, we focus on a specific architectural attribute, which is the error propagation probability throughout the architecture, i.e. the probability that an error that arises in one component propagates to other components. We introduce, analyze, and validate formulas for estimating these probabilities using architectural level information.

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.

An integrated cost model for software reuse

Several cost models have been proposed in the past for estimating, predicting, and analyzing the costs of software reuse. The authors analyze existing models, explain their variance, and propose a tool-supported comprehensive model that encompasses most of the existing models.

Relational heuristics for the design of deterministic programs

SummaryIt has been shown that the design of deterministic programs can be formulated as the resolution of relational equations. Because relational calculi are not sufficiently structured, there are no algorithmic solutions to relational equations. In this paper, we formulate some heuristic solutions to these equations.

Integration of sequential scenarios

We give a formal relation-based definition of scenarios and we show how different scenarios can be integrated to obtain a more global view of user-system interactions. We restrict ourselves to the sequential case, meaning that we suppose that there is only one user (thus, the scenarios we wish to integrate cannot occur concurrently). Our view of scenarios is state-based, rather than event-based, like most of the other approaches, and can be grafted to the well-established specification language Z. Also, the end product of scenario integration, the specification of the functional aspects of the system, is given as a relation; this specification can be refined using independently developed methods. Our formal description is coupled with a diagram-based, transition-system like, presentation of scenarios, which is better suited to communication between clients and specifiers.