bluuebunny/crossref_metadata_2025 huggingface dataset:
Efficient combination of index tables and hashing
Authors: Quittner Pál
Published: November 2006

It 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

A 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

Two 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.
The myth of virtual memory
Authors: Schneck Paul B.
Published: November 2006

A common myth surrounding virtual memory systems is that they eliminate completely the need for programmers and analysts to deal with conservation, allocation, and management of addressable memory. This paper shows that paying appropriate attention to these factors can have even greater impact on virtual memory system performance than on real memory system performance. Guidelines for effectively using virtual memory are presented.
Higher level programming and data abstractions—a case study using enhanced C
Authors: Katzenelson Jacob
Published: November 2006

In 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

A 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

In 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

A 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

The 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

Program 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

This 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

We 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

A 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

MIRA‐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

Although 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

This 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

An 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

Debugging 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.
Optimizing procedure calls and returns
Authors: Er M. C.
Published: November 2006

When a procedure is activated as a logical last statement in another procedure, optimization could be done to the procedure call and return. Several optimizations are discussed. The first optimization is based on the idea of reusing the current stack frame. With this approach, it is necessary to compute the order of passing parameters. A tactic of computing the dependency of parameters and a heuristic method of breaking the cyclic dependencies are therefore proposed. However, this approach has severe restrictions imposed on the kinds of procedure that can be called; in particular, the called procedure cannot contain references to the calling procedure. To remove all such restrictions, the second and third methods of optimization are put forwards. The second optimization revolves around the concept of continuation closure. It uses the normal stack frame of standard implementation, but alters its continuation closure to achieve quick procedure exit. The third optimization builds upon the concept of para‐stack frame and common continuation closure for achieving fast procedure exit. Various other refinements are also considered.
The influence of hardware and software considerations on the design of synchronous parallel algorithms
Authors: Clint M. , Perrott R. , Holt C. , Stewart A.
Published: November 2006

Matrix multiplication is used as an example to illustrate a method of transforming the specification of a problem into an algorithm suitable for execution on synchronous machines. The transformations are influenced both by the architectures of the target machines and their available high level languages. Three different synchronous machines, a conceptual MCC (mesh connected computer), the Cray‐1 and the ICL DAP are considered as target hardware.
An assessment of the XR project for compiler development and transportation
Authors: Qian Lu Ru , Chu Wei Zi
Published: November 2006

A software engineering project, the XR project, is described, and its results assessed. The goal of the XR project is to contribute to the mechanical development and transportation of compilers on widely used Chinese‐made computers. The basic tools are the compiler writing language XHY and the intermediate language CJY.

All the compilers are written in XHY and produce code in CJY form. In this paper, experiences, statistics and lessons of practising this project are given, together with an overview and a conclusion.
Towards a conversational language‐sensitive system for pascal
Authors: Robson D. J.
Published: November 2006

This paper discusses the problems involved in constructing a conversational editor for Pascal programs. A review of previous work in this area is given together with an alternative approach.
Kernel for a responsive and graphical user interface
Authors: Strubbe Hugo J.
Published: November 2006

A kernel that facilitates building graphical and responsive user interfaces for application programs has been constructed. A display tree representing the structure of the 2‐dimen‐sional screen image is defined. Each node contains an input procedure, an output procedure and links to their arguments. This display tree is the only interface between the user and the application program. For viewing purposes, the display tree can be ‘painted’ onto any viewport. The output routines attached to the nodes are invoked to produce the image. The arguments found in the ancestor nodes can be thought of as shared graphical attributes. Upon each input event, the display tree is traversed to determine which node is touched by the cursor. The input procedure attached to that node is then invoked. The use of a library with standard attached procedures (e.g. for screen editing and error checking) leads to a system that behaves uniformly across applications. Some demonstration programs, based on this kernel, show the very dynamic screen communication that can be achieved.
Playing cards on the PERQ: An algorithm for overlapping rectangles
Authors: Cook Steve
Published: November 2006

An algorithm is presented which provides a convincing animated visual illusion of a pack of playing cards on the bit‐mapped screen of a high‐performance personal computer. The technique is generally applicable to any display task involving the generation and manipulation of a number of overlapping rectangles, for example the ‘desktop model’ for integrated interactive systems.
A zilog Z8000 disassembler
Authors: Davis R. H. , Bathgate A. J.
Published: November 2006

A disassembler is described which will translate ZSOOO object code into syntactically correct ZSOOO assembly language. The disassembler carries out error checking, label insertion and command processing.
Update to ‘FORTRAN routines with optional arguments’
Authors: Fellows David M. , Cassidy Brian P. , Gujar Uday G.
Published: November 2006

A problem has been discovered when using the routine presented in Reference 1 with the IBM FORTRAN 77 compiler. The problem and its solution are discussed.
DTL: A language for the design and implementation of concurrent programs as structured networks
Authors: Hughes J. W. , Powell M. S.
Published: November 2006

DTL is an experimental programming language which has developed from an investigation of data structured design methods and data driven programming techniques. A DTL program is derived from a specification of the structure of its valid input and output languages. The program function is defined as a translation between these languages. A complex translation can be hierarchically structured into a network of simpler translations by stepwise refinement.
The implementation of DTL
Authors: Hughes J. W. , Powell M. S.
Published: November 2006

The DTL language is the result of a combined study of data structured design methods and the use of concurrency as a high‐level structuring device. Programs written in DTL are regarded as translations from input streams to output streams. Such translations are specified by the use of attributed translation grammars. This paper describes the implementation of DTL via an abstract virtual machine.
Building syntax graphs from syntax equations: A case study in modular programming
Authors: Crookes D. , Fee R. , Pickering V.
Published: November 2006

A system is described which inputs EBNF syntax equations as text, checks them and builds a corresponding syntax graph representation. An EBNF parser, with full error recovery, is included. The system is designed using the principles of modular decomposition and data abstraction, and is presented as a case study in the application of these principles to program design. The system is programmed in Pascal‐plus, and has been used as a basis for the automatic generation of parsers.
The necessity for accurate compiler‐provided routines when evaluating special functions
Authors: Oliver J.
Published: November 2006

Earlier authors have shown experimentally that the relative effect of rounding errors in the evaluation of polynomial approximations to certain special functions may be significantly reduced by first extracting an exponential factor. The critical importance of evaluating this exponential by an accurate library function is demonstrated, and the two principal methods of representing the polynomial part are shown to be equally accurate provided the recommended evaluation schemes are employed.
Parallel assignment revisited
Authors: Welch P. H.
Published: November 2006

The concept of truly parallel assignment is retrieved from obscurity. It is shown to be a natural technique for the expression of iterative algorithms that saves the programmer from being concerned with some ‘low‐level’ details imposed by the von Neumann machine. With their use, algorithms should be simpler to write, clearer to understand and contain fewer errors. The concept of history as a means for achieving the same purpose is criticized on the grounds of the new side‐effects that it introduces. An implementation method for truly parallel assignment on a conventional computer is described.
FUMBLE: A pascal program for initializing memory
Authors: McCaig J. M.
Published: November 2006

The operation of a Pascal program which is used to initialize the values of memory locations is described in detail. Examples are given which show how the program can be used to create assemblers for a variety of computers including the Intel 8080 and Motorola M6800 microprocessors.
Three solutions for a robot arm controller using Pascal‐Plus, occam and edison
Authors: Kerridge Jon M. , Simpson Dan
Published: November 2006

Three currently available concurrent language systems, Pascal‐Plus, occam and Edison, are used to implement a controller for a robot arm. The robot arm allows real parallelism of operation within the movements of the arm. The feasibility and restrictions placed upon the resultant solution for each of the language systems is then analysed and discussed. A Petri‐net solution is also presented for the generalized problem and it is shown that each of the solutions is a different folding of the general net.
A portable virtual machine for Ada
Authors: Ibsen Leif
Published: November 2006

A portable compiler can be constructed by letting it generate code for a virtual machine, which is then implemented on the real target machines. The design of a virtual machine which is especially suitable as a target machine for compiled Ada programs is described. The main design goals, implementability on mini‐computers and portability, are discussed and the resulting design is described in some detail. Some implementation strategies for the machine are proposed and the feasibility of the virtual machine approach is discussed.
Persistent object management system
Authors: Cockshot W. P. , Atkinson M. P. , Chisholm K. J. , Bailey P. J. , Morrison R.
Published: November 2006

This is a description of the integrated Persistent Object Management System (POMS) for the language PS‐algol. The objective of POMS is to provide an implementation of the PS‐algol persistent heap1 entirely by means of procedures written in PS‐algol.
The Pascal graphics system
Authors: Yip C. K.
Published: November 2006

A two dimensional high level graphics programming system based on the CORE standard graphics system1 has been implemented. The graphics programming language used in the system is an extension of the programming language Pascal. In this paper the graphics programming features in this system are presented and the implementation issues are discussed.
PEP: An interactive programming system with an Algol‐like programming language
Authors: Verhelst P. W. E. , Verster N. F.
Published: November 2006

PEP (Program Editor and Processor) is an interactive programming system based on an Algol‐like language. It is intended to replace BASIC as a system for interactive program development on small computers (LSI‐11).

The language processed by the system allows declaration of variables, constants and procedures; it has structured statements for conditional and repetitive execution of program parts.

We describe design and implementation of the system and give our impressions after 1 year of experience with the system.
Concurrent communication and synchronization mechanisms
Authors: Williamson Ronald , Horowitz Ellis
Published: November 2006

The concepts of process and guarded command have become the basic building blocks in concurrent programming language design. In this paper we deal with many of the proposed communication and synchronization primitives and we compare them from the perspective of their implementability. Our evaluation treats four basic criteria: the length of synchronization, process termination, deadlock and protocol complexity.
Application of an optimistic concurrency control method
Authors: Kersten Martin L. , Tebra Hans
Published: November 2006

This paper illustrates the implementation feasibility of an optimistic approach to concurrency control. After reviewing the approach and clarifying the underlying algorithms and assumptions, it is applied to the design of a multi‐user version of an existing relational database management system. Two different system architectures for a UNIX

UNIX is a trademark of Bell Laboratories.

‐based environment are presented and prototype implementations have been constructed. We also provide some performance statistics on the optimistic approach to concurrency control and compare it with a traditional locking protocol.
Calculation of co‐ordinates for optimal hatching
Authors: Vörös G.
Published: November 2006

The paper discusses details of a structured program which calculates co‐ordinate values for optimal hatching of planar shapes. The problem arises when there is a need for NC control of light spot plotters in manufacturing linear circuit printing.
A shorthand preprocessor for IDMS COBOL
Authors: Wyatt M. G.
Published: November 2006

Aspects of software development using Codasyl COBOL DML are considered. In limited trials, a preprocessor which makes a terse DML syntax available has been found to increase programmer productivity and improve software quality.
Toward complete programming language descriptions that are both formal and understandable
Authors: Pagan Frank G.
Published: November 2006

We describe an approach to, and a case study of, the construction of complete programming language descriptions that are at the same time formal and readily understandable. Such a description includes integrated specifications for abstract and textual syntax, context conditions (static semantics) and dynamic semantics. The imetalanguage is a powerful program design language based on a real general‐purpose programming language. The specifications are presented not as a monolithic block but as an intellectually manageable sequence of sections and subsections with a carefully designed format and cross‐referencing scheme. The approach could reduce the need to choose between formality and understandability in a language reference manual.
Implementation of predicate‐based protection in multisafe
Authors: Hartson H. Rex
Published: November 2006

This paper brings together a formal predicate‐based model of protection and a relational approach to a protection database within the modular architecture of MULTISAFE. An implementation model is developed for the management of stored representations of authorization information. Classes of access decision dependency are reviewed, and protection policies, design decisions, and some implementation problems are discussed. Detailed examples are used to illustrate the use of this flexible and generalized approach to database security within the MULTISAFE system architecture.
A LIS compiler for GCOS‐7
Authors: Henin Bernard , Couprie Daniel , Douspis Pierre
Published: November 2006

This paper describes the implementation of a LIS compiler for GCOS‐7. LIS is a high level system implementation language developed at CII‐Honeywell Bull during the middle 1970s, and experience with the language and its implementation have largely influenced the design of Ada. The design of the compiler was particularly aimed at efficient code generation. Design decisions concerning the run‐time organization in relation to procedure call and separate compilation are discussed. The structure of the compiler is described. The articulation between the different phases of the code generator is emphasized. Experience with the bootstrap is related.
The Application of Halstead's software science. Theory to Algol 68 programs
Authors: Woodward M. R.
Published: November 2006

M. H. Halstead has argued that all computer programs are composed entirely of operators and operands. By counting these entities the software science theory then enables program properties such as vocabulary, length, volume, program level and language level to be calculated. For well written, or so‐called ‘pure programs’, one would expect, according to the theory, good agreement between certain observed and predicted values. Also, one might expect an intuitive ordering of language levels to be confirmed by the theory, with for example, Algol 68 having a higher language level than Fortran. In this paper two different counting strategies have been applied to one implementation of the Numerical Algorithms Group (NAG) Algol 68 library. The results do not entirely match expectation.
The PHS protocol
Authors: Purser Michael , Horn Chris , Sheehan John
Published: November 2006

The paper presents a simple single layer protocol covering the functions of X25 levels 2 and 3. It can be used on synchronous or asynchronous lines, such as employed for normal computer terminals. It requires no special hardware, and can use the standard device driver software supplied by manufacturers. The protocol has been working successfully for over two years, and could be of interest to networking projects with limited resources.
Experience with a portable debugging tool
Authors: Steffen Joseph L.
Published: November 2006

Debugging tools are usually highly machine and compiler dependent programs that are either impossible to move or require a tremendous effort to move to another machine. This paper describes Ctrace, a portable debugging tool for the C language that provides the same, easy‐to‐use debugging environment on all machines. A similar debugger can be written for any language. Ctrace is a preprocessor that inserts source language debugging code into the program before compilation that, at execution time, prints the text of each source language statement along with the values of variables it uses and modifies. Redundant trace output from program loops is detected and eliminated. Tracing can be limited to selected statements or functions. Ctrace has shown its usefulness and popularity by its installation on over 200, computers at Bell Laboratories. It has proven its portability by being used to test software on four different operating systems and nine different processors.
Attributed linear intermediate representations for retargetable code generators
Authors: Ganapathi Mahadevan , Fischer Charles N.
Published: November 2006

This paper illustrates the usefulness of an attributed prefix linear intermediate representation for compiler code generation. In separating the machine‐independent and machine‐dependent aspects of a compiler, we discuss the advantages and disadvantages of an attributed linear intermediate representation with respect to tree‐structured intermediate representations. Some of these issues are relevant to fundamental questions of compiler structure with particular emphasis on retargetability. We discuss our implementation experience using this linear intermediate representation with a table‐driven code generation scheme for a variety of target architectures.
Immediate files
Authors: Mullender Sape J. , Tanenbaum Andrew S.
Published: November 2006

An efficient disk organization is proposed. The basic idea is to store the first part of the file in the index (inode) block, instead of just storing pointers there. Empirical data are presented to show that this method offers better performance under certain circumstances than traditional methods.
Guarded and unguarded coroutines: An implementation in BCPL
Authors: Fisher A. J.
Published: November 2006

This paper describes an implementation of coroutines in BCPL, and gives an example of the use of the coroutine mechanism in an experimental compiler for Algol 68.
An economical implementation of the high level real‐time language PEARL on microcomputers: Intel RMX86‐PEARL
Authors: Heine P. , Kaiser F.
Published: November 2006

We report on an implementation of the concurrent high level real‐time language PEARL on an Intel 8086‐based microcomputer. After a short introduction to the PEARL language emphasis is placed on the description of the method of implementation, one of the goals of which was to use standard high level languages and an existing real‐time operating system as far as possible. This way an economical, but nevertheless efficient, implementation was achieved.
Mixed language programming
Authors: Einarsson Bo , Gentleman W. Morven
Published: November 2006

Subroutines for numerical computation have in the past been written mainly in Fortran and in Algol 60, whereas most programming in the future is expected to be in more advanced languages, for example in Ada. It seems to be a great waste if it will become necessary to convert all existing numerical software into the new languages. What is needed is a facility to include subroutines written in the old languages into programs being written in the newer languages.

In this paper an automatic procedure to facilitate the use of mixed languages is suggested, the purpose of the paper is to indicate the desirability for providing the required facilities, and to encourage discussion and further research in the area of mixed language programming.
Integrating library modules into Pascal programs
Authors: Ancona M. , De Floriani L. , Dodero G. , Mancosu S.
Published: November 2006

We present the results of our experience in introducing modularity into the programming language Pascal in order to aid the creation and use of library modules. Our system performs the symbolic linking of source language modules producing a single Pascal text ready for compilation; performing the link phase before compilation anticipates interface consistency checks, and suggests a possible improvement of program development systems. Our extension is implemented in a preprocessor which ensures a complete compatibility with any standard Pascal compiler. In this paper we examine the main features of some high‐level programming languages which support modularization and data abstraction and some experiences in introducing modularity into Pascal; on this basis we describe our choice in detail. The design and implementation details are discussed and some examples are presented.
Concurrent programming in the Ada® language: The polling bias
Authors: Gehani N. H. , Cargill T. A.
Published: November 2006

The rendezvous is an important concept in concurrent programming—two processes need to synchronize, i.e. rendezvous, to exchange information. The Ada programming language is the first programming language to use the rendezvous as the basis of its concurrent programming facilities.

Our experience with rendezvous facilities in the Ada language shows that these facilities lead to and encourage the design of programs that poll. Polling is generally, but not always, undesirable because it is wasteful of system resources.

We illustrate and examine the reasons for polling bias in the Ada language. We give suggestions on how to avoid polling programs, and suggest changes to the rendezvous facilities to eliminate the polling bias. The ramifications of these changes to the implementation of the Ada language are also discussed.

Although we have focused on the rendezvous facilities in the Ada language our analysis is also applicable to other languages. A polling bias can occur in any concurrent programming language based on the rendezvous mechanism if it does not provide appropriate facilities.
Designing software for children
Authors: McKeag R. M. , Eves Ann , Rooney E. J.
Published: November 2006

This brief paper describes the considerations behind the design and use of a programming language and editor for use by children of primary school age.
The ‘Completeness’ of the pascal test suite
Authors: Ciechanowicz Z. J. , De Weever A. C.
Published: November 2006

The British Standards Institution aided by the National Physical Laboratory (NPL) are setting up the framework for a national service which will validate Pascal compilers against the requirements of the ISO Standard for Pascal.1 The basis of this service is the Pascal Compiler Validation Suite,2 a large collection of test programs (produced jointly by NPL and the University of Tasmania) which were derived directly from the Standard, Naturally, the Suite must be as searching as possible, and Ideally all features of the language should be exercised by the Suite. This paper describes an investigation into the ‘completeness’ of the Suite; note that ‘completeness’ is not used in any formal sense throughout the paper. The investigation is carried out by passing the entire Suite through a model implementation of Pascal, the Standard Pascal Static Checker,3 to determine whether any parts of this implementation do not get exercised by the Suite. Further tests are then written to exercise these parts. A by‐product of this work is a tool which produces an execution profile for a Pascal program; this paper describes the function of the tool.
UCSD Pascal on the VAX, portability and performance
Authors: Perkins Daniel R. , Volper Dennis
Published: November 2006

Between 1976 and 1980 the Pascal Project at UCSD produced a ‘nearly portable’ operating system based on Pascal. Under the auspices of a graduate student project at UCSD, the UCSD Pascal system was ported to run in the 32‐bit address environment of the VAX 11/780 under VMS and UNIX

UNIX is a trademark of Bell Laboratories. VAX and VMS are trademarks of Digital Equipment Corporation. UCSD Pascal is a trademark of the Regents of the University of California.

. This paper describes the implementation decisions and the portability and efficiency considerations that motivated the decisions. Improvements to portability and efficiency are discussed.
A flexible command generation technique for application in dialogue systems
Authors: Pfeiffer G.
Published: November 2006

An important problem in the design of image processing systems is the specification of appropriate command structures for control of dedicated hardware and software functions. This paper describes a general and flexible method for the definition and processing of specialized commands. The idea is to generalize the specification of parameters within procedures by allowing—in a well‐controlled way—a few syntactic extensions. The paper presents the extension mechanism, demonstrates the power of the command processor by practical examples and discusses some critical points.
Two implementations of the Ada program library
Authors: Briggs J. S.
Published: November 2006

The programming language Ada defines a separate compilation mechanism which must enforce the language rules in the same manner when compiling a program either in several units or as one compilation unit. Two implementations of the Ada program library required by this mechanism are described. Each has an associated compiler manager program which is the user's interface to the library. The first maintains a central map file containing the library structure. The second uses the UNIX tool make to maintain the library and permits more flexibility in the UNIX operating system environment. Higher level tools could use the second manager as a component part.
Software engineering in a development group
Authors: Ringland Gill
Published: November 2006

Productivity data are presented for a typical software development group working in small project teams. The wider aspects of productivity, including maintenance and release procedures, are considered. The group worked extensively with subcontractors, developing products by reusing software. The effect of this on the resulting products and the productivity is analysed: increased reliability was observed to be a consequence of software reuse, compared with first implementations.
The evaluation of software systems' structure using quantitative software metrics
Authors: Henry Sallie , Kafura Dennis
Published: November 2006

The design and analysis of the structure of software systems has typically been based on purely qualitative grounds. In this paper we report on our positive experience with a set of quantitative measures of software structure. These metrics, based on the number of possible paths of information flow through a given component, were used to evaluate the design and implementation of a software system (the UNIX operating system kernel) which exhibits the interconnectivity of components typical of large‐scale software systems. Several examples are presented which show the power of this technique in locating a variety of both design and implementation defects. Suggested repairs, which agree with the commonly accepted principles of structured design and programming, are presented. The effect of these alterations on the structure of the system and the quantitative measurements of that structure lead to a convincing validation of the utility of information flow metrics.
Automatic generation of make dependencies
Authors: Walden Kim
Published: November 2006

In the UNIX environment, it is standard practice to use the make program to keep a system of interrelated modules up to date. When text files contain so‐called include statements referring to additional text files whose contents are to replace the statements, it soon becomes impractical, in a growing system, to manually maintain all make dependencies implied by these references. Therefore, the dependencies are often generated automatically from extracted include statements by various methods. However, the methods we have seen in use are too simplistic and either generate the wrong set of dependencies, or give only partial support. This paper describes an algorithm that can be used to generate make dependencies implied by include statements from a wide class of include mechanisms.
The design of an interactive graphics system for the display of meteorological fields
Authors: Hamilton J. E. M.
Published: November 2006

We describe a computer graphics system for the display of meteorological fields (such as plots of temperature and pressure). Much of the design effort has gone into the command processor which uses the usual command format of VERB PARAMETER = VALUE … The parameter and values are defined in terms of a tree sructure and the program searches as much of the tree as is necessary to make an unambiguous indentification of a token (where such an identification is possible). Because of this, commands can generally be abbreviated to the format VERB VALUE. This shortened form is possible even when the value of the command parameter is numerical. This is achieved by always specifying the units of numerical values (such as 5 days, 24 hours, 1000 millibars, etc.). The command format allows the user to manipulate a number of fields to form derived fields such as the difference of two pressure forecasts. The use of defaults for all parameters (which change as the user requests plots), reduces the amount of typing required to a minimum. A ‘Help’ facility aids the user in his choice of commands.
Implementation of a Pascal based parallel language for a multiprocessor computer
Authors: Ardö Anders , Philipson Lars
Published: November 2006

This paper reports the work on implementing a parallel version of Pascal on a small scale multiprocessor computer. A few simple primitives were included to support parallel programming. The code generation, linking and loading procedures are described. An overview of the hardware is included. Finally some programming experience with the system is reported.
Using Ada for discrete event simulation
Authors: Bruno Giorgio
Published: November 2006

The process interaction approach is proposed for developing a discrete simulation environment in Ada. The introduction of simulation facilities in Ada not only concerns the classical aspect of model building, but allows a new class of problems to be tackled, that is the testing of correctness of programs intended for real‐time applications. In this paper attention is focused on the presentation of the process scheduling in the simulation context and on the definition of standard forms of interactions among processes. Simulation facilities are organized by making use of Ada's structuring concepts.
Steady‐state compilers
Authors: Cornelius B. J. , Lowman I. R. , Robson D. J.
Published: November 2006

Passing compilers through themselves is a well known technique whose major benefit is that any improvement in code generation will result in an improved compiler. Previous reports of work in this area have mentioned that it is possible to validate the compiler by running the compiler through itself a second time and comparing the resulting binary files. This paper is designed to clarify this technique which has received little attention and is often misleadingly described.
The use of ghost variables and virtual programming in the documentation and verification of programs
Authors: Clint M. , Vicent C.
Published: November 2006

Using ghost variables and virtual programming, a method for documenting programs which exhibit some common characteristics is presented. The annotations required are expressed in a powerful high level assertion language. The usefulness of these annotations is illustrated by the generation of verification conditions for some small example programs written in a dialect of Pascal. Demonstrations of the correctness of these programs are also given.