bluuebunny/crossref_metadata_2025_split huggingface dataset:
A correctness proof of an indenting program
Authors: Mateti Prabhaker , Jaffar Joxan 
Published: November 2006

AbstractThe correctness of an indenting program for Pascal is proved at an intermediate level of rigour. The specifications of the program are given in the companion paper.1 The program is approximately 330 lines long and consists of four modules: io, lex, stack and indent. We prove first that the individual procedures contained in these modules meet their specifications as given by the entry and exit assertions. A global proof of the main routine then establishes that the interaction between modules is such that the main routine meets the specification of the entire program. We argue that correctness proofs at the level of rigour used here serve very well to transfer one's understanding of a program to others. We believe proofs at this level should become commonplace before more formal proofs can take over to reduce traditional testing to an inconsequential place.
Hierarchical multi‐level computer network for laboratory automation
Authors: Lindgård Anders , Oxenbøll Jørgen , Sørensen Ejvind 
Published: November 2006

AbstractThe design and implementation of a microcomputer network to support laboratory automation is described and discussed. It is a multi‐level hierarchical star network connected to a multiprogrammed computer on which all program development is done. The system is capable of supporting a large number of experimental setups. The microcomputers are either used as (1) local microcomputers for experiment control, (2) multiplexers for other microcomputers or (3) controllers for peripherals known in the multiprogrammed computer.The system combines the advantages of a large multiprogrammed computer with those of a small cheap dedicated computer close to the experiment.Character‐oriented peripherals are connected to the multiprogrammed computer only. This reduces the amount of system software to be written for the network by an order of magnitude and eliminates the need for interfacing to existing small computer software. The system software consist of three small programs (monitors) providing a process concept and multibuffering of data in the involved computers. The monitor establishes a hierarchy of control and they eliminate the need for any local load device for the microcomputers as their monitors are in a read‐only store.The system developed is designed for control of experiments in an environment where the experiments and the control strategies change with time and where the data refinement required is beyond what can be done on the present generation of microcomputers.
XERROR, the SLATEC error‐handling package
Authors: Jones Rondall E. , Kahaner David K. 
Published: November 2006

AbstractThe XERROR package is a collection of portable Fortran routines for processing of errors that occur in other routines. It was developed as the error‐handling package for the SLATEC Common Mathematical Library, which is currently in use at a number of U.S. Department of Energy and other facilities. This paper describes how to use the package, from the viewpoint of the writer of library routines that need to call the XERROR package to handle errors, and from the viewpoint of the user of those library routines.
CMS—A chunk management system
Authors: Atkinson M. P. , Chisholm K. J. , Cockshott W. P. 
Published: November 2006

AbstractThe chunk manager provides simple transaction management, concurrency control and allocates, administers and retrieves apparently contiguous chunks of data of arbitrary and varying size on disc. This system is designed to permit students and research workers to rapidly assemble and test their own DBMS, supporting any data model. Currently it is being used to support PS‐Algol, an implementation of DAPLEX, a relational system and student database exercises.A chunk is similar to the common meaning of ‘record’ except that there is no implication of internal structure or consistent and static size. An efficient table processing capability is also provided.Locking and access control are implemented at the bag level to prevent conflicting use of data without excessive operating cost. The problems associated with concurrent access of shared bags have been studied and the currently implemented and future proposed solutions are discussed.
The costs and benefits of lazy interactive input in pascal
Authors: Comer Douglas 
Published: November 2006

AbstractThe programming language Pascal was designed and implemented in a non‐interactive programming environment. This paper surveys proposals for incorporating interaction into Pascal, and focuses on a scheme known as ‘lazy evaluation’. It presents and compares performance measurements of two Pascal run‐time systems for the same compiler; a buffered, non‐interactive version, and a modification of that system to support lazy evaluation.
The supermac macro processor in pascal
Authors: Brown P. J. , Ogden J. A. 
Published: November 2006

AbstractSUPERMAC‐Pascal is an implementation of the general‐purpose macro processor SUPERMAC. It allows the user to write macros using Pascal procedures and to compile these procedures using his normal Pascal compiler.This paper describes how the macro processor was adapted to fit Pascal, and how the apparently intractable problems of performing string processing in Pascal were tackled.
The programming language ACTUS
Authors: Perrott R. H. , Crookes D. , Milligan P. 
Published: November 2006

AbstractThis paper describes, in an informal manner, the programming language ACTUS which was designed to facilitate programming array processing and vector processing ‘supercomputers’.ACTUS extends the program structuring and data structuring facilities of Pascal to the synchronous parallel environment as represented by array and vector processor architectures. A knowledge of Pascal is assumed and only the parallel features of ACTUS are described.
OPTIMA—A portable PCODE optimizer
Authors: Wilk A. , Silverman W. 
Published: November 2006

AbstractThis paper describes the design and implementation of OPTIMA, a Portable optimizer for the PASCAL‐P4 compiler. The PASCAL‐P4 compiler generates code, called PCODE, for a hypothetical stack computer. The stack computer is easy to simulate or to emulate on a wide range of computer architectures. However, the code produced for it by PASCAL‐P4 is unoptimized and inefficient when emulated on conventional computers. OPTIMA improves the code which is produced by the compiler. It has three levels of optimization: PCODE transformations, TUPLE transformations and Code generation. Programs processed by the optimizer are substantially smaller and faster than before optimization. OPTIMA was implemented for the Weizmann Institute of Science GOLEM‐B computer.
Dynamic distributed systems
Authors: Whiddett R. J. 
Published: November 2006

AbstractThis paper introduces a new methodology for building flexible and programmable multiprocessor systems. It is based on a distributed implementation of monitors which is supported by a system‐wide address relocation mechanism. This provides the dynamic reallocation of processes and monitors within the system.Methods of implementing the communications subsystem based on a number of common network architectures are presented.An algorithm which effects dynamic resource allocation is presented. Its effect is that groups of processes which are interacting through a monitor will tend to accumulate at various sites in the system in a manner reflecting the dynamic interaction patterns of the program. This is accomplished without there being any centralized control, or even knowledge of the overall program interactions.The feasibility of the system has been investigated using a model system running on a loosely connected dual processor system.
Comprehensive tools for assembler construction
Authors: Collins W. Robert , Noonan Robert E. , Gregory Samuel T. , Knight John C. , Hamm Roy W. 
Published: November 2006

AbstractThe Mystro Assembler Construction System (MACS) is a tool kit for assembler writers, based upon a parser‐generator for ambiguous attribute grammars, automatic text manipulation, and a skeletal assembler. Attention has been paid in MACS to aiding the assembler writer in employing the software methodology of iterative enhancement and in avoiding the more tedious aspects of assembler construction.
Syntax directed program editing
Authors: Allison Lloyd 
Published: November 2006

AbstractA syntax editor provides alternative ways for manipulating programs (as opposed to text). Although not a new idea it has made only slow inroads into editing. This is because implementation is not easy and because of many practical considerations in the use of an editor. This paper covers the design issues of a syntax editor with particular reference to on—SED. Examples of different options taken by other editors are included.
Efficient combination of index tables and hashing
Authors: Quittner Pál 
Published: November 2006

AbstractIt is shown that for data stored on direct access devices access time can be reduced without increasing storage demand, through a single level index table which itself is accessible by hashing. If the complete index table can be stored in main memory this method is always superior to direct hashing and to sequentially organized index tables. If the index table is stored on disk it always yields smaller access time than multi‐level index tables and—depending on the size of the index table and on the number of records per track—it is comparable or better than hashing the data directly. Expressions are given to determine in this case which method is more efficient.
An electronic form system—an experience in prototyping
Authors: Gehani N. H. 
Published: November 2006

AbstractA prototype electronic form system was implemented to test the feasibility of a high level form definition mechanism. This mechanism is based on the concept of abstract data types in programming languages. This paper briefly discusses prototypes in general and describes the prototype electronic form system—specific objectives, design decisions, the implementation and evaluation. The prototype has proven invaluable in providing a better understanding of the facilities that should be included in a form definition language and of the implementation issues. Success of the prototype can be attributed to keeping prototype objectives in perspective throughout its implementation and ensuring that the objectives were not violated by any design decisions or implementation restrictions.
The implementation of generators and goal‐directed evaluation in icon
Authors: Wampler Stephen B. , Griswold Ralph E. 
Published: November 2006

AbstractTwo features of the Icon programming language strongly influence its implementation: generators and goal‐directed evaluation. A generator is an expression that is capable of producing a sequence of results. In goal‐directed evaluation, the results of generators are produced automatically in an attempt to complete computations successfully. This paper describes the generated code and run‐time support for generators, goal‐directed evaluation, and related control structures.
Higher level programming and data abstractions—a case study using enhanced C
Authors: Katzenelson Jacob 
Published: November 2006

AbstractIn this work the topological sort algorithm is programmed in EC, taking advantage of EC's set‐oriented features and its macro‐like data abstractions. The main issue was whether efficient run‐time code could be achieved while maintaining program structure and readability.The main conclusion is that in this particular example such code was achieved. Program structure and readability were maintained despite changes in both the higher level program and the data abstractions. Other conclusions are the following: (1) The program design process requires dependent data abstractions; (2) it is iterative rather than strictly top down; choosing data abstractions for run‐time efficiency requires insight into the properties of the algorithm. It is believed that global analysis can be used to enhance such insight.
An implementation of Algol 68 for a small computer
Authors: Nadrchal Jaroslav , Sklenář Ivan , Kříž Václav , Král Jaroslav 
Published: November 2006

AbstractA large subset of the language Algol 68 has been implemented on a small computer—the TESLA 200 with a 64 Kbyte store. In this paper, the general structure of the compiler and organization of the program at run‐time are described. Especially, the original methods and devices are mentioned that cause a considerable enhancement of the speed of compilation and program run. These concern the syntax analysis (consistent notation, error recovery), the organization of the resulting program (procedure organization, algorithms of work with multiple values) and the techniques of code generation.We try to show that Algol 68 is a suitable programming language for small as well as large computers and that it can successfully compete with traditional programming languages.
An execution profiler for modular programs
Authors: Graham Susan L. , Kessler Peter B. , McKusick Marshall K. 
Published: November 2006

AbstractIn modular programs, groups of routines constitute conceptual abstractions. A method for providing execution profiles for such programs is presented. The central idea is that the execution time for a routine is charged to the routines that call it. The implementation of this method by a profiler called gprof is described. The techniques used to gather the necessary information about the timing and structure of the program are given, as is the processing used to propagate routine execution times along arcs of the call graph of the program. The method for displaying the profile to the user is discussed. Experience using the profiles for hand‐tuning large programs is summarized. Additional uses for the profiles are suggested.
An integrated verification and testing environment
Authors: Taylor Richard N. 
Published: November 2006

AbstractA verification and testing environment that includes static analysis, symbolic execution, and dynamic analysis capabilities is presented. Tool integration and co‐operation are promoted through use of an intermediate program representation and a system data manager. A substantial user interface aids application of the tools. Their use is guided by a verification and testing methodology on which the system's design is based. The environment has been engineered to support the production of flight control software written in HAL/S. The environment itself is written in Pascal and is designed to be portable. Several development experiences are described. The environment demonstrates that a strong, unified verification and testing environment can be built; it serves as a basis for future investigations.
Assembly language as object code
Authors: Jones Douglas W. 
Published: November 2006

AbstractThe set of meanings that may be encoded in most object languages is a subset of the meanings that may be encoded in most assembly languages. Careful exploitation of this fact in the design of the SMAL assembly and object language allows the SMAL assembler itself to be used as a linkage editor, thus eliminating the need for an expensive and often misunderstood system program. The SMAL assembler is no more complex than many assemblers in common use today, nor are the relevant aspects of the SMAL language particularly unique.
Simple code optimizations
Authors: Hanson David R. 
Published: November 2006

AbstractProgram optimization has received a great deal of attention for many years, which has resulted in numerous advances in compiler technology. The effectiveness of various simple optimizations has received comparably little attention during the same time period. The simplicity of most programs suggests that straightforward optimizations pay the greatest dividends. This paper describes three such optimizations suitable for one‐pass compilers. The optimizations involve expression rearrangement, instruction selection, and the use of a cache for the allocation of resources. The cost of these optimizations is low; none require major changes to the size or structure of the compiler or reduce compilation speed by more than 10%. The benefits are high; each optimization results in at least a 10% average reduction in object code size and a corresponding reduction in execution time. Examples and implementation details are also described.
Experiences with coroutines in BCPL
Authors: Atkins Stella , Knight Brian 
Published: November 2006

AbstractThis communication describes a typical application of BCPL coroutines in simplifying the implementation of a multi‐event task, together with some problems encountered. The problems fall into two major groups: those associated with the routing of operating system messages to coroutines within a task, and those connected with data shared between coroutines. General solutions are suggested to these problems, which can occur in any program employing similar structures.
A simple technique for converting from a pascal shop to a C shop
Authors: Lalonde Wilf R. , Pugh John R. 
Published: November 2006

AbstractWe discuss a simple technique that we used for quickly converting a group of Pascal programmers into a group of C programmers. Our basic approach was to use the literal definition facility of C to make C programs ‘resemble’ Pascal programs.The approach is of interest to programmers because of its utter simplicity, and to management level personnel, familiar with Pascal but not with C, because it allows them to engage in productive code reading.
Hierarchical dialogue structures in interactive computer systems
Authors: Apperley M. D. , Spence R. 
Published: November 2006

AbstractA powerful yet simple‐to‐use command dialogue has evolved in the development of an interactive graphics system for the computer‐aided design of electronic circuits. This dialogue overcomes many of the problems typically encountered in systems with a strongly hierarchical command structure; the user is kept constantly aware of the current state within the hierarchy and is able to manoeuvre rapidly about this structure. The rules for the use of the dialogue are few and simple; mistakes are not catastrophic. The dialogue is equally suited to both naïve and experienced users.The dialogue is described in the context of an interactive graphics environment, but the extension of the principles to any interactive computer system should be obvious.
MIRA‐3D: A three‐dimensional graphical extension of pascal
Authors: Magnenat‐Thalmann Nadia , Thalmann Daniel 
Published: November 2006

AbstractMIRA‐3D is a three‐dimensional graphical extension of Pascal based on abstract graphical types. The user may define and manipulate complex 3D objects, as well as image transformations. Viewing transformations and attributes are compatible with the ACM GSPC Core System. A large set of graphical primitives are available and the paper discusses the most important ones. Portability has also been an important criterion in implementation.
An experimental COBOL restructuring system
Authors: Harandi M. T. 
Published: November 2006

AbstractAlthough COBOL lacks many features required to support structured programming, it can be used to simulate reasonably well‐structured programs. This simulation is particularly important for restructuring of poorly structured old programs. This paper describes the formulation of and experiments with a practical methodology for conversion of unstructured COBOL programs into reasonably well‐structured equivalents. The discussion includes the overview of an automatic COBOL restructuring system, the results of an experiment with this system and an interpretation of these results.
PIGS—A system for programming with interactive graphical support
Authors: Pong M. C. , Ng N. 
Published: November 2006

AbstractThis paper describes an implementation of a system for programming using structured charts with interactive graphical support. It provides a graphical editor for the user to interactively build and edit programs using Nassi‐Shneiderman diagrams (NSD)1 as the structured control constructs of logic flow. It can interpret a program in NSD chart form, and the execution sequence of the NSD is displayed at a graphical terminal. On‐line debugging and testing facilities are available which allow the user to examine and modify the program under execution. The system has been designed with the aim of supporting the development, debugging, testing, documentation and maintenance of programs in the same environment.
A sentence generator for a compiler for PT, a pascal subset
Authors: Murali V. , Shyamasundar R. K. 
Published: November 2006

AbstractAn implementation of a sentence generator system for a compiler for PT, a subset of Pascal, is discussed. Using the syntax definition of PT, the system automatically produces leftmost generations in a pseudorandom fashion. Syntactically correct as well as compile‐time correct programs can be generated. In the generation of compile‐time correct programs, only those statements that satisfy the contextual constraints imposed by the declarative part of the generated program are generated. The system also provides the facility of producing programs that have lexical or syntactic errors. All the generated programs are printed with appropriate indentations to show structural properties. Furthermore, the number of procedures in the generated program, the number of statements, identifier length and the number of generations can be controlled. The implementation has been successfully used for testing an error recovery parser as well as an intermediate code generator for PT.
Tools and techniques for teaching microprocessor software development
Authors: Charlton C. C. , Mander K. C. 
Published: November 2006

AbstractDebugging low level language software can be a difficult business—the bare microprocessor lacks the user interface; facilities, such as simulators, provided on another machine can be tedious to use on running or partially working programs. A resolution of this difficulty lies in the harmonious use of a mainframe‐based debugging system and a real microprocessor.This paper describes tools and techniques for the development of low level software for the Intel 8080 microprocessor employing both simulated and real microprocessors. The debugging system allows the user to set up a virtual microprocessor into which programs can be loaded and run and from which a flexible tracing of the executing program can be obtained. The debugging system is built into a general purpose multi‐access operating system and this approach makes it possible to provide the system cheaply to a large number of users. Additionally, users have access to all the general facilities (such as editors) provided by the operating system itself.The system has been implemented on a minicomputer with 60 VDU terminals all of which can be used for interaction with the 8080 simulator or for general interactions with the mainframe operating system. The system has also been implemented in a self‐simulating version to run on a real Intel 8080 microprocessor. Many of the VDUs on the minicomputer are controlled by Intel 8080 microprocessors and it is possible to load and run large Intel 8080 programs which were assembled (and tested) on the mainframe or run the self simulator based debugging system. In this way a range of complementary debugging environments is provided: the simulator on the mainframe with its access to backing store (and, hence, the ability to save trace information), the self simulator on the microprocessor (with its better performance for the single user), and the actual Intel 8080 itself. The user can easily move a partially tested program between environments and thus use the environment which best suits his current phase of testing.