Programming methodology,organizational environment,and programming productivity

Programming data involving 278 commercial-type programs were collected from 23 medium- to large-scale organizations in order to explore the relationships among variables measuring program type, the testing interface, programming technique, programmer experience, and productivity. Programming technique and programmer experience after 1 year were found to have no impact on productivity, whereas on-line testing was found to reduce productivity. A number of analyses of the data are presented, and their relationship to other studies is discussed.     

Software complexity metric sensitivity to program structuring rules

Several studies have appeared in recent years examining the sensitivity of standard software complexity metrics to common rules of program structuring. In most cases, these studies found support for the use of certain metrics as indices of program quality as represented by program structure. In the research described in this paper, a broader analysis of metric sensitivity to the structuring rules was conducted. The conclusions reached differ greatly from those previously advocated in the literature; i.e., the metrics under consideration are shown to be relatively insensitive to program structure.     

Status and outlook for DoD configuration management requirements

Since the release of Department of Defense (DoD) Directive 5000.29, “Management of Computer Resources in Major Defense Systems,” 26 April 1976, a significant increase in interest and emphasis on software configuration management has occurred. A review of the current status of configuration management within the DoD computer resources management environment is provided, and some predictions on future configuration management activities are offered.     

The evolution of the GANDALF system

The GANDALF System is used to generate highly interactive software development environments. This paper describes some design decisions made during the development of the GANDALF system and the system's applicability to the generation of single-user programming environments and multi-user software development environments.     

A study of several metrics for programming effort

As the cost of programming becomes a major component of the cost of computer systems, it becomes imperative that program development and maintenance be better managed. One measurement a manager could use is programming complexity. Such a measure can be very useful if the manager is confident that the higher the complexity measure is for a programming project, the more effort it takes to complete the project and perhaps to maintain it. Until recently most measures of complexity were based only on intuition and experience. In the past 3 years two objective metrics have been introduced, McCabe's cyclomatic number v(G) and Halstead's effort measure E. This paper reports an empirical study designed to compare these two metrics with a classic size measure, lines of code. A fourth metric based on a model of programming is introduced and shown to be better than the previously known metrics for some experimental data.     

Flow: A software development environment using diagrams

The multiuser software development system FLOW uses a diagrammatic language, FLOW-DL, to represent the system under development. Once a module has been keyed in, one of three post-processors is called to generate source code in Pascal, Fortran, or Cobol. A fourth post-processor generates documentation. The system also includes a syntax-directed editor, as well as a software production data base which holds the FLOW-DL source code, interface data relating to the program modules, and control information pertaining to the state of the system under development. The package is portable; a graphics terminal is not required. Versions of the production system have been used for the past 4 years to develop a number of medium-sized software systems.     

An improved block sequencing method for program restructuring

The execution performance of a program in a virtual memory system is highly dependent on its internal organization. There are several program tools available for reorganizing a program to improve its paging performance. This paper critically analyzes some of the methods in use and proposes a new approach that is experimentally shown to produce better results.     

A methodology to model the information structure of an organization

The Integrated Computer Aided Manufacturing (ICAM) program of the U.S. Air Force identified a need to better communicate and analyze manufacturing for the people involved in improving productivity. To satisfy that need, the ICAM program developed the IDEF (ICAM Definition) method to address particular characteristics of manufacturing. This IDEF method is equally applicable in analyzing other types of organizations. IDEF comprises three modeling methodologies: function model methodology (IDEF₀), information model methodology (IDEF₁) and dynamics model methodology (IDEF₂). This paper reports on the Information model methodology only. This methodology is used to construct an information model that helps in understanding the structure of information needed to support the functions of an organization.     

The GANDALF project

The GANDALF project is concerned with the automated generation of software development environments. In particular, the project has considered project management environments, system version control environments, and incremental programming environments. The artifacts surrounding these environments are described. Later versions of these environments have been constructed as structure editors. The processes and tools involved in generating structure editors for software development environments are also discussed. Future plans of the project are briefly mentioned.     

Module size: A standard or heuristic?

Current and proposed national software development specifications include module size limits in the form of an upper bound per module and an average for a group of modules. This paper claims that commonly specified limits such as 200 executable source statements have little practical value for programmers, and that the limits have not been validated. Module size guidelines based on corresponding complexity are derived for identifying extremly long modules, and are recommended for use by software quality engineers in monitoring development methodologies and by test engineers during preacceptance testing. Finally, research to derive a lower bound guideline for module size is recommended.     

Correct: A simulated text editor

This paper describes a project to write a simulator for the native mode text editor of one computer, which could be run on a different computer. This was done to give a user of both computers a common editing language. The method of design and construction is presented together with brief details of the syntax and semantics of the editing language.     

Automatic generation of execution tools in a GANDALF environment

The formal definition of a programming language in denotational style is taken as the basis for the automatic generation of its interpreter. The facilities available in GANDALF are exploited to implement and integrate such a generation technique in a GANDALF environment.     

Automatic deletion of obsolete information

Information generated in a programming environment is often allowed to grow indefinitely. Designer and user alike are counting on standard backup and disc clearing procedures for archiving old data. In this paper we take the view that one should distinguish between relevant old data that is purposely archived and obsolete information that should automatically be deleted. The two main topics of the paper are the strategies and mechanisms for deleting information and the facilities available to designers of programming environments to specify deletion strategies. Information can be deleted applying a passive or an active strategy. With the passive strategy, information will not actually be deleted until it is certain that there is no interest in it any longer. With the active strategy, an object is immediately deleted when it becomes obsolete, while users of the object are notified of the deletion event. The paper discusses various implementations for these two strategies and shows when they apply. Taking the view that it must be easy to modify and fine tune programming environments, much attention must be given to the designer's support environment for generating programming environments. The paper discusses in particular the facilities for expressing the semantics of names in an environment. Various naming modes are useful for a designer to specify the deletion strategies for his target programming environment. Details are illustrated by applying the ideas to an environment for software development and maintenance.     

Implementation of computing standards

The F-16 avionics implements what is likely the broadest application of standards of any USAF weapon system. Standards available in 1976 were applied which consisted of the MIL-STD-1553 Multiplex Data Bus, JOVIAL J3B which was the defacto software and precursor to JOVIAL J73 dialect and the MIL-STD-490 software documentation standard. These standards were instrumental in making the F-16 a very successful program. The F-16 avionic system is now being greatly expanded to accommodate advanced sensors and weapons currently in USAF funded development. Once again the F-16 is at the forefront in implementing the latest USAF standards. A key feature of the enhanced avionics is the application of JOVIAL J73 (MIL-STD-1589B) for all subsystems, the MIL-STD-1553B Multiplex Data Bus, the MIL-STD-1750A Computer Instruction Set Architecture, and the MIL-STD-1760 Stores Interface. Both the implementation of standards in the current F-16 avionics and also in the enhanced F-16 avionics now in development are described.     

Analysis of parallelism in nested DO loops

The execution time of FORTRAN programs can be decreased by putting solutions to problems in their maximally parallel forms. The most important issue is the DO-loop. In this study nested DO-loops were considered and analysis of parallellism was performed on matrix multiplication using a PROLOG program. When processed by the AIDS system, the maximally parallel graph was produced. This indicates the number of processors that could be used in parallel to execute the FORTRAN program. The study shows that the maximally parallel program can run in considerably less time than that needed to run the original sequential FORTRAN program. N×N matrix multiplication programs are speeded up by a time-saving ratio that is always greater then (1:N²), but it cannot exceed (1:N³), since N³ is the maximum number of processors used in parallel at any time. These time-saving ratio evaluations assume that all operations have equal execution time and initialization overhead is ignored.     

An analysis of program execution on a recursive stream-oriented data flow architecture

The functional or applicative approach to the development of software leads to the natural exposure of parallelism. Data flow architectures are designed to exploit this parallelism. This paper describes a method for modeling and analyzing program execution on a stream-oriented, recursive data flow architecture. Based on a maximum path length technique, a recursive analysis of nodes (corresponding to high level constructs) results in an approximation of the time required to execute the program given adequate resources. By relating the structure of a program to the degree of exhibited parallelism, this method provides a useful tool for studying parallelism and evaluating certain problem classes to be run on similar architecutures.     

A database model of debugging

Debugging a program can be viewed as performing queries and updates on a database that contains program source information as well as the state of the executing program. This approach integrates the facilities of a traditional debugger into a programming environment by providing access to runtime information through normal database query operations. We are building a programming environment in which all program information is stored in a relational database system. This system will include capabilities to provide the programmer a simple yet powerful mechanism for describing debugging requests.