bluuebunny/crossref_metadata_2025 huggingface dataset:
Separating policy from correctness in concurrency control design
Authors: Robinson John T.
Published: November 2006

The designer of a concurrency control is currently faced with a confusing situation: there has been a proliferation of proposed methods (in fact, it will be shown here that even in the ‘simple’ centralized case there are infinitely many methods), and although there has been some analysis of a few alternative methods using simulation and analytic models, it is usually impossible to accurately predict some of the parameters required by these models prior to the development of a system. Furthermore, over the lifetime of a system some parameters will change, possibly radically, due to changes in system usage, the replacement or addition of processors, memories, and I/O devices, the development of new applications, etc. Here, a practical approach to this problem is presented: separating policy from correctness in the design of the concurrency control. This technique was successfully used in the development of a transaction processing system for the Cm* multi‐microprocessor. As an illustration of this approach, the design of the concurrency control of this system is described in detail. This design should apply directly to any centralized single‐level (non‐hierarchical) concurrency control.
Implementing a scalar C compiler on the cyber 205
Authors: Li Kuo‐Cheng , Schwetman Herb
Published: November 2006

With the aid of the EM (encoding machine) compiler tool kit, a preliminary version of a scalar C compiler was implemented on the Cyber 205 in a relatively short period of time. This C compiler emphasizes functionality more than efficiency. Several benchmark programs were used to measure the performance and to compare it with an equivalent C compiler for the VAX/UNIX system. In order to make it a production‐quality C compiler, further enhancements will be necessary. This paper presents some motivating factors, implementation details, and proposes further work on developing the Cyber 205 C compiler.
Transducers are type‐converters
Authors: Pyle I. C.
Published: November 2006

The nature of a transducer is shown to be a mapping between representations (internal and external), analogous to the mapping between internal representations provided by typeconversion. Examples of this idea are given through programs in Ada and Modula.
Distributing and revoking access authorizations on abstract objecs: A capability approch
Authors: Corsini P. , Frosini G. , Lopriore L.
Published: November 2006

In this paper a capability addressing environment is presented, based on the concept of extended capability. First of all it is shown that such an environment is well suited for implementing objects of abstract type. Then the problem of distributing and revoking access authorizations on abstract objects is considered and an efficient solution is presented. The revocation mechanism results in being selective, transitive and deferred.
Implementation of the database programming language modula/R on the personal computer lilith
Authors: Reimer Manuel
Published: November 2006

Modula/R is a database programming language that integrates the programming language Modula‐2 and the relational database model. This paper describes the language concepts of Modula/R and its implementation on the personal computer Lilith within the database project LID AS. A transaction concept as an extension of the procedure concept is integrated into Modula/R to support its implementation in a multi‐user environment with access to shared distributed databases through a network of personal computers.
Applying Mccabe's complexity measure to multiple‐exit programs
Authors: Harrison Warren A.
Published: November 2006

The traditional short‐cut calculation for McCabe's complexity metric, π+1, does not handle the case of multiple‐exit flowgraphs. An alternative short‐cut calculation is presented that allows the metric to be applied to multiple‐exit programs.
Implementing a file transfer protocol between PDP11 and prime 550 computers
Authors: Ju J. B. , Baker K. D.
Published: November 2006

A protocol for file transfer between two computers connected by an asynchronous line and its implementation on a PDP11 are described.
A portable PDP‐11 simulator
Authors: Mandelberg K. I. , Doyle J. K.
Published: November 2006

This paper describes the design and implementation of a totally faithful, portable PDP‐11 simulator that could be used in the porting of the UNIX operating system to a new target computer, without the need for a development system already running UNIX.
A simple equation solver and its application to financial modelling
Authors: Derman Emanuel , Van Wyk Christopher J.
Published: November 2006

We discuss a simple algorithm for solving sets of simultaneous equations. The algorithm can solve systems of linear and some kinds of non‐linear equations, although it has nowhere near the power of a general non‐linear equation solver. Its principal advantages over more general algorithms are simplicity and speed. Versions of the algorithm have been used in a graphics language and in a system for interactively modifying the equations that constitute financial models. We discuss the second application in more detail here.
Wsh—a new command interpreter for unix
Authors: Bresnahan J. Barrie , Barnard David T. , Macleod Ian A.
Published: November 2006

WSH is a window managing command language interpreter (shell) for the UNIX operating system. This interface increases a user's power to communicate with UNIX by providing a process management environment based on an integrated virtual terminal‐shell design. Unlike conventional shells, WSH affords its user the ability to monitor and communicate with multiple processes within a single display context. Windows represent virtual terminals in the WSH design, and as such are device‐independent abstractions of real terminals. Since the design of the virtual terminal environment is based on UNIX's TERMCAP terminal database facility, WSH is portable across all versions of UNM supporting this feature. WSH requires neither alteration of existing UNIX facilities nor special display devices. The current implementation runs on a Digital VAX 11/780 under Berkeley UNIX 4.1 environment.
Program development by inductive stepwise refinement
Authors: Dromey R. Geoff
Published: November 2006

A constructive method of program development is presented. It seeks to unify two important ideas about program development. Namely that programming is a goal‐oriented activity and that there should be a correspondence between data and program structures. The latter concept is seen to be extensible beyond the data processing context in which it was originally proposed. Induction provides the vehicle for program development by stepwise refinement, with the final program being constructed by application of a sequence of progressively more powerful generalizations. The design process employed guarantees the correctness of the final program provided that each of the refinement steps have been correctly taken. The method is illustrated by a number of samples.
Programming divide and conquer for a mimd machine
Authors: Grit Dale H. , McGraw James R.
Published: November 2006

This paper discusses our efforts in implementing a divide and conquer algorithm (adaptive quadrature) on the HEP computer system. The one PEM HEP system performs in a MIMD fashion by pipelining execution of instructions from different processes. Unlike most divide and conquer approaches, our strategy ensures that the program will never deadlock due to memory expansion or spawning too many processes. Within this constraint we develop and analyse two different implementations: one using a static number of processes and the other a dynamic number of processes. Our results examine the relative performance of these two schemes. In addition we briefly discuss some of our impressions concerning some ‘myths of parallel programming’.
An IKBS implementation
Authors: Leith Philip
Published: November 2006

This paper details the practical approaches and solutions taken in the implementation of an INTERLISP programmed knowledge based program. Although some of the solutions used are particular to the specific problem domain of this program, the general pragmatic methods are of wider interest. The program excerpts are given in Pseudo‐LISP code.
Structural dimensions of small programming environments
Authors: Lyon Gordon
Published: November 2006

Although substantial variety exists among small programming environments, common points‐of‐choice in their design suggest the following structural characterization: real or virtual hardware; message‐passing or procedure‐calling; static or dynamic binding; horizontal or vertical organization; abstract or concrete structures; fixed or extensible language. Often these dimensions must support a very focused programming idiom, which combined with other requirements such as portability or performance, establishes structural dependencies, precludes features and forces exceptions. The characterization provides a rough framework that is useful in evaluating programming environments.
Orthogonality of concerns in module closure
Authors: George Geoffrey , Leathrum James F.
Published: November 2006

Information hiding in software design leads to the concept of module closure. The function of modularization in a design is to hide a design decision, facilitating the design of programs which employ that module. This produces a module which may be used elsewhere regardless of its implementation details. Module closure has two components—access closure, wherein the module and user share no data objects, but only the values of formal parameters, and computation closure, wherein the model which the module emulates is as simple as possible, and implementation independent.
Hardware/software trade‐offs for bitmap graphics on the blit
Authors: Pike Rob , Locanthi Bart , Reiser John
Published: November 2006

The Blit is an experimental bitmap graphics terminal built for research into interactive computer graphics on the UNIX time‐sharing system. The hardware is inexpensive and the graphics functions are implemented entirely in software. Nevertheless, the graphics performance of the Blit is comparable or superior to some displays with special‐purpose graphics hardware. This paper explains the paradox by referring to some principles of design: the hardware and software should be designed together to complement each other; carefully designed software can outperform infelicitous hardware; and simplicity of design leads to efficiency of execution. These principles are illustrated by examples from the Blit hardware and software and comparisons with other systems.
Implementation of the blit debugger
Authors: Cargill Thomas A.
Published: November 2006

joff is an asynchronous, source‐level, break‐and‐examine debugger for C programs running on the Blit, a programmable bitmap terminal, joff is implemented as two processes: a small process running in the terminal and a larger process running in a time‐sharing host. The constraints on its design and a menu‐driven user interface combine to present an unusual set of implementation difficulties. The way the problems were tackled and the degree to which they were solved may be interesting to those designing other debuggers. Operating system designers should assess the merits of a debugger that runs asynchronously with its subject and consider providing the necessary support.
The cost of a generated parser
Authors: Waite W. M. , Carter L. R.
Published: November 2006

The ‘fact’ that compilers employing generated parsers suffer significant performance degradation dis‐a‐vis recursive descent compilers is entrenched in the folklore of computing. We give detailed measurements that support this belief when the entire compiler is written in Pascal. We then define a general interface for a parsing module that hides significantly more information than usual, simplifying the process of generation and integration. This interface makes an assembly‐coded parse table interpreter feasible without changing the language used for the remainder of the compiler. When the parse table interpreter is written in assembly language, the costs of the generated parser are essentially the same as those for recursive descent. (A minor space/time trade‐off is possible, with the recursive descent implementation being slightly bigger and slightly faster.)
Follow set error recovery
Authors: Stirling Colin
Published: November 2006

Follow set error recovery is a popular technique, implemented as part of a recursive descent parser, for recovering from syntax errors by editing the input string at the point of error detection. A formal description shows that follow set error recovery is, in actual fact, a family of similar techniques differing according to how follow set is defined. A general algorithm for this family of schemes is offered. Standard accounts mention and make use of non‐systematic, almost ad hoc, additions which improve the performance of the technique. It is shown that some of these additions can be systematized using error productions. Criteria for assessment of the technique are offered. Using these criteria and a database of over 100 example programs three different follow set schemes are assessed with respect to each other.
A simula program to automate wire‐wrap schedule generation
Authors: Lester L. N. , Thelander H. A.
Published: November 2006

The production of wire‐wrap schedules by hand is extremely tedious and error prone. This paper discusses a program which has been developed to generate an easy‐to‐follow, cross‐referenced wiring schedule from a simply‐formatted data file. The program also provides extensive checking of the input data. The language used was SIMULA, and was found to be an ideal vehicle for implementing the requirements of wire‐wrap schedule generation. The class concept, in particular, was found to be most useful.
Software development tools for microcontrollers
Authors: Knight John C. , Russell James L.
Published: November 2006

Two software tools are described that are designed to facilitate software development for microcontrollers. One is a mid‐level programming language called Pascal/48 and the other is a circuit simulation system. Pascal/48 is designed to give the programmer many of the advantages of a high‐level language, but also provide access to all of the hardware of the Intel MCS‐48 series of microcontrollers. The circuit simulation system combines many of the advantages of simulation and emulation. It provides a software testing environment in which many more software functions can be tested than with conventional simulators. The system integrates an instruction‐set simulator with simulators for other devices. They operate in parallel and are synchronized by a clock that records simulated time. I/O lines of the microcontroller can be linked to other components so that complete circuits can be simulated. Displays are provided of the internal and external state of the simulated circuit, and of the Pascal/48 program being executed. They are updated as simulated execution proceeds using the screen updating facilities of ASCII terminals. Simulation can be continuous, single step, or execution can be reversed (i.e. instructions are ‘unexecuted’).
Practical considerations of global and local variables
Authors: Er M. C.
Published: November 2006

Fisher advocates that all variables should be made global to programs and subprograms in order to increase the maintainability and to reduce the problems with subprogram linkages, among other things. The fallacies of Fisher's arguments are shown and the advantages and necessity of using local variables are discussed. It is argued that, from a practical point of view, the use of local variables improves the comprehensibility and the time and space efficiency of programs, as well as makes correctness proofs easier and recursion possible.
Cwsh: The windowing shell of the Maryland Window System
Authors: Weiser Mark
Published: November 2006

The Maryland Window System is a set of programs for manipulating multiple overlapping windows on CRT terminals. Part of the package is the window shell, called the CWSH. The CWSH uses the windowing system to create multiple windows running shell processes. The CWSH differs from the WSH and BRUWIN window systems by permitting processes running in the windows access to window functionality, and by more fully implementing a Unix terminal within each window. Unlike BRUWIN and WSH, CWSH permits programs, such as other shells and editors, that intensively examine or modify their terminal environment to run unmodified in its windows.
A portable high‐level database debugger and software performance monitor
Authors: Jankowitz Hugo T. , Kilfoil Paul W. , Rabkin Ilana , Schach Stephen R.
Published: November 2006

The package DBDEBUG assits the users of CODASYL (network) database management systems in two ways. It can be used by applications programmers to debug their programs, and by the database administrator to monitor the performance of the database. The user may select the sections (or even individual statements) of his program to be traced and/or monitored. He may list the specific records and items he wishes to be investigated; he may also restrict tracing and monitoring to only certain DML verbs.

The user's database schema and subschema are submitted to processors which generate a data dictionary. This data dictionary is then used by DBDEBUG in modifying the user's DML source code in order to obtain the specified tracing or performance statistics. The output is high‐level in that it reflects the high‐level language (DML COBOL) in which the user's source code was written.

The package is designed to be portable. All but one of its components are written in standard Pascal or ANSI COBOL; assembler code is restricted to a ten‐line subroutine which obtains L/O and CPU times from the operating system.
Compact coding of syntactically correct source programs
Authors: Contla Jose Felipe
Published: November 2006

The technique for compacting source programs is based on recording the path followed by the parser while traversing the syntax tables of the programming language in which the program was written. However, to record every syntactical form visited by the parser would contain redundant information. For example: every syntactically correct Pascal program contains the terminal symbol PROGRAM. Consequently while recording the path followed by the parser, the fact that this terminal symbol has been traversed could be ignored. Therefore, these are techniques for recording only the information which is essential for the decoder to reconstruct the original program by traversing the syntax graph.
The robust implementation of sequence‐controlled iteration
Authors: Newey M. C. , Waite W. M.
Published: November 2006

Many Pascal compilers generate incorrect code for statements. The trap that catches many implementors, whereby overflow is generated incorrectly, is explained and means for avoiding it are discussed (with attention to cost). Most common languages have a similar construct in which iteration is ‘controlled’ by a sequence of values in that a variable takes on successive values of the sequence for the several executions of the ‘body’. Often, the size step is not restricted to plus‐or‐minus one (as in Pascal) and the correctness situation cannot be characterized in such black and white terms. Typically, there is a range of behaviours that are valid and the compiler writer is able to choose a compromise between time‐space overheads and avoidance of unnecessary overflow indications; we describe the latter behaviour as robust. We present techniques for implementation appropriate to several languages and direct comments at language designers warning against both ignoring and overestimating the cost of robustly implementing iteration statements with arbitrary step size. Lastly, we criticize the design of instructions available in some machines, ostensibly to support the implementation of such sequence controlled iteration statements.
A method of program transformation between variable sharing and message passing
Authors: Hikita Teruo , Ishihata Kiyoshi
Published: November 2006

There have been proposed and used many programming concepts for realizing interprocess communication and synchronization, and two fundamental categories among them are variable sharing (e.g. semaphores) and message passing (signals, input/output in CSP and redezvous in Ada). The aim of this paper is to investigate the relationship between these two mechanisms, and in particular, program transformation between them. We here propose a transformation method between parallel programs written in each of these two, which uses transformation schemes named monitor transformations. We exhibit the method by showing through a chain of program transformations the equivalence of two versions of a parallel algorithm called dynamic sorting array.
Combining mascot with modula‐2 to aid the engineering of real‐time systems
Authors: Budgen D.
Published: November 2006

This paper examines how the ‘MASCOT machine’ and the Modula‐2 language may be used together as a basis for engineering a range of real‐time systems. It is shown that Modula‐2 provides the features required for a satisfactory MASCOT implementation language without the normal need to add extra features or use preprocessing. The paper also describes how the MASCOT design tools can be interpreted more widely than has previously been considered in order to provide support for a large range of problems.
An evaluation of tagging
Authors: Van Vliet J. C. , Gladney H. M.
Published: November 2006

Tagging is the augmentation of run‐time data with some form of self‐description for type checking or storage management purposes. We have studied the contribution of automatic tagging by converting two programs written in object‐oriented languages to PL/1. We had thought that much of the apparent superiority of the object‐oriented version came from dynamic binding of operator invocations. However, of several factors contributing to program quality, automatic storage management and the availability of generic abstract data types seem equally important in the examples studied. Tags turned out to be needed for only a few data objects and are used in only a few places. When the obligatory tags are modelled in PL/1, the code becomes particular to the problem at hand and is less elegant. On the other hand, current implementations of object‐oriented languages have considerable overhead in both time and space for tags. This led us to consider combining tagged and non‐tagged objects in a single language.
A large scale network storage facility
Authors: Dakin R. J. , Lederer B. R. , Parker K. R.
Published: November 2006

This paper is concerned with the overall design of the Terabit File Store — a network storage facility based on a Braegen Automated Tape Library. The characteristics of the tape library — in particular its large capacity and slow access — provide both challenges and opportunities for the system designer. The use of disc cache and the optimization of file placement have been used to provide reasonable performance in the face of substantial tape handling times. Catalogue facilities have been tailored to cater for the support of large file holdings and user file back‐up applications. It has been possible to automate the back‐up of essential file‐store information which together with automatic integrity checks, helps to minimize the damage that can be caused by faults. Considerable attention has been given to facilities that automate much of the management of the system in a network environment. Other aspects of the design discussed in the paper include protection, housekeeping and host interfacing.
Video‐slide: A presentation aid for the bbc microcomputer
Authors: Rees Michael J. , Robson David J.
Published: November 2006

Video‐Slide is a powerful visual aid for the BBC Microcomputer. It can be used to support a wide variety of talks, ranging from lessons to business presentations. Video‐Slide manipulates screens of coloured information which are referred to as slides. These are compatible with the broadcast teletext standard. Slides are prepared in advance with graphics editor and librarian utilities. During the presentation itself, a display program gives simple, direct control over the sequencing of slides with several important features. Video‐Slide programs are menu‐driven with a simple visual interface, and are designed to be used by non‐computer users. This paper describes the design concepts and implementation of the Video‐Slide system.
Efficient algorithms to create and maintain balanced and threaded binary search trees
Authors: Iyengar S. Sitharama , Chang Hsi
Published: November 2006

The algorithm proposed by Chang and lyengar to perfectly balance binary search trees has been modified to not only balance but also thread binary search trees. Threads are constructed in the same sequence as normal pointers during the balancing process. No extra workspace is necessary, and the running time is also linear for the modified algorithm. Such produced tree structure has minimal average path length for fast information retrieval, and threads to facilitate more flexible and efficient traversing schemes. Maintenance and manipulation of the data structure are discussed and relevant algorithms given.
Design and implementation of the wisconsin storage system
Authors: Chou H‐T. , Dewitt David J. , Katz Randy H. , Klug Anthony C.
Published: November 2006

We describe the implementation of a flexible data storage system for the UNIX environment that has been designed as an experimental vehicle for building database management systems. The storage component forms a foundation upon which a variety of database systems can be constructed including support for unconventional types of data. We describe the system architecture, the design decisions incorporated within its implementation, our experiences in developing this large piece of software, and the applications that have been built on top of it.
The creation of a virtual NAG‐algol 68 program library
Authors: de Bruin R. , Van Laan C. G. Der
Published: November 2006

A method for the creation of a virtual Algol 68 program library on top of a subset of the NAG‐FORTRAN library is discussed.
Prtds — a pascal run‐time diagnostics system
Authors: White N. H. , Bennett K. H.
Published: November 2006

A run‐time diagnostics system has been described that allows the user to interrogate a program fully in source language terms. In particular, dynamically created data structures are catered for. The diagnostics system allows all objects including those created dynamically to be interrogated and can display a graphical representation of linked data structures. This paper describes the implementation of such a system with the language Pascal on a GEC 4080.
A debugger for message‐based processes
Authors: Smith Edward T.
Published: November 2006

This paper describes a debugger of message‐based, communicating processes. This debugger is designed to reduce the apparent complexity of large systems of communicating programs by regarding only the interprocess activities of such programs. The debugger provides users with information about how sets of processes behave rather than what each program associated with each process does. It also provides various primitives for manipulating the interprocess activities of processes. In order to concentrate on just those operations pertinent to multi‐process debugging, the debugger provides no ability to access the source code of any program. Our system includes a user‐interface program, a mechanism to fire and execute interprocess debugging demons and a mechanism to obtain transcripts of interprocess activities. The user interface executes commands for the user at a terminal for creating and manipulating individual interprocess events. Demons are an event‐driven mechanism used to automatically monitor and modify interprocess events. Transcripts provide a record of interprocess events executed for a process that can be replayed later. We make use of these tools to provide individual process control, communication monitoring and process testing.
An intelligent pascal editor for a graphical oriented workstation
Authors: Jesshope C. R. , Crawley M. J. , Lovegrove G. L.
Published: November 2006

A Pascal syntax directed screen editor, designed to run under PNX on an ICL Perq workstation is presented. The editor (Eliot) offers a structured approach to text editing and provides complete Pascal syntax checking. The exceptional graphic capabilities of the Perq are used to good effect in providing an efficient user interface by way of a hierarchy of pop‐up menus. Using this interface, skeletal programs may be entered down to the assignment statement, or procedure call level without recourse to the keyboard, selections being made from menus using a graphics tablet and puck. Eliot encourages block structured programs with nested blocks by the use of a tree structured menu, representing the program structure. This allows for efficient movement around the program, again using the tablet and puck. Syntax checking is performed continually with errors reported and highlighted immediately for correction at will. For further error checking a variable scan option can be invoked which lists details of variable names which are not declared, or declared more than once, or declared and not used at all.
A high level language based system for cross‐assembler definition
Authors: Ancona M. , Clematis A. , Dodero G. , Pino A.
Published: November 2006

A method to develop cross‐assemblers is explained by describing the XMETA system, where the advantages given by the semantic power of meta‐assemblies have been combined with the clarity of modern high level languages, such as Pascal, in defining assembly semantics. XMETA accepts a superset of the IEEE‐P694 microprocessor assembly language standard syntax: system structure is detailed and examples are provided to illustrate its use. Actual experiences are briefly summarized in the conclusions.
Implementation of an interpreter for abstract equations
Authors: Hoffmann Christoph M. , O'donnell Michael J. , Strandh Robert I.
Published: November 2006

This paper summarizes a project whose goal is the implementation of a useful interpreter for abstract equations that is absolutely faithful to the logical semantics of equations. The interpreter was first distributed to Berkeley UNIX VAX sites in May 1983. The main novelties of the interpreter are strict adherence to semantics based on logical consequences, ‘lazy’ (outermost) evaluation applied uniformly, an implementation based on table‐driven pattern matching, with no run‐time penalty for large sets of equations, and strict separation of syntactic and semantic processing, so that different syntaxes may be used for different problems.
Compact recursive‐descent parsing of expressions
Authors: Hanson David R.
Published: November 2006

Compiler writing tools, such as parser generators, are‐commonly used to build new operators. Nevertheless, constructing compilers by hand remains common. Such compilers are often built using recursive‐descent parsing for most of the language and operator‐precedence parsing for expressions. This paper describes a simple technique for parsing expressions using recursive descent that avoids the usual proliferation of procedures that occurs when recursive descent is used to parse expressions. By taking advantage of the similarity of the productions describing expressions in most languages, the n + 1 procedures usually required to parse expressions with n precedence levels can be replaced with a table and two procedures.
A new algorithm for generating hilbert curves
Authors: Fisher A. J.
Published: November 2006

A new algorithm is described which generates the co‐ordinates of the tth point along a Hilbert curve, given the value of the parameter t. The algorithm is expressed in the concurrent programming language occam.
Executable semantic descriptions
Authors: Watt David A.
Published: November 2006

We describe how the denotational semantics of a programming language can be executed directly, if it is expressed in a suitable functional programming language such as ML. We also apply Mosses' idea of ‘semantic algebras’ to construct semantic descriptions that are significantly more modular and understandable than usual. The possibility of executing a language's semantic description directly supports a methodology of language design that we advocate: express the design as a formal language description, and use this to test and refine the design, before becoming committed to constructing a compiler.
Printing Arabic text using dot matrix printers
Authors: Khayat M. G.
Published: November 2006

The increased use of Arabic in computer systems makes it necessary to consider the effects of using Arabic script for input and output. Printing Arabic text using dot matrix printers requires special software or firmware. First, character shapes must be developed and loaded into the printer's memory. Secondly, since an Arabic letter can have up to four different shapes depending on its position in the word, a program must be developed to determine which shape of a character is to be printed. This process is called contextual analysis. Dot matrix printers have a character set of 128 codes including control codes, which implies that not all possible shapes of the Arabic alphabet can be loaded into the printer's memory. There are at least two solutions to this problem. One is to delete some of the shapes of certain characters. The other solution involves decomposing some of the shapes into common parts that can be combined to form the desired shape. In our approach, we use a combination of the two solutions. The result of this study is the development of two programs. One program is used to print Arabic text containing English text. The second program prints English text containing Arabic text. The programs change the fount of the printer according to the type of text. Both programs also perform contextual analysis of Arabic text.
Insecurities in FORTRAN DO‐loops
Authors: Cooke D. J. , Abdollahzadeh F.
Published: November 2006

Despite a long‐established body of relevant computer science, lack of precise specification of certain aspects of FORTRAN and deviation from the published standards permit the construction of non‐standard programs which run under different systems to give contradictory results. This paper highlights certain deviant features of DO‐loops.
A probe effect in concurrent programs
Authors: Gait Jason
Published: November 2006

This paper reports on an experimental study of the probe effect, defined as an alteration in the frequency of run‐time computational errors observed when delays are introduced into concurrent programs. If the concurrent program being studied has no synchronization errors, then there is no probe effect. In the presence of synchronization errors, the frequency of observable output errors for a sample experimental program starts at a high value for small delays, oscillates rapidly as the delay is increased, and apparently settles at zero errors for larger values of delay. Thus, for sufficiently large delays, the probe effect can almost completely mask synchronization errors in concurrent programs. For sufficiently large concurrent process sets, even small values of embedded delay may mask synchronization errors, provided side effects in shared memory are not included in the observation.
File updating revisited
Authors: Lunbeck R. J.
Published: November 2006

Expositions of sequential master file updating are usually concerned only with insertions of new records, alterations or deletions of existing records and with the joint processing of these transactions. In actual practice other types of file transactions may also be needed, such as printing of (parts of) records, preventing possible alterations of certain records, etc. A general framework for dealing as well with such transactions in one processing run is presented. Simplifications of this framework are possible for random‐access files.
Syntax‐directed compression of program files
Authors: Katajainen Jyrki , Penttonen Martti , Teuhola Jukka
Published: November 2006

Parsing can be applied to compress source programs. A suitably encoded parse tree, together with the symbol table, constitutes a very compact representation of the program. The paper reports a Prolog implementation of the method, including automatic, syntax‐directed, encoder and decoder generators. The test results show compression gains of 50–60 per cent.
Interactive documentation
Authors: Brown P. J.
Published: November 2006

Documents are increasingly often read from computer screens rather than from paper. This paper describes a tool, called GUIDE, which allows readers of computer‐based documents to peruse these documents at any desired level of detail. GUIDE covers any kind of textual document, and is designed for environments where both author and readers are lay users.
Copying of dynamic structures in a pascal environment
Authors: Forsythe Kenneth , Matwin Stanislaw
Published: November 2006

Two problems involving the use of dynamic lists in Pascal are (1) the limited size of the heap and (2) the difficulty in creating copies of complex multi‐linked structures. Both these problems can be solved by writing the appropriate segment of memory to a file on disk. The heap segment may then be released. To recover the structure during a later phase of processing, the contents of the file can be transferred back onto the heap. This paper presents an algorithm to implement this solution.
An algorithm for displaying a class of space‐filling curves
Authors: Griffiths J. G.
Published: November 2006

A table‐driven algorithm for drawing a variety of space‐filling curves is presented. A method for discovering new curves is described. Numerous examples are shown.
Inter‐process communication in MVS/XA and applications for scientific and engineering information processing
Authors: Marinescu Dan C.
Published: November 2006

This paper surveys inter‐process communication in MVS/XA (multiple virtual system/extended architecture) and explores the use of cross‐memory services for this purpose. The lack of high‐level interfaces to system services is a major handicap in MVS/XA. Tools to provide high‐level services, in particular, tools for inter‐process communication, can be implemented in a simple, elegant and efficient way. The implementation and use of a communication subsystem, the extended communication facility (ECF), are also described. The ideas and mechanisms presented are useful for many scientific and engineering applications running under MVS/XA. Examples include distributed systems, applications using concurrent programming, a quasi‐batch environment, communication subsystems, and mail subsystems.
Iterative development of information systems: A case study
Authors: Blum Bruce I.
Published: November 2006

This paper makes some observations about the applicability of iterative development for system implementation. After a general discussion of the software process, the types of projects suitable for this approach are identified. A system designed to support the iterative development method is then briefly examined, and a case study of its use is presented. Conclusions about the process are drawn, and some research issues regarding productivity are defined.
Integrating distributed array processing into EMAS 2900
Authors: Brown Michael W.
Published: November 2006

This paper describes the integration of initially one, and later a second, ICL Distributed Array Processor (DAP) into a dual ICL 2972 installation running the Edinburgh Multi‐Access System (EMAS). The alterations made to each level of the operating system are briefly described, along with the methods for mounting some of the relevant ICL DAP compiler software. Software enhancements to enable multi‐programming of the DAP and a locally designed method for DAP data area expansion are also described. A brief résumé of the user facilities available is included, along with operational policies and some utilization figures.
Providing multi‐user access to distributed array processors
Authors: Stephens P. D. , Yarwood J. K.
Published: November 2006

This paper describes the integration of two ICL Distributed Array Processors (DAPs) into a dual ICL 2976 configuration running the Edinburgh Multi‐Access System (EMAS). The principles underlying the general multi‐access service are not compromised; special scheduling arrangements provide effective control and use of the DAP resource while allowing multi‐user access to the DAPs for DAP program development.
A fortran procedure for drawing some space‐filling curves
Authors: Palmer J. A. B.
Published: November 2006

A simple FORTRAN procedure for drawing curves defined in terms of recursion is shown. Examples of its use are given, and the use of parameters for identification of the curves is demonstrated.
Algorithms for pattern matching
Authors: Davies G. , Bowsher S.
Published: November 2006

This paper describes four algorithms of varying complexity used for pattern matching, and investigates their behaviour. The algorithms are tested using patterns of varying length from several alphabets. It is concluded that although there is no overall ‘best’ algorithm, the more complex algorithms are worth considering as they are generally more efficient in terms of number of comparisons made and execution time.
Formatted syntaxes and modula‐2
Authors: Woodman Mark
Published: November 2006

The formatted syntax notation has been developed for the specification of formatted programming languages. This paper describes how a formatted syntax may be constructed for the purpose of prettyprinting an existing free‐format language. Those aspects of the system of particular relevance to free‐format languages are emphasized and their use explained. Also, a number of deficiencies in the defining metasyntax and formatting symbol repertoire are discussed. Practical enhancements and further areas of research are suggested. The programming language Modula‐2 is used for illustration, and a formatted syntax for it is given.
Dbxtool: A window‐based symbolic debugger for sun workstations
Authors: Adams Evan , Muchnick Steven S.
Published: November 2006

Dbxtool is a window‐ and mouse‐based debugger for C, Pascal and FORTRAN programs running on Sun workstations. Its use of the mouse as the primary input mechanism eliminates the need to type variables, line numbers, breakpoints and most commands. Its multiple windows provide several qualitatively different perspectives on the debugging problem. Compared to the Unix 4.2 BSD dbx from which it is derived, it has been extended with the abilities to debug multiple‐process programs, already‐running processes, and the Sun Operating System kernel.
A monitor tool for a network based on the cambridge ring
Authors: Vassiliades Synnove , Sayers Michael D. , Bacon Jean M.
Published: November 2006

An evolving network is subject to technological advances and increasing user demands through out its lifetime. Continuous monitoring is therefore required to understand its behaviour in the operational environment and to provide an aid to planning. A monitor tool has been developed to meet such requirements in a heavily used service network.

A decentralized but integrated approach has been adopted. An active collection allows accumulated measurements to be retrieved. The measurements required are determined and the constraints imposed by existing mechanisms and the methods chosen are discussed.

Flexible user facilities are available to allow selected measurements to be collected and displayed, and these are described.

Daily sessions of network‐wide monitoring have been undertaken. The overhead incurred is quantified. The sessions revealed communications software errors and anomalous behaviour of a network node. Further analysis shows the symptoms of the latter, the result of a hardware fault.

Enhancements which would increase the flexibility of the tool are also suggested.
A multi‐processor implementation of occam
Authors: Fisher A. J.
Published: November 2006

This paper describes an implementation of the concurrent programming language occam on a multi‐processor computer, in which occam channels are multiplexed onto a token ring which links the processors.
Communications in meglos
Authors: Gaglianello Robert D. , Katseff Howard P.
Published: November 2006

Meglos provides a user‐level, message‐based programming environment for a system of interconnected processors. It allows the simultaneous execution of a wide range of applications including real‐time control and large‐scale computations requiring the co‐operative work of many processors. The communications mechanisms in Meglos are designed to be easy to use and to provide high performance at the applications level. The communications primitives are based on symmetric, error‐resilient channels that are independently flow controlled. Two‐ended channels between pairs of co‐operating processes provide communications with low latency and high throughput. Multicast channels are used to send messages efficiently among a large group of processors in a single operation.
An experiment with the newcastle connection protocol
Authors: Snow C. R. , Whitfield H.
Published: November 2006

An experiment is described in which a set of Unix systems linked together into a Unix United system by means of the Newcastle Connection Protocol1 is also linked to a system with a dissimilar structure. It demonstrates that the Newcastle Connection technique can be used to connect together operating systems with differing structures and philosophies. The non‐Unix system, known as Nimrod, offers a set of services which can be mapped onto requests for service from standard user processes running on a remote Unix system. The services offered by Nimrod are restricted to those required for providing remote input and output to a terminal, but the results of the experiment suggest that increasing the range of services offered would be possible, despite the substantial differences in structure between Nimrod and Unix. Some of the problems associated with greater levels of inter‐system connection are also discussed.
A modular operating system for the cray‐1
Authors: Huskamp Jeffrey C.
Published: November 2006

A new operating system for the CRAY‐1 supercomputer implements four types of objects that can be manipulated by user tasks. A directory object is used to implement a hierarchical directory structure, a file object stores random access data, a pipe object permits intertask communication and a process object is used to execute user programs. The advantages of implementing a restricted number of object types in the kernel and the lessons learned from developing a supercomputer operating system from scratch are discussed.
The ilem project: Pascal to algol in easy stages. I: Outward bound
Authors: Walker A. N.
Published: November 2006

Most academic institutions have Pascal compilers coming out of their ears. Most academic institutions have Algol compilers only on their dinosaur mainframes. The Ilem project consists of designing a sequence of intermediate languages, IL0, IL1, IL2, …, ILN–1, ILN, where IL0 is Pascal and ILN is Algol, and where any two consecutive languages differ so little that a one‐man spare‐time project suffices to convert a compiler for one language into a compiler for the next.
Joyce—A programming language for distributed systems
Authors: Hansen Per Brinch
Published: November 2006

This paper describes a secure programming language called Joyce based on CSP and Pascal. Joyce permits unbounded (recursive) activation of communicating agents. The agents exchange messages through synchronous channels. A channel can transfer messages of different types between two or more agents. A compiler can check message types and ensure that agents use disjoint sets of variables only. The use of Joyce is illustrated by a variety of examples.
Parsing ambiguous addresses for electronic services
Authors: Honeyman Peter , Parseghian Patricia E.
Published: November 2006

Pathparse is a tool with a practical approach to disambiguating problematic routes for services such as electronic mail. Pathparse resolves syntactic and host name ambiguities with the aid of a database that describes host connections. The parser generates a set of path/user pairs; heuristics are used to select one among these, which may then be used by a conventional mail handler.