bluuebunny/crossref_metadata_2025_split huggingface dataset:
Optimizing procedure calls and returns
Authors: Er M. C. 
Published: November 2006

AbstractWhen 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

AbstractMatrix 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

AbstractA 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.
Kernel for a responsive and graphical user interface
Authors: Strubbe Hugo J. 
Published: November 2006

AbstractA 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

AbstractAn 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.
DTL: A language for the design and implementation of concurrent programs as structured networks
Authors: Hughes J. W. , Powell M. S. 
Published: November 2006

AbstractDTL 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

AbstractThe 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

AbstractA 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

AbstractEarlier 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

AbstractThe 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.
Three solutions for a robot arm controller using Pascal‐Plus, occam and edison
Authors: Kerridge Jon M. , Simpson Dan 
Published: November 2006

AbstractThree 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

AbstractA 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

AbstractThis 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.
PEP: An interactive programming system with an Algol‐like programming language
Authors: Verhelst P. W. E. , Verster N. F. 
Published: November 2006

AbstractPEP (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.
Application of an optimistic concurrency control method
Authors: Kersten Martin L. , Tebra Hans 
Published: November 2006

AbstractThis 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 UNIXUNIX 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.
Toward complete programming language descriptions that are both formal and understandable
Authors: Pagan Frank G. 
Published: November 2006

AbstractWe 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

AbstractThis 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

AbstractThis 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

AbstractM. 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

AbstractThe 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

AbstractDebugging 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

AbstractThis 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.
An economical implementation of the high level real‐time language PEARL on microcomputers: Intel RMX86‐PEARL
Authors: Heine P. , Kaiser F. 
Published: November 2006

AbstractWe 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

AbstractSubroutines 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

AbstractWe 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

AbstractThe 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.
The ‘Completeness’ of the pascal test suite
Authors: Ciechanowicz Z. J. , De Weever A. C. 
Published: November 2006

AbstractThe 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

AbstractBetween 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 UNIXUNIX 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

AbstractAn 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

AbstractThe 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

AbstractProductivity 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.