bluuebunny/crossref_metadata_2025 huggingface dataset:
Measures for maintenance management: A case study
Authors: Neil Martin , Cole Robert J. , Slater David
Published: November 2006

Software maintenance is an important activity, but is often perceived as less challenging than software development. By following a management‐led discipline of data collection and reporting, maintenance control and visibility can be achieved. The discipline aims to promote the maintenance function within an organization and show that it is as demanding as software development.

This paper describes a maintenance data collection scheme (MDCS) which was implemented at an industrial site, as a case study. This implementation resulted in: an increase in management control, promotion of maintenance to senior management, systematic recording of faults, and the successful application of a statistical model to the weekly number of maintenance incidents. An incident form was developed to record data on the effort necessary to resolve incidents, the elapsed time, status, category and severity of incidents. It turned out that maintenance incident effort was highly variable. Maintenance reports were prepared for management based on the results of data analysis. These reports addressed the following questions: Is the maintenance effort increasing or decreasing? How fast are maintenance problems being dealt with? Which systems are demanding the most effort? Statistical techniques were used to model maintenance activities. Multivariate techniques were found to be inappropriate for the type of data collected. A log‐normal distribution was fitted to the weekly number of maintenance incidents. This distribution gave a confidence interval of practical use for management.
Creating specifications from code: Reverse‐engineering techniques
Authors: Breuer P. T. , Lano K.
Published: November 2006

Reverse‐engineering application codes back to the design and specification stage may entail the recreation of lost information for an application, or the extraction of new information.

We describe techniques which produce abstractions in object‐oriented and functional notations, thus aiding the comprehension of the essential structure and operations of the application, and providing formal design information which may make the code much more maintainable and certainly more respectable.

The two types of application considered here are (1) data processing applications written in COBOL — of primary importance owing to their predominance in present computing practice — and (2) scientific applications written in FORTRAN. These two require somewhat different abstraction approaches.
A formal approach to perfective software maintenance: Integration using a basis
Authors: Rine David
Published: November 2006

We investigate how a formalism, common to many areas of applied mathematics and engineering, known as a basis can be applied to perfective maintenance and integration in software engineering, using an object‐oriented approach. It is concluded that this formalism serves as a mathematical model for perfective software maintenance and integration activities. Theorems and properties about the model are reported as guides to software maintenance. The model and formal maintenance techniques have been applied to a software system in the management information systems area to demonstrate this approach to perfective maintenance and to assist in validating the model.
Software Maintenance: 1990 status
Authors: Dekleva Sasa M.
Published: November 2006

Results of a survey of the 1990 Software Maintenance Association Meeting and Conference attendees indicate a number of changes in software maintenance‐related issues. Systems are ageing and growing in size. Software maintenance is separated from new systems development in more than half of the organizations. Over 45% of maintenance work is spent on functional enhancements. About three out of four organizations depend on specific individuals because no‐one else can maintain particular systems and only 5% of organizations employ a formal method for determining when software should be rewritten. Responses describing major problems and preferred changes in DP organizations were classified into general categories and compared with previous similar studies. Trends show maturation of software maintenance toward a greater appreciation of maintenance and at least an intention of managers to improve the support of this activity.
From programs to object code and back again using logic programming: Compilation and decompilation
Authors: Bowen Jonathan
Published: November 2006

A compiler may be specified by a description of how each construct of the source language is translated into a sequence of object code instructions. It is possible to produce a compiler prototype almost directly from this specification in the form of a logic program. This defines a relation between allowed high‐level and low‐level program constructs. Normally a high‐level program is supplied as input to a compiler and object code is returned. Because of the declarative nature of a logic program, it is possible for the object code to be supplied and the allowed high‐level programs returned, resulting in a decompiler, provided enough information is available in the object code. This paper discusses the problems of adopting such an approach in practice. A simple compiler and decompiler are presented in full as an example in the logic programming language Prolog, together with some sample output. The possible benefits of usingconstraint logic programmingare also considered. Potential applications include reverse‐engineering in the software maintenance process, verification of safety‐critical object code, quality assessment of code and program debugging tools.
RE2: Reverse‐engineering and reuse re‐engineering
Authors: Canfora G. , Cimitile A. , Munro M.
Published: November 2006

Initial research in reuse was in the designing and implementation of reusable software. This research, although fruitful, did not address the area of extracting reusable components from existing software. In this paper the term reuse is used to mean the ‘reuse of existing source code’. A process called ‘reuse re‐engineering’ is defined and this, together with techniques from reverse‐engineering, form a new method for achieving reuse. A reference paradigm is established to implement the reuse re‐engineering process. This process is divided into five sequential phases, each characterized by the objects it produces. These phases are: candidature, election, qualification, classification and storage, and search and display. This paper concentrates on the first three phases because they produce reusable modules from existing systems. In selecting candidates for reuse, different abstractions have to be applied, namely functional abstraction (algorithms) and data abstractions (data structures and data types). This paper presents a formalized approach to each of these abstractions. The approach proposed in this paper aims to promote reuse in industrial software production environments.
Reusability in software maintenance: A Japan—USA comparison
Authors: Pei Gary , Victoria Agustina
Published: November 2006

Japan benefits from a level of software reuse in software maintenance more than ten times the level in the USA. We report in this paper on our investigation during 1992 and 1993 into the management factors associated with that difference. The four main parts of this paper are the motivation for applying software reusability, maintenance management in the USA, maintenance management in Japan, and USA versus Japan. Our investigation included on‐site visits in Japan and the USA, interviews with experts in Japan and the USA, and a review of the relevant Japanese and American literature (one of us speaks and reads Japanese fluently).

Organizations in Japan applying software reuse report reduced maintenance backlogs, better satisfaction of customer (user) requests, and improved maintenance productivity. In Japan, about a third of organizations apply software reuse, and the reuse level typically is in the 50% to 75% range, we observe. In the USA, less than 2% of organizations apply software reuse in software maintenance, and the reuse level those organizations achieve typically is below 35%. The approach to software reuse in Japan is more business‐oriented, with an emphasis on team work‐methods and quality improvement. The approach in the USA is more technically oriented, with an emphasis on tools and operating practices. The approach in Japan reflects a tradition of building and maintaining in terms of assemblies and subassemblies to help control product quality over a long term. The approach in the USA reflects managements' pressure for a short‐term payoff, and the relatively easy availability of personnel skills when needed. In both Japan and the USA, personnel factors are a major concern for information systems management in determining the extent of software reuse in software maintenance. Underlying all software maintenance reuse differences between Japan and the USA are structural and cultural differences which shape the extent and manner of applying software reusability in software maintenance.
A new approach to finding objects in programs
Authors: Livadas Panos E. , Johnson Theodore
Published: November 2006

Software maintenance is difficult and costly because the maintainer must understand the existing relationships in the maintained code. The maintainer's job can be made considerably easier if the objects in the code (related groups of types, data, and procedures) are identified. In this paper, we discuss methods for identifying objects in programs, and present a new approach that relies on these key features. First, our internal program representation (IPR) lets us make a more precise identification of objects than previous methods allowed. Second, we introduce the idea of receiver‐based object identification. Third, we introduce the idea of two‐step object identification, which gives the user greater control in precisely identifying objects. Our object finding tool can be used with the other tools our IPR provides to create an integrated software maintenance environment.
Cooperative work in large‐scale software systems
Authors: Belkhatir Noureddine , Estublier Jacky , Melo Walcélio L.
Published: November 2006

Software maintenance is responsible for approximately 80% of the total cost of software. In order to reduce maintenance costs by improving both software productivity and quality, several software engineering environments have been built. In this paper, we present the main characteristics of Adele system, showing how this system is able to take account of software maintenance problems. We concentrate on the ability of this system to accept the specification of project‐specific policies and how these policies can be enforced automatically. We illustrate this with examples which with software maintenance. The second example is presented in the annexe and shows an example of cooperative work in an aerospace company. We conclude this article by presenting the lessons learned using our approach and our projects for the future.
Decision‐driven Maintenance
Authors: Lanubile Filippo , Visaggio Giuseppe
Published: November 2006

This paper presents our approach to design recording which aims to facilitate the impact analysis of changes in data, functions, or the external environment. A whole software system is represented as a web which integrates the different work products of the software life cycle and their mutual relationships. A traceability relationship associates the objects with each other so that impact analysis can be performed. Internal traceability is provided by semantic links between software objects representing the work products of a development phase, while external traceability is assured by the cognitive links between software objects from different phases. System understanding is supported by the decisions which are involved in the transformation process. The history of these decisions is retained over time so that previous decisions can be examined for maintenance and reuse activities. The approach has been implemented through a Traceability Support System, a maintenance tool which combines the characteristics of program abstractors, project databases and design rationale capture tools. The approach and the tool also both support traceability in heterogeneous systems, which have subsystems implemented on different platforms. Finally, analysis is made of the results of an empirical investigation carried out to assess the approach.
An empirical study of maintenance activities in two object‐oriented systems
Authors: Li Wei , Henry Sallie
Published: November 2006

Decades of research on maintenance activities in the procedural paradigm has produced several conclusions. Among these conclusions are recommendations that a reduction in maintenance cost could be achieved by a more controlled design process, and by more rigorous testing of potential problem areas earlier in the life‐cycle. With the increased emphasis on the object‐oriented paradigm, the authors performed an empirical study of the maintenance patterns in two commercial object‐oriented systems. Although this is a preliminary study, intuition is presented as insight into the object‐oriented maintenance activities.
Formal methods for legacy systems
Authors: Ward M. P. , Bennett K. H.
Published: November 2006

A method is described for obtaining useful information from legacy code. The approach uses formal proven program transformations, which preserve or refine the semantics of a construct while changing its form. The applicability of a transformation in a particular syntactic context is checked before application. By using an appropriate sequence of transformations, the extracted representation is guaranteed to be equivalent to the code. In this paper, we focus on the results of using this approach in the reverse‐engineering of medium‐scale, industrial software, written mostly in languages such as assembler and JOVIAL. Results from both benchmark algorithms and heavily modified, geriatric software are summarized. It is concluded that the approach is viable, for self‐contained code, and that useful design information may be extracted from legacy systems at economic cost. We conclude that formal methods have an important practical role in the reverse‐engineering process.
Improving reverse‐engineering through the use of multiple knowledge sources
Authors: Layzell P. J. , Freeman M. J. , Benedusi P.
Published: November 2006

With the growing awareness of the importance of software maintenance has come a re‐evaluation of software maintenance tools. Such tools range from source code analysers to semi‐intelligent tools which seek to reconstruct system designs and specification documents from source code. However, it is clear that relying solely upon source code as a basis for reverse‐engineering has many problems. These problems include poor abstraction, which leads to over‐detailed specification models and the inability to link other parts of a software system, such as documentation and user expertise, to the underlying code.

This paper describes the work of the Esprit DOCKET project which has developed a prototype environment to support the development of a system model linking user‐oriented, business aspects of a system, to operational code using a variety of knowledge source inputs: code, documents and user expertise. The aim is to provide a coherent model to form the basis for system understanding and to support the software change and evolution process.
Software maintenance—an industrial experience
Authors: Onoma A. K. , Tsai W. T. , Tsunoda F. , Suganuma H. , Subramanian S.
Published: November 2006

This paper gives an overview of the software maintenance process of Hitachi Software Engineering (HSK) Co., Ltd in Japan‐including its success and failure cases. It discusses HSK's software processes, issues, use of specific tools and techniques such as IMOZU diagrams, and approaches in solving problems. These include the requirement capturing process, reverse‐engineering techniques, environmental changes, change management, and project management. By discussing actual project experiences, we point to certain lessons and their implications for research in software maintenance. We also present the latest re‐engineering CASE tools, such as RE‐ENGINEERING and SEWB3, used at HSK.
Understanding software through numbers: A metric based approach to program comprehension
Authors: Sneed Harry M.
Published: November 2006

There are many approaches to try to comprehend software. Code can be statically analysed and its structure and content displayed as lists, tables or graphs. Most of the literature on software comprehension deals with this approach. Code can also be dynamically executed and its reaction to impulses from outside registered and documented. This is a useful approach to understanding object‐orientated systems. A third approach is not to deal with the code at all, but instead to extract information from existing documents and to combine it into a whole. The problem here is that important documents are often missing and those that are available are out of date. A fourth approach is to interview the experts and to aggregate their views of the software, how it is composed and how it functions as opposed to how it should be composed and how it should function. All of these approaches have been examined and reported on by the participants of the ESPRIT DOCKET Project (1992).

A fifth approach to software understanding, the one to be presented here, is that of comprehension through numbers by software managers, i.e. using metrics to support the decision making process.
A definition of abstraction
Authors: Ward Martin
Published: November 2006

What does it mean to say that one program is ‘more abstract’ than another? What is ‘abstract’ about an abstract data type? What is the difference between a ‘high‐level’ program and a ‘low‐level’ program? In this paper we attempt to answer these questions by formally defining an abstraction relation between programs which matches our intuitive ideas about abstraction. The relation is based on examining the operational semantics of the programs, expressed as a set of traces (sequences of states) from a given initial state to a possible final state.
Developing a multi‐access system online
Authors: Poole P. C.
Published: November 2006

COTAN is a multi‐acess system designed to operate on linked KDF9–PDP8 computers. It supports 20 remote teletypes and provides the online user with both remote job entry and interactive capabilities

The development of COTAN relied heavily on the continuing availability of online access from an early stage in the project. Access was first obtained through the monitor console on the KDF9 and this was then used to ‘bootstrap’ the implementation of the multi‐access facilities. The new software was checked out in a real time, online test bed called an ‘environmental simulator’. This provided a close approximation to the ultimate operating conditions and enabled the system to be brought to a high degree of reliability before being placed in service.
An algol‐like assembly language for a small computer
Authors: Bell D. A. , Wichmann B. A.
Published: November 2006

In a classic paper1 Wirth describes a language which combines the readability of ALGOL 60 with the flexibility and degree of control of a conventional assembly language. This paper gives an outline of a similar language for a small 16‐bit computer—the Honeywell DDP‐516. Implementing the compiler in its own language by recoding an ALGOL version of the compiler has shown that the language is suitable for large systems. With the compiler written in a high‐level language, many enhancements have been possible even though these were not envisaged in the original coding

This use of the language clearly demonstrated that a high‐level assembly language can be a very effective tool for a small machine as well as for computers like the 360 series.
An empirical study of FORTRAN programs
Authors: Knuth Donald E.
Published: November 2006

A sample of programs, written in FORTRAN by a wide variety of people for a wide variety of applications, was chosen ‘at random’ in an attempt to discover quantitatively ‘what programmers really do’. Statistical results of this survey are presented here, together with some of their apparent implications for future work in compiler design. The principal conclusion which may be drawn is the importance of a program ‘profile’, namely a table of frequency counts which record how often each statement is performed in a typical run; there are strong indications that profile‐keeping should become a standard practice in all computer systems, for casual users as well as system programmers. This paper is the report of a three month study undertaken by the author and about a dozen students and representatives of the software industry during the summer of 1970. It is hoped that a reader who studies this report will obtain a fairly clear conception of how FORTRAN is being used, and what compilers can do about it.
Some improvements to the MINIMOP multi‐access operating system
Authors: Rees M. J.
Published: November 2006

The MINIMOP Multi‐Access system provides a range of on‐line facilities particularly suitable for a university environment. Programs in ALGOL and FORTRAN can be written and tested under MINIMOP; a conversational subsystem, derived from JOSS, considerably enhances the usefulness of the Multi‐Access system. After one year's operation at the University of Southampton, it was considered desirable to attempt to expand the facilities of MINIMOP, and correct some of the faults still present in the system. This paper, after a brief description of the basic system, describes the modifications that have been made, and presents some extensions that may be possible in the future.
Answering datel telephone calls by PDP‐8
Authors: Harvey D. W.
Published: November 2006

This paper discusses the development of software to enable the PDP‐8 to handle Datel telephone calls automatically. The software treats the automatic dataphone equipment as a finite state machine. This treatment is compared to the more ad hoc approach which deals with each function of the equipment in an individual way. It is shown that the more formal approach has considerable advantages in shortening development time by reducing debugging and produces a system which is easy to extend.
The design of a pascal compiler
Authors: Wirth N.
Published: November 2006

The development of a compiler for the programming language PASCAL1 is described in some detail. Design decisions concerning the layout of program and data, the organization of the compiler including its syntax analyser, and the over‐all approach to the project are discussed. The compiler is written in its own language and was implemented for the CDC 6000 computer family. The reader is expected to be familiar with Reference 1.
Some comments on the portability of a large algol program—the implementation of SID on KDF9
Authors: Brown F. D. , Calderbank Valerie J. , Poole M. D.
Published: November 2006

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.
A display package for CAD of control systems
Authors: Hambury J. N. , Karniel S. , Barney G. C.
Published: November 2006

A multi‐access computer system has been installed at the Control Systems Centre of the University of Manchester Institute of Science and Technology. The application of this computer to research into the computer aided design of industrial control systems involved the connection of two keyboard display terminals to the system. The ARDS storage tube displays chosen had the advantages of being teletypewriter compatible and not requiring the connection of a satellite computer

A graphics package for the entry and structuring of data derived from the stability analysis of control systems was required as soon as possible after the installation was commissioned. The initial package enabled data to be entered by program and then selected and plotted by keyboard requests. Translation, scaling, alteration of the method of plotting (with points or vectors) and the selection of different items for the display were all carried out by keyboard interaction

For long term CAD work a more extensive graphics package was required, the specification was determined following feedback from users of the initial package. It provided additional facilities for graphic interaction, alphanumeric annotation of the displays, specialized drawing and data entry functions and the storing of any pictures built up by the user, as well as a more linked data structure. The structure and facilities of this package are described.
A pascal compiler for ICL 1900 series computers
Authors: Welsh J. , Quinn C.
Published: November 2006

The transport of a PASCAL compiler from a CDC 6000 series computer to an ICL 1900 series computer is reported, with some comments on the method used.
The evolution of job control languages
Authors: Barron D. W. , Jackson I. R.
Published: November 2006

Job control languages are a feature of any large scale operating system. This paper traces the historical development of these languages, and compares two representative examples, OS/360 JCL and GEORGE 3 command language. The paper draws an analogy between job control languages and programming languages, showing that JCL is equivalent to an assembly language, whilst GEORGE 3 command language is like a simple autocode.
A high speed computer‐to‐computer data link
Authors: Cronin D. E. , Brandon J. P.
Published: November 2006

The ICL 1905E at Queen Mary College, London and the CDC 6600 at the University of London Computer Centre, have been linked by a 48 kilobaud Post Office line. Jobs can be transmitted from the 1905E to the 6600, and resuts returned to the 1905E. A modified CDC data terminal (the QSE 2815) is installed at QMC, and is connected to the 1905E through a peripheral channel via a British Standard Interface converter. Standard CDC data transmission procedures are used; the software system is based on the CDC IMPORT/EXPORT package, with a program in the 1905E simulating the operation of IMPORT

The 1905E software was written in two parts: an off‐lining package which writes batches of programs to magnetic tape, and subsequently prints off‐line output from tape, and a link control program which reads program batches from tape for transmission to the 6600, and writes to tape the output received from the link. This off‐lining technique ensures that the full capacity of the high speed line is realized

The link system began operation at the beginning of 1970, and is now used regularly to transmit jobs to ULCC and other sites in the network. Work is continuing on the provision of network facilities, and an integration of the link system with the operating system in the 1905E.
Debugging tools for high level languages
Authors: Satterthwaite E.
Published: November 2006

The design of an integrated programming and debugging system using the language ALGOL W is described. The debugging tools are based entirely upon the source language but can be effeciently implemented. The most novel such tool is a selective trace, automatically controlled by execution frequency counts. System performance information is included.
A format editor
Authors: Teperman A. , Katzenelson J.
Published: November 2006

This paper describes a text processing program for producing documents that are to be reproduced. The program runs on a small (12K) computer with paper tape input, a storage scope display unit and an on‐line teletype. Formatting commands are inserted in the text. Compound commands may be formed form the basic ones. This feature aids the specification of complicated formats required for items such as tables and titles. The user can display a page of text before and after the page is formatted and correct it interactively.
A note on internal merging
Authors: Jones Bush
Published: November 2006

A simple technique for conserving storage and operations when merging streings internally is presented. An analysis of the increase in efficiency obtained with this methos is given. The technique lends itself to iterative usage in algorithms.
Re‐creation of source code from reverse polish form
Authors: Brown P. J.
Published: November 2006

A method is described where, by adding redundant operators when compiling into reverse Polish notation, it is possible to re‐create source code in exactly its original form. An algorithm for performing this re‐creation is outlined. The method is useful for incremental compilers since it permits partial (and in some cases total) compilation without the need to maintain a copy of the original program.
Diagnostic messages
Authors: Hahn K. W. , Athey J. G.
Published: November 2006

An algorithm is presented for the compiler diagnostic phase by the introduction of a dictionary concept with elimination of duplicate words, synonymous words and messages, special symbols and non‐uniform spellings. The result is compared with an American Standard COBOL Compiler. This concept can be extended beyond the compilers to all systems which issue extensive messages. It will simplify modularity design and aid in standardization of output format.
CDC 6000‐series register save/restore
Authors: Baker John L.
Published: November 2006

A CDC 6000‐series central processor program to save and restore all programmable registers is presented. Comments on its utility and efficiency are included.
User‐like executives
Authors: Hamlet R. G.
Published: November 2006

A complex executive may be written as a core of minimum size, plus processes indistinguishable from those run by normal system users except for heavily circumscribed special privileges. Such an executive defines its virtual machine in a recursive fashion, since the processes abide by rules they help to enforce, and is ‘user‐like’ because most executive processing takes places in the protected, user mode. The advantages of such an executive are compactness because of lack of duplication of user and executive routines, good documentation because the user‐process interface is well defined and stable and, most important, excellent protection of the system from the executive itself, which utilizes all of the hardware protection available whenever possible.

Situations most appropriate for the user‐like technique are described, and a series of detailed examples is given to show its application to a multiprogramming executive's memory allocation service.
The systems programming language, Malus
Authors: Marcotty Michael , Schutz Henrik
Published: November 2006

This paper reports on the design and development of a high level language, Malus, for use in implementing a time‐sharing system. Emphasized are the ways that the language and its compiler accommodate the specialized requirements of systems programming and programmers. Among these are the need to generate highly efficient object code, to allow inter‐programmer communication by program self‐documentation, and to define and organize system tables and data. In addition, the Malus compiler is highly modular; thus the language may be modified or augmented in response to user needs unforeseen during langauge design. Systems programs cannot be machine independent and Malus allows explicit control of emitted code when an application requires particular efficiency or use of privileged instructions. There is also a facility allowing nested redefinition of identifiers. Efficient storage management and data access is effected by the availability of based structures, a register storage class and built‐in functions to facilitate their use. Malus is evaluated both in terms of some general criteria for systems implementation languages and by an appraisal of user reactions. While this assessment shows a few areas where the language might be improved, it is felt that Malus is a valuable and effective tool for systems implementation.
Handling asynchronous interrupts in a PL/1‐like language
Authors: Elshoff James L. , Beckermeyer Robert , Dill John , Marcotty Michael , Murray John
Published: November 2006

A method of handling asynchronous interrupts, which are defined to be events, in a highlevel, block‐structured language is described. The language facilities are based on PL/1 conditions. The functions of an interrupt handler and its relationship with the execution time support for the language are defined and discussed.

The development of the facilities being presented is also described. Solutions to design problems and implemenation details are stated. The use and benefits of the mechanism are discussed.
An exercise in resource allocation
Authors: Gomaa H.
Published: November 2006

In a large operating system, the probability that bottlenecks exist is high. The outcome of modifications to the system attempting to overcome these bottlenecks are often not easy to predict. It is frequently difficult to discover:

Whether an improvement has actually been made to the system.

Where exactly the improvement in system performance, if any, is occurring.

How to adjust parameters of the system to achieve an improved performance.

Performance tools are described in this paper which were used to help resolve these points in the implementation of a Peripheral Processor and Channel Scheduling mechanism in the operating system used at CERN on a CDC 6000 system. The paper shows how analysis of the performance data provided a clearer appreciation of the performance of the scheduling mechanism.
A storage mapping technique for the implementation of protective domains
Authors: Spier Michael J. , Hastings Thomas N. , Cutler David N.
Published: November 2006

As part of its effort to periodically investigate various new promising concepts and techniques, the Digital Equipment Corporation had sponsored a research project whose purpose it was to effect a limited exploratory implementation of a novel protective operating system framework, based on the kernel/domain architecture.

The project was carried out in 1972, and its successful completion led to a number of observations and insights. This paper concentrates on the technological solutions which were developed for the translation of a theoretical model on to commercially available hardware (the DEC PDP‐11/45 minicomputer); specifically, the storage mapping technique and the intermodule call/return mechanism.

We believe that we have made two contributions to the state of the art: firstly the identification of the doman's storage mapping properties which are expected to have an impact on the definition of storage class semantics for higher level programming languages to be developed for the domain environment, and secondly the development of a comprehensive intermodule communication mechanism combining all presently known forms of procedure activation within a single functional framework.
Heuristic procedures (if they work—leave them alone)
Authors: Williams M. R.
Published: November 2006

An heuristic graph colouring procedure is described along with the various attempts made to improve its performance. The paper ends with a warning about not spending too much time on what may be a fruitless endeavour.
Use of a software monitor in the validation of an analytic computer system model
Authors: Wong K. , Strauss J. C.
Published: November 2006

The use of a software monitor in validating a cyclic server multiprogramming model of OS/360 is presented. Following a brief development of the analytic model, a sampling software monitor designed to track CPU and channel I/O activity in OS/360 is described. A procedure for fitting the model to the system based on measurements obtained by the monitor is developed and comparative results of the adjusted model and the actual system are presented for validation of the model principles.
List structures in SIMULA and PL/1—a comparison
Authors: Palme Jacob
Published: November 2006

A typical list structurre application program was written in both SIMULA and PL/1. The program was executed using the IBM 360/370 SIMULA and PL/1 optimizing compilers.

SIMULA was found to give shorter compile time, about the same execution time and larger memory requirement than PL/1. The source program for the same algorithm was shorter in SIMULA. The SIMULA system could discover semantic programming errors earlier and diagnose them better them PL/1.
DSOS—a skeletal, real–time, minicomputer operating system
Authors: Frailey Dennis J.
Published: November 2006

This paper describes a skeletal operating system which provides the services and structure necessary to implement real‐time applications. Features which would require a specific configuration or a non‐minimal computer are either omitted or optional. In particular, although some protocol is established, no peripheral devices are required. System features include dynamic storage allocation, memory protection, multiprogramming, pseudo‐clocks, and co‐ordination and communication primitives. Due to its simple design, the system ‘kernel’ has proven to be remarkably error free.
An in – core batching standard fortran complier for large ICL 1900 machines
Authors: Rohl J. S. , Ellison H. D. , Collins R. J.
Published: November 2006

We are accustomed to thinking that the requirements of different users of FORTRAN (or any other language for that matter) are so varied that they can only be met by a series of compliers: a standard one, an optimizing one, an in‐core batching one and so on. This paper describes a complier which, although its main aim was to process batches of small student jobs, was desinged to compete with all the manufacturer's compliers on their chosen ground.
Scheduling for a share of the machine
Authors: Larmouth J.
Published: November 2006

This paper describes the mechanism used to schedule jobs and control machine use on the IBM 370/165 at Cambridge University, England. The same algorithm is currently being used in part at the University of Bradford, and implementations are in progress at the Universities of Leeds, Salford and Liverpool for the ICL 1900 series machines. The mechanism relies on allocating a share of the machine to each user (or project), and then varying the turnround time for jobs according to whether the project in question is over‐ or under‐using its share of the machine. The approach is believed to be an original one, having a number of advantages over more conventional scheduling and control algorithms.
A technique for evaluation of user systems on an IBM S/370
Authors: Bergeron R. Daniel , Bulterman Henri R.
Published: November 2006

As applications systems grow in complexity, the optimization of their resource usage becomes more important. This holds true not only as an attempt to increase their own effectiveness, but also to reduce the impact of that system on resources shared by other users in the environment. The analysis and optimization of user systems can be simplified considerably by identifying commonly required evaluation facilities and implementing these facilities in a system‐independent manner.

This paper examines existing techniques and describes a system, the SSD evaluation system, designed and implemented by the authors on an IBM System/370 for the purpose of monitoring the performance of applications systems.
Two simple windowing algorithms
Authors: Jarvis John F.
Published: November 2006

Two algorithms that solve the frequently occurring problem in computer graphics, windowing, are described. The primary distinction between the two algorithms is the need for multiplication and division in one of them. The algorithms are compared for running time and size on two commonly used minicomputer systems, the Digital Equipment Corporation PDP‐9/15 and PDP‐11. Not surprisingly the algorithm incorporating the extended arithmetic capability executes faster and the PDP‐11 versions are substantially smaller.
Debugging other languages in APL
Authors: Geller Dennis P.
Published: November 2006

The advantages (and disadvantages) of on‐line debugging have been discussed extensively in the profession. We propose to couple APL with the debugging process. Techniques for ‘translating’ other languages into APL are presented, and the trade‐off between the cost of this translation process and the benefits to be gained by debugging in APL are discussed in terms of an actual PL/1 programming project.
A multiprogramming nucleus with dynamic resource facilities
Authors: Shaw Alan , Weiderman Nelson , Andrews Gregory , Felcyn Mary‐Beth , Rieber John , Wong Gain
Published: November 2006

This paper describes a nucleus for controlling process interaction in multiprogramming systems. The nucleus has three components: a set of primitive operations and data structures for the management of processes and resources, a library of service routines for implementing a variety of resource management strategies and facilities for cleanly handling all input‐output and interrupts. The process management component is straightforward, but the resource facilities are novel in permitting the dynamic definition and control of classes of real or virtual resources. Resources are considered to be anything on which a process can be blocked and consequently encompass consumable (message‐like) as well as conventional, re‐usable objects. Applications of the nucleus as well as some implementation details are also presented.
Simple transforms for instrumenting fortran decks
Authors: Lyon Gordon , Stillman Rona B.
Published: November 2006

A recent revival of interest in measuring program execution behaviour has led to a number of distinct approaches. Arguments are given for a fairly simple method of modifying FORTRAN source code to collect frequency counts. No symbol table is necessary and only a single reserved name is introduced into the source.
Biomac: Block structured programming using PDP‐11 assembler language
Authors: Herman‐Giddens G. S. , Warren R. B. , Barr R. C. , Spach M. S.
Published: November 2006

Users of small computers must often program in assembler language. Macros are described which assist in the construction of block structured programs in assembler language. The macros are used in practical day‐to‐day programming in a cardiac electrophysiology laboratory in which the coarse grained control provided by the local FORTRAN compiler is not sufficient for, and even hinders, the writing of clear, easy to understand programs. The macros provide nestable control structures in place of the less structured transfers of conventional assembler language. The arithmetic and input/output control provided by the architecture of the machine is left fully available. The control structures implemented include conditional (IF, CASE), iteration (WHILE, REPEAT/UNTIL, FOR) and subroutine (PROC, CALL, etc.) constructs. No control of variable scope is provided. The macro implementation is discussed along with the code generated. There is a discussion of architectural features which allow the macros to be independent of specific register usage and addressing mode. Experience with use of the macros in a high‐speed, real‐time data acquisition and display environment is presented. We conclude that these macros are easy to use and assist in program readability and documentation.
Postlude to a PASCAL‐compiler bootstrap on a decsystem‐10
Authors: Grosse‐Lindemann C. O. , Nagel H. H.
Published: November 2006

There can be a considerable difference between a portable compiler and a usable one which is a high level language implementation with a fair chance of acceptance by the general public in competition with other—vendor supported—systems. The experiences gained in pushing a portable PASCAL compiler across such an acceptance barrier are discussed in detail. Comments on some shortcomings of the PASCAL definition and suggested remedies are included.

As a result, it seems feasible to reduce drastically the effort required for a bootstrap by supplementing a bare bone portable compiler with features hitherto considered as luxuries in this context. Only language Implementations which are portable in this broader sense might spread sufficiently easily to survive the competition, especially if the impact of increasingly available access to computer networks is considered.
Graph plotting in ALGOL 68‐R
Authors: Earnshaw R. A.
Published: November 2006

This paper describes the facilities that have been provided for plotting graphs in Algol 68‐R. The advantages of the method of approach arc discussed and examples of use are given.
A pascal compiler for PDP 11 minicomputers
Authors: Bron C. , De Vries W.
Published: November 2006

In this paper the development of a cross‐compiler running on the central computing facility is described. The compiler transforms PASCAL source code into object code for the PDP 11 family. The arguments for higher level languages on minicomputers and the choice made for PASCAL are discussed. It is shown that only a minor effort in terms of manpower is required if such a development is based on an existing compiler that is suited to the purpose of adaptation. Even without large amounts of optimization the code produced is both compact and efficient. Some attention is paid to requirements that should be fulfilled in portable compilers. The paper ends with a discussion of some strong points and weak points of the PDP 11 architecture.
The solo operating system: A concurrent pascal program
Authors: Hansen Per Brinch
Published: November 2006

This is a description of the single‐user operating system Solo written in the programming language Concurrent Pascal.* It supports the development of sequential and concurrent Pascal programs for the PDP 11/45 computer. Input/output are handled by concurrent processes. Pascal programs can call one another recursively and pass arbitrary parameters among themselves. This makes it possible to use Pascal as a job control language. Solo is the first major example of a hierarchical concurrent program implemented in terms of abstract data types (classes, monitors and processes) with compile‐time control of most access rights. It is described here from the user's point of view as an introduction to another paper describing its internal structure.
Disk scheduling at compile time
Authors: Hansen Per Brinch
Published: November 2006

This paper describes a simple algorithm* for allocating program files on a disk with a moving head. The algorithm tries to place a file on consecutive pages (but will scatter them somewhat if necessary). It then rearranges these pages to minimize the rotational delay during a sequential scan of the file. This method combines the best features of consecutive and non‐consecutive allocation: fast sequential access and fast allocation. It is used in the Solo operating system to reduce program loading time by a factor of 3.
The design and implementation of an interactive document editor
Authors: Coulouris G. F. , Durham I. , Hutchinson J. R. , Patel H. H. , Reeves T. , Winderbank D. G.
Published: November 2006

General‐purpose text editors have significant drawbacks when used for document preparation. This paper describes a system designed to combine the editing and formatting power of a text editor with the simplicity and immediacy of a typewriter for document preparation. The system is implemented on a minicomputer with a simple alphanumeric visual display unit.