PBASIC — a verifier for BASIC

The increase in the number of available dialects of BASIC has lead to the usual difficulties encountered when transporting software. The proposed American National Standard Minimal BASIC represents a small but almost universal subset of all BASICs. PBASIC is a verifier for ANS Minimal BASIC. The verifier is itself written in PFORT, a portable subset of FORTRAN IV.     

MUSS—a portable operating system

This paper describes a technique for producing a machine-independent operating system with a high level of performance. The technique is based on the definition of a hypothetical ideal machine, which acts as the target computer for the operating system. The characteristics of this ideal machine are described in detail.     

SOFTLIB — a documentation management system

This paper describes a software sysem (SOFTLIB) that has been developed to assist in the management of software documentation generated during systems development projects. It provides facilities to manage large numbers of documents, to file documents when they are complete and to issue them to system developers and maintainers. It also includes an information retrieval facility that allows programming staff to find documents, to examine their contents before issue and to assess the state of the software project documentation. SOFTLIB is explicitly intended to help manage the documentation generated during software development — it is not designed for use by end-users of that software or for managing end-user documentation. The novel characteristic of this system is the approach that is taken to the consistency and completeness of documentation. The documentation associated with a software system is organized in such a way that it may be detected if document sets are complete (that is, if all documentation which should be provided for a software component is available) and if document sets are likely to be inconsistent. This means that if a document has been changed without a comparable change being made to other associated documents, this is detectable by the librarian system. In addition, a subsidiary aim of our work was to investigate the utility of menu systems to complex software tools by building a user interface to SOFTLIB. We conclude that menu systems are far from ideal in such situations because of the range of possible options which must be handled by the system.     

Dave—a validation error detection and documentation system for fortran programs

This paper describes DAVE, a system for analysing Fortran programs. DAVE is capable of detecting the symptoms of a wide variety of errors In programs, as well as assuring the absence of these errors. In addition, DAVE exposes and documents subtle data relations and flows within programs. The central analytic procedure used is a depth first search. DAVE itself is written in Fortran. Its implementation at the University of Colorado and some early experience are described.     

Some comments on the portability of a large algol program—the implementation of SID on KDF9

Software engineering research is facilitated by the availability of general purpose programs which aid the production of other programs. These may conveniently be termed ‘software tools’. Software tools in themselves often represent a significant amount of intellectual effort and so their portability between different computing environments is important. We consider the requirements on an ALGOL 60 system to enable it to act as a recipient of a software tool written in ALGOL. In particular, our experience of implementing the translator–writing system, SID, on KDF9 is discussed.     

Self-healing systems — survey and synthesis

As modern software-based systems and applications gain in versatility and functionality, the ability to manage inconsistent resources and service disparate user requirements becomes increasingly imperative. Furthermore, as systems increase in complexity, rectification of system faults and recovery from malicious attacks become more difficult, labor-intensive, expensive, and error-prone. These factors have actuated research dealing with the concept of self-healing systems. Self-healing systems attempt to “heal” themselves in the sense of recovering from faults and regaining normative performance levels independently the concept derives from the manner in which a biological system heals a wound. Such systems employ models, whether external or internal, to monitor system behavior and use inputs obtaining therefore to adapt themselves to the run-time environment. Researchers have approached this concept from several different angles this paper surveys research in this field and proposes a strategy of synthesis and classification.     

Software malpractice — a distasteful experience

A sequence of events is described, leading to the severe deterioration of an initially well conceived and cleanly implemented compiler. It is shown how an initial “optimization” implanted a latent bug in the compiler, how the bug was subsequently activated through innocent compiler modification, and how the compiler then deteriorated because of the incompetent correction of the bus manifestation. This exceedingly negative case history is presented in the hope of conveying to the reader a better feeling for the complex problems inherent to industrial software production and maintenance. The difficulty in proposing any constructive (and complete!) software engineering methodology is known and acknowledged; the study of an episode such as described in this paper might help put the difficulties, with which we are confronted, into better perspective.     

The Argonne/GMD macros in FORTRAN for portable parallel programming and their implementation on the Intel iPSC/2

A macro package for expressing message passing functions within parallel FORTRAN program is presented. It makes the user program fully portable among all parallel computers where the macros are implemented. The implementation on the Intel iPSC/2 hypercube is discussed in more detail. New message passing primitives have been added to the iPSC/2 operating system, offering the user a broader functionality at no efficiency loss. The full macro set, using these primitives, works with the same performance as the original Intel primitives.     

RATSNO—an experiment in software adaptability

Adaptable programs are one of the benefits of structured programming. The adaptability of a program is the degree to which it can be transformed into another program that performs a similar, but slightly different, function. While it is clear that the aims of structured programming are best satisfied by the use of modern programming languages, a great number of programmers must use languages such as Fortran. To alleviate this situation, a number of preprocessors have been introduced that give Fortran a more structured facade. This paper describes an experiment performed to test the adaptability of programs written in RATFOR, one of these preprocessors. Judging from the results, the use of a good preprocessor can significantly increase the adaptability of Fortran programs.     

The earth's evolution and paleoclimatology —A computational model

The climatic history of the Earth through geological time can only be understood successfully by complementary use of geophysical data and evolutionary models. A numerical model of the evolution of the Earth's surface/atmosphere system is presented which characterizes the global climate by the average surface temperature, T_J. Recent geological data verify the existence of liquid water on the surface of the Earth 3.8 aeons ago and thus provide error bounds on T_J. The computer model includes explicit calculation of the “greenhouse increment” of surface temperature due to gaseous absorption. Data relating to the type and amount of gases in the early atmosphere are derived from geological evidence. Previous debate regarding the exact nature of the early atmosphere seems to be resolved by the results of the model described here. The numerical model is discussed in detail and validated in terms of our present knowledge of the Earth's evolution.     

K6 — a protected mode kernel for the iAPX286

This paper presents the design of an operating system kernel offering protection, and using the object model as the design methodology. Rich communication facilities are provided between domains of protection allowing stimuli, data and objects to be passed. All object types, including protection domains, may be created and deleted dynamically, and some may be ‘sealed’ and employed as user-defined objects by a type manager which alone can penetrate them.     

The viscom—a system of ‘soft’ video-terminals

The Portsmouth Polytechnic Visual-communication system, Viscom (vik-om), has been designed to provide high-speed Interaction with an ICL 4130 computer. A feature of the system is that its software device routine is used not only to facilitate data transfers but also to provide an open-ended list of keyboard functions to augment those provided by the hardware.     

Rcs — a system for version control

An important problem in program development and maintenance is version control, i.e. the task of keeping a software system consisting of many versions and configurations well organized. The Revision Control System (RCS) is a software tool that assists with that task. RCS manages revisions of text documents, in particular source programs, documentation, and test data. It automates the storing, retrieval, logging and identification of revisions, and it provides selection mechanisms for composing configurations. This paper introduces basic version control concepts and discusses the practice of version control using RCS. For conserving space, RCS stores deltas, i.e. differences between successive revisions. Several delta storage methods are discussed. Usage statistics show that RCS's delta method is space and time efficient. The paper concludes with a detailed survey of version control tools.     

Prtds — a pascal run-time diagnostics system

A run-time diagnostics system has been described that allows the user to interrogate a program fully in source language terms. In particular, dynamically created data structures are catered for. The diagnostics system allows all objects including those created dynamically to be interrogated and can display a graphical representation of linked data structures. This paper describes the implementation of such a system with the language Pascal on a GEC 4080.     

Yacc in sasl — an exercise in functional programming

Among the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.     

The Linux kernel as a case study in software evolution

We use 810 versions of the Linux kernel, released over a period of 14 years, to characterize the system’s evolution, using Lehman’s laws of software evolution as a basis. We investigate different possible interpretations of these laws, as reflected by different metrics that can be used to quantify them. For example, system growth has traditionally been quantified using lines of code or number of functions, but functional growth of an operating system like Linux can also be quantified using the number of system calls. In addition we use the availability of the source code to track metrics, such as McCabe’s cyclomatic complexity, that have not been tracked across so many versions previously. We find that the data supports several of Lehman’s laws, mainly those concerned with growth and with the stability of the process. We also make some novel observations, e.g. that the average complexity of functions is decreasing with time, but this is mainly due to the addition of many small functions.     

Application Portability Profile (APP)—The US government's Open System Environment profile OSE/1 version 2.0

Federal information systems initially developed from isolated islands of computing. Through progressive changes, these individual systems became connected by common users and common information needs. These systems are now well on the way to migrating toward computing environments that consist of distributed, heterogeneous, networked applications, databases, and hardware. The concept of a Federal computing environment that is built on an infrastructure defined by open, consensus-based standards is well on its way to becoming a de facto means of organizing these systems. Such an infrastructure is called an Open System Environment (OSE).

An Open System Environment encompasses the functionality needed to provide interoperability, portability, and scalability of computerized applications across networks of heterogeneous, multi-vendor hardware/software/communications platforms. The OSE forms an extensible framework that allows services, interfaces, protocols, and supporting data formats to be defined in terms of nonproprietary specifications that evolve through open (public), consensus-based forums.

A selected suite of specifications that defines the interfaces, services, protocols, and data formats for a particular class or domain of applications is called a profile. The Application Portability Profile (APP) integrates industry.