bluuebunny/crossref_metadata_2025_split huggingface dataset:
Yacc in sasl — an exercise in functional programming
Authors: Jones Simon L. Peyton 
Published: November 2006

AbstractAmong the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.
Towards a language for concurrent processes
Authors: Harland David M. 
Published: November 2006

AbstractIn this paper we shall discuss concurrency in programming languages, with a view towards designing a process‐oriented language which, by its inherent parallelism, is well suited to exploit the forthcoming generation of distributed processor networks.We shall start by discussing the traditional approach towards managing concurrency, with ‘monitors’ co‐ordinating the interactions of ‘processes’, and shall demonstrate that this approach actually degrades concurrency by imposing sequentiality during interactions because it is based on the premise of co‐ordinating secure access to shared resources. As a tool for interprocess communication it is felt that the ‘monitor’ is too far removed from the abstract nature of the problem, and so, as a purely engineering solution, it imposes too broad and too prolonged an exclusion to be acceptable in general.Instead we turn to a simpler, and ultimately more powerful notion of ‘message passing’ between parallel processes. We shall show how, if the message system is polymorphic, any data value, however large it is, can pass freely between any pair of processes. By making the processes themselves values in the language we shall discover that message networks can come into being dynamically, and tailor themselves to their applications as and when necessary by ‘short‐circuiting’ extensive communications paths. We shall also see how, if the message system is inherently asynchronous, the degree of the parallelism in a system can be enhanced, not degraded, as more and elaborate communications paths develop, the only sequentiality in the system as a whole being imposed by synchronizing processes, not the message passing system itself.After discussing the various built‐in system facilities that permit processes to dynamically find out about and study one another, thus permitting processes to set up and thereafter supervise whole subsystems, we shall round off by discussing the advantages of introducing the machines themselves into the language, making it possible for processes to become aware of, and then ‘migrate’ within, the topological structure of a multi‐processor distributed network, moving closer to their application, or just to a less‐loaded processor, as the need arises.To conclude we shall contrast this new‐style process‐oriented language with various existing programming languages which have experimented with concurrency, either implicitly or explicitly, in order to see if, and if so how, this new style is any simpler and more powerful than its precursors.
A distributed load‐balancing policy for a multicomputer
Authors: Barak Amnon , Shiloh Amnon 
Published: November 2006

AbstractThis paper deals with the organization of a distributed load‐balancing policy for a multicomputer system which consists of a cluster of independent computers that are interconnected by a local area communication network. We introduce three algorithms necessary to maintain load balancing in this system: the local load algorithm, used by each processor to monitor its own load; the exchange algorithm, for exchanging load information between the processors, and the process migration algorithm that uses this information to dynamically migrate processes from overloaded to underloaded processors.The policy that we present is distributed, i.e. each processor uses the same policy. It is both dynamic, responding to load changes without using an a priori knowledge of the resources that each process requires; and stable, unnecessary overloading of a processor is minimized. We give the essential details of the implementation of the policy and initial results on its performance.Our results confirm the feasibility of building distributed systems that are based on network communication for uniform access, resource sharing and improved reliability, as well as the use of workstations without a secondary storage device.
A reliable stable storage system for unix
Authors: Anyanwu J. A. 
Published: November 2006

AbstractThis paper describes the implementation of a stable storage system which converts several fallible disk stores into reliable devices for storing data. It provides reliable reading and writing of data in a distributed UNIXUNIX is a Trademark of AT&T Bell Laboratories
environment in spite of transient I/O faults, decay of physical storage devices and processor crashes. The implementation makes available to UNIX users a convenient way of using the facilities of a stable storage system by providing the abstraction of stable files and by maintaining the standard UNIX system call interface. It systematically handles abnormal situations by separating normal and exceptional processing in both the system description and implementation. This is achieved through the use of a fault tolerance design notation for the description of the system and the implementation of that notation using an exception handling package.
Integration of diskless workstations in unix united
Authors: Lobelle Marc C. 
Published: November 2006

AbstractThis document evaluates the feasibility of diskless UNIX systems connected to a disk‐providing machine via a local area network. The diskless UNIX systems are to be used as workstations in a UNIX UnitedUNIX is a trademark of A. T. & T. Bell Laboratories.
environment.Several solutions are presented and estimated to enable booting, file system access and swapping. Implementation techniques, compatible with the UNIX United philosophy, are proposed. Specific topics covered are file servers, swap servers, disk servers, indirect drivers, system call service access from kernel coroutines of UNIX processes, and communication subsystems.It is shown that the modifications to the UNIX system can be limited to one new device driver in the diskless workstation and one in the system providing the secondary storage facility.
DDA — a data definition facility for unix using awk
Authors: Bailes Paul A. 
Published: November 2006

AbstractWe discuss how the Awk language is an effective tool for interrogating sequential data files whose records consist of characters grouped into fields. This facility is used to implement a system to manage an ‘address book’ database. We then generalize the design, describing a system which allows one to interactively specify a DBMS according to one's own requirements within our general framework. We choose a wine‐tasting DBMS as an example specification for further consideration and evaluation.
Producing good code for the case statement
Authors: Bernstein Robert L. 
Published: November 2006

AbstractAfter summarizing different ways of generating selection code for the case statement, the execution speed of each type of selection code is described using the RISC machine model. A method for combining the selection code schemes is proposed. The method, part of the PL.8 compiler, is flexible enough to handle case‐selector data‐types that have a large range of values, such as the character‐string or floating‐point datatypes, and can be fine‐tuned when the probabilities of the case selector taking on particular values are known.
A software tool for the construction and maintenance of structured analysis notation
Authors: Woodman M. , Ince D. C. 
Published: November 2006

AbstractThis paper describes a portable software tool used for the processing and maintenance of data flow diagrams which form the basis of structured analysis techniques. The tool itself is based on the idea that data flow diagrams can be modelled by means of semantic nets and can be manipulated by a semantic net processor. A major feature of the tool is the facilities it provides for the maintenance programmer.
The pulse distributed file system
Authors: Tomlinson G. M. , Keeffe D. , Wand I. C. , Wellings A. J. 
Published: November 2006

AbstractA network of powerful personal computers, linked by a high‐speed local area network, is being seen increasingly as an alternative to a traditional centralized time‐sharing operating system. The PULSE project is investigating how such a system may be constructed to give the benefits of a self‐sufficient personal computer to each user without losing the facilities for communication and sharing of data inherent in centralized systems. In particular, a distributed file system has been built which provides a single global UNIXUNIX is a trademark of Bell Laboratories.‐like hierarchy, with a consistent appearance when accessed from any machine. Replicated copies of files are maintained to improve reliability, increase performance, and enable each machine to run stand‐alone, albeit with reduced facilities.
Treatment of tab characters by a compiler
Authors: Waite W. M. 
Published: November 2006

AbstractHow expensive is it for a compiler to process horizontal tab characters introduced arbitrarily into program text? The measurements discussed in this note show that if tabs are uniformly expanded by the source text input module of the compiler, the process of reading and tokenizing the source program is slowed by about 20 per cent. This overhead can be completely eliminated by using an ‘extra space count’ in the lexical analyser instead of a uniform expansion.
A critique of unix
Authors: Blair Gordon S. , Malone Jon R. , Mariani John A. 
Published: November 2006

AbstractThe UNIX operating system enjoys an ever increasing popularity throughout the computing community; there will be 1.4 million UNIX licences distributed by 1985, rising at a rate of about 400,000 per annum.With universal acceptance of a system comes a dangerously high degree of inertia. Consider the analogous area of programming languages, where there has been great resistance to change, despite major advancements.This paper presents a critique of UNIX, based on three areas which we consider to be of vital importance to future operating systems. These areas are operating system structures and design, programming support environments and distributed computing.The criticisms presented are in no way intended to discredit UNIX. UNIX compares favourably with most of the present generation of operating systems. The intention is to highlight deficiencies in the state of the art in operating system design.
Specifications and an implementation of the type‐ambiguity problem in pascal
Authors: Partridge Derek 
Published: November 2006

AbstractCertain ambiguities in the definition of Pascal imperil the portability of Pascal programs. Specifications and an implementation of alternative interpretations are presented. Context‐free grammars augmented with guarded commands are demonstrated as a notation for specifying the static context‐sensitive constraints of programming languages.Most of the advantages of context‐free grammars are preserved and yet the potential range of the syntactic definition component has been extended to encompass all static constraints. Context‐sensitive syntax typically tends to either clutter the semantic definition component or (as with type equivalence in Pascal) result in undesirable implementor‐dependent decisions.An implementation of a CFG‐based parser that automatically checks for the defined context‐sensitive constraints is also described. In addition stepwise abstraction is introduced as a practical technique for communicating formal programming language definitions.
Using coroutines in pascal
Authors: Horton I. A. , Turner S. J. 
Published: November 2006

AbstractCoroutines are routines which communicate with each other in a more general way than that provided by the normal subroutine mechanism. Although they have many potential applications, their use has been restricted by their lack of availability in common high‐level languages. This paper discusses some of the issues involved in implementing coroutines, and proposes an implementation written in Pascal which may be incorporated into a Pascal program to give coroutine facilities. Use of the system is illustrated by two solutions to the N‐Queens problem by different coroutine strategies. The basic system is then extended to allow more advanced use of coroutines.
Communicating parallel processes
Authors: Kerridge Jon , Simpson Dan 
Published: November 2006

AbstractBy considering the problem of an event timer it is shown that the commonly available synchronizing facilities (monitors, CSP, distributed processes) are not able to always satisfactorily model the requirements of several processes which must run in parallel and which have to communicate with each other. The problem is discussed in general terms which show that what is required are new concepts for communicating processes. The synchronization facilities proposed are augmented to incorporate the concept of process scheduling directly from a process. This ensures that proper scheduling of process components can take place. The new mechanism is then applied to a number of the standard problems. It is also shown that the use of nondeterminacy in current facilities is probably not required and is, in fact, for many applications, a positive disadvantage.
Implementing ALGOL 68 predicates
Authors: Patel R. R. , Hunter R. B. 
Published: November 2006

AbstractPredicates are used in the Revised ALGOL 68 Report to indicate blind alleys and to reduce the number of rules in the Report. They may also be used by the compiler writer to implement some of the non‐context‐free aspects of the language. This paper shows how the predicates can be transformed in a relatively straightforward way into ALGOL 68 procedures to form part of an analyser for the revised language.
Separate compilation in a modula‐2 compiler
Authors: Foster David G. 
Published: November 2006

AbstractA new approach to the compilation of Modula‐2Modula‐2 was designed at the Institut für Informatik, ETH, Zurich.
is described. The compiler uses a simple database which provides the basis for a portable programming support environment. The environment consists of a number of tools which operate on the database and provide the programmer with facilities to create, and easily maintain, a multi‐module system.
A crash resistant UNIX file system
Authors: Anyanwu J. A. , Marshall L. F. 
Published: November 2006

AbstractThe UNIXUNIX is a trademark of AT&T Bell Laboratories.
operating system has been extended to support a crash resistant file system. This paper describes the modifications which were made to the UNIX kernel to support such a file system and the associated recovery facilities for maintaining the internal consistency of files despite the failure of the host processor, transient hardware failures and decay of the storage medium.
Routines: An argument against the conventional approach to functions and procedures
Authors: Middleton A. G. 
Published: November 2006

AbstractThis paper discusses the concept of a ‘routine’, which embraces both the concepts of ‘function’ and ‘procedure’. Several related functions and procedures can be mechanically derived from the same routine. These functions and procedures are ‘variants’ of the routine.Variants of a routine are identified by specifying some subset of the capabilities of the routine. A routine can be regarded as a means of specifying several related functions and procedures ‘at one go’. Alternatively, a routine can be thought of as a collection of functions consorting together for the purposes of optimization.
SOFTLIB — a documentation management system
Authors: Sommerville I. , Welland R. , Bennett I. , Thomson R. 
Published: November 2006

AbstractThis paper describes a software sysem (SOFTLIB) that has been developed to assist in the management of software documentation generated during systems development projects. It provides facilities to manage large numbers of documents, to file documents when they are complete and to issue them to system developers and maintainers. It also includes an information retrieval facility that allows programming staff to find documents, to examine their contents before issue and to assess the state of the software project documentation. SOFTLIB is explicitly intended to help manage the documentation generated during software development — it is not designed for use by end‐users of that software or for managing end‐user documentation.The novel characteristic of this system is the approach that is taken to the consistency and completeness of documentation. The documentation associated with a software system is organized in such a way that it may be detected if document sets are complete (that is, if all documentation which should be provided for a software component is available) and if document sets are likely to be inconsistent. This means that if a document has been changed without a comparable change being made to other associated documents, this is detectable by the librarian system.In addition, a subsidiary aim of our work was to investigate the utility of menu systems to complex software tools by building a user interface to SOFTLIB. We conclude that menu systems are far from ideal in such situations because of the range of possible options which must be handled by the system.
A new list compaction method
Authors: Li Kai , Hudak Paul 
Published: November 2006

AbstractList compaction, or so‐called ‘cdr‐coding’, can greatly reduce the storage needs of list processing languages. However, existing methods do not perform well when several lists are being constructed simultaneously from the same heap, since the non‐contiguous nature of the cells being allocated eliminates the opportunity for compaction. This situation arises not only in true parallel systems sharing a common memory, and sequential systems supporting multiple processes, but also quite often in purely sequential systems, where it is not uncommon to build several different lists simultaneously within a single loop. In this paper, a new list compaction method is presented that performs well during both sequential and ‘parallel’ list generation. The method is essentially a generalization of cdr‐coding, in which lists are represented explicitly as linked vectors rather than implicitly as compacted memory. In addition, an encoding scheme is used that is as simple or simpler than all known encodings, and destructive operations are supported with no greater overhead than existing schemes. Performance figures in a simulated environment suggest that the strategy consistently performs better than conventional cdr‐coding, with essentially the same complexity.
Template design for file processing applications
Authors: Ramanathan Jay , Shubra Charley 
Published: November 2006

AbstractEven though the data processing domain is relatively well‐defined, application‐specific details vary too widely to conceive of totally automating programming and specification support. Conventional tools lack the semantic knowledge to constructively support software development. On the other hand, it is possible to design a prompting and guiding system that can elicit the application details. The limits of automated programming support possible for file and data processing applications were identified by means of a case study of COBOL and PL/I programs. The data gathered from this study facilitated the definition of seventeen widely applicable templates. The resulting template set has immediate value as a manual specification and documentation tool. The templates encourage programmers to make well‐considered design decisions and enforce standardized documentation.
A distributed programs monitor for berkeley UNIX
Authors: Miller Barton P. , Macrander Cathryn , Sechrest Stuart 
Published: November 2006

AbstractWriting and debugging distributed programs can be difficult. When a program is working, it can be difficult to achieve reasonable execution performance. A major cause of these difficulties is a lack of tools for the programmer. We use a model of distributed computation and measurement to implement a program monitoring system for programs running on the Berkeley UNIX 4.2BSD operating system. The model of distributed computation describes the activities of the processes within a distributed program in terms of computation (internal events) and communication (external events). The measurement model focuses on external events and separates the detection of external events, event record selection and data analysis. The implementation of the measurement tools involved changes to the Berkeley UNIX kernel, and the addition of daemon processes to allow the monitoring activity to take place across machine boundaries. A user interface has also been implemented.
Context: An on‐line documentation system
Authors: Ragan Richard R. 
Published: November 2006

AbstractThis paper presents CONTEXT, an on‐line documentation system that is simple in concept and implementation. In spite of the simplicity, CONTEXT still provides substantial power and ease‐of‐use in accessing material in structured on‐line manuals. This paper provides an overview of the system from both the writer's and the user's perspective.
An almost path‐free very high‐level interactive data manipulation language for a microcomputer‐based database system
Authors: Schach Stephen R. , Wood Peter T. 
Published: November 2006

AbstractVIADUCT is a very high‐level non‐procedural language designed to simplify usage of MDBS, a microcomputer database management system. Users need not have any knowledge of the structure of the database, because no path through the database is specified in a VIADUCT command. Instead, VIADUCT automatically determines which of a number of paths should be traversed in order to process the command. As this choice of path can critically affect the processing time required, VIADUCT chooses that path which is most likely to minimize the number of record occurrences retrieved from the database. But when a command can have more than one valid semantic interpretation, VIADUCT computes and then displays the alternative paths from which the user is required to make a choice.Following a brief description of relevant aspects of MDBS, an overview of VIADUCT is given. The body of the paper describes the algorithms that are used to find paths through the database, as well as the path‐traversal algorithms. An evaluation of VIADUCT is presented and some restrictions noted.