Ellis Horowitz

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 models estimation capabilities.

Abstract data types and software validation

A data abstraction can be naturally specified using algebraic axioms. The virtue of these axioms is that they permit a representation-independent formal specification of a data type. An example is given which shows how to employ algebraic axioms at successive levels of implementation. The major thrust of the paper is twofold. First, it is shown how the use of algebraic axiomatizations can simplify the process of proving the correctness of an implementation of an abstract data type. Second, semi-automatic tools are described which can be used both to automate such proofs of correctness and to derive an immediate implementation from the axioms. This implementation allows for limited testing of programs at design time, before a conventional implementation is accomplished.

Computing Partitions with Applications to the Knapsack Problem

Given <italic>r</italic> numbers <italic>s</italic><subscrpt>1</subscrpt>, ···, <italic>s<subscrpt>r</subscrpt></italic>, algorithms are investigated for finding all possible combinations of these numbers which sum to <italic>M</italic>. This problem is a particular instance of the 0-1 unidimensional knapsack problem. All of the usual algorithms for this problem are investigated in terms of both asymptotic computing times and storage requirements, as well as average computing times. We develop a technique which improves all of the dynamic programming methods by a square root factor. Empirical studies indicate this new algorithm to be generally superior to all previously known algorithms. We then show how this improvement can be incorporated into the more general 0-1 knapsack problem obtaining a square root improvement in the asymptotic behavior. A new branch and search algorithm that is significantly faster than the Greenberg and Hegerich algorithm is also presented. The results of extensive empirical studies comparing these knapsack algorithms are given

Exact and Approximate Algorithms for Scheduling Nonidentical Processors

Exact and approximate algorithms are presented for scheduling independent tasks in a multiprocessor environment in which the processors have different speeds. Dynamic programming type algorithms are presented which minimize finish time and weighted mean flow time on two processors. The generalization to m processors is direct. These algorithms have a worst-case complexity which is exponential in the number of tasks. Therefore approximation algorithms of low polynomial complexity are also obtained for the above problems. These algorithms are guaranteed to obtain solutions that are close to the optimal. For the case of minimizing mean flow time on m-processors an algorithm is given whose complexity is O(n log mn).

Software Requirements Negotiation and Renegotiation Aids: A Theory-W Based Spiral Approach

A major problem in requirements engineering is obtaining requirements that address the concerns of multiple stakeholders. An approach to such a problem is the Theory-W based Spiral Model. This paper focuses on the problem of developing a support system for such a model. In particular it identifies needs and capabilities required to address the problem of negotiation and renegotiation that arises when the model is applied to incremental requirements engineering. The paper formulates elements of the support system, called WinWin, for providing such capabilities. The key elements of WinWin are described and their use in incremental requirements engineering are demonstrated, using an example renegotiation scenario from the domain of software engineering environments, for satellite ground stations.

An Expansive View of Reusable Software

The present crisis in software development forces us to reconsider the fundamental ways in which programming is done. One often quoted solution is to exploit more fully the idea of reusable software. It is the purpose of this paper to examine this concept in all of its forms and to assess the current state of the art. In addition to its usual meaning of reusable code, reusability includes reusable design, various forms of specification systems. so-called application generators, and systems for prototyping. We examine each approach from the perspective of the practicing engineer, and we evaluate the work in terms of how it may ultimately improve the development process for large-scale software systems.

A linear time approximation algorithm for multiprocessor scheduling

Givenn jobs andm identical processors anO(n) approximation algorithm is presented which tries to determine a nonpreemptive schedule with minimum finish time. Ifr is the number of jobs placed onto the processor with maximum finish time, then the worst case ratio of the new algorithms finish time to the optimal solution is shown to be less thanrm/(rm−m+1). Extensive empirical results show that the new algorithm is competitive with the LPT algorithm in terms of quality of solution and faster in terms of computing time.

A Formal Model for Software Project Management

Absfraet-A model called DesignNet for describing and monitoring the software development process is presented. This model utilizes the AND/OR graph and Petri net notation to provide the description of a project work breakdown structure and the specification of relationships among different project information types (activity. product, resource, and status report information). Tokens are objects with specific properties. Token propagation through structural links allows aggregate information to be collected automatically at different levels of detail. The transition firing is a nonvolatile process and creates new token instances with time dependent information. The typed places, together with connections among them, defines the static construct of a project. Whenever transitions are fired, the project execution history is recorded by the token instances created. Using the model, we have provided definitions for basic properties of a successful project, namely connectedness, plan complete, plan consistent, and well-executed. We have given algorithms for computing these functions and shown that the computing time is linear in the size of the project. This assures that any system based on DesignNet should be able to compute these functions efficiently. Flnally. we have shown how the waterfall We cycle model maps onto a DesignNet and the implications for project planning, cost estimation, project network construction, reinitiation of activities, and traceability across the life cycle. Other life cycle models can be equally treated.

SODOS: A software documentation support environment — Its definition

A description is given of the data abstraction mechanisms used in SODOS (software documentation support), a computerized system which supports the definition and manipulation of documents used in developing software. The generic definition of a document is given, the operations of consistency, completeness, and traceability are defined precisely, and it is shown how the generic document and associated operations are mapped onto the relational model. The SODOS system differs from others in that it is built on top of a database management system and an object-based model of the software life cycle. One advantage of this model is that it supports software documentation independently of any fixed methodology that the developers may be using. Another advantage of the system is that it permits traceability through all phases of the software life cycle, thus facilitating the testing and maintenance phases. The document representation is defined in terms of a graph model mapped into a relational data model.

A survey of Application Generators

By encouraging the unsophisticated computer user to develop his own dataintensive programs, application generators can significantly improve software productivity.