bluuebunny/crossref_metadata_2025_split huggingface dataset:
Adam: An Ada‐based language for multiprocessing
Authors: Luckham D. C. , Von Henke F. W. , Larsen H. J. , Stevenson D. R. 
Published: November 2006

AbstractAdam is a high‐level language for parallel processing. It is intended for programming resource scheduling applications, in particular supervisory packages for run‐time scheduling of multiprocessing systems. An important design goal was to provide support for implementation of Ada and its run‐time environment. Adam has been used to implement Ada task supervision and also as a high‐level target language for compilation of Ada tasking.Adam provides facilities corresponding to the Ada sequential constructs (including subprograms, packages, exceptions, generics). In addition, it provides specialized module constructs for implementation of packages that may be shared between parallel processes, and new predefined types for scheduling. The parallel processing constructs of Adam are more primitive than Ada tasking. Strong restrictions are enforced on the ways in which parallel processes can interact.A compiler for Adam has been implemented in MacLisp on DEC PDP‐10 computers. Runtime support packages in Adam for scheduling (on a single CPU) and I/O are also provided. The compiler contains a library manipulation facility for separate compilation.The Adam compiler has been used to build an Ada compiler for most of the July 1980 Ada, including task types and rendezvous constructs. This was achieved by implementing the translation of Ada tasking into Adam parallel processing as a preprocessor to the Adam compiler. This present Ada compiler, which has been operational since December 1980, uses a procedure call implementation of tasking. It can be easily modified to other implementations. Compilation of Ada tasking into a high‐level target language such as Adam facilitates studying questions of correctness and efficiency of various compilation algorithms, and code optimizations specific to tasking, e.g. elimination of unnecessary threads of control.This paper gives an overview of Adam and examples of its use. Emphasis is placed on the differences from Ada. Experience using Adam to build the experimental Ada system is evaluated. Design of a run‐time supervisor in Adam is discussed in detail.
A standard Pascal event simulation package
Authors: Marsden B. W. 
Published: November 2006

AbstractA package implemented using standard Pascal is described. It provides the user with basic tools for discrete event‐orientated simulation, and includes facilities for scheduling and causing pending events, handling of LIFO and FIFO queues, control of periodical dumping of statistics and comprehensive initialization and error routines.Two versions of the package have been implemented, using tree and linked list structures for scheduled events. Their relative performances are compared. The tree structure proves to be more efficient except in the minority of cases where the set of scheduled events has to be searched frequently; it also provides a much more efficient scheduling algorithm than does a linked list structure.This package is primarily intended as a communication network design tool, and a simple example of this type of usage is included. It could also be used in undergraduate teaching. Coding examples are given for the main procedures, in the two implementations.
Compile—time detection of aliasing in euclid programs
Authors: Cordy James R. 
Published: November 2006

AbstractAliasing of variables occurs when two or more identifiers accessible in the same scope refer to the same storage location. When aliasing is present, the meaning of assignments becomes obscure because assignment to one variable identifier may change the value of others. Some of the more obscure kinds of variable aliasing can be the cause of particularly insidious bugs in computer programs. Axiomatic proof systems, such as that used for the Euclid language, assume that no aliasing is present so that the meaning of assignment is clear. For this reason, Euclid requires that no aliasing be present in Euclid programs and requires the compiler to implement checks to ensure this. This paper discusses the features of Euclid that aid in the detection of aliasing. It enumerates the kinds of aliasing that can be present in Euclid programs and gives efficient one‐pass algorithms for compile‐time detection of potential aliases. Aliasing is related to interference between concurrent processes, and a similar algorithm for detection of inter‐process interference in Concurrent Euclid programs is presented.
A general approach to queuing in C.S.P
Authors: Hull M. Elizabeth C. , McKeag R. M. 
Published: November 2006

AbstractIt has been our experience that, when writing software for operating systems, the synchronization techniques available in Communicating Sequential Processes are inconveniently primitive. In this paper we investigate how different types of queue can be represented in C.S.P., and we show how this approach can be developed into a general queuing mechanism.
Taming the PL/I syntax
Authors: Marks B. L. 
Published: November 2006

AbstractIdeally the syntactic part of a PL/I compiler would be generated directly from the semi‐formal definition of ANSI Standard PL/I. A practical approach to this is described, using finite state machines and an LALR parser generator.The parser uses a method due to Aoe which avoids list searching. Adapted for this method the PL/I grammar has 841 states. The parse table generator exploits the freedom to renumber states in a way that improves on previous algorithms for compacting the tables. The parser tables occupy less than 4K bytes.
Programs to process trees, representing program structures and data structures
Authors: Wilson Anne D. 
Published: November 2006

AbstractUtility programs discussed in this paper were initially developed to automate the ‘drawing’ of the non‐binary trees which occur when using a Jackson type methodology for program design; these trees represent either data structures or program structures, showing the selective, sequential and iterative relationships between nodesFirst a language was developed to allow information about tree structures to be input to the programs. Techniques and algorithms are described which enabled utility programs to be coded to process this data; transforming it into printable diagrammatic representation of trees; pseudo‐code representation of program trees; and PL/I or Cobol programsSecondly a merge operation for trees had to be defined, reflecting the step in Warmer's and Jackson's methodologies of combining data tree structures together to provide a program structure. Further algorithms are described which enable this step to be performed automatically, they include checks that each particular merge can be performedBecause the aims and concepts have been fluid some of the ideas have been discarded, and programs have been rewritten. Valuable insights were gained from persuing both the rejected and the acceptable ideas, these are described in this paper.
An Electronic Secretary
Authors: Sommerville I. , Smith D. J. 
Published: November 2006

AbstractThis paper describes an electronic mail system which has been implemented to provide facilities for the receiver as well as the sender of electronic mail. As well as the usual mail creation, transmission and filing operations, the system allows the receiver to specify automatic redirection of mail, and provides classification facilities so that the order of mail presentation is under the receiver's control. The system also includes an automatic mechanism for acknowledging mail and for cancelling mail which is either out‐of‐date or which was sent in error. The model on which the system is based is a non‐automated office, so analogues of waste paper baskets, etc. are provided.
Separating policy from correctness in concurrency control design
Authors: Robinson John T. 
Published: November 2006

AbstractThe designer of a concurrency control is currently faced with a confusing situation: there has been a proliferation of proposed methods (in fact, it will be shown here that even in the ‘simple’ centralized case there are infinitely many methods), and although there has been some analysis of a few alternative methods using simulation and analytic models, it is usually impossible to accurately predict some of the parameters required by these models prior to the development of a system. Furthermore, over the lifetime of a system some parameters will change, possibly radically, due to changes in system usage, the replacement or addition of processors, memories, and I/O devices, the development of new applications, etc. Here, a practical approach to this problem is presented: separating policy from correctness in the design of the concurrency control. This technique was successfully used in the development of a transaction processing system for the Cm* multi‐microprocessor. As an illustration of this approach, the design of the concurrency control of this system is described in detail. This design should apply directly to any centralized single‐level (non‐hierarchical) concurrency control.
Implementing a scalar C compiler on the cyber 205
Authors: Li Kuo‐Cheng , Schwetman Herb 
Published: November 2006

AbstractWith the aid of the EM (encoding machine) compiler tool kit, a preliminary version of a scalar C compiler was implemented on the Cyber 205 in a relatively short period of time. This C compiler emphasizes functionality more than efficiency. Several benchmark programs were used to measure the performance and to compare it with an equivalent C compiler for the VAX/UNIX system. In order to make it a production‐quality C compiler, further enhancements will be necessary. This paper presents some motivating factors, implementation details, and proposes further work on developing the Cyber 205 C compiler.
Distributing and revoking access authorizations on abstract objecs: A capability approch
Authors: Corsini P. , Frosini G. , Lopriore L. 
Published: November 2006

AbstractIn this paper a capability addressing environment is presented, based on the concept of extended capability. First of all it is shown that such an environment is well suited for implementing objects of abstract type. Then the problem of distributing and revoking access authorizations on abstract objects is considered and an efficient solution is presented. The revocation mechanism results in being selective, transitive and deferred.
Implementation of the database programming language modula/R on the personal computer lilith
Authors: Reimer Manuel 
Published: November 2006

AbstractModula/R is a database programming language that integrates the programming language Modula‐2 and the relational database model. This paper describes the language concepts of Modula/R and its implementation on the personal computer Lilith within the database project LID AS. A transaction concept as an extension of the procedure concept is integrated into Modula/R to support its implementation in a multi‐user environment with access to shared distributed databases through a network of personal computers.
A simple equation solver and its application to financial modelling
Authors: Derman Emanuel , Van Wyk Christopher J. 
Published: November 2006

AbstractWe discuss a simple algorithm for solving sets of simultaneous equations. The algorithm can solve systems of linear and some kinds of non‐linear equations, although it has nowhere near the power of a general non‐linear equation solver. Its principal advantages over more general algorithms are simplicity and speed. Versions of the algorithm have been used in a graphics language and in a system for interactively modifying the equations that constitute financial models. We discuss the second application in more detail here.
Wsh—a new command interpreter for unix
Authors: Bresnahan J. Barrie , Barnard David T. , Macleod Ian A. 
Published: November 2006

AbstractWSH is a window managing command language interpreter (shell) for the UNIX operating system. This interface increases a user's power to communicate with UNIX by providing a process management environment based on an integrated virtual terminal‐shell design. Unlike conventional shells, WSH affords its user the ability to monitor and communicate with multiple processes within a single display context. Windows represent virtual terminals in the WSH design, and as such are device‐independent abstractions of real terminals. Since the design of the virtual terminal environment is based on UNIX's TERMCAP terminal database facility, WSH is portable across all versions of UNM supporting this feature. WSH requires neither alteration of existing UNIX facilities nor special display devices. The current implementation runs on a Digital VAX 11/780 under Berkeley UNIX 4.1 environment.
Program development by inductive stepwise refinement
Authors: Dromey R. Geoff 
Published: November 2006

AbstractA constructive method of program development is presented. It seeks to unify two important ideas about program development. Namely that programming is a goal‐oriented activity and that there should be a correspondence between data and program structures. The latter concept is seen to be extensible beyond the data processing context in which it was originally proposed. Induction provides the vehicle for program development by stepwise refinement, with the final program being constructed by application of a sequence of progressively more powerful generalizations. The design process employed guarantees the correctness of the final program provided that each of the refinement steps have been correctly taken. The method is illustrated by a number of samples.
Programming divide and conquer for a mimd machine
Authors: Grit Dale H. , McGraw James R. 
Published: November 2006

AbstractThis paper discusses our efforts in implementing a divide and conquer algorithm (adaptive quadrature) on the HEP computer system. The one PEM HEP system performs in a MIMD fashion by pipelining execution of instructions from different processes. Unlike most divide and conquer approaches, our strategy ensures that the program will never deadlock due to memory expansion or spawning too many processes. Within this constraint we develop and analyse two different implementations: one using a static number of processes and the other a dynamic number of processes. Our results examine the relative performance of these two schemes. In addition we briefly discuss some of our impressions concerning some ‘myths of parallel programming’.
Structural dimensions of small programming environments
Authors: Lyon Gordon 
Published: November 2006

AbstractAlthough substantial variety exists among small programming environments, common points‐of‐choice in their design suggest the following structural characterization: real or virtual hardware; message‐passing or procedure‐calling; static or dynamic binding; horizontal or vertical organization; abstract or concrete structures; fixed or extensible language. Often these dimensions must support a very focused programming idiom, which combined with other requirements such as portability or performance, establishes structural dependencies, precludes features and forces exceptions. The characterization provides a rough framework that is useful in evaluating programming environments.
Orthogonality of concerns in module closure
Authors: George Geoffrey , Leathrum James F. 
Published: November 2006

AbstractInformation hiding in software design leads to the concept of module closure. The function of modularization in a design is to hide a design decision, facilitating the design of programs which employ that module. This produces a module which may be used elsewhere regardless of its implementation details. Module closure has two components—access closure, wherein the module and user share no data objects, but only the values of formal parameters, and computation closure, wherein the model which the module emulates is as simple as possible, and implementation independent.
Hardware/software trade‐offs for bitmap graphics on the blit
Authors: Pike Rob , Locanthi Bart , Reiser John 
Published: November 2006

AbstractThe Blit is an experimental bitmap graphics terminal built for research into interactive computer graphics on the UNIX time‐sharing system. The hardware is inexpensive and the graphics functions are implemented entirely in software. Nevertheless, the graphics performance of the Blit is comparable or superior to some displays with special‐purpose graphics hardware. This paper explains the paradox by referring to some principles of design: the hardware and software should be designed together to complement each other; carefully designed software can outperform infelicitous hardware; and simplicity of design leads to efficiency of execution. These principles are illustrated by examples from the Blit hardware and software and comparisons with other systems.
Implementation of the blit debugger
Authors: Cargill Thomas A. 
Published: November 2006

Abstractjoff is an asynchronous, source‐level, break‐and‐examine debugger for C programs running on the Blit, a programmable bitmap terminal, joff is implemented as two processes: a small process running in the terminal and a larger process running in a time‐sharing host. The constraints on its design and a menu‐driven user interface combine to present an unusual set of implementation difficulties. The way the problems were tackled and the degree to which they were solved may be interesting to those designing other debuggers. Operating system designers should assess the merits of a debugger that runs asynchronously with its subject and consider providing the necessary support.
The cost of a generated parser
Authors: Waite W. M. , Carter L. R. 
Published: November 2006

AbstractThe ‘fact’ that compilers employing generated parsers suffer significant performance degradation dis‐a‐vis recursive descent compilers is entrenched in the folklore of computing. We give detailed measurements that support this belief when the entire compiler is written in Pascal. We then define a general interface for a parsing module that hides significantly more information than usual, simplifying the process of generation and integration. This interface makes an assembly‐coded parse table interpreter feasible without changing the language used for the remainder of the compiler. When the parse table interpreter is written in assembly language, the costs of the generated parser are essentially the same as those for recursive descent. (A minor space/time trade‐off is possible, with the recursive descent implementation being slightly bigger and slightly faster.)
Follow set error recovery
Authors: Stirling Colin 
Published: November 2006

AbstractFollow set error recovery is a popular technique, implemented as part of a recursive descent parser, for recovering from syntax errors by editing the input string at the point of error detection. A formal description shows that follow set error recovery is, in actual fact, a family of similar techniques differing according to how follow set is defined. A general algorithm for this family of schemes is offered. Standard accounts mention and make use of non‐systematic, almost ad hoc, additions which improve the performance of the technique. It is shown that some of these additions can be systematized using error productions. Criteria for assessment of the technique are offered. Using these criteria and a database of over 100 example programs three different follow set schemes are assessed with respect to each other.
A simula program to automate wire‐wrap schedule generation
Authors: Lester L. N. , Thelander H. A. 
Published: November 2006

AbstractThe production of wire‐wrap schedules by hand is extremely tedious and error prone. This paper discusses a program which has been developed to generate an easy‐to‐follow, cross‐referenced wiring schedule from a simply‐formatted data file. The program also provides extensive checking of the input data. The language used was SIMULA, and was found to be an ideal vehicle for implementing the requirements of wire‐wrap schedule generation. The class concept, in particular, was found to be most useful.
Software development tools for microcontrollers
Authors: Knight John C. , Russell James L. 
Published: November 2006

AbstractTwo software tools are described that are designed to facilitate software development for microcontrollers. One is a mid‐level programming language called Pascal/48 and the other is a circuit simulation system. Pascal/48 is designed to give the programmer many of the advantages of a high‐level language, but also provide access to all of the hardware of the Intel MCS‐48 series of microcontrollers. The circuit simulation system combines many of the advantages of simulation and emulation. It provides a software testing environment in which many more software functions can be tested than with conventional simulators. The system integrates an instruction‐set simulator with simulators for other devices. They operate in parallel and are synchronized by a clock that records simulated time. I/O lines of the microcontroller can be linked to other components so that complete circuits can be simulated. Displays are provided of the internal and external state of the simulated circuit, and of the Pascal/48 program being executed. They are updated as simulated execution proceeds using the screen updating facilities of ASCII terminals. Simulation can be continuous, single step, or execution can be reversed (i.e. instructions are ‘unexecuted’).
Practical considerations of global and local variables
Authors: Er M. C. 
Published: November 2006

AbstractFisher advocates that all variables should be made global to programs and subprograms in order to increase the maintainability and to reduce the problems with subprogram linkages, among other things. The fallacies of Fisher's arguments are shown and the advantages and necessity of using local variables are discussed. It is argued that, from a practical point of view, the use of local variables improves the comprehensibility and the time and space efficiency of programs, as well as makes correctness proofs easier and recursion possible.
Cwsh: The windowing shell of the Maryland Window System
Authors: Weiser Mark 
Published: November 2006

AbstractThe Maryland Window System is a set of programs for manipulating multiple overlapping windows on CRT terminals. Part of the package is the window shell, called the CWSH. The CWSH uses the windowing system to create multiple windows running shell processes. The CWSH differs from the WSH and BRUWIN window systems by permitting processes running in the windows access to window functionality, and by more fully implementing a Unix terminal within each window. Unlike BRUWIN and WSH, CWSH permits programs, such as other shells and editors, that intensively examine or modify their terminal environment to run unmodified in its windows.
A portable high‐level database debugger and software performance monitor
Authors: Jankowitz Hugo T. , Kilfoil Paul W. , Rabkin Ilana , Schach Stephen R. 
Published: November 2006

AbstractThe package DBDEBUG assits the users of CODASYL (network) database management systems in two ways. It can be used by applications programmers to debug their programs, and by the database administrator to monitor the performance of the database. The user may select the sections (or even individual statements) of his program to be traced and/or monitored. He may list the specific records and items he wishes to be investigated; he may also restrict tracing and monitoring to only certain DML verbs.The user's database schema and subschema are submitted to processors which generate a data dictionary. This data dictionary is then used by DBDEBUG in modifying the user's DML source code in order to obtain the specified tracing or performance statistics. The output is high‐level in that it reflects the high‐level language (DML COBOL) in which the user's source code was written.The package is designed to be portable. All but one of its components are written in standard Pascal or ANSI COBOL; assembler code is restricted to a ten‐line subroutine which obtains L/O and CPU times from the operating system.