bluuebunny/crossref_metadata_2025_split huggingface dataset:
On the performance of COBOL programs in large vs. mini computers
Authors: Jalics Paul J. 
Published: November 2006

AbstractThe comparative performance characteristics of COBOL programs in a small versus large computer systems are investigated. The vehicle consists of a set of synthetic benchmark COBOL programs, each measuring a particular aspect of COBOL computations, data manipulation, and input/output is made on both a large scale computer (IBM 370/158) and a minicomputer (Texas Instruments TI980). Results of a number of such experiments are presented and comparisons made between results obtained from the two systems.
An assessment of a new technique for the representation of boolean matrices
Authors: Dodd W. P. 
Published: November 2006

AbstractA general‐purpose method, based on a sparse matrix approach, is proposed for the representation of boolean matrices, and algorithms are presented both for representation formation and element access. The method is then compared with the bit‐map approach using the criteria of storage requirements, element access time, and execution time for logical operations on the whole matrix. Finally the conditions are discussed under which the proposed method may be profitably used in preference to the bit‐map approach.
Software segmented virtual memory
Authors: Baxter Anthony Q. , Hart Johnson M. 
Published: November 2006

AbstractThe techniques of paged virtual memory, commonly employed only in large operating systems, can be provided at the software level by a small collection of primitive procedures. This paper defines the primitives and their implementation. The techniques of applying software virtual memory are also discussed, and these techniques are useful for compilers, database systems, and other applications in which large amounts of random access memory are required. Other benefits of using software virtual memory are transportability, modularity in program design, implementation on mini and microcomputers, and improved speed performance over alternative approaches.
A contextual analysis of Pascal programs
Authors: Cook Robert P. , Lee Insup 
Published: November 2006

AbstractMore than 120,000 lines of Pascal programs, written by graduate students and faculty members, have been statically analysed to provide a better understanding of how the language is ‘really’ used. The analysis was done within twelve distinct contexts to discover differences in usage patterns among the various contexts. For example, it was found that 47 per cent of the operands in arguments lists were constants. The results are displayed as tables of frequency counts which show how often each construct is used within a context. Also, we have compared our findings to the results from studies of other languages, such as FORTRAN, SAL and XPL.
Pointer variables in concurrent Pascal
Authors: Ravn A. P. 
Published: November 2006

AbstractConcurrent Pascal and similar languages are inefficient when used to program systems where processes exchange large messages. The inefficiencies, caused by copying of data, can be removed by introducing pointer variables, and this paper shows how this is done without allowing unrestricted sharing of variables. Pointer variables also give means to solve problems of dynamic resource allocation and dynamic addressing. Examples with performance figures for an actual implementation are given.
A programmable text editor
Authors: Fraser Christopher W. 
Published: November 2006

AbstractWhile operating system command languages have improved in recent years, the advances have not yet been widely applied to other command interpreters. This paper describes an editor that has been given two features popular in operating system command languages — i/o redirection and programmable command files. The result is suited both to editing and to some repetitive reformatting tasks often solved by one‐shot, ad hoc programs. Examples display the utility of the extensions, and implications for still other command interpreters are discussed.
A tool to aid in the installation of complex software systems
Authors: Griswold Ralph E. 
Published: November 2006

AbstractThis paper describes a programming language, SIDL, in which various aspects of software installation can be modeled. SIDL supports hierarchical file systems, computers, and processes for executing programs to produce new programs and data. An example, illustrating the installation of Ratfor, and experience with the use of SIDL for describing the installation of a large software system are included.
Description of a menu creation and interpretation system
Authors: Heffler Michael 
Published: November 2006

AbstractThe Menu Creation and Interpretation System (MCIS) is a menu system development tool that can provide the high‐level control structure and the user interface for any application program or software system. MCIS simplifies the task of building menu‐driven systems while presenting a user interface that is easily learned and easy to use.Human factors considerations have been stressed in the system design. A user is able to jump from one menu to another, obtain help whenever it is needed, and easily recover from errors. Menu systems created with MCIS are extensible and easily modified, enabling them to meet changing user needs. In addition, through the specification of user profiles, menu systems can be customized to meet the needs of individual users.MCIS is written in the C programming language under the UNIXUnix is a trademark of Bell Laboratories.
operating system. It can be used in any environment that includes a C compiler and the UNIX standard I/O library.
Extending the power of Pascal's external procedure mechanism
Authors: Tsin Yung H. 
Published: November 2006

AbstractThe CDC Pascal 6000–3.4 compiler allows external procedures to be designed and compiled separately. Such a mechanism strongly enhances the extensibility of the language. However, the external procedures are restricted to having ‘fixed’ parameter list only and is therefore unsuitable for designing I/O routines. This paper describes a cheap way to release the restriction thereby extending the power of the external procedure mechanism significantly. The method is to include a new compiler option, called the Z option, to the existing Pascal compiler. The Z option allows a user to breach the strong binding between format and actual parameters while not diminishing program reliability. The main advantage is that the I/O system can now be isolated from the compiler. I/O features can be added and removed easily as with other library routines.
Meta: A language system for bitslice applications
Authors: Witsel Willem Maarten 
Published: November 2006

AbstractBitslice technology is a widely used method for building microprogrammable bitslice processors. Manufacturer supplied language tools required for the production of the microcode, however, are usually too expensive. The Meta system, described in this paper, provides the necessary language facilities at minimal cost, making it ideal for small bitslice projects.The concept of the Meta system is very simple: a description of the datapath structure and the information processing capabilities of the bitslice processor is written using the four basic operations of the Meta language. Meta uses this description to generate a translator for machine‐oriented microprogramming language. This offers the programmer a tool for implementing microprogrammed functions.Because of the simplicity of the Meta system, language translators can be built in a very short period of time.
The software engineering of a microcomputer application system
Authors: Gomaa H. , Lui J. , Woo P. 
Published: November 2006

AbstractA system development methodology is outlined before describing its application to the development of a microcomputer system. Structured analysis techniques were used for determining the information flow through the system. The system was then structured into modules using structured design and information hiding techniques. The detailed design of the system was described in pseudocode. The system was coded in assembler supplemented by a set of structured programming macros. A systematic bottom‐up testing procedure was adopted for system integration.
The STAB multiprocessing environment for CYBA‐M
Authors: Artym Richard 
Published: November 2006

AbstractMulti‐Thread STAB is an implementation of the notional STAB stack machine1,2 on the CYBA‐M multi‐microprocessor.3–5 Designed expressly for the study of synchronization and performance issues within multiprocessing, the MTS system comprises a highly interactive user interface and multiple program‐gated clocks which, respectively, control and monitor the execution of a STAB kernel. This provides a flexible high‐level environment within which multiple processor STAB programs may be run and analysed in terms of effective concurrency, sequential flow of control and interprocessor synchronization.The MTS kernel is a re‐entrant STAB interpreter which can simultaneously support any number of 8080 processors, thereby implementing a notional STAB multiprocessor. The STAB processors communicate by access to common global data structures, and primitive binary semaphore operations are available to provide both simple and conditional mutual exclusion in critical regions. Any of the proposed schemes for controlled process interaction6–10 may be implemented on the basis of these fundamental means for communication and synchronization. This provides a useful framework within which general high level multiprocessing control structures may be investigated, and also allows special structures to be created for optimized harnessing of concurrency in specific areas of applications research.
Two examples of block structuring
Authors: Tennent R. D. 
Published: November 2006

AbstractThis article defends the concept of block structure using two examples that have previously been discussed in a recent article by D. R. Hanson and in textbooks by Wirth and Brinch Hansen. It is shown that effective use of block structuring makes it possible to combine the advantages of the nested versions in the textbooks and Hanson's linear versions, calling into question the disadvantages attributed to the block structure concept by these and other authors.
Specifications: Formal and informal—a case study
Authors: Gehani Narain 
Published: November 2006

AbstractFormal specifications (algebraic) are given for an informally specified small subsystem of the Change Management Automatic Build System. A comparison of the two specifications shows that although informal specifications are easier to read, the formal specifications are clearer, specify operation domains precisely, define the interaction between the operations, show the incompleteness of the informal specifications and are devoid of implementation details. The formal specifications pointed to the need of a function not in the subsystem whose inclusion would improve the system design. This inclusion is now being considered. However, the use of algebraic specifications requires practice and experience. Although the formal specification of large systems is somewhat impractical at the moment, experience in using formal specifications can lead to better informal specifications.
A multi‐user operating system for transaction processing, written in Concurrent Pascal
Authors: Kruijer H. S. M. 
Published: November 2006

AbstractThis paper presents a medium‐sized operating system written in Concurrent Pascal, thereby describing further experience with this language and giving further indications of its scope. The operating system was developed to support an application in the area that is usually termed ‘commercial’ or ‘administrative’. Both the functional capabilities and the structure of the operating system are described, with emphasis on its facilities for data file management, and its size and performance are given. A secondary theme of the paper is the relationship of the operating system's qualities to the properties and facilities of the programming language Concurrent Pascal used for its development.
Designing structured cobol programs
Authors: Ferstl O. K. , Sinz E. J. 
Published: November 2006

AbstractCOBOL is now more than 20 years old and will probably survive to become much older. Since it has some features which are out of date it is desirable to adapt at least the program style to some standards of modern programming languages. The adaption is not only a matter of style but also of costs of program production and program maintenance. This paper presents constructional rules for programming in COBOL which by‐pass some of the drawbacks and allow more readable and more maintainable program structures. Finally a postprocessor is presented, that allows verification of the chosen constructional rules and documentation of the resulting programs.
A test data synthesizer for telephone company accounting office processing of call data
Authors: Covington W. O. , Wexelblat R. L. 
Published: November 2006

AbstractTesting a program designed to recognize several dozen kinds of anomalies in large volumes of input data requires test data with many combinations of the anomalies in the data stream. The large number of combinations of anomalies makes it impractical to generate test data manually. This paper describes a test data synthesizer designed to help verify the accuracy, capacity and correctness of such a program. The operation of the synthesizer is analogous to the Fourier synthesis of a periodic function. A sweep action permits test data with well known response to be combined in a methodical way to explore complicated interactions which are not well understood.
Experiences in benchmarking for the selection of an interactive system
Authors: Lang T. , Newbury J. P. , Watkins D. E. P. 
Published: November 2006

AbstractThe paper describes how a benchmark was constructed to assist in the selection of a general purpose interactive computing system. Because no existing user programs were available, a ‘synthetic’ program was constructed to load the different parts of the system, and the program embodied into a job script with edit, compile and run phases. The calculation of the program and job parameters were successfully derived from the operational requirements. The problems of running the benchmark and analysing the results are also described. The results of the exercise contributed significantly to obtaining a satisfactory system and show a reasonable correlation with subsequent system usage.
An adaptive system for dynamic storage allocation
Authors: Leverett Bruce W. , Hibbard Peter G. 
Published: November 2006

AbstractWe describe a technique (the adaptive creation of free lists) for dynamic storage allocation that is particularly suited to situations in which the distribution of sizes of blocks requested has one or more sharp peaks. We describe a particular dynamic storage allocation system and the environment in which it runs, and give the results of some experiments to determine the usefulness of the technique in this system. Our experiments also tested the efficacy of a technique suggested by Knuth for improving the performance of similar systems.
Modelling and validating the man‐machine interface
Authors: Casey Bernice E. , Dasarathy B. 
Published: November 2006

AbstractThis paper describes a formal model for expressing the functional requirements of the man‐machine interfaces of interactive systems. It also shows how this model can facilitate the automation of other useful activities such as checking for inconsistency, redundancy, and incompleteness in the specification, and validating the implementation of the interface against its original requirements. Finally, the paper comments on the authors' experience in developing an interactive system using this formal model.
The Cambridge ring and Unix
Authors: Collinson R. P. A. 
Published: November 2006

AbstractIn March 1980, a VAX 11/780VAX is a trademark of Digital Equipment Corp.
was installed at the Computing Laboratory of the University of Kent. The VAX runs UNIX as a user service. This paper discusses what has been learnt from the integration of an existing operating system (UNIX) into a local area network based on the Cambridge ring. The approach which has been evolved attempts to make the network connections invisible to the operating system so that the utilities running on the system can access the network as if they were talking to standard peripherals. The paper gives an overview of the ring and the protocols in use at Kent; and points to alternative approaches to the implementation which could be used in a different environment.
Introduction of history to variables
Authors: Takaoka Tadao , Maclean Michael , McKenzie Bruce 
Published: November 2006

AbstractThe concept of history is introduced to the variables of a programming language. At each execution of assignment statement for a variable x, the current value of x is saved to x〈1〉, that of x〈1〉 to x〈2〉 and so on automatically. With the aid of this facility, a programmer will not worry about bookkeeping of saving the content of a variable and will make fewer errors in programming. A possible implementation method for the history on a conventional computer is also discussed.
HADES—A command environment that supports structure
Authors: Wilkes John 
Published: November 2006

AbstractHADES is a command program designed to aid programmers and authors involved in writing systems with an inherently high degree of structuring. It presents the system being developed in a hierarchical fashion, encouraging a top down approach to its design, and alleviates many of the problems experienced with traditional filing systems. Unlike other programming environment systems, the utility programs and tools do not have to be ‘integrated’ into the system, which means that new and existing tools can be quickly and easily added. This results in a rich set of operations implemented at very low cost.The paper outlines some of the problems that arise with traditional filing systems from the point of view of software development, and then presents the approach adopted by HADES. This is followed by a discussion of the strengths and weaknesses of the result and some reflections on the lessons that have been learnt.
A dialogue generator
Authors: Kaiser Pavel , Stetina Ivan 
Published: November 2006

AbstractThis paper describes work done on the Dialogue Generator, DIAGEN, at the Computing Research Centre in Bratiplava. The general aim of this work was to design and implement a generalized software tool for creating an interactive interface which would permit the non‐programmer to work directly with the computer in various application areas.The Dialogue Generator, DIAGEN, separating completely the dialogue from the application program that is to be dialogue‐driven has been implemented. A specialized DIAGEN Language is used for the dialogue description in the form of a scenario. The DIAGEN Conversational System interprets the dialogue program generated from the scenario, and controls the flow of a dialogue session.
A microprogrammed P‐CODE interpreter for the data general eclipse S/130 minicomputer
Authors: Hall J. A. 
Published: November 2006

AbstractThis paper describes the implementation of a P‐CODE interpreter by microprogramming. An existing system based upon the Pascal P compiler was modified by rewriting the interpreter in microcode. Consequent improvements in the system performance are illustrated by times for compiling the compiler and various small Pascal programs. The execution rate for the new system is also compared with several other languages available on the Eclipse. Problems relating to Eclipse microcode when used for tasks of this type are also discussed.
Low cost computer graphics for micro computers
Authors: Morrison Ronald 
Published: November 2006

AbstractA graphical output system small enough to fit on a medium range micro computer is described. The system, called Outline, allows the user to produce line drawings in an infinite two dimensional space. It also offers a picture building facility in which the relationship between different sub‐pictures is specified by mathematical transformations. A basic set of picture manipulating facilities along with a set of physical drawing attributes for each device is defined. The system is embedded in a high level language for simplicity of use.
Computer system simulation in Pascal
Authors: Haá Anna 
Published: November 2006

AbstractThe programming language Pascal is considered as one of the most interesting computer system simulation tools. This paper discusses design facilities required in simulation languages, making use of a model described in Pascal. An important area is seen to be that of queues, lists or sets, and the facilities that are powerful yet simple to use are stressed. The problem of parallelism and synchronization in a simulator is solved. The structure of the simulator is considered.
How to improve computer advisory services
Authors: Dawson A. F. , Coombs M. J. , Alty J. L. 
Published: November 2006

AbstractThere are an increasing number of active computer users who are not computer professionals and so require continuous guidance in order to effectively employ computer facilities. In universities such guidance is provided by a formal advisory service. While advisory services play a vital role for university users, there are numerous problems which can detract from their effectiveness. This paper identifies many of these problems, and recommends ways of overcoming them. These suggestions are largely based on the results of a research project carried out for the past four years at the University of Liverpool. Topics considered are: (i) the assessment of various methods for organizing advisory services; (ii) the specific needs of inexpert users and strategies for effectively advising them; (iii) problems of the comprehension of computing information; (iv) guidelines for good advisory communication; (v) methods for improving the professional status of the advisory function.
Compilation of the Pascal case statement
Authors: Hennessy John L. , Mendelsohn Noah 
Published: November 2006

AbstractPascal case statements can be compiled using a variety of methods, including comparison trees and branch tables. The scheme discussed here combines the two techniques to allow comparison trees with entries that are branch tables. The use of a combination of the two techniques is shown to adapt well to certain instances of case statements. Extensions to the standard case statement also require such a scheme to obtain an efficient implementation.
User acceptance: Design considerations for a program generator
Authors: Mathewson S. C. 
Published: November 2006

AbstractThe paper discusses those features in a program generator, a simulation program preprocessor, which are significant in the context of providing an effective interface with a user of the package. Discussion identifies two different roles for a generator: (1) to teach simulation languages and (2) to assist in the construction and use of a simulation model as a problem solving tool. In the context of the first role emphasis is placed upon both input design and upon the relationship between output and published texts. In the second role, discussion centres upon the need for a careful consideration of the related teaching techniques. DRAFT/SIMSCRIPT 11.5 is used to illustrate the discussion.