bluuebunny/crossref_metadata_2025_split huggingface dataset:
Compiler testing using a sentence generator
Authors: Celentano A. , Reghizzi S. Crespi , Vigna P. Della , Ghezzi C. , Granata G. , Savoretti F. 
Published: November 2006

AbstractA system for assisting in the testing phase of compilers is described. The definition of the language to be compiled drives an automatic sentence generator. The language is described by an extended BNF grammar which can be augmented by actions to ensure contextual congruence, e.g. between definition and use of identifiers. For deep control of the structure of the produced sample the grammar can be described by step‐wise refinements: the generator is iteratively applied to each level of refinement, producing at last compilable, complete programs. The implementation is described and some experimental results are reported concerning PLZ, MINIPL and some other languages.
Microcomputers as protective interfaces in computing networks
Authors: James E. B. , Ireland D. 
Published: November 2006

AbstractIn a computing network environment, a user may have access to several different computers, each with its own command language. For the inexperienced user a uniform interface would be a great benefit. Since there is little possibility that a universal command language will ever be developed, we have devised a system in which a microcomputer is used to intercept all messages between the user and the orginal operating system, presenting a consistent interface to the user. This paper describes the design of such a protective interface and gives an account of experience with its use.
Procedures for managing extendible array files
Authors: Knott Gary D. 
Published: November 2006

AbstractVarieties of files are reviewed and the notion of a file space is discussed. A number of properties which characterize file spaces are listed. This modest theoretical framework has a clarifying influence on the subject of files. Certain file‐system primitives are introduced which are similar to those in most commonly‐known operating systems, and then these primitives are used in constructing a collection of routines for reading and writing extedible arrays. Extendible arrays are based on fixed page size randomly‐accessible files and they are a useful universal input/output (I/O) structure for many different storage and retrieval schemes. The routines for managing such files are similar to the mechanisms used in handling a paged address space in a virtual memory system. The contribution of this paper lies in the detailed implementation which is presented; these routines are well understood in principle, but tricky to construct in practice. Finally, these routines are used in a practical example which provides for managing a variable blocksize free space list within a extendible array.
‘Long return’: A technique for improving the efficiency of inter‐module communication
Authors: Stroustrup Bjarne 
Published: November 2006

AbstractThis paper describes a concept called ‘long return’ for use in inter‐module communication systems. First an implementation which implies a simplification of—rather than an extension of—traditional inter‐module communication systems is outlined. This implementation allows long returns to be used as an optimization technique without violating the commonly accepted principles of system structuring. Thereafter an experiment that provides an estimate of the improvements in efficiency of a particular operating system is described. In the SIMOS operating systems (based on the Cambridge CAP operating system) about 20 per cent of all inter‐process communication operations can be avoided by using long returns, and as a consequence the amount of useful work done in the system is typically increased by about 2.0 per cent.
On the access‐control mechanism of the program component manager
Authors: Silberschatz Abraham 
Published: November 2006

AbstractThis paper examines various issues that pertain to the access‐control mechanism of the program component manager. We examine such questions as what constitutes an access‐right, what kind of information about managed resources does one need, how revocation keys, right‐sets, and exception conditions are handled, etc. It is argued that most of these issues can be handled by the compiler with no explicit programming required. This simplifies the task of programming and enhances reliability. A possible method for handling these issues which was adopted in our implementation is also described.
Handling type information when compiling a language with user‐defined types
Authors: Wallis Peter J. L. 
Published: November 2006

AbstractA discussion of the handling of type information by the translator for the Portable Programming Language is broadened to include some related details of the PPL design and the way in which type information is used during storage management. No knowledge of PPL is assumed and the presentation is sufficiently broad‐based to provide insight into the compiling actions needed for more complicated languages such as Algol 68 and Ada; some design details of the three languages are contrasted. The implemented type‐handling in the PPL translator takes many details from a denotational semantics for a forerunner of the language.
Editors: Two for the price of one
Authors: Charlton C. C. , Leng P. H. 
Published: November 2006

AbstractText editors designed for interactive use on visual display units offer significant advantages, particularly in simplicity of use, but non‐visual editors can provide facilities which are difficult to incorporate into a VDU editor without undermining these advantages. This paper describes a text editing system which offers both a visual and non‐visual mode of use, via two user interfaces to a common set of editing primitives, and allows the user to switch freely between modes during the course of an edit. The visual editing interface consists of a set of single‐key control functions which require no unusual VDU characteristics, while non‐visual editing is provided by a set of context editing commands which both duplicate these control functions and offer extra facilities, particularly for repetitive editing.
A design language for the definition of a retrieval system interface for casual users of a relational database
Authors: Thomas P. G. , Staff B. E. 
Published: November 2006

AbstractA design language is described that enables the information analyst to produce a tailor‐made interface for the casual user of a relational database system. The ideas are extended to show howad hocretrieval systems can be constructed from the building blocks incorporated in the relational model.
CHEF: A versatile portable text editor
Authors: Maclean M. A. , Peck J. E. L. 
Published: November 2006

AbstractCHEF is an interactive text editor for use with both printing and display terminals. Its prime field of application is computer source program editing but it has some word processing capabilities that make it useful for documentation and general text editing work. There is a comprehensive set of whole‐line operations, including block moves and the insertion of text from external files, together with substring replacement and line segmentation based on a flexible pattern‐matching algorithm. There is a set of one‐line buffers for temporary storage of lines or command strings and complex command sequences can be built up by macro substitution. Considerable effort has been made to design a command syntax that is flexible and consistent and, at the same time, minimizes effort during the editing process. CHEF copies the user's file into an internal work‐space so that the original is not disturbed until the user is satisfied with the results of the editing session. A virtual memory technique is used to provide a work‐space that can be almost any desired size, with random access to any part and efficient editing operations. CHEF is written in BCPL and has already been implemented on four different machines.
Modularization of large programs
Authors: Henderson Peter , Gimson Roger B. 
Published: November 2006

AbstractThis report describes a macroprocessor, ‘Supermac’, and its use for modularization of large programs. The development of the macroprocessor and its application to program modularization was undertaken in a research project sponsored by GEC Telecommunications, Coventry, and this document forms the final report of that project.The project arose from the wish to be able to structure large pieces of software, written in a conventional programming language, in order to make them more easily understood and hence more easily constructed, maintained and modified. In this report the use of the specially developed Supermac macroprocessor to achieve better structured programs will be described in detail. A full definition of the Supermac notation.
Error reporting and recovery in Sangrah
Authors: Prakash Naveen , Gejji P. N. 
Published: November 2006

AbstractIn Sangrah, exception conditions of CODASYL have been replaced by fatal errors and by boolean valued functions. Fatal errors can occur either because all the preconditions necessary for a DML statement are not fulfilled or because of the state of the data base at the time when this statement is executed. A mechanism which anticipates the former situation and thereby saves the data base from corruption is presented. Another recovery scheme which protects the data base from an abnormal termination of the user program is also described. This scheme uses a differential file.
How to make your own simulation system
Authors: Lindstrom Hans , Skansholm Jan 
Published: November 2006

AbstractA simple way to make a simulation system based on any language is described, in fact, the system was designed and implemented on a minicomputer by the authors in less than one week. A simulation program that uses the system looks almost like a SIMULA program. All subroutines and functions in SIMULA (except input and output routines) are included in this system.
Considerations for the design of array processing languages
Authors: Perrott R. H. , Stevenson D. K. 
Published: November 2006

AbstractThis paper summarizes the major results of a formal survey of array processor users and indicates how these results were used in the design of a language suitable for array and vector processors. A comparison is also given with an informal survey of other large‐scale computer users, which concluded that the best plan was to extend Fortran 77 to meet the requirements for array processing.
Partitioned and prioritized access to timesharing services: The reserved availability method
Authors: Hunter Geoffrey 
Published: November 2006

AbstractThe Reserved Availability Method is a software mechanism for allocating a non‐sharable machine resource such as multi‐access ports according to different user catagories and priorities. The method avoids the queuing of user requests for allocation. Instead, some of the available resources are reserved for allocation to high‐priority, or particular categories of users. The resources reserved vary with machine usage in order to optimize machine utilization with user demand. The method is applied to the partitioning of a machine's ports between different user groups, and to access according to user priority.
Eliminating recursion from combinatoric procedures
Authors: Rohl J. S. 
Published: November 2006

AbstractThe problem of eliminating linear and binary recursion has received quite a deal of attention. Less has been given to the elimination of the more general form of recursion that arises in combinatorics. In this paper we extend earlier work and produce two pairs of equivalent schemata. The correspondences between these schemata and the classical combinatoral problems are given and two applied examples: topological sorting and the set covering problem, are discussed in detail.
Dynamic program building
Authors: Brown P. J. 
Published: November 2006

AbstractThis paper argues that programs are better regarded as dynamic running objects rather than as static textual ones. The concept of dynamic building, whereby a program is constructed as it runs, is described. It also describes the Builder system, which is an implementation of dynamic building for an interactive algebraic programming language. Dynamic building aids the locating of run‐time errors, and is especially valuable in environments where programs are relatively short but run‐time errors are frequent and/or costly. It is a good method for non‐specialist programmers.
MROS‐68K, a memory resident operating system, for MC68000
Authors: Pohjanpalo Hannu 
Published: November 2006

AbstractThe operating system described has been designed and implemented for use in dedicated one‐purpose applications, typically in real tihe. Specific attention has been paid to flexible intertask contkol. In the first installation the application system was the steering and controlling of large hydraulic devices. Typical subtasks involved were measuring, coordinate transformations, control, teaching and following robotic paths and evaluating daily material transfkrs.As a programming effort, developing the operating system was fairly reasonable being of the order of three or four months for one person, including design, coding, testing and documentation.
An Interactive Manager for Pascal Software
Authors: Oldehoeft R. R. , Ralph W. D. , Tindall M. H. 
Published: November 2006

AbstractAn interactive facility for development and maintenance of Pascal programs is described. Features include interactive addition, deletion and modification of modules, independentcompilation of groups of procedures, and automatic recompilation of an entire program only if global declarations are modified. The implementation required modification of a Pascal compiler to process an arbitrary number of programs in a single run and to compile correctly if the main program is missing. Overall processing is managed by a parameterized control statement procedure that invokes several system utilities. The facility has been used successfully in instructional and research computing situations. Significant remaining problems are errors caused by mismatched parameters between independently compiled procedures, and interpretation by users of error messages generated by system utilities.
Improving the structure of large Pascal programs
Authors: Young S. J. 
Published: November 2006

AbstractThis paper describes an extension to Pascal in the form of an encapsulation mechanism aimed at improving the structure of large Pascal programs. It is based upon the module structure of Modula but extended to include a more detailed specification of module interfaces and to allow the definition of a module body to be deferred. Called Pascal/M, the extended language is implemented via a preprocessor. It has been successfully used in large programming projects and been found to both aid in the application of top‐down design methods and to greatly improve the documentation of the final product by breaking up the program text into a hierarchy of short readable modules. The use of Pascal/M is illustrated by a program example and aspects of its design and implementation are discussed.
Full‐screen editing in a hostile environment
Authors: Cargill T. A. 
Published: November 2006

AbstractThis paper describes a simple full‐screen editor which operates effectively in a very restrictive hardware and software environment in which dumb CRT terminals run half‐duplex at 1200 baud to the line buffering front‐end of a timesharing mainframe. The use of such an inappropriate system is dictated by other considerations and the experiment with screen editing was motivated by the frustration encountered in manipulating highly formatted text with a line‐oriented text editor. Early success with a crude editor lead to an improved version which functions acceptably for a several types of text. The particular constraints of this environment, how they were overcome or avoided and their influence on the editor are addressed. The paper demonstrates that successful full‐screen editing in this environment calls for software that differs in its basic design from other full‐screen editors.
Experience with software conversion
Authors: Samet Hanan 
Published: November 2006

AbstractExperience with a program to convert from LISP 1.6 to INTERLISP is described. The conversion program was designed with two goals in mind. First, it had to be capable of being executed in either of the languages's environments and it had to yield identical results. Second, the speed of the converted program was to be approximately the same as the original program. This meant that the conversion process must be completed prior to execution of the converted program. The various constraints and considerations imposed by these goals are examined. In addition, aside from problems in finding INTERLISP analogs for various LISP 1.6 constructs, careful consideration must also be paid to input/output functions, escape characters, global variables, representation of numbers and different string implementations.
Breaking paragraphs into lines
Authors: Knuth Donald E. , Plass Michael F. 
Published: November 2006

AbstractThis paper discusses a new approach to the problem of dividing the text of a paragraph into lines of approximately equal length. Instead of simply making decisions one line at a time, the method considers the paragraph as a whole, so that the final appearance of a given line might be influenced by the text on succeeding lines. A system based on three simple primitive concepts called ‘boxes’, ‘glue’, and ‘penalties’ provides the ability to deal satisfactorily with a wide variety of typesetting problems in a unified framework, using a single algorithm that determines optimum breakpoints. The algorithm avoids backtracking by a judicious use of the techniques of dynamic programming. Extensive computational experience confirms that the approach is both efficient and effective in producing high‐quality output. The paper concludes with a brief history of line‐breaking methods, and an appendix presents a simplified algorithm that requires comparatively few resources.
A communicating sequential process language and implementation
Authors: Roper T. J. , Barter C. J. 
Published: November 2006

AbstractThe design of a communicating sequential process language is presented, featuring a parallel command, communication by message passing and the use of the guarded command as a means of introducing and controlling non‐determinism. The language described here incorporates a number of new proposals regarding communications between sequential processes. The principal proposal is that messages are to be selected for reception by a receiving process solely on the basis of their type and arrival order within type; in particular, the identity of the sending process does not influence message reception. This results in a greater degree of parallelism and non‐determinism, which is useful to both the programmer and the language implementor. Also a hierarchichal composition regime is proposed, which gives communications significance to the organization of subprocess hierarchies; this promotes an independence of specification of program components through information hiding properties. The language implementation is described, and several aspects are of particular interest: the design of a process scheduler in a non‐deterministic situation leads to some interesting optimizations, as does the design of a message handler in the case where the communicating processes can access the same memory. Finally, example programs are given to illustrate some of the novel features of the language.
Modular programming with Pascal
Authors: Steensgaard‐Madsen J. 
Published: November 2006

AbstractA technique is presented by which the programming language Pascal as defined by the expected standard, can be used to write programs divided into modules containing mutually hidden information. The technique fits nicely with the programming by stepwise refinement methodology, combines top‐down and bottom‐up methods, and illustrates that stepwise refinement does not necessarily lead to simple tree‐like programs. Limitations for the application of the technique with Pascal are pointed out.
The practicality of text signatures for accelerating string searching
Authors: Tharp Alan L. , Tai Kuo‐Chung 
Published: November 2006

AbstractThis paper studies the use of text signatures in string searching. Text signatures are a coded representation of a unit of text formed by hashing substrings into bit positions which are, in turn, set to one. Then instead of searching an entire line of text exhaustively, the text signature may be examined first to determine if complete processing is warranted. A hashing function which minimizes the number of collisions in a signature is described. Experimental results for two signature lengths with both a text file and a program file are given. Analyses of the results and the utility and application of the method conclude the discussion.
The syntax of interactive command languages: A framework for design
Authors: Hardy I. Trotter 
Published: November 2006

AbstractVarious qualities of simple command languages, such as ease of use and flexibility, are defined in terms of syntax. Certain design attributes—namely style, structure and level of abstraction—are described for command languages, and these attributes are shown to strongly influence the defined qualities. Commands are designed for three functions to show how the design trade‐offs are made in light of the qualities and attributes discussed.
Real‐time checkout: The ‘source error first’ approach
Authors: Glass Robert L. 
Published: November 2006

AbstractThis paper proposes some improvements to the archaic methodologies currently used for checkout of real‐time software. The emphasis is placed on removing errors from the computer program source code in the host computer environment, and deferring target computer checkout until those errors have been largely removed. Specific tools and techniques to make this possible are described. This improvement is seen to be risk‐free and to reduce cost. It is, however, controversial.
Time token design methodology
Authors: Celko Joe 
Published: November 2006

AbstractA program design methodology is proposed and an example is given using it for a small inventory system.The method depends on viewing a problem in terms of tokens that carry date information. This date information gives the date of the creation, and exit of the token from the active system. The source of creation and the place of exit are also coded into the token.The method is most useful in an environment that has time‐dependent, on‐line interactive processing.
Immediate turnround—an elusive goal
Authors: Newbury J. P. 
Published: November 2006

AbstractThis paper, inspired by the work of Larmouth,1 describes a job scheduler now in service on an ICL 1906A with the GEORGE 4 Operating System. The main goals were to apply a smooth control of machine usage, enabling users to run work at rates proportional to their shares without any sharp cut‐off; to maximize the amount of work achieving very fast turnround; to provide predictable turnround; to allow users some control over turnround; to eliminate cheating; to be easy to understand and use. An outline of our method is given together with a discussion of some of the practical and theoretical problems with this sort of approach.
Executing large graphics programs with a small computer
Authors: Van Tilborg Andrè M. 
Published: November 2006

AbstractThis article describes a simple graphics compiler which allows the owner of a personal computer system with a graphics display and access to a larger computer to execute large application programs remotely but still use his display as though the programs were running locally. Simple graphics primitives and the program structures used to implement them are discussed. The compiler includes a simple packet switching subsystem which allows display data to be transmitted over the telephone network.