bluuebunny/crossref_metadata_2025_split huggingface dataset:
Synchronization under a commercial operating system
Authors: Jensen Jørn , Lauesen Søren , Ravn A. P. 
Published: November 2006

AbstractMutual exclusion and general synchronization of concurrent processes (‘tasks’) are well‐known principles for constructing reliable real‐time systems. This paper shows how to implement these principles under a typical commercial operating system which provides incomplete synchronization operations. The problem of synchronizing erroneous tasks is discussed briefly.
A human‐computer interface for non‐computer specialists
Authors: Palme Jacob 
Published: November 2006

AbstractThe COM teleconferencing system was designed to be easy to use for both beginners and people with much computer experience. A number of design choices in organizing the human‐computer interface were considered very carefully. These design problems are not unique for teleconferencing applications, but will appear in many other developments of human‐computer interfaces for non‐computer specialists.This report discusses naming conventions, menu format, user commands, help facility and the treatment of ‘type ahead’ from the users.
Some aspects of concurrent programming in CCNPASCAL
Authors: Narayana K. T. , Prasad V. R. , Joseph M. 
Published: November 2006

AbstractCCNPASCAL is a language derived from Pascal and Concurrent Pascal which has been used in the development of an operating system for a multiprocessor. This paper introduces some of the important features of the language and illustrates them with examples. The language provides mechanisms for interfacing separately compiled modules, for building abstractions of collections of resources and for efficient asynchronous communication.
An assessment of concurrent Pascal
Authors: Coleman D. , Gallimore R. M. , Hughes J. W. , Powell M. S. 
Published: November 2006

AbstractThis paper assesses Concurrent Pascal against its design aims. The language is shown to be suitable for writing reliable non‐trivial concurrent applications programs and operating systems. The major weakness of the language is its inability to provide an environment for other Concurrent Pascal programs. A new language construct, group, is proposed to remedy this difficulty.
Using convert to transform source code
Authors: Wolberg John R. , Rafal Marshall 
Published: November 2006

AbstractThere are a number of reasons why one might wish to transform the source code of an operational program:

To make the program conform to a standard layout.
To make the program conform to syntax and semantics standards.
To improve the performance of the program.
The primary advantage of transforming source code into a standard form is that the programs become easier to maintain. The cost‐benefit of standardization is thus realized at a later stage in the lifetime of the programs. Alternatively the cost‐benefit of improving performance is immediate.The desirability of transforming source code is affected by several parameters:

The benefit to be realized from transformation.
The cost of transformation.
The time involved in transformation.
The risk associated with transformation.
If the benefit of transformation is significant, the cost, time and risk associated with the process can be considerably reduced by automating the process.In this paper, application of the CONVERT language to the transformation problem is discussed. CONVERT was developed as a vehicle for writing automatic language and dialect converters. Clearly, the features useful for converters are also applicable when the application involves transformation of source code.
MPLOT3—A system‐independent plotting package
Authors: Sethi H. R. , Paul D. H. 
Published: November 2006

AbstractThis paper describes a general purpose plotting package which enables sets of data points to be plotted on a variety of output devices by simply specifying the mnemonic name and without any programming on the part of the users. A plot can be produced with the default options from a simple data file which can be expanded to call in many extra facilities. Options include scaling, automatic selection of axes and their markings, and identification of curves/shapes by varying‐length dashed lines, different symbols or colours. English and Greek characters can be written at any angle and size. Clipping or voiding facilities are provided to confine plotting inside or outside a given area. The package is expandable to allow new facilities to be added. The present form has been arrived at through feedback from the users over the last four years and has found a wide variety of applications in a scientific environment.
Input/output in high level programming languages
Authors: Pyle I. C. 
Published: November 2006

AbstractA system's input/output is its communication with the other systems in its environment. By viewing the relationship as communication between partners, we identify the fundamental requirements in input/output programming, and discuss the responses of various programming languages to these requirements. Traditional programming languages provide either nothing or an expensive incomplete solution. The new languages Modula and Ada now offer major improvements in this area. We describe the style of their solutions, and give corresponding guidance for low‐level input/output programming.
A campus network based on ICL 2900 series protocol
Authors: Eaglestone B. M. , Partington N. J. 
Published: November 2006

AbstractA campus network has been built at the University of Salford in which a number of minicomputers have been linked to a PRIME 300/400 system using the protocol adopted for ICL 2900 series communications. This protocol is known as Extended Basic Mode, or XBM. The network is integrated into a wider regional network of ICL machines through a link to the local ICL 1904S service. The protocol defines a standard terminal model which is used as a machine‐independent basis for the network construction. The benefits are described which the network brings to users both of the various minicomputers and of the PRIME system.
p—a timesharing operating system for laboratory automation
Authors: Lindård Anders 
Published: November 2006

AbstractAn operating system supporting laboratory automation and interactive use of a computer has been designed and implemented for the multiprogrammed RC4000 computer. The emphasis in the design has been to give the user interactive access to as many system resources as possible, and to facilitate writing of process control programs in a high‐level language, i.e. ALGOL. The operating system is used to run control and data collection programs for a variety of experiments in physical chemistry. Laboratory automation programs can be started and removed dynamically, and may even be restarted automatically after a system failure. The operating system is a 1500 line ALGOL program. The first version was designed, implemented and debugged in about 4 person‐months. The operating system has been running day and night for approximately 5 years without errors despite heavy use.
Concurrent Pascal with backward error recovery: Language features and examples
Authors: Shrivastava S. K. 
Published: November 2006

AbstractThe programming language Concurrent Pascal has been extended to include some language features that facilitate the writing of fault‐tolerant software. As a result, it is possible now to (1) write operating systems with a measure of fault‐tolerance, and (2) for such an operating system to support fault‐tolerant user programs. The paper describes these language features and illustrates their use with the help of a few working examples.
Debugging methods in recursive structured FORTRAN
Authors: Arisawa Makoto , Iuchi Minoru 
Published: November 2006

AbstractA version of structured FORTRAN named STAR is introduced. STAR allows recursive subroutines. Implementation problems such as parameter passing by value and local variable stacking are discussed. The major difficulty in the preprocessor approach is debugging. We claim that execution profiles are strong debugging aids, and demonstrate how to debug a STAR program at source language level with the clue in the profiles plus assertion statements. We make use of a quicksort program as an example.
Development of the ZED text editor
Authors: Hazel Philip 
Published: November 2006

AbstractThe development process which resulted in a new text editor is described. The reasons for undertaking this development are discussed, and in particular the increased amount of non‐interactive use of text editors is stressed. The approach taken to the project is described, including the involvement of users in defining the specification and testing prototypes. Finally the main features of the new editor, ZED, are covered.
A simple nucleus written in modula‐2: A case study
Authors: Hoppe Jiri 
Published: November 2006

AbstractA simple nucleus for a single‐processor computer is considered. The entire nucleus program is written in the high‐level programming language Modula‐21 without assembly coding. The concepts of the nucleus and some simple applications are described. A complete listing of the nucleus is included. We conclude that programming of a nucleus in an appropriate high‐level language is simpler than in an assembly language. The resulting nucleus has a comparable performance with other nuclei written in assembly code.
A process oriented simulation model specification and documentation language
Authors: Frankowski Elaine N. , Franta W. R. 
Published: November 2006

AbstractWe present a language for specifying and documenting discrete event simulation models, designed to facilitate communication during model design, implementation and maintenance. The systems from which models are developed are viewed as collections of communicating elements. Each element is specified separately in a module consisting of attributes, axioms and a scenario. The model's specification consists of each model element's specification and some systemwide attributes and axioms. Synchronization among model elements (model dynamics) is specified within the model elements rather than globally. Each language control structure has a monitor associated with it. Appropriate changes are made in the model's state in response to a monitor's sensing an attribute change. The language contains a library of specifications for common simulation model entities such as the priority queue. The syntax and semantics of the language are presented through examples. Examples of a library specification and a model specification are included.
MM/1, a man‐machine interface
Authors: Schofield D. , Hillman A. L. , Rodgers J. L. 
Published: November 2006

AbstractThis paper discusses the software interface between a computer system and its users, and how it can be made convenient and practical for both the users and implementors of systems. Consistency of interaction is essential, though it is argued that it is too early to define true standards. Standards must be based on experience of actual systems, and must meet specifications that can be justified from the performance of the best of such systems. As one contribution to such a specification, a description is given of MM/1, a family of user interfaces which can be used as a basis for interactive dialogues. MM/1 is suitable for both large and small computers. The thinking behind the interface is given, together with experience of its use in three different systems.
Extension of Pascal by coroutines and its application to quasi‐parallel programming and simulation
Authors: Kriz J. , Sandmayr H. 
Published: November 2006

AbstractThis paper describes an extension of Pascal by coroutines as a basic tool to make quasi‐parallel programming possible. This extension is acheived by predefined procedures, i.e. by semantical means without modification of the syntax of the language. Process and simulation concepts are developed entirely in the extended Pascal. These concepts are suited for quasi‐parallel programming and for process‐oriented simulation of discrete‐event systems. The presented simulation system is easy to implement, it is flexible and modifiable. It retains the powerful facilities and the portability and availability of Pascal.
Experiences with a schematic logic preprocessor
Authors: Triance J. M. , Yow J. F. S. 
Published: November 2006

AbstractA COBOL preprocessor to implement Michael Jackson's program design language, Schematic Logic, has been written and used in the Computation Department at UMIST. This paper investigates the problems inherent in using preprocessors of this type and details the advantages which accrue from the preprocessor when teaching and using the Jackson Method.
The design of an inter‐task communication scheme
Authors: Barnett J. K. R. 
Published: November 2006

AbstractThe paper describes an implemented inter‐task communication scheme, and its design motivation. The scheme provides a well‐defined environment for all situations, including abnormal ones, such as misuse of its facilities. The main design goal is that users of the scheme should be able to verify their communication logic by inspection. Methods are described for reducing the complexity of communication logic to a minimum. The analogy with inter‐CPU communication is discussed.
Infinite power series
Authors: Harrington Steven 
Published: November 2006

AbstractThe creation, manipulation and evaluation of univariate infinite power series is discussed. Unlike truncated power series, which store the first n terms of an expansion, infinite power series create a procedure for calculating a general term, and are thus a formal representation of the entire expansion. No term is calculated until it is actually needed. All results may be saved along with the environment in which they were evaluated in order to prevent repeated calculation. Laurent expansion is used, and expansion in rational powers is allowed to expand expressions containing poles and branch points. The formulas applicable to the manipulation of these extended series forms are presented. The system is implemented in MODE‐REDUCE with infinite power series a new data type, or mode, which allows interfacing with the usual algebraic operators including substitution, differentiation, and integration. A series may also be inverted. Examples of the capabilities and use of the system are presented.
FORALL: An extensible fortran system for conversationally accessing subroutine libraries
Authors: Kerr John D. 
Published: November 2006

AbstractThe implementation of a user‐extensible Fortran system is described. The control syntax, in which all arrays may be referenced by name, is outlined, including language‐like extensions. A summary of the algorithms implemented is tabulated. Facilities for the user to add algorithms to the system are described and the methods of handling arrays outlined. Features to facilitate portability are mentioned.
University computing advisory services: The study of the man—computer interface
Authors: Alty J. L. , Coombs M. J. 
Published: November 2006

AbstractUniversity research workers need to use the computer as a tool. They are not computer professionals and it is not possible for them to effectively exploit computer facilities without advice and guidance. We argue that amongst the various sources of information available in a University, the official Advisory Service of a Computer Centre plays a crucial role in assisting users. Moreover, its relation to other sources of information makes it a valuable ground for studying the general problems of guiding non‐professional computer users. Two groups of variables are isolated: those concerned with user expertise and those concerned with the quality of software. A gross measure of expertise is suggested and shown to generate behavioural questions which will need to be addressed by any theory of computing skill that is broad enough to apply to the design of computer guidance systems. An analysis is made of user queries and suggestions made for the improvement of applications software. A research programme is outlined.
The trio operating system
Authors: Hansen Per Brinch , Fellows Jon 
Published: November 2006

AbstractThis paper is an overview of the Trio system which enables users to simultaneously develop and execute programs at three terminals. The system consists of an operating system written in Concurrent Pascal and a set of standard programs written in Sequential Pascal. The system has been used on a PDP 11/55 minicomputer since spring 1979. This work concludes 5 years of experience with the first abstract language for concurrent programming.
Scanner design
Authors: Dedourek John M. , Gujar Uday G. , McIntyre Marion E. 
Published: November 2006

AbstractThe scanner is a subroutine which is frequently called by an application program like a compiler. The primary function of a scanner is to combine characters from the input stream into recognizable units called tokens. A method has been presented in this paper for designing such a scanner, also frequently referred to as a lexical analyser in the current literature. The major steps involved in this design process are: identification of tokens, construction of a state diagram, building driver tables and finally writing a scanning routine. The rules for generating the driver tables are described and an algorithm for the scanner, utilizing these driver tables, is included. The method has been successfully used to build the system scanner for a user oriented plotting language. It is concluded that the method is well defined, gives rise to a modular design and as such easily lends itself to language extensions.
An experimental study of relative throughput in a multiprocessor computer system
Authors: Sreenivasan K. , Nelson G. A. , Maksin J. A. 
Published: November 2006

AbstractThis paper describes the results of controlled experiments with a Honeywell H6000 series multiprocessor computer system, 212 experiments were performed using 14 test workloads on 8 H6000 configurations. The number of processors varied from 1 to 4, system controller units (SCUs) from 1 to 4, and main memory from 256K to 1024K words. The ratio (P) of I/O time and CPU time for the test workloads varied from 0.01 to 5.07. The improvement in throughput is expressed in terms of relative throughput (φ), defined as the ratio of elapsed time for a given test workload on a single‐processor configuration to that on a multiprocessor configuration. The relative throughput increased monotonically with an increase in the number of processors for test workloads in the range 0<P<0.4 (CPU‐bound) and φ exhibited an asymptotic behaviour for test workloads in the range 0.4<P<5.07 (I/O‐bound).
The evolution of the operating system EMAS 2900
Authors: Stephens P. D. , Yarwood J. K. , Rees D. J. , Shelness N. H. 
Published: November 2006

AbstractAs a result of experiencing problems with manufacturer's software on the early 2900 machines Edinburgh University took the bold step of attempting to move the general purpose timesharing system EMAS from an ICL 4–75 to an ICL 2970 computer. This paper describes the move together with the changes made and includes some preliminary performance figures from the new system. This implementation project has produced a major time‐sharing virtual memory operating system with a fraction of the effort required to implement the original system.
Transportable package software
Authors: Hamlet R. G. , Haralick R. M. 
Published: November 2006

AbstractPackage programs allow people who are not computer experts to use the power of machine computation for specialized purposes. Because the designers of scientific packages are more often experts in their scientific field than in computing, they may ignore issues of transportability and ease‐of‐use until too late, and produce a package that is difficult to use, and difficult to move to a different computer. In this paper we suggest some techniques to aid the scientific package designer.We suggest a kernel of routines that interface to the peculiar operating system of each machine, providing sophisticated but standard operating system services. This kernel makes the operating system of each computer appear identical and does not pose a difficult implementation problem. Above this interface all code can be machine‐independent, without sacrificing power and ease of use on any machine.We also suggest some novel organizations of processing routines designed to make the system easy to alter and extend. Complete independence of modules encourages centralization of tasks, which is both efficient and essential for easy extension. With this organization, the vast preponderance of package code can be written in machine‐independent ANSI FORTRAN. We suggest the use of a preprocessor like RATFOR to make this more pleasant.The paper closes with an application to an image‐processing package, in which a major problem is the flexible sequencing of processing routines.
A case study in rapid prototyping
Authors: Zelkowitz Marvin V. 
Published: November 2006

AbstractA case study in rapid prototyping of a new language processor is described. A quick version of the system was developed in SNOBOL4, revised in SNOBOL4, and then rewritten in Pascal. This led to an operational system very early in the development cycle where operational characteristics of the system could be tested easily. The goals of this experiment as well as some of the results are described.
A graphical pascal extension based on graphical types
Authors: Magnenat‐Thalmann Nadia , Thalmann Daniel 
Published: November 2006

AbstractThe goal of this paper is to present a graphical Pascal extension, named MIRA. This extension gives the user the means of defining and using specific graphical types. A complete vector arithmetic has been developed and a new structured type has been introduced: the figure type. Instructions to create and delete figures are discussed and it is shown how the graphical types can be used as other Pascal types. The implementation is carried out by a portable Pascal preprocessor.
The LTPL‐E tasking proposals
Authors: Kronental M. , Roberts J. W. , Timmesfeld K. H. , Wand I. C. 
Published: November 2006

AbstractThe Long Term Procedural Language Committee of the International Purdue Workshop for the Standardization of Industrial Computer Systems has studied, over a number of years, the design of a programming language suitable for use in industrial real‐time systems. Various parts of a language suitable for this kind of application have been designed during this period. This paper presents the results of part of this work. In particular it describes the tasking facilities that are seen to be necessary in the industrial real‐time environment. The paper concludes with a comparison of the proposed features with those in Ada.
Software cost estimation: Present and future
Authors: Mohanty Siba N. 
Published: November 2006

AbstractThe state‐of‐the‐art in software cost estimation is reviewed. The estimated cost of a software system varies widely with the model used. Some variation in cost estimation is attributable to the anomolies in the cost data base used in developing the model. The other variations, it is claimed are due to the presence or absence of certain ‘qualities’ in the final product. These qualities are measures of ‘goodness’ in design, development, and test‐integration phases of software. To consider quality as a driver of software cost, we have suggested an association between cost and quality and have proposed a way to use quality metrics to estimate software cost.
Forward‐declared procedures parameter‐lists and scope
Authors: Sale A. H. J. 
Published: November 2006

AbstractThis paper examines some issues which relate to the definition of scope in Pascal, and pressures which have been brought to bear on the draft international standard for Pascal for duplicate procedure headings for forward‐declared procedures. The causes for these pressures, and the conceptual integrity of Pascal are discussed. The interfacing nature of parameter lists is examined, and the concept of ‘detergent construct’ introduced, leading to ‘detergent scope rules’.