Frank W. Calliss

Problems with determining package cohesion and coupling

The cohesion and coupling guidelines described by Yourdon, Constantine and Myers have proved useful aids for the design of modular programs. They have also provided direction for the evaluation of existing modules, pointing to those candidates for restructuring during perfective maintenance. For languages like Ada, where support for a higher‐level of abstraction is provided in the form of a package, subprogram heuristics are inadequate. This paper examines existing guidelines and taxonomies for the Ada package and proposes extensions to these schemes. These package‐level schemes are applied in a case study of an existing Ada program.

The application of deductive databases to inter-module code analysis

Intermodule code analysis is a process by which a programmer can analyze a program consisting of a collection of interconnected modules. A deductive database that records the information needed for intermodule code analysis is presented. The application of a deductive database to this domain utilizes the rule capability for data structuring and facilitates the declarative specification of recursive operations. This deductive database was derived from a conceptual schema, which describes the dependencies that exist in a program. A method for mapping a conceptual schema to a deductive database framework is outlined. An example query is used to show how this database can be used for intermodule code analysis.<<ETX>>

Preliminary hazard analysis for safety-critical software systems

The authors identify strategies for conducting preliminary software hazard analysis, which includes software hazard identification, documentation, and review. The goal for such strategies is to improve a systems overall safety by increasing the hazard lists completeness, correctness, and preciseness. Along with presenting these strategies, a framework is introduced for applying them to safety-critical software development. Before explaining the framework and its related strategies, relevant background issues that relate to safety are discussed.<<ETX>>

A comparison of module constructs in programming languages

Modules are constructs that help implement the principle of information hiding. Some languages provide general purpose modules, while others provide modules that are more specialised. This paper compares the modules that are provided by some languages.

An information-hiding metric

Abstract The most critical problem facing developers and maintainers of large software systems is overwhelming complexity. Abstraction, a powerful tool for dealing with complexity, limits details that must be considered to those that are most relevant. Programming languages have evolved to provide a high-level construct, called a module or a class, that supports abstraction by allowing the encapsulation of details and enforcing information hiding. Programs written in these modular programming languages should be designed to produce programs that are easier to understand, modify, and test. This article describes the creation of metrics for information hiding at the module level. The relationship between the information-hiding metrics and the maintainability of programs is examined by use of subjective validation and a case study of a large Ada program.

A Controlled Software Maintenance Project

A group project is presented that introduces students to the need for inter-group communication and controlled work on an evolving program. The project concentrates on the maintenance phase of the software lifecycle and gives students experience in configuration management, version control and software management.

An outline for a software maintenance course

The author briefly discusses the course structure for the graduate software maintenance course offered at Arizona State University. Introduction to software maintenance, forms of maintenance, reverse engineering and re-engineering, maintenance models, and maintenance personnel are the topics examined.<<ETX>>

An experiment investigating the effect of information hiding on maintainability

An experiment was conducted to investigate the effects of different levels of information hiding on maintainability. Two versions of an Ada program where created. Each version contained a set of modules with good information hiding and a set with poor information hiding. Subjects were given one of two versions of an Ada program and two modifications to perform. One modification was performed on the well-designed set of modules and one on the poorly-designed set. The results show that sections of the programs with good information hiding do not suffer structural decay as a result of the modification and that sections with poor information hiding are improved in approximately two-thirds of the new versions. These results are especially notable considering that the programmers were, for the most part, unfamiliar with Ada and object-oriented design.<<ETX>>

DESIGNING KNOWLEDGE-BASE TOOLS FOR PROGRAM COMPREHENSION: A COMPARISON OF EDATS & IMCA

Since software engineers spend a large proportion of their time trying to understand computer programs, many tools have been proposed to help them with this task. The construction of such tools raises a series of specification and design issues and requires a careful choice among alternative user interfaces, tool architectures, and knowledge representations. This paper discusses the information needs of software engineers and describes and compares two such tools, the Extensible Dependency Analysis Tool Set (EDATS) and the Inter-Module Code Analysis system (IMCA). A case study is presented showing how each tool would be used to support typical program comprehension tasks. Though the two tools have quite similar objectives, their designs are radically different, leading to interesting contrasts in flexibility and ease of use.

Using deductive databases to facilitate the maintenance process

This paper focuses on how the novel integration of intermodule code analysis (IMCA) and deductive database (DD) technology facilitates program understanding and the software maintenance process. Specifically, we describe the implementation of IMCA for the object-based language Ada using the CORAL deductive database system. Since we have future plans to look at other languages and emerging database technologies, we call this implementation IMCA/sub DD//sup Ada/. Specifically, we describe in more detail the architectural issues of IMCA/sub DD//sup Ada/ and its implementation in the CORAL deductive database system, including the detailed schema of the facts and rules. A non-trivial code analysers example illustrates how the flexibility and extendibility of IMCA/sub DD//sup Ada/ facilitates the maintenance process, highlighting the advantages offered by the declarative technology.<<ETX>>