bluuebunny/crossref_metadata_2025_split huggingface dataset:
A case study in fault tolerant software
Authors: Black J. P. , Taylor D. J. , Morgan D. E. 
Published: November 2006

AbstractThe addition of redundancy to data structures can be used to improve the ability of a software system to detect and correct errors, and to continue to operate according to its specifications. A case study is presented which indicates how such redundancy can be deployed and exploited at reasonable cost to improve software fault tolerance. Experimental results are reported for the small data base system considered.
The architecture of the PLAIN data base handler
Authors: Kersten Martin L. , Wasserman Anthony I. , Wasserman Anthony I. 
Published: November 2006

AbstractThe programming language PLAIN has been designed to support conversational access to a data base, and incorporates relations as a built‐in data type. This paper describes the architecture of the data base handler for PLAIN, emphasizing the separation of the data base handler from other aspects of the language processor, and the modularization of the data base architecture to support modifications to the language and its implementation with minimal difficulty. The data base architecture is layered in order to provide the greatest possible degree of information hiding and separation of functionality. The paper shows the structure of the data base handler and the functions of the various modules of the system.
DIALOG: A scheme for the quick and effective production of interactive applications software
Authors: Negus B. , Hunt M. J. , Prentice J. A. 
Published: November 2006

AbstractDIALOG is a collection of routines, including a main ‘driver’ program, which is used by an applications programmer as the user interface to interactive applications programs. The routines handle command analysis, data input and editing, as well as processing standard commands such as HELP. DIALOG offers, with no extra effort from the applications programmer, not only a simple interface for first‐time users which gives complete instruction in using the program, but also a ‘command driven’ interface for more experienced users. DIALOG permits the quick and effective production of interactive applications software by programmers with no previous experience of writing such programs. User reaction to the programs so far produced and offered as part of a university computing service has been extremely favourable.
A modula based language supporting hierarchical development and verification
Authors: Bernstein A. J. , Ensor J. R. 
Published: November 2006

AbstractThis paper describes a proposal for a modification to the language Modula. The modification was motivated by a desire to bring to the language the ability to build hierarchical systems and to support program verification efforts.In the modified language, called SB‐Mod, modules are grouped into levels and calls are permitted from the modules of one level to those of a higher level. Verification is supported through a set of clearly described synchronization constructs and by restricting the flow of information between levels. A result of this is that levels do not interfere with each other and can be treated separately for purposes of verification.In considering modifications, an attempt was made to provide the user with a variety of control mechanisms, while at the same time avoiding situations in which excessive run‐time overhead would be incurred.
A comparative study of task communication in ada
Authors: Welsh Jim , Lister Andrew 
Published: November 2006

AbstractA previous paper compared the mechanisms for process communication in Hoare's communicating sequential processes and in Brinch Hansen's distributed processes, by both qualitative and quantitative analyses. This paper extends these analyses to the corresponding features for communication between tasks in Ada. The similarity between Ada's features and Hoare's proposals is confirmed, but some limitations on non‐determinism in Ada are noted.
Linguistic mechanisms for resource management strategies
Authors: Ancilotti P. , Lijtmaer N. , Boari M. , Natali A. 
Published: November 2006

AbstractIn this paper a unified set of linguistic features for providing a very flexible range of resource management strategies is presented. These features may be embedded in an object oriented programming language with abstract data type definitions. Firstly some of the more frequently used resource management strategies are illustrated and the related problems of resource allocation, access and synchronization are discussed. Then linguistic mechanisms to allow static and dynamic resource allocation, static access control and synchronization are presented. Finally some examples, reflecting a wide range of resource management strategies, are discussed in order to illustrate the application of the proposed linguistic features.
An experiment with Fortran and Pascal
Authors: Perrott R. H. , Dhillon P. S. 
Published: November 2006

AbstractThis paper reports on a programming experiment involving the languages Fortran and Pascal. The subject of the experiment was the simulation of the X‐ray department of a local hospital. The programming was carried out by two different programmers at different periods of time.A static analysis was performed on both models to determine how the languages were used by both programmers. The compilation and execution speeds of both models were then determined when executed on an ICL 1906S computer. The results indicate that the Pascal program is substantially faster in both compilation and execution speed than an equivalent Fortran program.
A portable lisp compiler
Authors: Griss Martin L. , Hearn Anthony C. 
Published: November 2006

AbstractThe programming language LISP is usually implemented via an interpreter, and a compiler is added later as a LISP program. However, all such production compilers known to the authors produce explicit instructions for the given computer being used. This paper describes the development of a portable LISP compiler in the sense that only Standard LISP functions are used in its definition and the output is a sequence of abstract machine codes, easily mapped to instruction sequences on current computers. The resulting code is quite efficient, demonstrating once again the maxim that most compiler optimization is largely machine independent.
A new fast and safe marking algorithm
Authors: Kurokawa Toshiaki 
Published: November 2006

AbstractA new marking algorithm for garbage collection is presented. Although the method is a variation of the usual simple stacking algorithm, in practice this algorithm has quite improved both in stack space and processing time. One significant modification is to stack a node only when both the sublists are unmarked. The other innovation is a ‘stacked‐node‐checking’ method invoked after each stack‐overflow. With this method, a number of unnecessary nodes are eliminated, the stack is compacted, and the marking process can resume using the generated space in the stack. This algorithm has been used for LISP1.9 garbage collection for years, and succeeded in showing good figures.
An analysis/synthesis interface for Pascal compilers
Authors: Waite W. M. , Carter L. R. 
Published: November 2006

AbstractMany Pascal compilers are based upon a model which has two unpleasant properties: a large working set of procedures and lack of flexibility in object code structure. In this paper we analyse the source of these faults and describe an alternative model which avoids them. We then present the details of the key interface in the alternative model, as realized by a particular compiler.
COPAS—A conversational Pascal system
Authors: Atkinson L. V. , North S. D. 
Published: November 2006

AbstractTerminal systems usually permit a user to interact with a running program, if only by using the terminal for input and output. It is possible to extend the interaction to include the compilation phase. Program text is translated as it is supplied and edits are checked immediately they are made. A system displaying these characteristics can be called conversational. COPAS is such a system.
Has the program been altered?
Authors: Wichmann B. A. 
Published: November 2006

AbstractIt is often essential to know if a computer program has been altered. If the text has been provided on magnetic tape and subsequently loaded onto another computer with possible changes in the character set, the problem becomes more difficult. This paper proposes the use of a ‘parity check’ as used in digital data transmission. An implementation of this algorithm in Pascal is given together with details of how a Pascal source text can be checked for alterations using the algorithm.
The implementation of case statements in Pascal
Authors: Sale Arthur 
Published: November 2006

AbstractThis paper examines the probable implementations of the case statement in Pascal, and analyses their consequences. A particular implementation for the Burroughs B6700/7700 series illustrates the necessary investigations. The techniques, although not new, are brought together to serve as a stimulus to improving the implementation of case‐statements in other compilers for Pascal, and to provide ideas for implementors. The architectural limitations of even high‐level computers in implementing the case statement are briefly discussed.
Design for a robust simple and highly reliable filestore
Authors: McGregor D. R. , Malone J. R. 
Published: November 2006

AbstractThis note describes a robust, simple‐to‐implement filestore. The filestore provides facilities for creating named, dynamically allocated files which can be accessed via a block level interface (both randomly and sequentially). The design is particularly well‐suited to the type of environment found on personal computers, word processors, and other stand alone systems where a high degree of resilience against hardware and software malfunction is required. It is ideally suited for use with floppy discs or any other cheap removable rotating medium, because of its high reliability and good performance, gained at the price of a slight reduction in available disc capacity.
Document preparation systems
Authors: Hansson Hasse , Steensgaard‐Madsen Jørgen 
Published: November 2006

AbstractThis paper gives an introduction to programs used to prepare the layout of a text for publication. It presents a suitable terminology, independent of any particular systems but in no way complete, for the description of documents. The basic characteristics of phototypesetting equipment are described. Finally, highlights of a particular system are given. Very little is said on the implementation of that system.
The community file station
Authors: Barnett Richard , Beckwith Richard C. 
Published: November 2006

AbstractThis paper describes the design and use of the Community File Station, an intelligent terminal system, at a college with a large central computer facility. The Community File Station allows functions such as text preparation, editing, local file management and rapid text display to be performed locally without any interaction with the central computer system. It is hoped that the combination of such a terminal system with a high speed campus network will have a significant impact on the way in which the user community uses the central system. Some examples of the way in which the terminal is used is given, along with the way in which the role of the central system changes for the user of the Community File Station.
Distributing viewdata and teletext services to a user community
Authors: Wood G. K. , Larmouth J. 
Published: November 2006

AbstractThe normal method of access to Viewdata and teletext services is via special TV sets, however it is possible to make these services available to terminal users of a computer system. This paper describes how the British Viewdata and teletext services were adapted to run at Salford University and also discusses some of the problems that were encountered in the implementation. In order to do this, certain relevant features of the Prestel and the broadcast systems are described and discussed in detail.
Task management in Ada—A critical evaluation for real‐time multiprocessors
Authors: Roberts Eric S. , Evans Arthur , Morgan C. Robert , Clarke Edmund M. 
Published: November 2006

AbstractAs the cost of processor hardware declines multiprocessor architectures become increasingly cost‐effective and represent an important area for future research. In order to exploit the full potential of multiprocessors, however, it is necessary to understand how to design software which can make effective use of the available parallelism. This paper considers the impact of multiprocessor architecture on the design of high‐level programming languages and, in particular, evaluates the language Ada in the light of the special requirements of realtime multiprocessor systems. We conclude that Ada does not, as currently designed, meet the needs for real‐time embedded systems.
Fortran 77 portability
Authors: Larmouth J. 
Published: November 2006

AbstractThis paper is the result of a study of the portability problems which might arise in the use of the Fortran 77 language. The study involved both an examination of the text of the Standard and discussions with a number of compiler‐writing teams. The paper identifies areas of Fortran 77 which are likely to cause problems, either because of an incomplete language specification, difficulties in compilation, or user inattention. It will be of interest not only to users writing large packages in Fortran, and to Fortran compiler writers, but also to those involved in language standardization and portability in general.
Dynamically structured data
Authors: Madhavji N. H. , Wilson I. R. 
Published: November 2006

AbstractWhile the control structures in recent programming languages are structured, the data structures are still primitive. This paper examines data structures and operations on them, and proposes some new features in programming languages. These new features are principally in the areas of data description and data usage. In data description, the emphasis is on a global view of dynamic data structures; in data usage, semantic relationships between data items are innate in the operations on these data structures. Finally, example data descriptions and algorithms using some of the new features are contrasted with those using conventional features.
LCCD a language for Chinese character design
Authors: Mei Tung Yun 
Published: November 2006

AbstractOne of the critical problems of Chinese data processing is to make a computer produce Chinese characters as output. This paper describes a language called LCCD, which is especially intended for high quality design of Chinese characters, although it can in fact be used for any kind of symbols. Special attention is given to the methodology of character design, using a parametric graphical approach. The underlying methods of implementation are also discussed.
Generalized non‐recursive traversal of binary trees
Authors: Kilgour A. C. 
Published: November 2006

AbstractA non‐recursive algorithm for the traversal of a binary tree is presented in which the order of traversal is defined by an external data array, allowing any of the six possible orders to be selected without modification to the algorithm itself. The extra storage requirements are three pointer variables and two bits per node (or two bits per level if an auxiliary stack is used.) The algorithm is a generalization of the pointer reversal method of Schorr and Waite and is derived by transformation of a generalized recursive version. The algorithm is described using the notation and conventions of Pascal.
Micro MUMPS: An interactive database language for micro‐computers
Authors: Watanabe Tan , Ohsawa Tsuneharu , Kuma Hisao , Tsukada Wakunaga 
Published: November 2006

AbstractA simple interactive language named Micro MUMPS has been implemented on a microcomputer system. Its powerful facilities for data base manipulation and character handling make programming easy for end users who are unfamiliar with computers. Micro MUMPS is a practical subset of the language MUMPS which has been implemented on many minicomputers, and it also has some additional capabilities indispensable to micro‐computer applications. A modified prefix B‐tree is used in Micro MUMPS database and its organization can be changed according to the requirements of space and time efficiency.The design criteria of Micro MUMPS and micro‐computer based implementation techniques are discussed in this paper.
Backtrack search algorithms and the maximal common subgraph problem
Authors: McGregor James J. 
Published: November 2006

AbstractBacktrack algorithms are applicable to a wide variety of problems. An efficient but readable version of such an algorithm is presented and its use in the problem of finding the maximal common subgraph of two graphs is described. Techniques available in this application area for ordering and pruning the backtrack search are discussed. This algorithm has been used successfully as a component of a program for analysing chemical reactions and enumerating the bond changes which have taken place.
A FORTRAN implementation of Concurrent Pascal
Authors: Kerridge J. M. 
Published: November 2006

AbstractThis paper describes the transportation of sequential and concurrent Pascal from the SOLO distribution tape to a non‐PDP‐11 like mainframe (IBM 370/145). An interpreter for the idealized virtual machine was written in FORTRAN. Subsequently the PDP‐11 dependencies were removed from the interpreter and compilers so that a more transportable version of concurrent Pascal could be generated. A FORTRAN system was then constructed which simulated an operating system environment in which the interpreter could run. Clock and device interrupts are simulated so that process scheduling can be undertaken as if real interrupts were being generated.The system was constructed for a teaching environment so that several students could make use of the Polytechnic's interactive computer system each running their own concurrent system.
A comparison of three string matching algorithms
Authors: De V. Smit G. 
Published: November 2006

AbstractThree string matching algorithms—straightforward, Knuth‐Morris‐Pratt and Boyer‐Moor—re examined and their time complexities discussed. A comparison of their actual average behaviour is made, based on empirical data presented. It is shown that the Boyel‐Moore algorithm is extremely efficient in most cases and that, contrary to the impression one might get from the analytical results, the Knuth‐Morris‐Pratt algorithm is not significantly better on the average than the straightforward algorithm.
A rapid lookup table method for trigonometric functions
Authors: Sewell B. T. 
Published: November 2006

AbstractAn algorithm for determining the values of sin 2πx and cos2πx, given x, is described. The value of the function is determined by a single masking operation. By storing 2n values in the table it is possible to exploit the periodicity of the two's complement representation to locate values for negative x and thus avoid treating negative values of x as a special case. The algorithm can be coded in some modern high level languages (e.g. PL/I) and is particularly suitable for use in structure factor routines for protein crystallography.
Implementing a compiler‐based test tool
Authors: McMullin Paul R. , Gannon John D. , Weiser Mark D. 
Published: November 2006

AbstractDAISTS (Data Abstraction Implementation, Specification and Testing System)1 is a compiler tool‐base for program development. The compiler combines an automated ‘oracle’, which checks consistency conditions derived from algebraic specifications of modules, with run‐time routines that judge the quality of a user's test data according to statement and expression coverage criteria. This paper describes some of the implementation techniques used in DAISTS.
An algorithm for an efficient command interpreter
Authors: Gait Jason 
Published: November 2006

AbstractThe function of a command interpreter is to evaluate a command line, select an action according to the command entered and then execute the action, passing such parameters from the command line as required. Efficient run‐time behaviour is exhibited when the action is selected via a hash table, which provides constant time performance as the number of commands increases. Since the hash table is static and can be closely packed in an optimal fashion, the execution time can be limited to an average of less than two probes per selection even for closely packed tables.
The seismic kernel system — a large‐scale exercise in fortran 77 portability
Authors: Hatton Les , Wright Andy , Smith Stuart , Parkes Gregg , Bennett Paddy , Laws Robert 
Published: November 2006

AbstractThe portability of software has become a major commercial issue in recent times. Such portability does not come easily, as few if any computer languages are really portable in practice. An additional complicating factor, especially in the commercial environment, is that the resulting software must be efficient. This paper describes the design and successful implementation of a 500,000+ line portable FORTRAN 77 package for the processing of seismic data. The package exhibits demonstrably high efficiency on a wide variety of machines from minicomputers to the largest supercomputers. Experiences gained during this exercise throw much light on the integration of the various thought processes which occur during the software engineering cycle, especially the notion of locality.
A simple algorithm for clock synchronization in transputer networks
Authors: de Carlini Ugo , Villano Umbeeto 
Published: November 2006

AbstractIn a distributed system based on Transputer components there is one clock for each processing element, and the definition of the global system time requires the choice of a hardware or software synchronization method. This paper describes the RING_SYNC algorithm, based on a ring‐structured synchronization scheme. RING_SYNC has no provision for fault tolerance, but it introduces little overhead, thanks to the optimization of both the number of messages exchanged at sync time and the resynchronization frequency. The implementation of the algorithm together with the tests performed for measuring the synchronization error and their results are discussed extensively, and some typical applications are pointed out.
An interpreter for LOTOS, a specification language for distributed systems
Authors: Logrippo L. , Obaid A. , Briand J. P. , Fehri M. C. 
Published: November 2006

AbstractLOTOS is an executable specification language for distributed systems currently being standardized within ISO as a tool for the formal specification of open systems interconnection protocols and services. It is based on an extended version of Milner's calculus of communicating systems (CCS) and on ACT ONE abstract data type (ADT) formalism. A brief introduction to LOTOS is given, along with a discussion of LOTOS operational semantics, and of the executability of LOTOS specifications. Further, an account of a prototype LOTOS interpreter is given, which includes an interactive system that allows the user to direct the execution of a specification (for example, for testing purposes). The interpreter was implemented in YACC/LEX, C and Prolog. The following topics are discussed: syntax and static semantics analysis; translation from LOTOS external format to internal representation; evaluation of ADT value expressions and extended CCS behaviour expressions. It is shown that the interpreter can be used in a variety of ways: to recognize whether a given sequence of interactions is allowed by the specification; to generate randomly chosen sequences of interactions; in a user‐guided generation mode, etc.