bluuebunny/crossref_metadata_2025_split huggingface dataset:
Job scheduling in multiprogrammed computer systems
Authors: Schwetman Herbert D. 
Published: November 2006

AbstractThe job‐scheduling function in a multiprogramming computer system plays a key role in the achievement of the performance goals for the system. It is possible and convenient to partition this scheduling function into a priority assignment function and resource assignment function. Implementation of a general purpose resource assignment module permits a large family of scheduling strategies to be implemented via different priority calculation schemes. The implications of this partitioning of the scheduling function are studied by use of a simulation model. A system embodying this approach to job scheduling is discussed as an application of the approach to other types of systems.
Threaded code for laboratory computers
Authors: Phillips J. B. , Burke M. F. , Wilson G. S. 
Published: November 2006

AbstractAn extension of the threaded code technique has been developed. This new development has been used to convert a typical minicomputer into a threaded code machine by the addition of a simple, fast interpreter implemented in microcode. When made directly available to the programmer, the threaded code programming technique is a very convenient and efficient means of structuring programs, particularly in systems where programs are continually being modified.
An effective program development environment for BCPL on a small computer
Authors: Atkinson M. P. , Jordan M. J. 
Published: November 2006

AbstractThe essential components of an effective program development environment are described. These assist in the interactive investigation of program behaviour and accelerate the rate at which programs are modified. The whole system is compact and simple, being designed for use on small machines. It is considered as important to understand how to use these tools as it is to provide them.
SLP: A paged processor for compact lists
Authors: Jordan M. J. 
Published: November 2006

AbstractA list processor, SLP, is presented as a means for manipulating data structures represented as compact lists. The list space is both paged and segmented in order to handle large data structures on a conventional minicomputer. The list processing primitives arc provided as procedure calls embedded in a high‐level language, and the system includes aids for developing user programs. The implementation for a PDP 11/45 computer is presented along with a discussion of the use and performance of the system in practice.
Use and misuse of SPSS
Authors: Leece John , Parker Frank 
Published: November 2006

AbstractThis paper reports a survey of the use of SPSS at a major nationwide university computer centre. SPSS was modified to output a record each time it was used reporting:

who was using the program;
resource consumption;
size of data set;
SPSS commands used;
SPSS syntax errors which occurred;
job status at termination.
We found that SPSS was used 3,000‐4,000 times monthly by a user community from over 30 departments. Resource consumption varied greatly but the majority of jobs are quite small in our terms. Data sets also varied greatly but most were up to 300 cases by up to 20 variables.The majority of users employ a subset of the SPSS command language and attempt only one ‘procedure’ in each run. About 30 per cent of jobs fail due to a user error in the syntax, and we found considerable consistency from month to month in the syntax errors made.Our detailed observations have many implications for the ongoing development of SPSS and its documentation, for the users, and for those who teach or advise in SPSS.
An implementation of structured multiprogramming
Authors: Beaumont W. P. 
Published: November 2006

AbstractThe study of operating systems principles is greatly enhanced if processes can be expressed in language constructs that explicitly allow for multiprogramming. The enhancement is increased if such a system actually exists for practical use. This paper describes an implementation of such a system. The language used (a forerunner of Concurrent Pascal) is described briefly. The body of the paper describes the implementation method in some detail. In order to achieve multiprogramming with a single processor, a number of process descriptors are maintained, each associated with the execution point in the program of a parallel process. Control is distributed among the processes in a manner determined by the program environment. The design of the implementation, in itself, provides an interesting example of operating systems principles at work.
A simplification of code tables in a one‐pass PL/M compiler
Authors: Johnsen Kari 
Published: November 2006

AbstractA two‐dimensional table containing code to be output for one binary operation is replaced by an algorithm and two one‐dimensional tables. This algorithm constructs the entries of the first table only whey they are needed. The algorithm is in fact an implementation of the thought process used in the hand construction of the first table.
A 1900 FORTRAN post mortem dump system
Authors: Ng P. H. , Young G. 
Published: November 2006

AbstractThis paper reports a FORTRAN post mortem dump system (PMD) for the ICL 1900 computers. The system, Jointly implemented by Birmingham and Liverpool Universities, can perform a core/storage dump In terms of the original FORTRAN source following the segment (subroutines, etc.) history of execution when the program falls to terminate successfully. The compilation overheads of the new system are very low and the execution overheads practically none.
Data mappings again
Authors: Hutt Andrew T. F. 
Published: November 2006

AbstractExtracting data from a relational data base in order to respond to a request for information requires the use of a large number of algorithms. Some of these algorithms are responsible for validating data values, others support the relational operators while others still support the basic data structures used at the lowest levels of the system. This paper recognizes that the successful operation of a relational data base management system is dependent on the organization of these algorithms and emphasizes this point by describing a coherent architecture to embrace them.
User‐interface design for text editing: A case study
Authors: Sneeringer James 
Published: November 2006

AbstractThis paper describes the design of the user interface of a text editor named Occam with the goal of communicating by example the process of user‐interface design. An attempt is made to induce principles; where that attempt falls, the raw details are presented. First Occam Itself Is described, and then aspects of its user Interface are used to exemplify (1) power versus ease of learning, (2) the use of prototypes and user feedback, (3) the importance of planning and (4) error detection and handling.
Use of a formal notation for static semantics in compiler design
Authors: Williams M. H. , Bulmer A. R. 
Published: November 2006

AbstractFormal notations for the specification of the syntax and the dynamic semantics of languages exist and are of great benefit to the compiler writer. However, formal notations for the static semantics of languages have tended to be tools of the language designer and of little practical significance to the compiler writer. This paper describes how a particular notation was used to assist in the implementation of a Cobol compiler and of an interpreter for a simulation language.
Experience with the universal intermediate language janus
Authors: Haddon B. K. , Waite W. M. 
Published: November 2006

AbstractJanus is a symbolic language intended for use as an intermediate language in the transportation of software. Since its initial design four years ago, it has been used to implement a portable Pascal compiler, in the design of an Algol 68 compiler, and to realize a portable package of mathematical routines. These experiences, together with a critical re‐evaluation of the design criteria, have led to some modification of the specifications of Janus and an increased confidence in the viability of the approach. They have also indicated some problems yet to be solved. This paper reviews the significant lessons which we have learned, and quotes some results which support our confidence.
Experience with the pascal P‐compiler
Authors: Berry R. E. 
Published: November 2006

AbstractThe paper seeks to document the experience of a small group interested in implementing and using Pascal on a modest but perhaps typical minicomputer. The implementation was achieved by transporting the intermediate code produced by a CDC 7600 version of the Pascal P‐compiler to the minicomputer and producing an assembler and interpreter to execute this code on the mini. Some aspects of the performance of the resulting system are reported.
Reproducible testing of monitors
Authors: Hansen Per Erinch 
Published: November 2006

AbstractThis paper describes a systematic method for testing monitor modules which control process interactions in concurrent programs. A monitor is tested by executing a concurrent program in which the processes are synchronized by a clock to make the sequence of interactions reproducible. The method separates the construction and implementation of test cases and makes the analysis of a concurrent experiment similar to the analysis of a sequential program. The implementation of a test program is almost mechanical. The method, which is illustrated by an example, has been successfully used to test a multicomputer network program written in Concurrent Pascal.
A support system for interactive languages
Authors: Parsons I. T. 
Published: November 2006

AbstractThe implementation of a support system for interactive languages is described, which include a controlling routine, a macro processor, lexical and syntactic analysis routines, semantic actions, error handling and analysis, log and code generation routines. There are also utility programs for generating the state tables for the syntax analysis.By using a structured programming approach these routines have been developed very quickly, but can still be developed and enhanced due to a well‐defined working environment, a simple approach to coding and reasonable internal documentation.
Computer programming and the human thought process
Authors: Tracz William J. 
Published: November 2006

AbstractThis paper analyses certain human thought processes associated with computer programming and observes some limitations, inherent in the human mind, that affect the writing of good computer programs.The thought processes associated with computer programming fall into two major categories: those associated with the nature of problem solving; and those associated with man/computer communication using conventional programming languages.The questions raised in this paper bring to light the psychological and physiological implications of such programming tools and procedures as structured programming, code walkthroughs and top‐down design in support of their use.
Public online pool—a method for managing online direct access space
Authors: Spitz Eli , Yuval Asher 
Published: November 2006

AbstractThis paper describes a software system, implemented at the Weizmann Institute of Science Computer Center, for managing online direct access space in a heavy batch/time sharing environment. Appropriate background discussion of the problem is presented in general, yet practical, terms. We describe the ‘ideal’ solution along with its shortcomings as we see them, followed by the solution as implemented at our installation and successfully operating for 5 years. Finally, we point out the effect this system had on our installation and show where future efforts could be rewarding. The work this paper describes won the 1975 prize of the Information Processing Association of Israel.
A compiler model for a relational data base management system
Authors: Hutt Andrew T. F. 
Published: November 2006

AbstractOne of the chief difficulties which needs to be overcome during the early design stages of a system is that of establishing a satisfactory design for that system. From the time it was first conceived it was apparent that the Relational Data Base Management System is like a compiler in so far as it takes a succession of user requests for information formulated in an applied predicate calculus and translates each one into a series of calls which access an underlying data base and transform data from that data base into the form the user wishes to see.This paper compares the architecture of the Relational Data Base Management System with that of a compiler, and then demonstrates the use of the architecture when processing a language based on an applied predicate calculus. Finally, the paper describes a number of extensions to that architecture which are required to solve the particular problems raised by the data base system.
Parallel processing in an adaptable application oriented language processor
Authors: Ellis T. M. R. 
Published: November 2006

AbstractA framework for an application‐oriented language processor is described which is based on a series of independent modules operating in parallel. All intermodule communication is handled by means of monitor procedures. The way in which this allows modules to be added or removed at will is discussed, and the implications of this approach for adaptable processors are described, with particular reference to the numerical control of machine tools.
Microcomputer comparison
Authors: Hansen Per Brinch , Hayden Charles 
Published: November 2006

AbstractThis paper illustrates a precise method for comparing microcomputer instruction sets for the purpose of language implementation. The standard of comparison is the Concurrent Pascal interpreter for the PDP 11/45 minicomputer. The paper identifies the most frequent virtual instructions and their implementation on the PDP 11/45 computer. It then compares the speed and size of interpreters implemented on various 16‐bit microcomputers. It also includes the process switching times of these computers.
Long/short address optimization in assemblers
Authors: Williams M. H. 
Published: November 2006

AbstractIn a number of computer systems an instruction in symbolic assembly language may be translated as either a long form or a short form instruction in machine code depending on certain conditions. Assemblers which optimize the size of a program by using short form instructions wherever possible, sometimes require three or more passes to achieve this. This paper describes an approach to solving this type of problem which can be implemented in a two‐pass or even a one‐pass assembler.
Make — a program for maintaining computer programs
Authors: Feldman Stuart I. 
Published: November 2006

AbstractGood programmers break their projects into a number of pieces, each to be processed or compiled by a different chain of programs. After a set of changes is made, the series of actions that must be taken can be quite complex, and costly errors are frequently made. This paper describes a program that can keep track of the relationships between parts of a program, and issue the commands needed to make the parts consistent after changes are made. Make has been in use on UNIXUNIX is a trademark of Bell Laboratories.
systems since 1975. The underlying idea is quite simple and can be adapted to many other environments.
A highly‐structured interpreter for a SNOBOL4 subset
Authors: Pagan Frank G. 
Published: November 2006

AbstractA highly‐structured and conceptually simple processor, written in Algol 68, for a basic but useful subset of SNOBOL4 is presented. It provides a significant, large‐scale demonstration of a particular methodology for constructing ‘master’, machine‐independent implementations of programming languages. The processor is closely related to a formal operational definition of the SNOBOL4 subset in that it incorporates an abstract machine, a high‐level abstract syntax (in the form of mutually recursive mode definitions) for the internal form of programs, and a set of mutually recursive interpretation procedures for programs in this internal form. The various aspects of the processor are documented in some detail. The experience of testing the processor is briefly discussed.
Design of software for text composition
Authors: Mudur S. P. , Narwekar A. W. , Moitra Abha 
Published: November 2006

AbstractText composition software is mainly used by compositors, who are usually not programmers, and who do not necessarily know much about the underlying technicalities of computer usage. It is important, therefore, that the text composition system be such that a compositor would have a minimum amount of learning to do. Factors such as flexibility of style specification and economical proof generation are important from a user's point of view. On the other hand, multilingual text input, output device independence and system portability are points of concern for the system designer. In this paper, a specific text composition software system designed on the basis of such considerations is briefly described. The way in which the above‐mentioned factors affect the design of the system is discussed in some detail.
Design and analysis of a hyphenation procedure
Authors: Moitra Abha , Mudur S. P. , Narwekar A. W. 
Published: November 2006

AbstractA hyphenation procedure is described wherein the search list includes exceptional words, prefixes, suffixes as well as a probabilistic Break‐Value‐Table. The list of prefixes and suffixes is augmented with what are termed as root words to achieve greater flexibility and accuracy. Importance is given to a number of ways whereby the overall algorithm can be speeded up; in this connection a number of rejection rules are formulated so that only the likely candidates are processed. The order of searching of the various data tables is also considered. A further refinement is tried wherein the common suffixes and common prefixes are given preferential treatment. The algorithm developed was tested on approximately 2,700 common English technical words and an attempt is made to analyse the incorrectly handled words.
A draft description of Pascal
Authors: Addyman A. M. , Brewer R. , Burnett‐Hall D. G. , de Morgan R. M. , Findlay W. , Jackson M. I. , Joslin D. A. , Rees M. J. , Watt D. A. , Welsh J. , Wichmann B. A. 
Published: November 2006

AbstractThis paper provides a description of the programming language Pascal. It has been published to enable those without easy access to the official BSI ‘draft for comment’ to comment on the description.
A useful data‐structuring technique
Authors: Ellis T. M. R. 
Published: November 2006

AbstractA data‐structuring technique is described which enables data of widely varying types to be stored in a simple tree structure, and which requires only the name of a variable for both its type and value to be retrieved. The method uses well‐established list‐processing concepts in an unusual environment and illustrates the advantages to be gained by their use in application‐oriented software. It has been used with some success in a modular processor for the storage of geometric and other data but is equally applicable to other fields.
Lattice structure segmentation of ALGOL‐like programs
Authors: Kawai Satoru 
Published: November 2006

AbstractA segmentation scheme for ALGOL‐like programs is presented. This scheme, based on the separate compilation facility of the language ALGOL 68C, enables the programmers to use a branch‐and‐merge (lattice) structure in segmenting their programs, besides the tree which is the only one structure usable in ALGOL 68C programming. The necessity of this scheme is explained and the way of its implementation is described. The effectiveness of this scheme compared with tree structure segmentation is shown in terms of the recompilation cost of an example program of reasonably large size which has been resegmented from the tree to the lattice structure with no addition or duplication of codes.
TRIPOS—a portable operating system for mini‐computers
Authors: Richards M. , Aylward A. R. , Bond P. , Evans R. D. , Knight B. J. 
Published: November 2006

AbstractThere are several successful operating systems for mini‐computers written in high level languages and the time is now ripe for the development of portable systems for such machines. The system described in this paper is primarily designed to provide a friendly interactive multiprocessing environment for a single user. From his point of view, substantial parts of the system are completely machine independent. These include, for instance, the filing system, the command language, text editors, overlaying facilities and interprocess communication primitives. The system is suitable for many different application areas ranging over process control, data acquisition, data communication, text handling, data base systems and teaching.
Implementing data abstraction features in a stack‐based language
Authors: Gannon J. D. , Rosenberg J. 
Published: November 2006

AbstractThis paper describes SIMPL‐D, a stack‐based language with data abstraction features, and some of the details of its implementation. The language allows users to define new types that are parameterized by size and to perform system‐defined operations (e.g. assignment) on objects with user‐defined types. The use of object‐describing templates in the implementation of storage allocation, assignment and returning values from functions is discussed. Finally, the conflicts between automatic initialization and separate compilation are explained.
Choosing a tag‐list algorithm for a compiler with special application to the ALEPH compiler
Authors: Grune Dick 
Published: November 2006

AbstractRequirements are formulated for a tag‐list algorithm, i.e. the algorithm used in a compiler for handling the symbol table or identifier list. Starting from a very general tag‐list algorithm, 18 practical versions are developed and their merits judged. Although the final choice (binary search in a diluted table) depends on the details of the application, the main part of this article is not devoted to that final choice itself but rather to ways of reaching it.
The portable compiling systems of MUSS
Authors: Barringer H. , Capon P. C. , Phillips R. 
Published: November 2006

AbstractPortability of MUSS compilers is achieved by using an abstract machine model concept. Two different abstract models, both suited for multi‐language multi‐machine usage, have been developed and evaluated. These models differ mainly in the level of interface to the compiler. The form of these models and the performance of two compilers, each using both models, are presented.
Experiences with the UNIX time‐sharing system
Authors: Lions John 
Published: November 2006

AbstractThe UNIXUNIX is a trademark of Bell Laboratories.
Time‐sharing System has been in use at the University of New South Wales since 1975, and favourable experience has led to its widespread adoption on campus for both teaching and research. It has proved very adaptable to the university's needs, and very usable in a situation where staffing levels are critically low. One important application area, the teaching of Computer Science, is now firmly based upon the use of the UNIX system.
On publication Pascal
Authors: Bishop Judy M. 
Published: November 2006

AbstractHaving recently read several new Pascal textbooks, I was struck by the multitude of ways in which programs are represented in print. Some of these are more pleasing to the eye than others, and with a typesetting machine, anything is possible. However, several books are being produced these days from typewritten copy and there seems to be no accepted second‐best to the italics‐and‐bold favoured by most publishers. It would also be desirable if the style used by books could correspond more closely to that which is handwritten or computer‐produced. This note summarizes the possibilities and makes a call for stability, if not outright standardization.