bluuebunny/crossref_metadata_2025 huggingface dataset:
Program view generation and change analysis using attributed dependency graphs
Authors: Al‐Zoubi Ratib , Prakash Atul
Published: November 2006

Software maintenance is usually the most expensive phase of the software life‐cycle. Program understanding and impact‐of‐change analysis are two of the major activities during this phase. In this paper, we describe attributed program dependency graphs (APDGs), a model to store information derived from the program source code and ease construction of tools for software maintenance. We show how the model can be used for interactive view generation and doing two kinds of impact‐of‐change analysis—incremental and comparison‐oriented. Incremental change analysis uses APDGs and a Rule Base to provide a way for the user to analysis the effect of proposed well‐defined changes. Comparison‐oriented change analysis allows a user to generate structural semantic differences between two versions of a subsystem after an arbitrary sequence of changes. We also introduce SCAN, a prototype collection of loosely integrated tools based on the APDG model and describe our experiences with the system.
Interview with E. Burton Swanson
Authors: Swanson E. Burton , Chapin Ned
Published: November 2006

E. Burton Swanson summarizes and explains his typology of software maintenance (corrective, adaptive, and perfective), and describes his research on maintenance. His two major projects have been the large DPMA study done in 1977 with Bennet P. Lientz, and the in‐depth intensive study of twelve sites done a bit over a decade later with Cynthia M. Beath. Professor Swanson includes some of his views of the current situation and future in software maintenance.
Assessing modularization and code scavenging techniques
Authors: Canfora G. , Cimitile A. , Visaggio G.
Published: November 2006

The destiny of legacy software is a relevant economic problem. Many companies are experiencing the friction that legacy systems oppose to the change and growth of their business. Nevertheless, these systems cannot be simply discarded and replaced with new ones developed according to the new organization requirements. Existing systems record a great deal of knowledge and expertise used to set up solutions to real problems in different application domains and it is imperative that this knowledge must not be lost, partly because it may not be recorded anywhere else than in the code.

This paper discusses the problems related to the modularization of legacy systems, with the emphasis being placed on the automation of code scavenging. It is argued that a balance must be struck between the modularization of legacy code, and the production of reusable, easy‐to‐evolve modules. The paper provides a framework for examining system modularization methods and identifies a set of attributes that define their quality. An overview of modularization techniques is presented, and an evaluation is made to assess their strength and identify and understand their major limitations. Finally, an attempt is made to identify techniques and tools that are nature enough to be transferred from research laboratories to industry.
The portability of the BCPL compiler
Authors: Richards M.
Published: November 2006

Methods of achieving program portability are discussed, with particular reference to the mobility of compilers. The method of transferring the BCPL compiler is then described including the specification of OCODE which is the language used as an interface between the machine independent and machine dependent parts of the compiler.
Simulating a small machine for teaching purposes
Authors: Goble P. N.
Published: November 2006

A need exists within universities, polytechnics and other educational establishments, for computers which are specifically designed for teaching purposes, particularly in the promotion of understanding how computers can be organized to process programs. Economically, it often makes more sense to design a teaching machine and then simulate it on an existing installation than to acquire a separate purpose‐built computer. This paper describes a simulation program that has been devised, and is currently in operation on the ICL 1907 at the University of Southampton, and comments on its power and use in the teaching situation.
An on‐line retail collection data system
Authors: Banton G. A.
Published: November 2006

This paper comprises a description of the evolutionary processes and the solution to the problem of a large data gathering system. The report defines the approaches and the use of an ‘intelligent’ terminal network, the file constructs and the main cycle programs designed for the system. Illustrations show the evolution from a mark sensing approach, with a slow 24 hour reconciliation, to an ‘on‐line’ application catering for ‘peaking’ of arrivals of milkmen and processing the return data as soon as received

The system is unique in its approach to a large dairy combine where costs, due to government control of price of products, have to be tightly controlled to provide adequate working margins.
Modularity the key to system growth potential
Authors: Taliaferro W. M.
Published: November 2006

General Electric's Apollo Systems has developed several information systems over the last eight years in support of the Apollo project. The expertise gained in these development efforts has shown the efficiency of a modularized approach to retrieval system design

Systems analysts and programmers who design and build these systems should follow the normal systems engineering approach of requirements definition, system design, system implementation, test and verification and operational installation. Short‐cutting any one of these phases leads to greater effort in one of the later phases, usually with a longer over‐all schedule or greater developmental cost

Project management, too, is a major factor in the success of such systems. The tracking of critical milestones in the schedule, consistent and up‐to‐date documentation, and comprehensive test and verification plans are necessary to a controlled approach to systems implementation

Finally, the benefits of such an approach are reduced cost and implementation time, along with simplification of system maintenance, standardized software, adaptability to new environments, and a potential for continued growth to meet users' ever‐expanding needs.
The evolution of a graphics system for linked computers
Authors: Kilgour A. C.
Published: November 2006

The development of a comprehensive two‐dimensional graphics package for an ICL 4130 with a high‐speed data link to a DEC PDP‐7 with Type 340 refreshed C.R.T. display and light pen is traced from its origin as a package of ALGOL procedures for graphical output. The design criteria imposed by the requirements for light‐pen tracking and identification of picture parts are described, and decisions which affected the subsequent development of the sysetm are identified and commented upon. The various types of display file editing which may be performed are described, and a facility mentioned for saving display files on the backing store of the PDP‐7. The idea of a ‘fixed‐function satellite’ is introduced and its potential usefulness in other operating environments discussed.
The design and implementation of the GINO 3D graphics software package
Authors: Woodsford P. A.
Published: November 2006

The design and implementation of a general purpose graphics software package (GINO) is described. GINO provides facilities for 3D graphics (co‐ordinate transformation, clipping, intensity modulation) but is organized so that 2D facilities form a clean subset. It is device independent, permitting use of refresh CRT displays, storage tube displays and plotters. A characteristic feature is the use of small satellite computers attached to a large multiaccess computer (ATLAS 2)

GINO takes the form of a subroutine library accessible from FORTRAN and other languages, and the case for this level of graphics software is argued. The reasons for not using a mandatory graphical data structure are also discussed. GINO is not biased towards any particular style of interaction, but two techniques are described; one based on the light pen and the other on teletype command languages

Efficiency of implementation is achieved without loss of flexibility by use of a systems programming language (SAL).
MAPLIB–A data bank of FORTRAN functions describing material properties
Authors: Schumann U.
Published: November 2006

MAPLIB is a program system which is able to incorporate the values of the properties of many materials in a form suitable for computer‐aided design. Thus, MAPLIB is a data bank whose customers are not men but computer programs with their much higher scanning rate. Therefore in MAPLIB the data are not stored in tables as usual but in algorithms implemented as FORTRAN functions

Such a program system should fulfil a number of conditions related to standardization, flexibility, security, effectivity, transparency and compatibility. In this paper these conditions are discussed in some generality and it is shown how they are implemented in MAPLIB.
Programming and compiling strategies for paging systems
Authors: Weinberg Gerald M.
Published: November 2006

Designers of paging systems have tended to believe that programmers can influence system performance, but usually for the worse, rather than for the better. Their efforts to find operating system solutions to poorly styled programs may have discouraged efforts to produce paging‐oriented compilers, to educate programmers in techniques to use under paging, and to open communication channels between the programmer and the paging system—all of which now promise to give increased satisfaction with paging systems.
A failure tolerant filing system
Authors: Whaley Alfred D.
Published: November 2006

A random access tree structure filing system has been constructed that is immune to operating system or internal failures through constant maintenance of a correct data structure on disk. Emphasis is placed on the fail‐safe nature of the filing system, the speed of access to random lines in a data file and the low level of human intervention required over an extended period of time.
Intraprogram documentation
Authors: Flores Ivan
Published: November 2006

Three kinds of documentation are examined: summary documentation describes the intent and nature of the program; detail documentation gives all the information the user needs to put the program to work; intraprogram documentation is information written into the program to inform the user or programmer. The need for intraprogram documentation occurs at four different times: in the initial design period; during debugging; as the program and system evolve; when it is necessary to adapt the program to other systems

There are several means for providing intraprogram documentation. There are comments which can be placed in the header, on each line, at the beginning and end of a subroutine. Also noted is the important use of space for making the comments easier to read and for separating chunks of the program. Special symbols serve the same purpose. Examples are provided to bring home these points.
Workload characterization for timesharing system selection
Authors: Nolan Lawrence E. , Strauss Jon C.
Published: November 2006

The problem of selecting a general‐purpose timesharing system satisfying performance criteria for user‐oriented tasks is examined and a new approach is developed. This approach characterizes the user workload by a set of terminal user level functions and results in a representative script.

A response time definition is developed and employed to measure the Xerox Sigma 7/UTS timesharing system and user community at McDonnell Douglas Automation Company.
The myth of multiprogramming
Authors: Schneck Paul B.
Published: November 2006

A common myth surrounding multiprogramming is that it it a necessary mode of operation to deal with the high levels of I/O activity found on most computers. This paper shows that the high level of I/O activity is to a great extent a direct result of multiprogramming. Monoprogramming is proposed as a method of achieving high performance which yields advantages in turnaround time, efficiency and equipment configuration.
A general purpose task queueing mechanism for small machines
Authors: Lang T. , Fox D. A.
Published: November 2006

A general purpose mechanism for the queueing of tasks is an important component in an ‘intelligent satellite’ system interfacing a community of users to a range of computing facilities. The queueing mechanism should provide spooling, warm and cold restarts, the ability to pool common resources (e.g. a number of line printers), a means of servicing the queues on a priority basis, and a flexible control mechanism for the system operators. The implementation of such a system for a small (i.e. 16‐bit) computer system is described.
Writing software in ALGOL
Authors: Brown P. J.
Published: November 2006

For many years the Burroughs Corporation has been writing software in ALGOL. Those of us who have no direct access to Burroughs hardware have always regarded this with interest, perhaps with envy. Nevertheless most of us have been just a little sceptical, as witnessed by the fact that, until recently, few have followed or imitated Burroughs' example. Outsiders have their doubts about efficiency and wonder about such questions as:

Is it really ALGOL?

Is the technique oriented to a particular type of hardware?

Are there some machine‐language ‘fiddles’?

This paper is simply a description of a personal software experience. Recently I had an opportunity to spend some time as a user of a Burroughs B6700, and to write some software for it in ALGOL. This article combines a tutorial introduction with a personal evaluation.
Random search on the 8‐queens problem or a simple solution for a simple problem
Authors: Plum Thomas W.‐S.
Published: November 2006

Certain principles of practical program development lead to a different approach to the 8‐queens problem: Do not re‐invent the wheel, solve the simple problem first, and worry about efficiency only when the program works and is needed often.
New format for flowcharts
Authors: Chapin Ned
Published: November 2006

This paper proposes a new chart format as an alternative for the flow diagram variety of flowchart. This new chart format is more informative, more compact and easier to use and draw than the ANS format, and facilitates modularization in design and programming. The new chart format supports restrictions on control transfers, and clearly identifies the control structures used in structured programming. The new chart format also permits showing multiple levels of detail unambiguously in a single flowchart, and enables HIPO charts and system charts to be usefully augmented.
The pfort verifier
Authors: Ryder B. G.
Published: November 2006

The PFORT Verifier is a program which checks a FORTRAN program (i.e. a main program and a set of subprograms) for adherence to a large, carefully defined, portable subset of American National Standard FORTRAN called PFORT. Unlike many FORTRAN implementations, the Verifier diagnoses errors in interprogram‐unit communication through argument lists and COMMON. The Verifier is itself written in PFORT and has been installed on a variety of computers. This paper describes the development of PFORT and the Verifier. A detailed definition of PFORT noting its differences from ANS FORTRAN is included.
Parallel processing in fortran with floating‐point hardware
Authors: Nelson James M. , Cohn Charles E.
Published: November 2006

With some types of floating‐point hardware, the central processor is free to perform other tasks while a floating‐point operation completes. The FORTRAN complier for the SEL‐840MP computer was modified to execute subscripting calculations in parallel with floating‐point operations where possible. This is done by operating on the triad table for an expression before scanning it to generate code. Skip pointers are inserted into the table to change the order in which entries are processed.
A portable diagnostic facility for SNOBOL4
Authors: Griswold Ralph E.
Published: November 2006

In programming systems based on abstract machine modelling concepts, the underlying structure of the abstract machine can be made available to the software implemented on it. The result is an unusual facility for diagnosis and exploration of software structure. Such a facility has been added to the macro implemention of SNOBOL4. This paper describes the nature of the facility, illustrates its use, and presents some results of using it for language implementation and development.
Gathering run‐time statistics without black magic
Authors: Yuval G.
Published: November 2006

It is shown that it is possible to gather run‐time statistics from a program without either slowing it down too much, or changing things such as the hardware or the operating‐system kernel.
The translation and interpretation of stab‐12
Authors: Colin A. J. T. , Shorey K. , Teasdale W.
Published: November 2006

This paper describes two of the abstract machines used to support the STAB‐1 language, and discusses some problems of implementing the language on two different computers, the DEC PDP‐11 and CTL's Modular‐1, Interpretation of the abstract machine code and direct translation is considered for both computers.
Experience with a conversational parser generating system
Authors: Cohen Jacques
Published: November 2006

The author describes some of his experience gained by working in the area of syntax‐directed compilers and parser generating systems during the past ten years. His most recent work in this area was designing and supervising the implementation of a conversational parser generator which has been operational for about two years. The paper describes this generator, its implementation, usage and the characteristics which make it practical to use. The author's main conclusion is that althouth it is relatively easy to implement nuclei of parser generating systems which are of educational value, the implementation of a practical system requires a major programming effort.
A general‐purpose software measurement tool
Authors: Ferrari Domenico , Liu Mark
Published: November 2006

A software measurement tool designed for the users of PRIME, an interactive system being developed, is presented. The tool, called SMT, allows its user to instrument a program, modify a pre‐existing instrumentation and specify how the collected data are to be reduced by typing in a few simple commands. The user can also write his own measurement routines, which specify the actions to be taken at event detection time, and submit them to the SMT; after checking their correctness, the SMT deals with them as with its built‐in, standard measurement routines. The design goals of a general‐purpose tool like the SMT are discussed, and the prototype version of the tool, which has been implemented, is described from the two distinct viewpoints of a user and of a measurement‐tool designer. An example of the application of the prototype to a measurement problem is illustrated, the reasons why not all of the design goals have been achieved in the implementation of the prototype are reviewed, and some of the foreseeable extensions of the SMT are described.
Development of an advanced satellite system
Authors: Fox D. A. , Lang T.
Published: November 2006

A basic satellite system consists of a minicomputer, with card reader and line printer, emulating the Remote Job Entry (RJE) workstation of a mainframe manufacturer. The addition of a disk stroe increases the range of facilities which can be offered by such a system. Apart from a number of subsidiary advantages, this leads to a system which can interface a community of computer users to its mainframe computing facilities, and hence to a user image which is stable over some long period of time. The paper outlines how an advanced satellite system was simply assembled from four basic components. These components were written in different languages by different institutions, but the use of a standard message passing programming interface provided a sound framework for the detection and elimination of errors.
Writing algorithms in algol 60
Authors: Hill I. D. , Scowen R. S. , Wichmann B. A.
Published: November 2006

This paper discusses the difficulties of writing procedures and programs in ALGOL 60 for general use. It also shows how the problems can be alleviated and overcome.
RATFOR—a preprocessor for a rational fortran
Authors: Kernighan Brian W.
Published: November 2006

Although Fortran is not a pleasant language to use, it does have the advantages of universality and (usually) relative efficiency. The RATFOR language attempts to conceal the main deficiencies of Fortran while retaining its desirable qualities, by providing decent control flow statements and some ‘syntactic sugar’. RATFOR is implemented as a preprocessor which translates this language into Fortran

Once the control flow and cosmetic deficiencies of Fortran are hidden, the resulting language is remarkably pleasant to use. RATFOR programs are markedly easier to write, and to read, and thus easier to debug, maintain and modify than their Fortran equivalents

It is readily possible to write RATFOR programs which are portable to other environments. RATFOR is written in itself in this way, so it is also portable; versions of RATFOR are now running on computers of six different manufacturers

This paper discusses design criteria for a Fortran preprocessor, the RATFOR language and its implementation, and user experience.
Portability—prediction and correction
Authors: Hague Stephen J. , Ford Brian
Published: November 2006

We consider the attainment of portability through the successive refinements of an initial coding attempt. This may be seen as prediction followed by correction. Recent attention has been given to the mechanical selection of software variants stored in a single composite file. We conclude that, under some circumstances, it is also necessary to consider the updating of the file as well as extraction from it.
Quick compiler construction using uniform code generators
Authors: Lancaster Ronald L. , Schneider Victor B.
Published: November 2006

This paper describes our experience in using a common set of code generating subroutines as the basis for compilers of ALGOL W, ALGOL 60 and subsets of PL/I and COBOL. The advantages of using a common set of primitives for implementing more than one compiler include: (1) greatly reduced effort to implement additional languages; (2) simplified maintenance of the generated compilers; (3) standardized diagnostic messages for all compilers implemented using this system; and (4) simplified documentation of the compilers.
A user‐oriented approach to control languages
Authors: Brunt R. F. , Tuffs D. E.
Published: November 2006

This paper describes the design approach adopted for SCL which is the control language of System B, the operating system of ICL's new 2900 Series of computers. The design emphasis of SCL is ‘usability’ and the paper sets out to show that SCL provides what users require.

The authors both work in the Systems Programming Division of ICL where the majority of their recent work has centred around the design of job management in System B and SCL in particular.
Testing ALGOL 60 compilers
Authors: Wichmann B. A. , Jones B.
Published: November 2006

This paper describes some programs used to test ALGOL 60 compilers. The results of the tests on six compilers are given together with some comments on their likely effectiveness in locating bugs in other compilers.
Systematic programming of scheduling algorithms
Authors: Shrivastava S. K.
Published: November 2006

This paper applies the technique of systematic (or structured) programming for programming scheduling algorithms as encountered in operating system design. Monitors are used for structuring scheduling algorithms and a synchronizing method is proposed for process scheduling. Some fairly difficult scheduling problems are solved systematically to illustrate the usefulness of the monitor concepts and the synchronizing method. Certain implementation aspects are also discussed.
Experience from the standardization of the SIMULA programming language
Authors: Palme Jacob
Published: November 2006

SIMULA is a high‐level language comparable in power to PL/I or ALGOL 68. SIMULA compilers exist for eight different computer series. SIMULA is standardized by a committee mainly consisting of one representative for each implementation. This has given good compatibility between the implementations and the efficient handling of standards problems. The fact that the SIMULA language is defined in such a way that there are no undefined constructs in the language has also helped compatibility and standardization.
Six PL/I compilers
Authors: Wortman David B. , Khaiat Phillip J. , Lasker David M.
Published: November 2006

This paper describes an experimental evaluation of the execution speed of object programs produced by six PL/I compilers. A set of 139 representative PL/I statements were compiled and executed under the PL/I Optimizing, PL/I(F), PL/C, PL/I Checkout, SP/k and PLUTO compilers. An analysis is made of the relative speed of the object code produced by each compiler and also of the relative execution speed of each statement.
Memoryless execution: A programmer's viewpoint
Authors: Gat Israel , Saal Harry J.
Published: November 2006

A set of rules for memoryless execution on third‐gene ration computer systems is presented. These rules facilitate binary memoryless interactions within the context of a trustable operating system, without restricting the dynamic use of central processor general purpose registers. An estimate of the required machine support indicates that the firmware modifications required for an implementation based on a segmented microprogrammable computer are not extensive. It is shown that the impact of the solution on operating system design is modest. Moreover, programming generality among memoryless programs is maintained.
Linking a CYBER76 to a 3600
Authors: Austin B. J. , Ewens P. M. , Hudson R. H.
Published: November 2006

In mid‐1973, the Division of Computing Research, CSIKO, took delivery of a Control Data CVBER76 computer, which acts as the primary processing power of the CSIRO computer network (CSIRONET), replacing the Control Data 3600. The 3600, running under the DAD operating system, has been retained as a ‘front‐end’ to the CYBER76 and continues to support the following functions:

An interactive system allowing both editing and CYBER76 job submission

Input of job files centrally from 3600 input devices, remotely from CSIRONET devices, or from interactive console users, and output of results similarly

A permanent file (document) system, with tape archiving

This paper describes the linking of the CYBER76 to the 3600. Software for a CYBER76 PPU has been written and some changes to the 3600 and CYBER76 operating systems have been required.
A review of design techniques for programs and data
Authors: Shneidebman Ben
Published: November 2006

The proliferation of papers on programming methodology focus on the program development process but only hint at the form of the final program. This paper distinguishes between the development process and the program product and presents a catalogue of possible program organizations and data structures with examples drawn from the published literature. The methods for sharing data among modules and a classification scheme for programs and data structures is presented.
Modula: A language for modular multiprogramming
Authors: Wirth N.
Published: November 2006

This paper defines a language called Modula, which is intended primarily for programming dedicated computer systems, including process control systems on smaller machines. The language is largely based on Pascal, but in addition to conventional block structure it introduces a so‐called module structure. A module is a set of procedures, data types and variables, where the programmer has precise control over the names that are imported from and exported to the environment. Modula includes general multiprocessing facilities, namely processes, interface modules and signals. It also allows the specification of facilities that represent a computer's specific peripheral devices. Those given in this paper pertain to the PDP‐11.
Compaction of diagnostic messages for compilers
Authors: Heaps H. S. , Radhakrishnan T.
Published: November 2006

The use of a space optimal storage scheme for compiler diagnostic messages is described. The space reduction achievable through word coding may be predicted in terms of text length, vocabulary size and average word length. A method of word or phrase selection is discussed. Illustration is made by application to the FORTRAN FTN and COBOL compilers under the operating system KRONOS for the CDC 6400 computer.
On the use of integer arithmetic to achieve confirmably correct computation
Authors: Neely Peter M.
Published: November 2006

An example is provided from biostatistics to show that transformation to a unit normal deviate can be inadvisable. This is used to motivate a definition of commensurable units of measurement. An argument is presented to show that a unit cell size can be determined that is termed the ‘least distinguishable difference’. The recommended commensurable unit is obtained by reseating the least distinguishable difference to unity. Thus, the data are transformed to Integer‐valued variates.

Since the transformed data are integer‐valued and optimally ranged for integer accumulation, this is recommended. On most computers integer overflow is detectable, therefore in the absence of overflow one is assured that the intervening computation is correct.

A few concluding remarks are appended.
A simulation sequencing algorithm
Authors: Macewen Glenn H.
Published: November 2006

In the course of developing a programming project for a course in operating systems, a general purpose language (Burroughs B6700 Algol) possessing concurrency and semaphores was used to provide a process oriented simulation sequencing facility. This facility has been used successfully to simulate several simple operating systems. The facility comprises three procedures along with ‘simulation semaphore’ variables. The first procedure, when called, inserts a simulated time delay into the progress of a simulation model process: the latter two procedures provide a P and a V operation on simulation semaphores, and are used to synchronize processes in a simulation model. The P operation may insert a simulated time delay into the progress of a process. These procedures are explained and presented along with a simple example to show their use.
Non‐interpretive' FORTRAN input/output
Authors: Torsun I. S. , Robinson S. K.
Published: November 2006

The classic method of dynamically matching input/output items to FORMAT field descriptors at program run‐time is reconsidered in the light of a static analysis of FORTRAN programs and the results from a basic FORTRAN batch compiler system.
A fast approximation to the sine function
Authors: Colquhoun D. G.
Published: November 2006

A function approximating the sine function is given which was designed for high speed when coded into a computer routine. The domain is divided into a small number of intervals and in each of these a straight line approximation is used. The slopes of the straight line segments have denominators which are powers of 2, and so an implementation needs no floating point multiplication or division operations. With [0, 1/2£] divided into only four intervals, an absolute error of about 0.013 is achieved by a routine taking just over a third of the time used by a more conventional one. Such accuracy is adequate for certain graphics applications, especially moving displays.
Converting a class of recursive procedures into non‐recursive ones
Authors: Rohl J. S.
Published: November 2006

The paper describes a technique for converting a class of recursive procedures which occur frequently in combinatorial problems into non‐recursive ones.
Non‐recursive recursion
Authors: Carpenter B. E. , Dohan R. W. , Hopper K.
Published: November 2006

A programming situation different from an exit on a condition, but where the effect of a GOTO statement is still necessary, is examined. A notation for expressing the desired effect and s mechanism for implementation are proposed.
Interpretation control using a linear tree representation
Authors: Lichtman Zavdi L.
Published: November 2006

A linear tree structure is considered for the internal representation of programs executed by interpreters. This representation is appropriate when one wishes to have an internal representation preserving the high level structures of the source language. The linear tree structure facilitates a simple mechanism for interpretation control in the context of high level control structures.
How to call procedures, or second thoughts on Ackermann's function
Authors: Wichmann B. A.
Published: November 2006

Various problems have been encountered in using Ackermann's function to measure the efficiency of procedure calls in System Implementation Languages. Although measurements have been made of some 60 systems, the ones presented here are included only when comparisons are possible. For conventional machine design, it is possible to draw some conclusions on desirable instruction set features. A surprising result from the analysis is that implementation quality is far more important than the overheads implied by language design.
A simple network interacting programs' executive (SNIPE)
Authors: Dawes N. W.
Published: November 2006

A small operating system SNIPE has been developed to enable minicomputers on the National Physical Laboratory's Data Communication Network to be used from terminals anywhere on this network. The system allows users to load and run programs over the network and provides network input and output facilities (e.g. for file transfers) with terminals and other computers. SNIPE has been kept small enough to be readily used for many network‐based minicomputer, microprocessor and intelligent terminal applications.
A language for inquiring about the run‐time behaviour of programs
Authors: Cohen Jacques , Carpenter Neal
Published: November 2006

This paper describes a language for studying the behaviour of programs, based upon the data collected while these programs are executed by a computer. Besides being a useful tool in debugging, the language is also valuable in the experimental evaluation of the complexity of algorithms, in studying the interdependence of conditionals in a program and in determining the feasibility of transporting programs from one machine to another. The program one wishes to analyse is written in an Algol 60‐like language; when the program is executed it automatically stores, in a data base, the information needed to answer general questions about computational events which occurred during execution. This information consists (basically) of the list of labels passed while the program is being executed, and the current values of the variables. Since the list of labels is describable by regular expressions, these expressions can also be used to identify specific subparts of the list and therefore allow access to the values of the variables. This constitutes the basis for the design of the inquiry language. The user's questions are automatically answered by a processor which inspects the previously generated data base. The paper also presents examples of the use of the language and describes the implementation of its processor.
Implementation independent arithmetic: Speculation for discussion
Authors: Neely Peter M.
Published: November 2006

The specification of a truly portable implementation independent programming language requires that digital arithmetic be specified in an implementation independent manner.

Variable length storage is proposed for digital numbers. Linked storage and linked overflow storage are proposed so as to enable the use of variable length numbers. It is suggested that significant digit arithmetic be used for single numbers and interval arithmetic be used for interval pairs. The question is put to numerical mathematicians to specify the decision rules to be used in deciding on the number of digits to be retained when computing in either the significant digit mode or in the interval mode. The question is also raised as to what other arithmetic modes should be provided for.

The speculation is offered not for the purposes of suggesting useful hardware design techniques but rather to indicate feasibility of some design. If the implementation independent arithmetic is considered feasible, then language designers can design a language freed from present hardware restrictions.
An operating system for interactive terminals
Authors: Wiseman N. E. , Robinson P.
Published: November 2006

Conventional operating systems have for many‐years used the ideas of standard stream interfaces to peripherals. Multi‐tasking has been used in order to give an efficient response while maintaining simplicity and flexibility for the user. This paper describes an extension to an operating system which makes similar facilities available for the control of interactive workstations, and also provides a command dispatcher which enables the straightforward implementation of arbitrary user‐defined command languages. The current system has been written in BCPL to run on a PDP 11/45 handling a Vector General display, but the design is suitable for use with a variety of terminals, computers and languages.
Profiling a large program
Authors: Fitch John
Published: November 2006

A profiling technique is used on a large algebra system, CAMAL, in order to determine where time is being used. The system is written in a machine‐independent language, and a machine‐independent measuring device is used. The end result is an improvement on various algorithms, which together save up to 70 per cent of the processor time when running user programs.
The evolution of a new discrete event simulation language for inexperienced users (WIDES)
Authors: Thesen Abne
Published: November 2006

This paper describes the evolution and use of the Wisconsin Discrete Event Simulator (WIDES). WIDES is a GASP‐based collection of ANSI FORTRAN subroutines and data structures designed as a discrete event simulation language for use on small machines by inexperienced users in an educational environment. A list of criteria for selection of a language for such use is presented. These criteria include considerations and constraints in areas such as the language's modelling capabilities, its programming ease, storage requirements, educational features, cost and availability. Among commonly available languages only GASP meets the postulated storage constraints. Unfortunately, this language exhibits a lacklustre performance in the other performance areas, and in our experience it is not an ideal language for the above‐stated audience and environment. However, GASP is based on a sound design, and it is extremely well implemented; thus, GASP was chosen as the basis for the development of a new language that meets the criteria stated above. This development is presented here. The resulting language is briefly presented and an example of its use is given. Program listings, users' guides and sample problems are available from the author.
EDIT—an interactive network service; design and implementation
Authors: Hillman A. L. , Schofield D.
Published: November 2006

EDIT is a time‐sharing system which offers interactive services over the NPL network. These services include various kinds of editing, word processing, data movement and file control. The system is implemented on a PDP11/40 and can serve up to 30 users simultaneously, on high‐speed displays and other terminals. There is an attached background processor (PDP11/45) which supports graphics and background jobs.

This paper describes the design and implementation of EDIT and relates this to the needs of the system and of its users.
The simulation and use of a TABLE data type in algol W
Authors: Shave M. J. R.
Published: November 2006

This paper reviews the role of RECORD and REFERENCE variables in Algol W, points out some restrictions in their use, and describes a method for simulating a new TABLE data type within the existing syntax. It is shown how the use of a few simple procedures generated in a preprocessor phase enable this new type to be used freely within dynamic structures of data. A comparison is made with some alternative methods of implementation in Algol W.
Steps to an efficient program for floating‐point summation
Authors: Ushijima Kazuo
Published: November 2006

This paper shows how helpful a tool for stepwise improvement of programs an execution profiler is. As a demonstration we develop an efficient program for getting the sum of n addends by using Huffman's algorithm. Rewriting an old version of a program step by step, using as a guide information about its dynamic behaviour obtained by the profiler, we finally get an efficient program whose CPU time is reduced to about 1/20 of the first version's for n = 200.
Some aids for program documentation
Authors: Scowen R. S.
Published: November 2006

The documentation of computer programs can be considerably eased and standardized using the programs described in this paper. They are basically machine‐ and language‐independent, possess a simple structure, use one serial input and one output stream, and require no backing store. The code size for each program is a few thousand bytes and the time for running them is dominated by that needed for input and output. The programs are:

INDEX (gives an index of all identifiers used in a program).

POLISH (paginates a program listing so that the global structure is evident).

WATER (helps find misprints in computer‐readable reports).

UNDOC (creates a live program from its documented form).

Also included are examples of the output from these programs.
An exercise in the transportation of an operating system
Authors: Snow C. R.
Published: November 2006

An attempt lo transport an operating system and some associated software from one machine to another is described. Some comments are made on the suitability of the system for such a task, and some recommendations are put forward to future operating system writers to assist in making their systems more portable.
The formal definition of human/ machine communications
Authors: Lawson Harold W. , Berthan Miquel , Sanagustin Javier
Published: November 2006

The specification of human/machine dialogues for general purpose terminals and special purpose consoles in a natural language is difficult and frequently leads to ambiguities and misinterpretations between terminal and dialogue constructors and users. In this paper, the problem of operator console definition is related to the problem of language and language translator definition. An efficient metalanguage tool (TBNF) for the handling of the latter problem is applied to the solution of the first problem. An example from the Telecontrol of a Power Network, being developed at ENHER (Barcelona, Spain), is described as an illustration.
Economic range checks in pascal
Authors: Welsh J.
Published: November 2006

A Pascal implementation is described which exploits the information provided by subrange type declarations to minimize the run‐time checking involved in detecting range violations. An evaluation of its performance is given, and some possible modifications are discussed.
Event associations in SNOBOL4 for program debugging
Authors: Hanson David H.
Published: November 2006

An event association facility for the SNOBOL4 programming language is described. This facility permits the execution of a programmer‐defined function to be associated with the occurrence of a specified event. The events with which associations can be made are those applicable to program debugging. Associations can be made with events such as variable referencing, statement execution, program interruption, function call and return, and execution‐time errors. By making event associations available at the source‐language level, debugging aids can be written in SNOBOL4 itself, using the full capabilities of that language. As illustrated by several examples, this approach facilitates the implementation of simple yet powerful debugging aids written in the same language as the programs to be debugged. Event associations provide a mechanism for the unification of the existing SNOBOL4 debugging facilities, and a basis for the addition of other events. The implementation of event associations is also described.
A study of machine‐level software profile
Authors: Barak Amnon B. , Aharoni Moshe
Published: November 2006

The instruction mix of a CDC CYBER/74 computer in a university environment was monitored, and in this paper frequencies of execution for the most commonly used instructions are given. From these measurements we make a number of observations about several aspects of computing patterns. One observation is the fact that if we exclude the idle loop of the operating system, the percentage of occurrences for each type of instruction over various time intervals is constant. This fact is used to define a machine‐level software profile (MLSP) for the type of machine operations in the given computing environment. It is shown that the MLSP could be used to find machine utilization and the extent to which software takes advantage of machine architecture, and as a consistent method to improve the performance of a machine configuration.
The use of a procedure‐oriented language for process‐oriented simulation
Authors: Stirling W. Douglas
Published: November 2006

It is fairly easy to use a language like ALGOL W1 for event‐ or activity‐oriented simulation. A method is described to use such a language for process‐oriented simulation. The illusion of co‐routines necessary in this type of simulation is maintained by low‐level language procedures which alter the run‐time stack. Two new scheduling procedures are also described.
Programming aids for the teaching of programming
Authors: Foxley Eric
Published: November 2006

This paper describes a system of library segments which have been written to help in the teaching of programming to undergraduates at Nottingham. Each segment contains input for a number of problems in a very specific area of programming, together with checks that the student has solved the problems satisfactorily. The system is implemented in Algol 68‐R.
Input/output facilities in LISP 1.9
Authors: Kurokawa Toshiaki
Published: November 2006

LISP1.9 provides new input/output facilities, the conceptual channel and the current channel, which make program writing easier and execution faster. The channel attributes‐column‐setting, line number option, prompt‐string, user‐buffer, eol‐handler, eof‐handler and access rights‐are useful for program writing; the channel interaction attributes‐input‐memo, output‐memo and file I/O verification‐are useful for system development. Random file I/O, array I/O, record handling, array‐string conversion and Japanese character output are also provided.
Experiences with the portability of concurrent PASCAL
Authors: Neal David , Wallentine Virgil
Published: November 2006

The process of transporting Brinch Hansen's implementation of Concurrent PASCAL to another minicomputer is described. Applicable porting strategies are discussed with emphasis on the design decisions made for a specific transportation. Important design decisions include the use of a virtual code interpreter and implementation in an operating system environment. The problems of this transportation are illustrated with accompanying suggestions for a more portable system.
An exercise in program design using SIMULA class invariants
Authors: Cunningham B. J. , Kramer T.
Published: November 2006

The concept of an invariant assertion has been shown by Hoare to be central to the problem of proving correctness of data representation in a program. A consequent approach for program design is to establish the parts of an overall invariant which characterize the components of the design. In this way it is feasible to synthesize a verified program. There is a gulf between verification theory and practical reality in this area, but the SIMULA class concept is close to the data representation technique required for such an approach. Some of the benefits and problems of this approach to design have been explored by the development of a SIMULA program to simulate a bounded delay resource allocation strategy in a job scheduling environment.