bluuebunny/crossref_metadata_2025 huggingface dataset:
Reverse‐engineering and intermodular data flow: A theoretical approach
Authors: Canfora G. , Cimitile A.
Published: November 2006

Starting from the need for formalization and models to represent and repeat reverse‐engineering activities, this paper presents a proposal in the field of data flow analysis. In particular, the authors propose a formal model for a practical approach to the reconstruction of intermodular data flow associated with the structure charts of a Pascal software system. Specific matrices extracted straight from code are presented and matrix calculation is then exploited to obtain a final matrix containing all the information needed for the reconstruction of the data flow. Finally, this flow is reconstructed by means of transformations on the elements in this matrix.
Athena: A software measurement and metrics environment
Authors: Tsalidis C. , Christodoulakis D. , Maritsas D.
Published: November 2006

ATHENA is a parametrizable software tool oriented towards the measurement of software quality characteristics. Measurement is based on the syntax and semantic (graph‐based) analysis of programs. ATHENA is language‐independent and customizable, i.e. language specifications as well as measurement algorithms are input to the tool which automatically generates the measurement environment for the corresponding language. Currently ATHENA has the ability to support Pascal, ADA and C and offers the possibility of measuring a set of kernel metrics (e.g. Halstead's ‘Software Complexity Measure’, McCabe's ‘Cyclomatic Complexity Metric’, Tai's ‘Data Flow Complexity Measure’ etc.). A specially designed specification language allows for easy implementation of design and code metrics. This is one of the reasons that ATHENA is particularly useful for software maintainability control.
The maintenance problem of application software: An empirical analysis
Authors: Alkhatib Ghazi
Published: November 2006

This paper presents findings from the analysis of data contained in reports and documents maintained by an MIS department of a major pharmaceutical and nutritional manufacturer. To guide data collection, the paper develops a conceptual framework consisting of a descriptive scheme and an explanation model. The descriptive scheme classifies maintenance activities into four categories: adaptive, corrective, perfective, and ongoing support. The explanation model identifies meta‐factors that affect maintenance activity. The meta‐factors are age, size, programming language, processing environment, structured programming, modularization, analysis and design methodologies, end‐user involvement, documentation generation, and maintenance management. The paper analyses three business functions with high, middle, and low average time per repair maintenance project (ATM) measured in person‐hours over a period of one year. Each function has several systems, and each system consists of modules. The analysis of available data for all functions maintained shows that maintenance (both repair and update) consumed 49% of data processing (DP) resources. For the three functions, the majority of these resources are devoted to perfective maintenance and corrective maintenance. Guided by the explanation model, several variables belonging to the meta‐factors are identified. The following variables have the most significant influence over maintenance: real‐time processing, database processing, end‐user ongoing support, module size, number of runs and runtime per module, and number of reports and number of copies per function.
A framework for software maintenance: A foundation for scientific inquiry
Authors: Haworth Dwight A. , Sharpe Shane , Hale David P.
Published: November 2006

This manuscript develops a framework for software maintenance. The development is based on an approach called ‘grounded theory’, which is an iterative process of theory formation and empirical assessment. The framework's purpose is to unite past theoretical concepts and scientifically observed facts. The result is a four‐component model consisting of programmers, source code, maintenance requirement, and organizational influences. The interaction of these four components provides 16 distinct areas of software maintenance inquiry. The manuscript concludes by providing sample uses and implications for the use of the framework.
Document quality indicators: A framework for assessing documentation adequacy
Authors: Arthur James D. , Stevens K. Todd
Published: November 2006

This paper presents the results of an ongoing investigation that focuses on assessing the adequacy of project documentation through an identified taxonomic structure relating numerous documentation characteristics. Previous research in this area has been limited to the study of isolated characteristics of documentation and English prose, without considering the collective contributions of such characteristics. The research described in this paper takes those characteristics, adds others, and establishes a well‐defined approach to assessing the ‘adequacy’ of software documentation. The identification of document quality indicators (DQIs) provide the basis for the assessment procedure. DQIs are hierarchically defined in terms of document qualities, factors that refine qualities and quantifiers that provide for the measurement of factors.
On the re‐engineering of transaction systems
Authors: Kozaczynski Wojtek , Wilde Norman
Published: November 2006

This paper provides a framework for considering the problems of re‐engineering transaction processing systems. Such systems are key components of most modern business operations, and their continued enhancement is crucial for competitiveness.

The paper grew out of a study of software re‐engineering problems and practices carried out by Andersen Consulting at several major companies in the telecommunications industry. It describes some of the practical difficulties found in re‐engineering transaction systems, especially the problems caused by the need for an incremental approach and the difficulties of re‐engineering in parallel with the continuing evolution of the operational system.

This paper presents a model of the maintenance and re‐engineering processes showing the main activities that are needed and the data flows among them. Existing tools for re‐engineering are then analysed against this model to identify gaps and potential for further tool development. Finally, there is a brief discussion of the very stringent personnel needs of software re‐engineering projects.
MACS: Maintenance assistance capability for software
Authors: Georges Mari
Published: November 2006

MACS1 has for its objective the definition and implementation of a software maintenance assistance system. A basic premise is that all maintenance activities require understanding of the application under maintenance, and hence the maintainer could profit by expression of the application's design (the facts) and the rationale behind it (the reasons). Furthermore, MACS proposes to aid the maintainer in approaching the problem at hand, in formulating and applying a strategy, and in fully exploiting the possibilities of the MACS tools themselves. Using knowledge representation and expert system techniques, the MACS project is developing a tool‐set that will provide the means to analyse existing systems and to capture information about new applications, for maintenance purposes.
Reverse‐engineering cobol via formal methods
Authors: Lano K. , Breuer P. T. , Haughton H.
Published: November 2006

We describe methods and software tools which aid in reverse‐engineering COBOL application programs back to specifications (and in validating them against specifications). The aim is to create object‐based abstractions from the implementation to capture design and functionality. The central process which the tools support is ‘transformation from formalism to formalism’, first from COBOL to the intermediate language Uniform, then from Uniform to a functional description language, and then to the specification language Z. In the process, dataflow diagrams, entity‐relationship diagrams and call‐graphs, and other types of information, are extracted from the code.
pRETS: A parallel reverse‐engineering toolset for FORTRAN
Authors: Harrison Warren , Gens Cynthia , Gifford Bruce
Published: November 2006

The widespread acceptance of parallel and distributed processing will result in migration of millions of lines of sequential code to parallel environments over the next decade. Unlike movement across sequential environments, significant structure and code changes must be made in order to benefit from the increased processing power of parallel computing. Nowhere is this problem more obvious than in the scientific computing community. The sequential nature of FORTRAN has limited its ability to utilize the performance achievable from parallel and/or distributed systems.

Strand, a concurrent logic programming language based on Edinburgh Prolog, is intended to exploit concurrency in both parallel and distributed environments, while offering portability across a variety of platforms and topologies. Strand minimizes reprogramming of existing software by providing a Foreign Language Interface (FLI) which allows inclusion of C and/or FORTRAN code in Strand programs. This paper describes a set of tools called the pRETS (parallel Reverse engineering ToolSet) which supports the semi‐automated conversion of FORTRAN programs into Strand Foreign Language Kernels.
A reverse‐engineering approach to subsystem structure identification
Authors: Müller Hausi A. , Orgun Mehmet A. , Tilley Scott R. , Uhl James S.
Published: November 2006

Reverse‐engineering is the process of extracting system abstractions and design information out of existing software systems. This process involves the identification of software artefacts in a particular subject system, the exploration of how these artefacts interact with one another, and their aggregation to form more abstract system representations that facilitate program understanding.

This paper describes our approach to creating higher‐level abstract representations of a subject system, which involves the identification of related components and dependencies, the construction of layered subsystem structures, and the computation of exact interfaces among subsystems. We show how top‐down decompositions of a subject system can be (re)constructed via bottom‐up subsystem composition. This process involves identifying groups of building blocks (e.g., variables, procedures, modules, and subsystems) using composition operations based on software engineering principles such as low coupling and high cohesion. The result is an architecture of layered subsystem structures.

The structures are manipulated and recorded using the Rigi system, which consists of a distributed graph editor and a parsing system with a central repository. The editor provides graph filters and clustering operations to build and explore subsystem hierarchies interactively. The paper concludes with a detailed, step‐by‐step analysis of a 30‐module software system using Rigi.
Software configuration management issues in the maintenance of existing systems
Authors: Capretz Miriam A. M. , Munro Malcolm
Published: November 2006

The application of the Software Configuration Management (SCM) discipline during the maintenance process of an existing poorly documented software system is vital to bring it under control. Incremental documentation, the activity of building up the software documentation whilst it is examined during the maintenance process, has a key role in such a process. The COMFORM (COnfiguration Management FORmalization for Maintenance) system provides a framework for aiding the maintenance process through the application of the SCM discipline. In this way reliable documentation of an existing software system is obtained incrementally whilst maintaining it. Our goal in the design of the COMFORM system is to define a method for the maintenance process through the use of forms representing each phase of a software maintenance model. This approach allows traceability among the software representations throughout the software maintenance process. In this paper we describe the foregoing steps of the COMFORM system's method towards its formalization.
An early impact analysis technique for software maintenance
Authors: Turver Richard J. , Munro Malcolm
Published: November 2006

The accurate estimation of the resources required to implement a change in software is a difficult task. A method for doing this should include the analysis of the impact of the change on the existing system. A number of techniques for analysing the impact of a change on the source code have been described in the literature. While these techniques provide a good example of how to apply ripple effect analysis to source code, a weakness in these approaches is that they can be difficult to apply in the risk assessment phase of a project. This is because the source code is often not very well understood at this phase, and change proposals are written at a much higher level of abstraction than the code. It is therefore often the case that in practice subjective impact analysis methods are used for risk assessment and project investment appraisal. The underestimated resources for dealing with the ripple effects of a change can result in project schedules becoming so tight that only the minimal quality is achieved. This paper surveys existing ripple analysis techniques and then presents a new technique for the early detection of ripple effects based on a simple graph‐theoretic model of documentation and the themes within the documentation.

The objective is to investigate the basis of a technique for analysing and measuring the impact of a change on the entire system that includes not only the source code but the specification and design documentation of a system, and an early phase in the maintenance process.
An investigation into software maintenance—Perception and practices
Authors: Layzell Paul J. , Macaulay Linda A.
Published: November 2006

This paper presents the results of a survey conducted on the perceptions and practices in software maintenance in five major companies in the United Kingdom. It is clear from the study that software maintenance is undergoing a significant transformation, in particular, in terms of its image, its relationship with users and in the nature of software maintenance tools required.

The image of the software maintenance task appears to be changing from one which is dull, passive and isolated to one which is reactive, responsive and vital to the business. Maintenance departments are becoming more accountable to user departments and are developing a market orientation. The study found little use of existing software maintenance tools and identified a need for support technology which will facilitate communication between users, developers and maintenance staff.

The paper presents the background to the investigation, the procedures followed and a summary of current practice. An analysis of the material highlights the main problems and trends identified within software maintenance practice and its implications upon organizational structure.
A design for information systems which can adapt to changing organizational requirements
Authors: Sillince J. A. A.
Published: November 2006

Systems requirements change, which necessitates expensive and error‐prone maintenance. Such change is unavoidable, because requirements are intellectually and politically fluid. A five‐stage method is suggested for developing systems which adapt to their host organization. Business rules are established during a negotiation stage, which consists either of making contracts if agents have resources to exchange and compatible goals, or of argumentation when such conditions do not apply. Business rules, specification, preconditions and postconditions, and program control flow are discussed, and transition rules specified for moving from one stage to the next. The environment enables users and maintenance programmers to renegotiate business rules at any time and to regenerate program control flow automatically.
The economic impact of software reuse on maintenance
Authors: Schach Stephen R.
Published: November 2006

Software reuse has traditionally been put forward as a mechanism for reducing the cost of developing a product. This paper shows that the overall economic impact of reuse on maintenance is greater than its impact on development. A specific reuse example is worked in detail to illustrate the impact of reuse on the various types of maintenance that are performed on a software product. On average, the cost savings during maintenance as a consequence of reuse are nearly twice the corresponding savings during development. The results are generalized to show that, for an arbitrary product, the cost savings during maintenance as a consequence of software reuse exceed the cost savings during development as a consequence of reuse when more than about 51% of the software budget is devoted to maintenance, and increase rapidly as the proportion of the budget devoted to maintenance becomes large.
Inverse‐engineering a simple real‐time program
Authors: Younger E. J. , Ward M. P.
Published: November 2006

Reverse‐engineering of interrupt‐driven, real‐time programs with timing constraints is a particularly challenging research area, because the functional behaviour of a program, and the non‐functional timing requirements, are implicit and can be very difficult to discover. However, in this paper we present a significant advance in this area, which is achieved by modelling real‐time programs with interrupts in the wide spectrum language, WSL. A small example program is modelled in this way, and formal program transformations are used to derive various timing constraints and to ‘inverse‐engineer’ a formal specification of the program. (We use the term ‘inverse‐engineering’ to mean ‘reverse‐engineering achieved by formal program transformations’.)
Downsizing large application programs
Authors: Sneed Harry M. , Nyary Erika
Published: November 2006

There is a great demand in industry to migrate from the mainframe to distributed client/server type systems. The following paper proposes three methods of splitting up oversized host application programs with the goal of offloading them on to workstation computers. The three approaches are by procedural connection, functional decomposition, and abstract data typing. The author describes his experience in applying each of the methods and explains what other measures are necessary to downsize a program.
An object finder for program structure understanding in software maintenance
Authors: Ogando Roger M. , Yau Stephen S. , Liu Sying S. , Wilde Norman
Published: November 2006

The maintenance or re‐engineering of a program usually begins with considerable effort in understanding the program structure. In this paper, an interactive tool for understanding the structure of non‐object‐oriented programs, known as the Object Finder, is presented. The structure of a program is defined in terms of the groupings of routines and data into modules within the program and the hierarchical relationships among the modules. The Object Finder incorporates two complementary approaches, one being top‐down and the other bottom‐up, to assist the software engineer in understanding the structure of a program based on the object‐like features found in the program. In the top‐down approach, the user obtains an overall understanding of the entire program as a collection of hierarchically organized objects. In the bottom‐up approach, the user obtains a view of the information which is closely related to the components under examination.

In both approaches, two methods are used to identify the objects in a program written in a non‐object‐oriented programming language. These methods identify sets of objects based on the data bindings and on the type bindings found in a program. An object is considered as a collection of routines, types, and/or data items of the program. The Object Finder combines the top‐down and bottom‐up approaches while using human input to guide the object identification process. Two examples of using this Object Finder are also presented to demonstrate the capabilities of the approaches to assist the software engineer in attaining a high‐level understanding of the program structure.
Life‐cycle approach to strategic re‐engineering of software
Authors: Jarzabek Stan
Published: November 2006

Software systems must be constantly upgraded to be in tune with an evolving business environment. Owing to the inefficiency of current maintenance methods, many of the old programs do not meet companies' strategic needs. Can we re‐engineer those programs or must they be rewritten from scratch? Common goals for re‐engineering software have been to improve maintainability of programs and to convert programs into a newer computer, database or language. In this paper, we describe a framework for strategic re‐engineering in which programs are substantially redesigned in order to meet companies' strategic goals. Strategic re‐engineering is much like redevelopment, accelerated by reuse of information that is extracted from existing, still viable from the business point of view, progams. We discuss the impact of companies' strategic plans on software re‐engineering and describe life‐cycle phases of strategic re‐engineering with CASE.
Measuring the readability and maintainability of hyperdocuments
Authors: Hatzimanikatis A. E. , Tsalidis C. T. , Christodoulakis D.
Published: November 2006

The problem of poorly written hyperdocuments has already been identified. Furthermore, there is no complete definition of hyperdocument quality and the methodology and tools that will help in analysing and assessing the quality of hyperdocuments are missing. The ability to measure attributes of hyperdocuments is indispensable for the fields of hyperdocument authoring and hypertext engineering. Useful paradigms can be drawn from the practices used in the software engineering and software measurement fields.

In this paper we define a hyperdocument quality model, based on the ideas of the well‐known Factor‐Criteria‐Metric hierarchical model. The important factors of readability and maintainability are defined, as well as the corresponding criteria. Finally, structure metrics, that can be computed on the hypertext graph, are presented. Most of these metrics are derived from well‐known software metrics.

Experimentation is a key issue for the application of measurement, and flexible tools for the automatic collection of measures are needed to support it. Athena, a tool that was originally developed for software measurement and later tailored to meet hypertext measurement needs, is used for hyperdocument measurement.
A new algorithm for the calculation of transitive dependences
Authors: Livadas Panos E. , Croll Stephen
Published: November 2006

Program slicing can be used to aid in a variety of software maintenance activities including code understanding, code testing, debugging, and program re‐engineering. Program slicing (as well as other program analysis functions including ripple analysis) can be efficiently performed on an internal program representation called a system dependence graph (SDG). This paper will describe a new method for calculating transitive dependencies in the presence of recursion. This method requires neither the (explicit) calculation of the GMOD and GREF sets nor the construction of a linkage grammar and the corresponding subordinate characteristic graphs of the linkage grammar's nonterminals. Additionally, a beneficial side effect of this method is that it provides us with a new method for performing interprocedural, flow‐sensitive data flow analysis.

Finally, this paper will illustrate the versatility of the SDG as an internal program representation by briefly describing a tool that we have developed that permits slicing, dicing, ripple analysis, and other static analysis functions to be performed on programs written in a subset of ANSI C (e.g., C without gotos and pointers).
Measurement of functional reuse in maintenance
Authors: Abran Alain , Desharnais Jean‐Marc
Published: November 2006

This paper is concerned with the identification and measurement of reuse within projects in which functional enhancements have been added to existing software applications. The proposed approach is based on the measurement of reuse from a functional perspective rather than from a technical perspective. Two key concepts are introduced: a reuse indicator and a predictor ratio. The reuse indicator is derived from an analysis of the function types as currently defined in Function Points Analysis. The predictor ratio is derived from an understanding of the avoided‐cost concept and of how it can be captured using historical databases of function points from previous development projects. This paper indicates how, in functional enhancement projects, the predictor ratio can be combined into the reuse indicator to derive an alternative size measure which takes into account functions reused and not redeveloped. The paper also demonstrates how these ratios can then be integrated in a maintenance productivity model to analyse the benefits of reuse by taking into account the avoided cost of functions reused. A case study based on an industrial data set is provided to illustrate the measurement of functional reuse in an enhancement project and its impact in maintenance productivity analysis.
On the distinction between functional development and functional maintenance
Authors: Krogstie John
Published: November 2006

The large amount of work on information systems being taken up by maintenance activities has been one of the arguments of those announcing a ‘software crisis’. In this article we have investigated the applicability of this statement, and propose instead to look at the percentage of work being done on functional maintenance to assess the efficiency of the information system support in an organization, seen from the end‐user's point of view.

A survey with results from 52 Norwegian organizations on development and maintenance of information systems has been performed, and some of the results are presented in the article. These are compared with results from similar investigations acting as calibration for our more novel results on functional development and maintenance. This is the first time to our knowledge that figures for functional maintenance have been investigated in a survey.

From a functional point of view, the situation is better than previously perceived. Still, almost 45% of the work being done on computerized information systems in organizations is functional maintenance, i.e. not improving the information system support of the organization functionally. The amount of functional maintenance appears to be negatively correlated with the size measures for the organization, and with organizations having a well‐developed maintenance and development methodology, although further investigations should be performed to uncover the mechanisms of functional maintenance.
A survey instrument for understanding the complexity of software maintenance
Authors: Stark George E. , Oman Paul
Published: November 2006

Software maintenance is a multi‐faceted, multidimensional effort that, upon inspection, is larger and more complex than it first seems. At least three components contribute to the complexity of the software maintenance effort: (1) the code and documentation being produced, (2) the process used to manage the maintenance, and (3) the maintenance and target computer system environments. This paper describes the development and use of a simple spreadsheet tool designed to measure the complexity of a software maintenance release. The tool can be used by software maintenance managers to direct their attention at the cost drivers associated with a software maintenance release, to aid in the re‐engineering decision, and to keep track of the degradation or improvement associated with a software system due to maintenance actions or process improvements. The approach has been successful in identifying complex deliveries and identifying components that contributed the greatest to that complexity.
A software architecture for the 70's: Part I—the general approach
Authors: Spooner C. R.
Published: November 2006

A framework is described on which it should be possible to construct general purpose systems suitable for the 70's. The companion paper will describe a particular implementation; comparisons with other recent approaches are deferred to a subsequent paper. The first section of this paper postulates the requirements of the 70's, concluding with the need for a useful method of modularizing, which both recognize, that code is seldom perfect, and allows hitherto mandatory and untouchable components to be optional and alterable. The second section develops an approach to modular structure. It takes as the three basic ingredients: Activities (or processes), tools (code, processors, etc.) and the organization of applying the tools to the activities. The structure modularizes both what happens (into activities) and the code that is used (into logical and into physical units). By developing the role of the central organizing element, as a caretaker of management decisions taken by activities, a means of modularizing the management function is arrived at. The third section discusses the extent to which implementation to date has vindicated the theory, makes some observations on the interface with the hardware, and as a postscript traces the evolution of the concepts.
Installing an ASP system
Authors: Evans J. B.
Published: November 2006

This article describes the installation of an ASP System on 3 × 360/65 computers at Rolls Royce Limited. It shows the benefits from controlling the total resources of the computers from a central point and the secondary benefits from the additional ASP facilities. The installation plan is described and indicates that factors taken into account when changing over to ASP. These factors required a team of highly skilled people working for several months and many modifications to the basic ASP System

The article concludes with a practical assessment of the final system.
A design for a text editor
Authors: Bourne S. R.
Published: November 2006

This paper describes a program for editing text on the Titan (prototype ICL Atlas II) computer at Cambridge University

The program is an essential part of the multiple‐access system that is in operation on that computer, although it is also used non‐interactively through the more conventional job‐shop system. The program, EDIT, has also been implemented on an IBM 1130 and an IBM 360/65

Among the facilities provided by this program are the basic operations of text replacement, insertion and deletion

Editing operations may be specified either by line number or by reference to a particular context

The program is a compromise between a low cost, high‐speed system and the flexible multi‐function editor that is demanded by users from all departments of the University.
A planar graph drawing program
Authors: Hope Alexander K.
Published: November 2006

This paper describes a program, written in FORTRAN, for a 64K I.C.L. 4130 which will accept data describing the ordering of nodes and branches within the regions of a planar graph, and generate a two‐dimensional representation, without crossovers, from these data. The program was written to provide one of the basic ‘tools’ required in the development of a printed wiring board layout program for the electronics industry

The program generates display code which is sent to a satellite PDP‐7 computer driving a 340 display. On completion of the automatic drawing phase an interactive phase is entered in which the user can ‘tidy’ and label the drawing, by means of keyboard and light‐pen commands

Brief notes are included on the hardware, the data structures package (MINIJASP, derived from ASP) and the graphics package, employed.
A note on radix conversion for integers
Authors: Samet P. A.
Published: November 2006

A simple algorithm is presented for efficient computer conversion of integers from one radix to another. The method is shown to work for all radices and is also valid for multi‐length and mixed‐radix working.
Documentation and the management of a software project—a case study
Authors: Katzenelson Jacob
Published: November 2006

The purpose of this article is to discuss documentation and management technique in a software production project. It is claimed that clear and concise documentation is a major contribution to communication between people who are either inside or outside the software project and that such documentation plays an important role in the management of the project. A university software project is used as a case study to illustrate the above points and to describe the means for achieving them. This project developed a supervisor and an assembler for a small 4K words machine and at various times it involved up to ten parttime people (instructor and students). One of the goals of the project was the development and improvement of documentation technique, and the techniques described in this article were practised and improved as the project progressed. It is felt that with minor changes the conclusions of the university project can be used in industrial projects of similar size.
A macro facility for interactive display
Authors: Jones W. R.
Published: November 2006

This paper describes how a user of a graphical display unit, e.g. a designer or draftsman, etc. can create procedures at the console which will perform geometric constructions and calculations. These procedures may be recorded, and subsequently recalled and executed, using data values supplied by the user

This system may be regarded as an extension to the IBM program Graphic Part Programmer (GPP) Number 360D–23.4.003.1 The basic system utilized is the contruction part of this program which has been extended to provide drafting facilities. No programming courses are needed as no language is involved, and the only prior experience necessary is that needed to become familiar with the drafting system.
Software engineering techniques used in the development of the cambridge multiple‐access system
Authors: Landy B. , Needham R. M.
Published: November 2006

Testing and development of elaborate systems requires the assistance of sophisticated techniques and software aids at several stages in the process. These include systems for managing and manipulating the source text, producing and testing new versions in a realistic but ‘safe’ environment and arranging for easy and compatible fall back to a previous version in case of unforeseen difficulties. The paper describes a number of such aids that have been found useful during the development of the Cambridge Multiple‐Access system.
The design of the internal structure of the ICL george 3 operating system
Authors: Oestreicher M. D.
Published: November 2006

This is the first of two papers on the design of the low‐level internal structure of the ICL GEORGE 3 operating system. After a discussion of the background and ancestry of the system, descriptions of the core allocation system, the chapter changer and the co‐ordinator are given. An attempt has been made to give the reasoning behind the decisions made in the early design stages.
A second‐order bug with delayed effect
Authors: Pyle I. C. , McLatchie R. C. F. , Grandage B.
Published: November 2006

The HUW Multi‐Access system1 operates under OS/360. This note describes the analysis of a troublesome error in HUW. Related bugs are lurking in many other systems.
The kent on‐line system
Authors: Brown P. J.
Published: November 2006

KOS is a simple multi‐access operating system that is particularly geared to the needs of teaching and research. It is fully conversational in that it allows interaction between user and program at all times, and it supports a variety of teaching packages, compilers, application programs, etc.
Development of scheduling strategies in the TITAN operating system
Authors: Landy B.
Published: November 2006

Scheduling strategies are evolved to solve problems of selection in operating systems. Such strategies frequently undergo evolution in time as details of the specification are changed or, more frequently, as inadequacies in them are shown up by use in a heavily loaded system. This paper describes a number of scheduling strategies used in the TITAN system, and their development to meet changing circumstances or to overcome inadequacies.
Implementation of an editing algorithm. Allowing repeating corrections
Authors: Poole M. D.
Published: November 2006

A research project on the application of computers of computers to typesetting, financed by the Ministry of Technology, has recently been concluded at the University of Newcastle upon Tyne. The design of one of the programs developed as part of this project is discussed in this paper. The program is an editor which runs in batch mode and which has been extensively used for the correction and maintenance of files of natural language text in preparation for computer typesetting. An important feature of the program is the handling of repeating corrections which allow consistent changes of notation over arbitrary parts of the file as well as the more usual local or non‐repeating corrections. The internal representation of corrections which is used to implement this facility is described. An appendix gives some examples of corrections and illustrates some of the difficulties inherent in any such correction process.
Monitoring the operation of system software
Authors: Cuming C. B.
Published: November 2006

To provide a picture of the operation of system software on the University of Nottingham KDF9, a log of library, composer and compiler usage has been created dynamically during normal use of the machine. Analysis of the results points to one or two unexpected conclusions.
Talk—an interactive system for a small computer
Authors: Kingslake R.
Published: November 2006

TALK is an interactive file creation and editing system implemented on a very small computer. It provides facilities for FORTRAN syntax checking and an interactive ‘desk‐calculator’. Major computing tasks are sent over a high speed link to CDC 6600/6400 computers

A number of teleprinters can be controlled by TALK in the usual way, but also the card reader/line printer pair may be used as a terminal. This is useful for creating or printing large files

When a user has logged in he can work in one of several modes. These include INPUT, EDIT and CALCULATE modes. It is possible to nest modes, for example, by entering CALCULATE mode while in INPUT mode without losing one's place in the input file

An unusual feature of TALK is the ‘inclusion’ facility. This enables a user to specify previously filed text to be included within another file, either as the file is being created or dynamically whenever the file is used. It also gives users the ability to build up macros of commonly used commands. Many system commands are in fact macros with only simple primitives provided as executable code.
Practical experience with algol 68
Authors: Woodward P. M.
Published: November 2006

The ALGOL 68‐R system has been in successful use for over a year at the Royal Radar Establishment. The paper describes how ALGOL 68 came to be implemented for the ICL 1900 Series and adopted as the standard user language of the RRE computing service. The language can easily be learned as a modification and extension to ALGOL 60, but is best approached ab initio. The paper outlines all the main characteristics of ALGOL 68, including a brief section on independent compilation of program segments as provided in the ALGOL 68‐R system. The future of ALGOL 68 depends on how acceptable it proves to be; to judge from experience to date, there are no grounds for lack of confidence in the design of the language or the feasibility of implementation.
Some techniques in multi‐computer system software design
Authors: Pyle I. C.
Published: November 2006

This paper describes some problems and solutions in the design of software for a multi‐computer system for real‐time use. Particular concepts discussed are inter‐computer communication, computer‐aided reconfiguration, data integrity control, selective notification of amendements and the influence of debugging, testing and assembly sequence on the design approach. The problems of designing software for given hardware and ill‐defined functions are also mentioned.
A resource‐oriented time‐sharing monitor
Authors: Reiter Allen
Published: November 2006

A design for a time‐sharing monitor on a small‐to‐medium size computer is presented. A system objective is to achieve good resource utilization and thus be able to do more with limited resources. To this end, some assumptions are made about the user environment (information management applications), and some co‐operation is required from application programmers. The design is machine independent, but 360 and Sigma 2 implementations are also described.
Control of queues in a permissive society
Authors: Thomas R. E. , Kent P.
Published: November 2006

By attaching an XDS Sigma 2 computer to Atlas via a shared disk, a multi‐access facility has been developed without causing any interruption in the day to day running of the Atlas batch processing system. Jobs may be initiated on Atlas from a terminal and results from such jobs may be either returned to files or published on any of the normal Atlas peripherals

A statistics collecting package is included, which allows the gathering of information about any part of the system. Also, modifications can easily be made to the system to test the predictions of such a model. The model described here tries to relate response time to various system loads. In order to allow for the overlapping of disk and CPU time, we have queued the two activities in series

One of the useful side effects of constructing such a model is the focussing of attention on areas of the software which really do affect the response time. The paper outlines the development of this model, which is still in progress, highlighting some of the milestones and pitfalls encountered so far.
Abstract machine modelling to produce portable software—a review and evaluation
Authors: Newey M. C. , Poole P. C. , Waite W. M.
Published: November 2006

This paper discusses the use of abstract machine modelling as a technique for producing portable software, i.e. software which can be moved readily from one computer to another. An overview of the principles involved is presented and a critical examination made of three existing abstract machines which were used respectively to implement a macro processor, a text editor and a BASIC compiler.
The implemention of stab‐1
Authors: Colin A. J. T.
Published: November 2006

This paper describes the implementation of STAB‐1, a BCPL‐like language for a small PDP‐11 computer. The paper lays considerable emphasis on the actual techniques of implementation, and highlights some of the practical difficulties which were encountered. Finally, the experience gained is distilled into a set of precepts for compiler writers. The paper is seen as mainly tutorial in nature.
An implementation of phrase structures in algol
Authors: Housden R. J. W.
Published: November 2006

This paper describes an implementation of syntax definitions in ALGOL in the form of phrase structures which are translated into ALGOL source statements by a preprocessor. No analysis records are constructed but ALGOL statements within the syntax definitions specify any action to be taken as soon as data are recognized. The first sections are concerned with definitions of the syntax and the semantics of phrases and phrase elements. The use of ALGOL phrases is illustrated by a complete phrase structure program, and finally the method of implementation is described

This work arose from a need for extended teaching facilities in an environment in which the main programming languages in use were ALGOL and FORTRAN. The facilities implemented have also been used in applications requiring the input of structured data.
Solo—system for on‐line optimization
Authors: Pankhurst R. J.
Published: November 2006

SOLO (system for on‐line optimization) is a system of interactive computer programs for solving problems of optimization. It exists in two forms, one of which uses a teletypewriter exclusively for both input and output. The other retains the teletypewriter for input but presents outputs mainly on a cathode ray tube display. The optimization problem is expressed as the maximization of a function of an arbitrary bumber of parameters. Optimization problems often occur in engineering design, where it is often a matter of fitting a computed output, response or performance curve to the one desired. SOLO can be regarded as a tool for computer‐aided design in this sense. SOLO does not make use of any methods of numerical analysis, but relies instead on organized interactive searching. No function derivatives are computed, so that SOLO can be applied to any type of function. Experience so far suggests that SOLO is much more efficient with functions possessing many local optima than it is with functions which have just one maximum.
Generation of interactive displays from FORTRAN using the PDP ‐ 10/LDS‐1 computer graphics system
Authors: Lesk Arthur M.
Published: November 2006

The PDP‐10/LDS‐1 combination is a powerful and versatile computer graphics system. A package of programs described here permits the generation of displays and interaction with them by means of simple calls from FORTRAN programs. This makes computer graphics available to individuals who know a little FORTRAN but no assembler language. It serves also as a useful introduction to the LDS‐1 for experienced programmers who intend to learn the assembler language and to write their own programs

Experience with the language has shown that it is learnable quickly by the class of users at which it is aimed. In addition, the same package has been used by more experienced programmers as a powerful research tool in the study of conformations of biological macromolecules, such as proteins, DNA and RNA.
A notation describing corrections in files
Authors: Moudrý J.
Published: November 2006

A simple, human‐oriented notation enabling one to describe corrections in files is presented. The notation may be used as an input language for a program to produce a corrected file.
What was, what is and what should have been: A critical evaluation of the chilton multi‐access system
Authors: Thomas R. E. , Baldwin J. C.
Published: November 2006

The Chilton multi‐access system has been running for about three years, and it is now possible in the light of experience to look back critically at the decisions taken during its definition. No system is entirely perfect and, by considering the highlights and shortcomings of this one (which may be described as being of the ‘support system’ type), similar designs in the future can benefit.
An extension of FORTRAN containing finite difference operators
Authors: Gary John , Helgason Richard
Published: November 2006

Design of a language (PDELAN) to assist the programming of finite difference approximations to partial differential equations is described. A key part of the language is the representation of finite difference operators. The language is an extension of FORTRAN and is implemented as a preprocessor to a FORTRAN compiler.
PIT: A macro‐implemented implementation language
Authors: Zelkowitz Marvin V.
Published: November 2006

An implementation technique called PIT, for pseudo instructional technique, is described which utilizes the macro capabilities of most macro assemblers. A low level machine architecture is described via a set of macros that include some ‘high level’ features. Since the macros manipulate computer words, and refer to actual registers, their implementation in a system is relatively efficient, but since they do not reflect any one particular hardware design, they can be implemented by almost any macro assembler. Tests are built into the macros so that a PIT program will run without change on any machine that has defined these macros

This technique should provide an alternative to using higher level languages as implementation languages if the object code produced by those compilers is deemed too slow (or too large) for the application that is being programmed.