bluuebunny/crossref_metadata_2025_split huggingface dataset:
A specification schema for indenting programs
Authors: Mateti Prabhaker 
Published: November 2006

AbstractA two level specification of the functional behaviour of a class of indenting programs for Pascal is presented. The transformation that these programs perform on the input text is a composition of splitting input lines, altering the blank space between lexical tokens and computing the margin required in front of each of the split lines. The high level specification is given as a stylized Pascal grammar in Extended BNF. In contrast, the low level specifications, which are operationally closer to a program, and which define how syntactically invalid text is dealt with, require several mathematical functions that capture the essence of these basic transformations. The specifications of an indenting program for Pascal are then obtained as a further elaboration of these functions. Most indentation styles appearing in the literature can be specified with precision using methods developed in this paper. Our experience in this case study indicates that although specifications for real‐life programs can be given using simple mathematics, the effort required is still considerable.
Short communication dmert crash resistant file systems
Authors: Wallace John J. 
Published: November 2006

AbstractDMERT (Duplex, Multi‐Environment, Real Time) is a real‐time operating system that supports reliable telecommunications applications. Although DMERT file systems are based on UNIXTM file systems, which suffer robustness drawbacks, DMERT file systems do not suffer these drawbacks. The DMERT file manager uses synchronous writes and file system audits to manage crash resistant file systems. The performance penalty for this crash resistance is minimal. This note describes DMERT's crash resistance policy and shows how UNIX and UNIX‐like file systems can be made crash resistant without sacrificing performance.
Exception handling in C programs
Authors: Lee P. A. 
Published: November 2006

AbstractThis paper describes a software package which has been constructed to allow programs written in the C language to make use of exception handling facilities. The package is implemented as a set of macros and procedures and requires no modification to the C compiler or preprocessor. The operation of the package and its facilities are described, and practical experience of its use is presented. The code in the package is given in the appendix.
A system for analysing Ada programs at run‐time
Authors: Holdsworth David 
Published: November 2006

AbstractThis paper describes a prototype system for analysing core dump files from crashed Ada programs. In addition the general question of Ada runtime debugging is discussed. It is suggested that the Ada scope rules are not appropriate to control visibility in this situation. An alternative scheme has been implemented in the prototype. Some first impressions of live use of the Ada language are included among the conclusions.
Decision tables
Authors: Chvalovský Václav 
Published: November 2006

AbstractDecision tables have been known for almost 20 years but there are still data processing shops where systems analysts and programmers have not used them at all. That is why it is felt important to re‐open their case once again and publicize experience with their use, as well as more recent developments and expected future trends. It appears, from experience gained with decision tables over the past 10 years, that they can be of great help in programming, program maintenance, as well as in design communication between analysts and programmers. To assist also in training, a brief user's guide is included in this article, which is belived to make the first attempts to easier design of a decision table. Finally, the procedure adopted to implement a machine independent (portable) decision‐table preprocessor for COBOL is outlined. In as much as the availability of such a preprocessor appears essential for the degree of use of decision tables, this single fact may well become a milestone in the overall popularity of decision tables world‐wide.
A program structuring preprocessor for a macro assembly language
Authors: Hayashi Tsunetoshi 
Published: November 2006

AbstractThis paper deals with design considerations and implementation of a program structuring preprocessor for a macro assembly language. The macro assembly language is used for writing the code generation pass of a compiler. Macro instructions become lengthy, tedious and cumbersome when they incorporate some mild code improvement. This is chiefly because the macro assembly language lacks an adequate program structuring facility. Program structuring is a great help in improving ease of programming and the under‐standability of the expansion control statements of a macro instruction in such a kind of programming. Considerations on the design of the source language and the outline of implementation are described. The design objective is ease of implementation and ease of use, and is fairly well satisfied by the language.
Introduction to enhanced C (EC)
Authors: Katzenelson Jacob 
Published: November 2006

AbstractThe main goals of EC are to design a set‐oriented, extensible, C‐like language and to build a translator for this language that produces efficient run‐time code.A set‐oriented language supports higher level data aggregates and operations. In EC these are sets, sequences, tuples, oneofs, and the corresponding operations. Extensibility in EC involves the use of data abstractions to define new types. EC's data abstractions, called clusters, are macro‐like devices that perform substitution on the typed syntax tree. They handle names in a way that prevents name conflicts at substitution time. They also have some novel error reporting properties. Run‐time efficient code is understood as code of the quality expected from a programmer using C.This paper describes the EC language and, in particular, the data abstractions. The description is by examples and assumes familiarity with C. Conclusions and the experience gained in applying EC are summarized in the last section.
Access path query language for relational database systems
Authors: Patnaik L. M. , Shailendra Phule , Rao K. Venkateswara 
Published: November 2006

AbstractDatabase management systems offer a very reliable and attractive data organization for fast and economical information storage and processing for diverse applications. It is much more important that the information should be easily accessible to users with varied backgrounds, professional as well as casual, through a suitable data sublanguage. The language adopted here (APPLE) is one such language for relational database systems and is completely nonprocedural and well suited to users with minimum or no programming background. This is supported by an access path model which permits the user to formulate completely nonprocedural queries expressed solely in terms of attribute names. The data description language (DDL) and data manipulation language (DML) features of APPLE are also discussed. The underlying relational database has been implemented with the help of the DATATRIEVE‐11 utility for record and domain definition which is available on the PDP‐11/35. The package is coded in Pascal and MACRO‐11. Further, most of the limitations of the DATATRIEVE‐11 utility have been eliminated in the interface package.
The real‐time debugging monitor for the bell system 1A processor
Authors: Witschorik C. A. 
Published: November 2006

AbstractReal‐time computer systems can be difficult to test when their timing characteristics influence the occurrence of problems. Because of this, tools for debugging real‐time systems must account for the interference that they produce in the system they are monitoring. The debugging monitor for the Bell System 1A processor is an example of just such a tool. This paper examines the 1A processor debugging monitor, focusing on the division of the monitor into three separate devices: a hardware monitor that allows autonomous debugging; a resident monitoring program that allows debugging with a minimal interference to normal timing; and a separate mini‐computer monitor that offers extended capability at the expense of unrestricted interference.
Implementation of a retrospective tracing facility
Authors: Malone J. R. 
Published: November 2006

AbstractThe implementation of a retrospective trace facility, which produces diagnostics in terms of the original source code language, is described. In its simplest form the mechanism is straightforward to implement, requiring perhaps one man‐month of effort. As the generated object code is bulkier measurements of the expected size increase. Suggestions to reduce code volume have been outlined.
Implementing a simulation tool in a high‐level language with no multitasking facilities
Authors: Cavouras John C. 
Published: November 2006

AbstractWays to implement coroutines in a block‐structured language with no multitasking facilities are presented. Coroutines are implemented as procedures. The reactivation points are kept in global variables, one variable for each procedure. Local variables whose values are required on re‐entry are stored as STATIC objects. The variables or data of re‐entrant coroutines are stored in an event list associated with each such coroutine. A procedure with several entries is a convenient mechanism to trap the primitive calls issued by the coroutines. This procedure returns to the master program by using a non‐local GOTO. The implementation of the above in PL/I and C is described and a comparison is made with sequential Pascal. Ada includes constructs which satisfy most requirements.
The effect of scope delimiters on program comprehension
Authors: Sykes Floyd , Tillman Raymond T. , Shneiderman Ben 
Published: November 2006

AbstractScope delimiters, such as BEGIN‐END or DO‐END, are used in many programming languages, but they can lengthen and clutter a program listing. This paper provides experimental evidence that ENDIF or ENDWHILE statement terminators make for easier to comprehend programs than BEGIN‐END pairs surrounding compound statements.
Tools: An environment for time‐shared computing and programming
Authors: Ellis John R. , Mishkin Nathaniel , van Leunen Mary‐Claire , Wood Steven R. 
Published: November 2006

AbstractThe Yale Tools environment provides integrated modern computing facilities to a mixed group of programmers and users on time‐shared machines. Hundreds of people use the environment every day for systems and applications programming, word‐processing and university business. The success of the environment is in its integration and engineering detail. Building such a system without a high‐level language and a run‐time library would have been impossible.
On the design of a special‐purpose scientific programming language
Authors: Knight John C. , Dunlop Douglas D. 
Published: November 2006

AbstractObservations on the design of the special‐purpose scientific programming language SL/1 are presented. SL/1 is intended for applications programming of the Control Data Corporation Cyber 203, a very high‐performance vector processor, which is mainly used for scientific computation. The language design has been heavily influenced by the hardware characteristics of this machine and the needs of the Cyber 203 user community. Various aspects of the design of SL/1 are discussed and measurements of their use are presented. In addition, unexpected similarities between the resulting design of SL/1 and the design of FORTRAN are examined and several reasons for the continued widespread use of FORTRAN are suggested.
Software tools for first‐order logic
Authors: Cunningham R. James , Zappacosta‐Amboldi Silvana 
Published: November 2006

AbstractA suite of software tools for the manipulation and validation of first‐order logic expressions is presented. The suite ponsists of a collection of modules, each performing a precise and well‐defined task. More sophisticated tasks such as theorem proving can be achieved by concatenating modules and interacting at suitable stages.
Real‐time BASIC
Authors: Bull Gordon , Lewis Alan 
Published: November 2006

AbstractA standard for BASIC is nearing completion. An integral part of that standard is a module of the language addressing the needs of real‐time applications. This paper describes the features of real‐time BASIC, highlighting the concurrency aspects, the mechanisms provided for inter‐process communication and synchronization, and for communication with the hardware system. An example showing how the language may be used to control the environment and pump water from a mine shaft is included. The use of the language with a distributed control system is also discussed.
Syntax driven COBOL compilers—an assessment
Authors: Layzell P. J. , Triance J. M. 
Published: November 2006

AbstractMost syntax analysis phases of COBOL compilers are written as sequences of procedural code instructions each of which validates a particular part of the syntax of a COBOL program. This paper examines the structure of a syntax driven COBOL compiler and a practical implementation is described. The problems encountered with this type of compiler construction are explained, and its advantages are examined. Finally, some other potential applications of syntax driven technology are suggested.
The new mexico state university ring‐star system: A distributed unix environment
Authors: Karshmer Arthur I. , Depree Dirk J. , Phelan James 
Published: November 2006

AbstractA distributed version of the UNIX operations system is currently under development through a joint effort of New Mexico State University and the Hebrew University of Jerusalem. A microprocessor version of the UNIX kernel has been developed which will run on any PDP‐11 or LSI‐11 based processing element and allows processes to run in a UNIX ‘look‐alike’ environment. Each process is fully transportable among all processors in the system. Although the preliminary version of the system was built in a star configuration, the system is currently being upgraded by the addition of a communication ring with 8‐bit microprocessors as ring interface units. The current paper describes the software structure, the hardware structure and the communication protocol of the system.
Perseus: Retrospective on a portable operating system
Authors: Zwaenepoel Willy , Lantz Keith A. 
Published: November 2006

AbstractWe describe the operating system Perseus, developed as part of a study into the issues of computer communications and their impact on operating system and programming language design. Perseus was designed to be portable by virtue of its kernel‐based structure and its implementation in Pascal. In particular, machine‐dependent code is limited to the kernel and most operating systems functions are provided by server processes, running in user mode. Perseus was designed to evolve into a distributed operating system by virtue of its interprocess communication facilities, based on message‐passing. This paper presents an overview of the system and gives an assessment of how far it satisfied its original goals. Specifically, we evaluate its interprocess communication facilities and kernel‐based structure, and discuss its portability. We close with a brief history of the project, pointing out major milestones and stumbling blocks.
Andra: The document preparation system of the personal workstation Lilith
Authors: Gutknecht Jürg , Winiger Werner 
Published: November 2006

AbstractAndra is a modern text editor and formatter designed for the personal computer Lilith. Lilith was developed at the ETH by Prof. N. Wirth. The interactive part of Andra makes extensive use of Lilith's characteristic features, namely its high‐resolution raster scan display and the mouse. The printer component of Andra allows the creation of high‐quality hardcopies on a laser printer. The Andra program is written in the language Modula‐2.
The design of an interactive program development system for Pascal
Authors: Nordström Bengt , Wikström Åke 
Published: November 2006

AbstractA program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program‐structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.
A semantically‐based formatting discipline for Pascal
Authors: Bailes Paul A. , Salvadori Antonio 
Published: November 2006

AbstractThe abstract (or semantic) syntax of the Pascal language is identified, and a linear representation for the trees so formed within the framework of the concrete syntax for that language is imposed. The indentation scheme so formed, augmented with a small number of pragmatic considerations, is compared with several previously proposed formatting schemes for Pascal and an example of the use of this new method is given.
An interactive data visualization system
Authors: Thalmann Daniel 
Published: November 2006

AbstractGRAFANA is an interactive program, which allows the user to produce drawings based on data stored on a disk file. The major advantage and originality of the system is that the user can interactively determine the visual effect of a drawing and immediately see it on the screen. Moreover, any drawing produced by GRAFANA can still be edited by a generalpurpose graphics editor. This system allows the user to obtain precisely the right drawing for any book, paper or report.GRAFANA has been implemented in MIRA‐2D, a graphical Pascal extension. It is available for different machines and kinds of graphical devices.
Preprocessing embedded actions
Authors: Sethi Ravi 
Published: November 2006

AbstractSome parser generators allow the user to attach actions, consisting of executable code, to syntax rules. Actions are usually in the local programming language, so they are simply copied into the generated parser. However, we show two situations in which it is convenient to allow actions to be in a different notation. A preprocessor is used to translate such notations into the local programming language. A preprocessor must know where to find actions and how to translate them. We show how these two activities can be programmed separately. Often, the user only has to worry about the second part: once the parser generator is known, the placement of the actions is known as well, so routines for finding actions can be separately compiled and linked in. Examples in the paper are based on the parser generator Yacc, but the approach is not limited to Yacc, or even to parser generators. Certain compositions of syntax‐directed translations can be implemented by preprocessing actions.
A methodology and notation for compiler front end design
Authors: Brown Cynthia A. , Purdom Paul W. 
Published: November 2006

AbstractA methodology and associated notation for designing compiler front ends, and in particular the interface between the parser and the semantic routines, is described. The methodology leads to a clean, easy to understand, documentable design. The notation is similar to an attribute grammar, but its purpose is to document the first pass of a specific compiler, rather than to describe the semantics of a language. It is designed to be accessible to non‐specialists, easy to learn, and natural. It can be used with or without software support. The notation was used during the development of a large compiler, and to assist in the transfer of the compiler to the group that will maintain it. Experience with the notation indicates that it meets its goals.
Exception handling—A static approach
Authors: Knudsen Jørgen Lindskov 
Published: November 2006

AbstractThis paper presents a static approach to exception handling. The static approach is proposed as a consequence of an examination of existing language constructs for exception handling in which several trouble spots have been revealed. The static approach consists basically of one concept, namely the sequel concept. Although the sequel concept is sufficient to specify exception handling within a program, one additional concept is introduced, namely the derived definition concept that is introduced as a generalization of the derived type and generic concepts from Ada.The main advantages of the static approach are first that it is truly static as opposed to the existing language constructs in which dynamic association is used in some way or another; and, secondly, the language constructs for exception handling are simple, easy to implement and based on familiar concepts.
Reference count garbage collection
Authors: Christopher Thomas W. 
Published: November 2006

AbstractA garbage collection algorithm that permits a reference count storage reclamation scheme to collect circularly linked inaccessible structures is presented. The algorithm requires no additional information beyond that required by a reference count scheme. In particular, it does not require the garbage collector to be able to find pointers outside the heap. The algorithm is most useful for augmenting reference count storage reclamation systems and for implementing storage management systems on top of languages that do not provide their own. It is, however, considerably less efficient in space and time than conventional garbage collection systems.
Exploiting partial order with Quicksort
Authors: Dromey R. Geoff 
Published: November 2006

AbstractThe widely known Quicksort algorithm does not attempt to actively take advantage of partial order in sorting data. A simple change can be made to the Quicksort strategy to give a bestcase performance of n, for ordered data, with a smooth transition to O(n log n) for random data. This algorithm (Transort) matches the performance of Sedgewick's claimed best implementation of Quicksort for random data.
A software development system based on a macroprocessor
Authors: Barcucci Elena , Pelacani Gianluca 
Published: November 2006

AbstractIn this paper a system for software development is described. This system consists of a general‐purpose macroprocessor and a set of service programs. The macroprocessor has been planned to work in a conversational environment and to this purpose a set of utilities has been inserted to aid the editing and the debugging of the macrodefinitions. Indeed the system allows the user to select, by means of commands, the flow of the operations to be executed and to choose when and how any program has to be expanded. The macroprocessor is easy to use and it is suitable to generate codes for both high‐level languages and assembler languages.