bluuebunny/crossref_metadata_2025_split huggingface dataset:
Postlude to a PASCAL‐compiler bootstrap on a decsystem‐10
Authors: Grosse‐Lindemann C. O. , Nagel H. H. 
Published: November 2006

AbstractThere can be a considerable difference between a portable compiler and a usable one which is a high level language implementation with a fair chance of acceptance by the general public in competition with other—vendor supported—systems. The experiences gained in pushing a portable PASCAL compiler across such an acceptance barrier are discussed in detail. Comments on some shortcomings of the PASCAL definition and suggested remedies are included.As a result, it seems feasible to reduce drastically the effort required for a bootstrap by supplementing a bare bone portable compiler with features hitherto considered as luxuries in this context. Only language Implementations which are portable in this broader sense might spread sufficiently easily to survive the competition, especially if the impact of increasingly available access to computer networks is considered.
A pascal compiler for PDP 11 minicomputers
Authors: Bron C. , De Vries W. 
Published: November 2006

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

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

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

AbstractGeneral‐purpose text editors have significant drawbacks when used for document preparation. This paper describes a system designed to combine the editing and formatting power of a text editor with the simplicity and immediacy of a typewriter for document preparation. The system is implemented on a minicomputer with a simple alphanumeric visual display unit.
Software malpractice — a distasteful experience
Authors: Spier Michael J. 
Published: November 2006

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

AbstractThe problems of achieving efficiency in middle weight computation are discussed with reference to experience in the Meteorological Office with the operational and research computations which support work on long range weather forecasting. An account is given of the reasoning behind the latest form of the METOCODE system, and of the objectives it is intended to fulfil.
Quasiparallel programming
Authors: Kaubisch W. H. , Perrott R. H. , Hoare C. A. R. 
Published: November 2006

AbstractThis paper describes SIMONE, an extension of PASCAL,1 which provides the quasiparallel programming facility of SIMULA 67, but without classes or references. The language is intended to be suitable for the design, testing and simulation of operating system algorithms. It is illustrated by simple examples, suitable as project material in a course on operating systems. A simple, restricted, but efficient implementation is described. It is suggested that the language might be suitable for more general simulation purposes, and an example of a general job shop simulation is given.
Lektor‐a list‐oriented, machine‐independent programming system for conversational applications
Authors: Hummel Helmut 
Published: November 2006

AbstractThis paper introduces the machine‐independent programming system LEKTOR which has been used for research and developmental work in computer‐based learning since the beginning of 1974. The most important language elements and the system architecture are described. Emphasis is placed upon questions of implementation, particularly with regard to the data structures and the organization and administration of the workspace.
Macro SPITBOL—a SNOBOL4 compiler
Authors: Dewar Robert B. K. , McCann A. P. 
Published: November 2006

AbstractA fast and compact compiler/interpreter for SPITBOL (a variant of SNOBOL4) has been written in a machine‐independent macro assembly language and implemented initially on the ICL 1900 range of computers. The interpreter uses a novel form of indirect polish code which assists portability. Compile‐time pre‐evaluation of constant expressions has proved to be a worthwhile optimization. A description is given in some detail of the simple but rapid scheme, requiring no marker bits, employed for garbage collection.
Generating code for a hypothetical computer using a production assembler
Authors: Nutt Gary J. , Schulz Waldean A. , Williamson Karl H. 
Published: November 2006

AbstractProduction assemblers are often thought of as being useful only for generating machine code from a symbolic assembly language delivered with the system. Most production assemblers that have a macro capability can be used to create an assembler for an arbitrary target machine through the use of the technique discussed in this short communication. This approach has the advantages of quick construction, easy modification and a resulting assembler for the target machine that is nearly as powerful as the original production assembler.
Does APL really need run‐time parsing?
Authors: Strawn George O. 
Published: November 2006

AbstractMost APL systems delay all parsing until run‐time. Because the APL expression language is inherently ambiguous and because identifier binding is delayed until run‐time, some runtime parsing is shown to be necessary. Nevertheless we argue that most APL statement parsing can be done at entry‐time and that there are several reasons for doing so. Then a technique is described whereby APL statements are partially parsed at entry‐time and are parse completed at run‐time.
The advantages of stream output procedures over format‐dominated record transmissions
Authors: Hunter G. , Kuriyan M. , Wallis A. 
Published: November 2006

AbstractThis paper shows that stream output procedures can produce well‐formatted printing, with the layout of each line being totally under program control to suit the particular data being processed. This capability for completely general and dynamically variable formats is not possessed by the more commonly used unit‐record output facilities. The distinction is illustrated by a simple example, which in terms of stream‐oriented procedures is an almost trivial programming exercise, but where the use of conventional unit‐record facilities leads to a combinatorial explosion. The corresponding input procedures are also discussed.
Using pascal in a fortran environment
Authors: Mohilner Patricia R. 
Published: November 2006

AbstractThe ability to use existing libraries is essential if a programming language is to be of practical value. This paper presents the experience gained in using Pascal in a Fortran environment and details the resolution of problems encountered in file communication, parameter passing and establishing default values under the condition of mixed language programming. It is concluded that Pascal is viable as a practical programming language, provided that EXTERN and FORTRAN procedures are implemented.
Success and failure analysis of a problem solving system implementation
Authors: Symes L. R. , Oldehoeft R. R. 
Published: November 2006

AbstractThe NAPSS (Numerical Analysis Problem Solving System) project was an attempt to develop an interactive system, with a high‐level language resembling conventional mathematics, for solving problems in numerical analysis. This report uses NAPSS as an example to discuss some aspects of the design and implementation of the programming languages and software which comprise problem solving systems. Successful features as well as failures (with alternative proposals) are detailed in the areas of general language management, specific language features and the operating system interface. In general, a massive, coherent implementation of theoretical work being done at the frontiers of research has abundant opportunity for failure.
Real‐time BASIC for laboratory use
Authors: Ormicki Andrzej 
Published: November 2006

AbstractThe syntax and implementation of an interpretive method for handling interrupts within the context of a small foreground‐background BASIC system are described. The implemented system can be used on an 8K NOVA minicomputer without background storage and is designed for data collection and process control in the laboratory.Non‐standard I/O devices can be easily serviced in the foreground.
Designing overlay structures
Authors: Gentleman W. Morven , Munro J. Ian 
Published: November 2006

AbstractAlthough overlaying code segments is a very old technique, there is very little literature 68 on what the ground rules are, what the options are and how to select an overlay structure. As a result, the facilities provided by most linkage editors are much poorer than they need be. In this paper we define the problem, give an algorithm for obtaining ‘minimal’ overlay structures and describe the surrounding commands and environment that are necessary to turn this algorithm into a practical tool.
Hierarchical monitors
Authors: Lister A. M. , Sayer P. J. 
Published: November 2006

AbstractA technique is presented for constructing an operating system as a hierarchical set of monitors. The hierarchy reflects and reinforces the system structure, and extends down to the system nucleus itself. The nucleus is in fact treated as a specialized monitor for handling the central processor. The technique has been used to write a small pilot system for a DEC PDP‐15, and experience with the system is reported. The mutual exclusion problem for monitor procedures is discussed, and a viable solution suggested.
BASIC—an evaluation of processing methods and a study of some programs
Authors: Hammond John 
Published: November 2006

AbstractThe relative merits of compiling and interpreting BASIC are examined, and these methods are compared with the technique called throw‐away compiling. The comparison reveals that a throw‐away compiler has much to recommend it, and some reasons for its superior performance are explained. The BASIC programs used for the performance tests are analysed, both statically and dynamically, and certain features are picked out for comment.
Design and implementation of a display oriented text editor
Authors: Macleod Ian A. 
Published: November 2006

AbstractThis paper outlines the design and implementation of a text editor which is designed for use on an alphanumeric display terminal with cursor control. Text may be edited directly on the screen by deleting, overstriking or inserting characters. There also exist commands to manipulate and search sections of text. A major design consideration was that the editor should be easily usable by untrained casual users.
The calibration and validation of a hybrid simulation/regression model of a batch computer system
Authors: Gomaa H. 
Published: November 2006

AbstractCalibration and validation are two stages in the development of a performance model of a computer system during which the degree of confidence in the model is established. This paper describes a case study of the calibration and validation of a hybrid simulation/regression Load Adjusting Model of a batch computer system. During calibration, a given workload trace was applied to the Load Adjusting Model and the parameters of the model were adjusted using an iterative tuning procedure. During validation, the parameters of the model, established during calibration, were kept constant and the model was tested using different workload traces.
MOUSE4: An improved implementation of the RATFOR preprocessor
Authors: Comer Douglas 
Published: November 2006

AbstractRATFOR is a preprocessor language for FORTRAN that supports structured flow of control statements and macrosubstitution. The RATFOR processor, written in RATFOR, is modular, carefully coded and portable, but extremely inefficient. A profile of the running time revealed that a linear search in the macroprocessor consumed over half of the CPU time. Running time was reduced by over 50 per cent when a binary search was used. Our observation is of interest primarily because it differs from previously reported measurements.A more dramatic improvement in running time was obtained by rewriting the ad hoc lexical scanner using a standard method based on finite automata. For a 3,000‐line source program the standard RATFOR required 185.470 CPU seconds on a CDC 6500 while the automata‐based version needed only 12.723 seconds.We conclude that, contrary to evidence exhibited by the designer of RATFOR, sequential search is often inadequate for production software. Furthermore, in the case of lexical analysis, well‐known techniques do seem to offer efficiency while retaining the simplicity, ease of coding and modularity of ad hoc methods.
An evaluation of the effectiveness of symbolic testing
Authors: Howden William E. 
Published: November 2006

AbstractThe effectiveness in discovering errors of symbolic evaluation and of testing sad static program analysis are studied. The three techniques are applied to a diverse collection of programs and the results compared. Symbolic evaluation is used to carry out symbolic testing and to generate symbolic systems of path predicates. The use of the predicates for automated test data selection is analysed. Several conventional types of program testing strategies are evaluated. The strategies include branch testing, structured testing and testing on input values having special properties. The static source analysis techniques that are studied include anomaly analysis and interface analysis.Examples are included which describe typical situations in which one technique is reliable but another unreliable. The effectiveness of symbolic testing is compared with testing on actual data and with the use of an integrated methodology that includes both testing and static source analysis. Situations in which symbolic testing is difficult to apply or not effective are discussed. Different ways in which symbolic evaluation can be used for generating test data are described. Those ways for which it is most effective are isolated. The paper concludes with a discussion of the most effective uses to which symbolic evaluation can he put in an integrated system which contains all three of the validation techniques that are studied.
A symbolic system for computer‐aided development of surface interpolants
Authors: Feng David Y. , Riesenfeld Richard F. 
Published: November 2006

AbstractThe design and implementation of a symbolic input end computation package and its application to the development of several new surface interpolation schemes are described. Capabilities such as the composition of operators and symbolic differentiation have been incorporated into the system. This allows, in particular, the specification of Boolean sum projectors. The new schemes which have been implemented include an interpolant to randomly spaced data and a 'shape operator1 which has quadratic precision.
Implementation of a computer job scheduling algorithm: A case history
Authors: Gujar Uday G. , Fellows David M. 
Published: November 2006

AbstractMultiprogramming systems require that a fair, equitable algorithm be used for the scheduling of jobs. This paper discusses some of the problems associated with this and proposes an automatic job scheduling algorithm. The major parts of the algorithm have been implemented and have been in use for over one year. The user interface is simplified and the operational complexities are minimized. The parameters used for the algorithm are the estimates of the central processor time and the memory required by the job. All types of jobs including those requiring operator attention during execution are covered under the scheme. Operational data and the reactions from the users indicate that the results have been as expected.
Introducing graphics capabilities to several high‐level languages
Authors: Ng Nam , Marsland T. A. 
Published: November 2006

AbstractThe development of basic support software for a graphics facility requires extensive programming effort, which is sometimes duplicated when the facility is made available from other languages. This paper explores an alternative, which has the advantages that only a single software package need be built for use by a variety of host languages, and no modification is necessary to their compilers. Fortran, PL/I and Algol W are the example hosts used in the feasibility studies, but the approach can be extended.
A highly reliable file system which supports multiprocessing
Authors: Barnett J. K. R. 
Published: November 2006

AbstractA file system is described which should be proof against hardware and software errors of considerable severity, as well as overcoming the problems caused by a sudden system stop (due, for example, to power failure). An important aspect of the latter is preservation of logical integrity at arbitrary levels of abstraction. Multiprocessing is supported at a record‐locking, rather than file‐locking, level. The system allows highly efficient access to large (e.g. multimillion) keyed‐record files. The system is considered suitable for operating system file catalogues, and data bases.
The UNIX™ programming environment
Authors: Kernighan Brian W. , Mashey John R. 
Published: November 2006

AbstractThe UNIXUNIX is a trademark of Bell Laboratories.
operating system provides an especially congenial programming environment, in which it is not only possible, but actually natural, to write programs quickly and well.Several characteristics of the UNIX system contribute to this desirable state of affairs. Files have no type or internal structure, so data produced by one program can be used by another without impediment. The basic system interface for input and output provides homogeneous treatment of files, I/O devices and programs, so programs need not care where their data comes from or goes to. The command interpreter makes it convenient to connect programs, by arranging for all data communication.Complex procedures are created not by writing large programs from scratch, but by interconnecting relatively small components. These programs are small and concentrate on single functions, and therefore are easy to build, understand, describe, and maintain. They form a high level toolkit whose existence causes programmers to view their work as the use and creation of tools, a viewpoint that encourages growth in place of reinvention.Tools interact in a limited number of ways, but can be used in many different combinations. Thus, an addition to the toolkit tends to improve the programming power of the user faster than it increases the complexity of interconnection and maintenance. Finally, tools are connected at a very high level by a powerful command language interpreter. The error‐prone and expensive process of program writing can often be avoided in favor of program‐using.In this paper we will present a variety of examples to illustrate this methodology, focusing on those aspects of the system and supporting software which make it possible.
A new implementation technique for applicative languages
Authors: Turner D. A. 
Published: November 2006

AbstractIt is shown how by using results from combinatory logic an applicative language, such as LISP, can be translated into a form from which all bound variables have been removed. A machine is described which can efficiently execute the resulting code. This implementation is compared with a conventional interpreter and found to have a number of advantages. Of these the most important is that programs which exploit higher order functions to achieve great compactness of expression are executed much more efficiently.
The NAG library ‘machine’
Authors: Ford B. , Bentley J. , du Croz J. J. , Hague S. J. 
Published: November 2006

AbstractIf a reliable, high quality numerical algorithms library is to be developed then it is essential that we recognize the need for collaboration between different technical communities in the development of the library. This paper suggests an ultimate design for the library and describes the implications of that design for the people involved in the development of the library.
A heap‐based implementation of the programming language Pascal
Authors: Marlin C. D. 
Published: November 2006

AbstractThe implementation of Pascal known as Pascal ‘P’ was modified so that activation records for blocks (procedures and functions) were no longer allocated on a stack, but were instead allocated on a heap. This was done partly to test the feasibility of using Pascal ‘P’ for experimenting with extensions to Pascal, and partly to assess the efficiency of implementing Pascal procedures and functions in this way. The necessary changes to Pascal ‘P’ are described; where alternative strategies were possible, these are outlined and the reasons for the final choice given. The heap management algorithms used are presented and, in particular, their behaviour when managing the activation records of Pascal programs which do not involve dynamic variables is explained. Quantitative comparisons are made between Pascal ‘P’ and the version with heap‐allocated activation records, to assess their relative efficiencies; these comparisons indicate that the modified system uses more storage, but it gives rise to only slightly longer execution times. Alternative heap management algorithms are discussed. Finally, some advantages of heap‐allocated activation records are presented.