bluuebunny/crossref_metadata_2025_split huggingface dataset:
A function for generating nearly balanced binary search trees from sets of non‐random keys
Authors: Frost R. A. , Peterson M. M. 
Published: November 2006

AbstractA function for generating nearly balanced binary search trees from sets of non‐random keys is described. This function can be used in hashing organization where collisions are resolved by construction of binary trees. In particular it can be used as the secondary function in the relatively new technique of dynamic hashing.
The design and implementation of parametric types in Pascal
Authors: Hennessy John , Elmquist Hilding 
Published: November 2006

AbstractParametric types offer an attractive solution to the problems of dealing with arrays in Pascal. These problems arise from the use of strong, static type checking, especially of array‐type procedure arguments. Parametric types provide solutions both for the array procedure argument problem and allow the consistent inclusion of arrays with dynamic bounds. A parametric type mechanism is proposed and design issues are discussed. The inclusion of parametric types has major effects on the implementation of a language like Pascal. The implementation issues and implementation versus design tradeoffs are examined. The implementation strategy used can be extended to accommodate the standard and generic types in Ada.
The transfer of a BCPL compiler to the Z80 microcomputer
Authors: Cowderoy Richard I. , Wallis Peter J. L. 
Published: November 2006

AbstractWe describe the transfer of a BCPL compiler installed on a PDP‐11 to a hobbyist's home Z80 microcomputer. The design of the Z80 support software needed is explained in some detail. The development of a debugging Ocode interpreter and of an Ocode loader featuring code compression proved particularly helpful.
A high‐level debugger for PL/I, Fortran and Basic
Authors: Elliott Brig 
Published: November 2006

AbstractDartmouth College has implemented a single debugger for several languages sharing a common runtime environment: PL/I, Basic and Fortran. The debugger is fairly powerful; users set breakpoints and traces which occur whenever the values of given variables change, or whenever certain relational expressions become true, for example. All debugging is carried on in a syntax similar to that of a high‐level language.This debugger was implemented in about a month. It should be fairly easy to implement on most timesharing systems. This paper describes the debugger's user interface and gives a rough sketch of its implementation.
A machine‐independent linker
Authors: Fraser Christopher W. , Hanson David R. 
Published: November 2006

AbstractLinkers, although a well‐established component of language translation, are typically machine‐dependent, idiosyncratic, and hard for many users to understand. This paper describes a machine‐independent linker and object language. The linker embodies those linking functions that are machine‐independent and centralizes them in a single tool, simplifying compilers, assemblers, and loaders. Included are descriptions of its operation, implementation, and application.
Exploiting machine‐specific pointer operations in abstract machines
Authors: Fraser Christopher W. , Hanson David R. 
Published: November 2006

AbstractIncreasingly powerful machine instructions complicate abstract machine design for portability. Abstract machine instructions must be “larger” than the target machine instructions that they are to exploit, but they must not grow so large as to complicate the realization of the abstract machine on real machines. This paper presents related techniques for low‐level yet machine‐independent access to typical stack and string‐processing instructions.
Design of a simple screen editor
Authors: Elliott Brig 
Published: November 2006

AbstractThis paper describes a simple screen editor, which could be implemented fairly easily on most interactive computer systems. A screen editor shows whole pages of text on a video display terminal; text is modified by moving the cursor and overtyping mistakes. Screen editors are significantly more pleasant to use than conventional (hard copy) editors for most editing tasks. In this paper, one editor is described in some detail, then design goals and implementation problems for all editors of this type are discussed.
Another program for drawing diagrams
Authors: Lang T. 
Published: November 2006

AbstractMost installations provide a program to assist in drawing stylized diagrams which can illustrate structures, relationships and flows. The DRAUGHTSMAN program was written to overcome shortcomings in earlier examples of this type. Firstly, drawing movements can be specified in relative terms, and positions on the diagram can be labelled, giving the advantages of flexibility for subsequent modification equivalent to those of relative addressing over absolute addressing in programming. Secondly, the program will, unless instructed otherwise, make its own selection of a reasonable paper size and orientation. Thirdly, the inclusion of text within boxes and along lines is flexible and unrestricted; this is combined with a wide range of drawing styles. A specification of the drawing language is given and an illustrative example provided.
A multiprogramming system for a microcomputer
Authors: Smith A. , Bell D. H. 
Published: November 2006

AbstractA multiprogramming operating system nucleus has been constructed for a microcomputer. An account is given of the implementation, analysing the problems encountered, the magnitude of the effort required and the performance characteristics. The aim is to aid other implementors by drawing attention to those aspects of the work likely to be characteristic of microcomputer implementations in general.
Implementation of a CORAL66 programming environment
Authors: Yip C. K. 
Published: November 2006

AbstractCORAL66 programming environment has been implemented on a host environment of a Nova real time disk operating system. It consists of a CORAL66 C‐compiler, a program for compilation error code summary, a c‐code assembler, an interpreter as well as utilities from the host environment. In this paper, details of the implementation are discussed and we argue that such an implementation on mini‐computer systems can be used as an important and flexible tool for teaching and research purposes in software engineering.
A design medium for software
Authors: Leathrum J. F. 
Published: November 2006

AbstractA design medium for software is proposed and illustrated. The medium, which employs rectangular, embedded contours, provides a high level of scale independence. Module specifications, logic design and program elements are easily intermixed in a design. The proposed module formalization includes interface specification, exceptions, logic design and effects in an order which will ultimately be exhibited by the program code as well.
A pattern matching system
Authors: Sommerville Ian 
Published: November 2006

AbstractThis paper describes a pattern matching system which has been implemented as a set of library procedures. The system provides a concise and consistent method of pattern definition and facilities for defining context sensitive pattern matching, defining repetitive patterns and defining alternatives. The operations available to the user allow him to identify if a substring matches a pattern, to extract that substring, to replace that substring and to associate a name with that substring. The system has applications in information retrieval, text manipulation and language processing.
Optimizing two‐state case statements in Pascal
Authors: Atkinson L. V. 
Published: November 2006

AbstractSome recent work implies that user‐defined two‐state scalar variables, as available in Pascal, are a significant improvement on booleans. Accordingly, alternative ways of expressing conditionals suggest themselves.Four different way of expressing the same simple conditional are presented. Two widely available compilers are tested and it is discovered that neither produces the same object code for all four cases. It is argued that the same code should be produced, for at least three of the cases, and the feasibility of this is examined.
The design and calibration of a simulation model of a star computer network
Authors: Gomaa H. 
Published: November 2006

AbstractA simulation model of the CERN (European Organization for Nuclear Research) SPS star computer network is described. The model concentrates on simulating the message handling computer, through which all messages in the network pass. The paper describes the main features of the model, the transfer time parameters in the model and how performance measurements were used to assist in the calibration of the model.
A programmable text‐editing system
Authors: Levison Michael 
Published: November 2006

AbstractA full‐screen text‐editor is described which has been augmented with a programming facility. The facility consists of an interpreter which inspects a program and generates output to drive the editor. This bridges the gap between text‐editing and text‐processing and allows the editor to carry out complicated operations. The features of the editor are described briefly, and the programming language employed by the interpreter is presented. Several applications are discussed to show the range and versatility of the system.
Verifying abstract data types with SNOBOL4
Authors: Fleck A. C. 
Published: November 2006

AbstractThe presentation of an abstract data type by a series of equational axioms has become an accepted specification mechanism. Verifying the correctness of such specifications has been recognized as a problem troubling their use. A means is presented for experimenting with a directly executable version of the axioms without having to choose representations for the data structures or describe algorithms for the operations.
The kernel of the EMAS 2900 operating system
Authors: Rees D. J. , Stephens P. D. 
Published: November 2006

AbstractThe role of the kernel of the operating system EMAS 2900 and the implementation of its functions are described in some detail. The significance of local scheduling policies and their implications on the design of the kernel are discussed with particular reference to paging management and scheduling control. It is shown that the concept of local and global control of resources can lead to a considerable simplification in the structure of an operating system kernel. The resulting operating system, EMAS 2900, provides interactive time‐sharing services very effectively and efficiently to a large computing community.
Hash‐bucket search: A fast technique for searching an english spelling dictionary
Authors: Comer Douglas , Shen Vincent Y. 
Published: November 2006

AbstractWhen a document is prepared using a computer system, it can be checked for spelling errors automatically and efficiently. This paper reviews and compares several methods for searching an English spelling dictionary. It also presents a new technique, hash‐bucket search, for searching a static table in general, and a dictionary in particular. Analysis shows that with only a small amount of space beyond that required to store the keys, the hash‐bucket search method has many advantages over existing methods. Experimental results with a sample dictionary using double hashing and the hash‐bucket techniques are presented.
A unified theory for software production
Authors: Schach S. R. 
Published: November 2006

AbstractThe central problem of software engineering, namely an overall strategy for the successful production of large‐scale software, has not yet been solved. Various techniques do exist for separate sections of the production process, but largely owing to the huge costs involved, it is virtually impossible to perform controlled experiments to test their validity, or to compare competing methodologies.One alternative way of deciding which techniques are to be preferred is to set up a science of software management, and to evaluate methodologies within its framework. This paper is a first step towards such a science. It notes similarities between certain techniques for structuring the programming group, the program modules, the testing process and the actual code itself. A theory is then deduced which enables programming managers to choose from among the wide selection of available techniques those which are applicable to the specific system to be written.
String searching in text editors
Authors: Davies D. Julian M. 
Published: November 2006

AbstractProposals have been made for fast string search algorithms that can search a string for a given pattern without having to examine every character of the text passed over. These algorithms are effective only if search patterns are in practice long enough, and enough text is traversed in a search to justify the costs of initializing the sophisticated search algorithm. We report observations of routine uses of an editor instrumented to determine the characteristics of use. It appears that many searches are indeed for patterns of 3,5 or more characters, and that these searches cover substantial amounts of text. However, searches for patterns of a single character are very common, while only moving a short distance on average. The implementation of a sophisticated search algorithm must take care to deal with short single‐character searches efficiently.
The distributed programming language SR—Mechanisms, design and implementation
Authors: Andrews Gregory R. 
Published: November 2006

AbstractSR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation.
Computer‐aided production of language implementation systems: A review and classification
Authors: Lecarme Olivier , Pellissier Mireille , Thomas Marie‐Claude 
Published: November 2006

AbstractThe paper gives a classification of methods for producing translators, interpreters, and macro‐processors using source language, written language, and object language as characteristics. Possible configurations of these characteristics are discussed and documented with examples.The paper starts with definitions of the terms used. It then presents the tools that are used for the description. These are the so‐called T‐diagrams, which are used to describe translators and interpreters, and some kind of flow‐charts, indicating the steps in the production of a translator or interpreter from a given configuration to a final product.The next chapters of the paper give the classification of the possible and meaningful elementary configurations. Important and well known special cases are mentioned with examples. Further it is shown how these elementary cases are combined to a whole implementation system. Especially mentioned is self‐compilation. The final section gives some examples of actual implementation systems and their evaluation.
A case study of run‐time errors in Pascal programs
Authors: Leblanc Richard J. , Fischer Charles N. 
Published: November 2006

AbstractThe results of a case study in which over 100,000 Pascal program executions were monitored for run‐time errors are reported. A large number of run‐time errors in a wide variety of categories were observed. The data reported provided insight into the use and misuse of the features of Pascal by a large population of programmers. Some implications of these statistics on compiler implementation and programming language design are discussed. The number and variety of errors detected suggests that run‐time checking mechanisms are more important and useful than is generally recognized, judging by the incompleteness of such mechanisms in many compilers.
DASD sharing in DOS/VSE
Authors: Ottmann Josef S. 
Published: November 2006

AbstractThe first part of this report discusses DASD sharing in loosely‐coupled data processing systems. For the locking of shared files two design concepts are presented.The second part describes DASD sharing in the IBM operating system DOS/VSE. The control program routines which serialize the lock requests within one processing unit and the cross‐system locking facility are discussed.
A network screen editor implementation
Authors: Hunter J. Alan , Hall Nigel F. 
Published: November 2006

AbstractA screen‐based editor has been implemented by the authors. Starting from the view that the screen image should at all times reflect the intended contents of the file, a scheme has been developed which requires the minimum compromise from this philosophy but at the same time provides a sophisticated tool which can be accessed from unmodified low‐cost ASCII terminals connected via a local area network. Good performance is achieved by the adoption of a special buffer forwarding technique in the terminal concentrator machines. A further design goal was that the user's view of the editor should be independent of either the terminal type or of the host machine operating system.
Development methodologies for scientific software
Authors: Dodds Robert H. , Rehak Daniel R. , Lopez Leonard A. 
Published: November 2006

AbstractApproaches to the development of scientific application software have matured over the past two decades and now constitute identifiable methodologies. Three software development methodologies are described, compared, and contrasted from the viewpoint of development effort, continued maintenance, and subsequent extension. Pertinent software aspects of the POLO‐FINITE system are described to provide an example of the software virtual machine approach to solve database, memory management, and processing module integration problems. Finally, possible extensions of the virtual machine concept are discussed as a means to further advance software development methodologies.
Meta‐assembly: A fresh assessment
Authors: Fiddian N. J. 
Published: November 2006

AbstractAn experimental software tool called FAST‐Fast Assembly Tool—has been used to evaluate the operational characteristics and range of application of the program translation technique known as meta‐assembly. It has been applied successfully in practice to a variety of different types of assembly problem and would appear to show some promise for the future in a microprocessor support context. The most significant aspects of the design, implementation and application of FAST are discussed.
On the power of traps and diversions in a document preparation language
Authors: Witten Ian H. , Bonham Mike , Strong Evelyne 
Published: November 2006

AbstractThis note illustrates the power of software interrupts (traps) and text diversions in document preparation languages by considering three difficult problems in typesetting: figure placement; setting text in arbitrary shapes; and balancing final columns in multi‐column layout. The solution of each of these in the nroff document preparation system is discussed, and an Appendix gives the nroff macros which accomplish the tasks.
An overview of the Yale Gem system
Authors: Levine John 
Published: November 2006

AbstractThe Gem system is an experimental computing facility that provides low cost, high speed, graphics‐oriented computing to between ten and sixteen simultaneous users. It provides many unusual facilities to its users and presents a user interface that is unique in its convenience and flexibility. The motivation for the system, its design and user experience are described. Possible future avenues of research are also outlined.
The newcastle connection or UNIXes of the world unite!
Authors: Brownbridge D. R. , Marshall L. F. , Randell B. 
Published: November 2006

AbstractIn this paper we describe a software subsystem that can be added to each of a set of physically interconnected UNIX or UNIX look‐alike systems, so as to construct a distributed system which is functionally indistinguishable at both the user and the program level from a conventional single‐processor UNIX system. The techniques used are applicable to a variety and multiplicity of both local and wide area networks, and enable all issues of inter‐processor communication, network protocols, etc., to be hidden. A brief account is given of experience with such a distributed system, which is currently operational on a set of PDPlls connected by a Cambridge Ring. The final sections compare our scheme to various precursor schemes and discuss its potential relevance to other operating systems.
A note on extension of Pascal by coroutines
Authors: Gerritse J. J. 
Published: November 2006

AbstractIn this communication, a simplification is suggested for the coroutine extension of Pascal described by Kriz and Sandmayr. In addition to being simpler to implement, it is also more user‐friendly and secure because most of the strict sequence constraints on procedure invocations are lifted. The scheme uses the Pascal‐P compiler, without modification except for the addition of a few built‐in procedures, together with a macroassembler for Pcode preprocessing.
Modelling of space‐efficient one‐pass translation using attribute grammars
Authors: Koskimies Kai , Räihä Kari‐Jouko 
Published: November 2006

AbstractAutomatic production of one‐pass compilers from attribute grammars is considered. An examination of a one‐pass grammar for the programming language Euclid shows that the present definition of one‐pass grammars is too general: the space behaviour of the produced compilers differs from that found in conventional hand‐written compilers. A new class of attribute grammars is defined. The class models naturally the use of space in a hand‐written compiler. This implies that the compiler produced automatically on the basis of the grammar uses space in the same way as a practical hand‐written recursive descent compiler. Furthermore, a graphical notation is introduced as a design tool for obtaining grammars in the proposed class.
Typesetting mathematics on multi‐access systems
Authors: Day Robert A. 
Published: November 2006

AbstractA program giving facilities for the setting of mathematical expressions in running text is described. It acts as a pre‐processor to many of the commonly‐available text‐formatting programs running on current multi‐access systems. Particular attention has been given to designing a package that can easily be implemented on the wide variety of equipment in use on these systems, and emphasis has been given to the use of low‐cost, readily‐available peripherals. Equal importance has been attached to the ability to use the system over wide‐area networks, with potential applications in the computerized distribution of mathematical material. A comparison is made of the method adopted for entering mathematical expressions into the program with other methods that are currently available.
Adding classes to the C language: An exercise in language evolution
Authors: Stroustrup Bjarne 
Published: November 2006

AbstractThe C language is a fine tool for writing compact and efficient programs. It is relatively easy to produce good compilers for, and the number of tools available for supporting program‐ ming in C is large, especially in its ‘home environment’, the UNM system. However, C'S facilities for structuring programs were, until recently, rather limited. To remedy this situation, a data abstraction facility, called classes, was added. The class concept described here has benefitted from the experience gained through a year's use. It is now in use at close to a hundred installations.The guiding principles of the design of C classes were simplicity both in concept and in implementation. Smooth blending of the new facilities into the existing C programming environment was considered essential. Classes can be used without sacrificing the run‐time efficiency expected from C. This paper presents some of the reasons why C classes are what they are.