bluuebunny/crossref_metadata_2025_split huggingface dataset:
A survey of systems programming languages: Concepts and facilities
Authors: Appelbe William F. , Hansen Klaus 
Published: November 2006

AbstractIn recent years, high‐level programming languages have evolved specifically for systems programming. In this paper, systems programming languages are surveyed to find common characteristics and individual differences and limitations of a number of current languages, including Ada, Concurrent Pascal, CLU, Pascal‐Plus, Modula‐2, Mesa, Edison, PLZ/SYS and C. The survey is based on the following classification of systems programming concepts and facilities: types, sequential control, concurrency, encapsulation, environment specifications and programming support environments.
A flexible software character generator
Authors: Gujar Uday G. , So Frank W. L. 
Published: November 2006

AbstractThis paper describes a general and flexible character generator which is capable of producing virtually an unlimited number of character founts. To demonstrate this flexibility, eight different founts, ranging from Roman letters and symbols, double line letters, APL characters etc. to a Devanagari script have been generated. These founts have been chosen to see how characters with wide ranging requirements can be generated.Each of the founts can be manipulated in a variety of different ways. The user can display a desired character string, with specified height and width, anywhere on the display device with any inclination, each character in the string having a desired orientation. Moreover, various other transformations, such as stretch, fall and skew, can be applied to the string. Mathematical formulae for all the transformations are included. The system is described both from the user's as well as system programmer's point of view.Several examples illustrating the ease of use and the flexibility of the system are given.
Portable real‐time software for 8‐bit microprocessors
Authors: Saxena S. , Field J. A. 
Published: November 2006

AbstractThis paper discusses a method for developing efficient and portable software for 8‐bit microprocessors used in real‐time applications. The technique used is to design an ‘intermediate level language’ (ILL) which defines low‐level primitives to support the real‐time application programming and the constructs of high level languages. Thus, the high level language (HLL) program goes through two stages of translation; first to the ILL code and then to the machine code of a microprocessor. The ILL instruction set developed bridges the gap between high level languages and the poor instruction set of microprocessors. This allows the development of optimized and portable code for the microprocessors. The ILL operations, data types, data organization, control structures, synchronization, communication and multi‐tasking facilities are described. The effectiveness of this technique is shown by comparing the code generated by the ILL approach with the code available for a sample real‐time application written directly in assembly level language.
Developing ada programs using the vienna development method (VDM)
Authors: Jackson M. I. 
Published: November 2006

AbstractA method is presented for the systematic development of sequential Ada programs using the Vienna Development Method (VDM). The approach is based upon using the facilities of Ada for supporting parameterized abstract data types to implement the primitives of the VDM specification language. More experimental work is required to assess the utility of the method, but a systematic approach is promised for using features of Ada unfamiliar to most programmers (e.g. packages, generics and exceptions).Familiarity with Ada is assumed. An overview of VDM is presented so that unfamiliar readers can understand the example given in the paper.
Writing portable fortran programs for microcomputers
Authors: Onibere E. A. 
Published: November 2006

AbstractThis paper is concerned with choosing a subset of FORTRAN which will make it possible to write portable programs on medium‐sized microcomputers.To achieve this, some restrictions are placed on ANSI 1966 Standard FORTRAN after studying and analysing a collection of FORTRAN manuals for medium‐sized microcomputers. Some assumptions are made concerning machine dependent constants after a careful observation. By combining these restrictions with those made in compatible Fortran1 and making use of the assumptions, portable programs can be written.
Foam: A two‐level approach to text formatting on a microcomputer system
Authors: Ganzinger Harald , Willmertinger Walter 
Published: November 2006

AbstractThis paper describes the design and implementation of the FOAM text formatting system. FOAM runs on an 8085 microprocessor system under CP/M and produces output on Diablo printers. The main feature of the system is that it supports two levels of formatting. On a meta level, the system accepts descriptions of text and document classes together with formatting styles for text components. From the description, a specific instance of a formatter is generated. This formatter, then, on the text level accepts the input of a text of the described class and produces a formatted document as specified by the formatting styles.
Network management in a local computer network
Authors: Nakamura Tomoo , Ikeda Katsuo , Ebihara Yoshihiko , Nishikawa Masafumi 
Published: November 2006

AbstractThe functions and structure of the network management subsystem of the GAMMA‐NET, a local computer network at the University of Tsukuba, are presented. The network management subsystem is an integrated subsystem that offers a convenient man‐machine interface for the network users during the execution of required jobs, and levels the workload throughout the system, as well as managing the network operations.
Run‐time diagnostics in pascal
Authors: White N. H. , Bennett K. H. 
Published: November 2006

AbstractA compiler maps abstract data and control structures into equivalent representations at the order code level of a computer. When a program written in a high level language fails, there is presented the problem of interpreting the state of the abstract (high level) machine in terms of the state of the physical machine which is all that is available. This interpretation is undertaken by a program usually known as a run‐time diagnostics package. In this paper a novel package is described which provides diagnostics for dynamically created data structures in addition to the usual facilities. It has been implemented for the language Pascal and has been used successfully for 18 months.
Newlong: A program for manipulation of data on populations of individuals subject to change
Authors: Carter B. S. 
Published: November 2006

AbstractIn longitudinal studies subjects are measured from time to time at examinations. The subjects have some data, such as birth date, which do not change between the examination occasions. The bulk of the data are values, of variables such as height, which are taken at the examinations. The essence of these longitudinal studies is found in the change from one exam to the next. A program is described which will derive values from this type of data structure and produce summary statistics. Values can be sent to BCD files for printing or further analysis.
A low‐cost implementation of coroutines for C
Authors: Bailes Paul A. 
Published: November 2006

AbstractWe identify a set of primitive operations supporting coroutines, and demonstrate their usefulness. We then address their implementation in C according to a set of criteria aimed at maintaining simplicity, and achieve a satisfactory compromise between it and effectiveness. Our package for the PDP‐11 under UNIX† allows users of coroutines in C programs to gain access to the primitives via an included definitions file and an object library; no penalty is imposed upon non‐coroutine users.
Topic libraries for mathematical computation
Authors: Cox M. G. 
Published: November 2006

AbstractThis paper describes software engineering aspects and the scope of three subroutine libraries developed at the U.K. National Physical Laboratory (NPL). The libraries are concerned with three important fields of mathematical computation: data approximation, linear algebra and optimization. A portable subset of Fortran was used in the construction of these libraries, which have a highly modular structure and are supported by full user documentation.Reference is made to Microtext, an NPL software product for displaying structured information. Its value in respect of the subroutine libraries lies in its ability to assist the user in selecting appropriate subroutines for the solution of his problem.
Software for an air pollution measuring system: An application of modula
Authors: Dubery J. M. , Pinches A. J. 
Published: November 2006

AbstractThe program for a small embedded computer system has been implemented in Modula. The execution speed of this program was particularly important and the speed achieved was adequate. Some parts of this program are described using a notation derived from the Mascot approach. The use of the Mascot notation with a module‐structured language is discussed and some suggestions for an appropriate style are made. Some simple optimizations of the program were made in order to achieve increased execution speed and it was observed that the final program ran at about twenty times the rate of an equivalent Fortran program. Some points on the suitability of Modula are briefly discussed and, in a similar way to previous authors, it is concluded that Modula is suitable for applications of this type.
Analysis and design for a standard transport protocol
Authors: Garratt P. W. , Michaelson G. G. 
Published: November 2006

AbstractIn the development of computer networks, the trend towards open systems interconnection is creating the need for standard protocols. The transport level protocols published by ECMA and ISO are supported by the Department of Industry as ‘intercept’ standards to be adopted by the computing community as a whole. This paper presents the published standards interpreted as a set of state transition diagrams. This reinterpretation is a necessary prerequisite to the method of implementation which is based on a finite state automaton. We summarize the advantages of a software ‘funnel machine’ to effect the state transitions during the execution of the transport protocol server. The same analysis and design technique has been used successfully to implement network and link protocol handlers. We recommend its adoption on a variety of machines in any programming language to ensure a relatively short development period and to achieve compatability among the different classes: 0, 1, 2, 3 and 4, of the transport protocol.
Unisex: A unix‐based symbolic executor for pascal
Authors: Kemmerer Richard A. , Eckmann Steven T. 
Published: November 2006

AbstractUNISEX is a UNIX‐based symbolic executor for Pascal. The UNISEX system provides an environment for both testing and formally verifying Pascal programs. The system supports a large subset of Pascal, runs on UNIX and provides the user with a variety of debugging features to help in the difficult task of program validation. This paper contains a brief introduction to symbolic execution, followed by an overview of the features of UNISEX, a discussion of the UNISEX Pascal language, and some of the implementation details for the UNISEX system. Finally, some of the problems encountered when designing and implementing the system are discussed as well as future directions.
ISDMS—a scientific data management system
Authors: Bruestle H. R. , Snider D. M. , Russell K. D. , Stewart H. D. 
Published: November 2006

AbstractThis paper describes the design and development of the Idaho National Engineering Laboratory Scientific Data Mangement System (ISDMS). The ISDMS is an integrated system providing organization, processing, control and retrieval of scientific time series data in a large laboratory environment using Control Data Corporation (CDC) computers. Data reformatting, graphics, data manipulation, data management, engineering analysis and general utility functions are offered to engineers, scientists, and other end users. The ISDMS usage has grown steadily since its first release into production status in early 1979. The current configuration is well received by the user community and meets most requirements for studying and analysing data in a scientific environment.
Sre—a syntax recognizing editor
Authors: Budinsky Frank J. , Holt Richard C. , Zaky Safwat G. 
Published: November 2006

AbstractThis paper presents a syntax‐directed editor dubbed SRE, for syntax recognizing editor. Unlike other syntax‐directed editors, SRE enables the user to edit programs with nearly the same natural and unrestrictive ease as a conventional text editor. In addition, it helps identify syntax errors and many typing errors before leaving the editor and attempting to compile a program. Programs are also formatted during entry, thereby providing immediate visual feedback of the recognized structure. The editor replaces the scanner/parser pass of a conventional compiler and thus reduces compilation time substantially.
Automating the selection of code templates
Authors: Horspool R. Nigel , Scheunemann André 
Published: November 2006

AbstractA new methodology for code generation in compilers is advanced. The underlying principle is a simple one—that machine memory resources must be matched to intermediate code values. It is possible to view the methodology as a generalization of the Graham‐Glanville approach, but where there is a wider‐ranging search for the best code sequences. This new approach has been implemented for the IBM/370, the VAX‐11 and the Intel 8086 instruction sets.
A debugger for concurrent programs
Authors: Gait Jason 
Published: November 2006

AbstractThis paper reports on an experimental debugger for concurrent programs. Design objectives include a showing of greatest usefulness when dealing with multiprocess interactions, creation of a simplified more approachable interface for programmers, allowance for the systematic organization (and limitation) of debugging information by programmers, reflection of a natural view of concurrency, and portability. The design responds to a perceived need for debugging techniques applicable in systems of concurrent, communicating, asynchronous processes. During debugging sessions, a user is able to dynamically explore interprocess synchronization points, parallel actions and deadlock situations. The programmer interface is based on a transparent window multiplexer providing a set of windows for each concurrent process. The window manager interactively maps interesting windows to programmer‐specified viewscreen locations, while relegating temporarily uninteresting windows to the background. In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged. For the examples explored, the probe effect was not observed to limit the localization of implanted synchronization errors.
Ada's derived types and units of measure
Authors: Gehani N. H. 
Published: November 2006

AbstractTypes in programming languages cannot model many properties of real world objects and quantities. Consequently, many errors resulting from the inconsistent usage of program objects representing real world objects and quantities cannot be detected automatically. For example, the real variables PRICE and WEIGHT, representing the price of diesel fuel and the weight of a person, may be inadvertently added, giving a non‐sensical value; such an error cannot be detected by a compiler. The programming language Ada introduces the concept ofderivedtypes to tackle this problem. An alternative solution to this problem is the incorporation ofunits of measureas a new data attribute. Derived types only partially solve the problem of detecting the inconsistent usage of objects; some valid usages of objects are also not allowed. Moreover, the solution is inelegant and inconvenient to use. On the other hand, specification of units of measure solves the problem elegantly and conveniently. The two solutions are compared and analysed. Several ways to implement units of measure in Ada are examined.
On squeezing the unix quart into a data general eclipse pint pot
Authors: Cooper R. E. M. 
Published: November 2006

AbstractUNIX has become widely accepted as an efficient, highly flexible operating system for a wide range of computers. It is viewed as being portable because much of it is written in a high‐level language, but transporting it to machines other than its original host is not a trivial procedure. This paper describes the design decisions necessary in moving UNIX to the Data General Eclipse range of minicomputers, and some of the difficulties that arose because of the limited address space on these processors.
A program design language based software maintenance tool
Authors: Ince D. C. 
Published: November 2006

AbstractProgram design languages are an increasingly important method of expressing the detailed design of a software system. Such languages can be modelled using a data structure known as a semantic net. This paper describes a maintenance tool for program design languages based on such a data structure. The tool allows the user to interrogate a semantic net using an interactive procedural language in order to derive information necessary for software maintenance. The technique upon which this tool is based is applicable to the maintenance of activities throughout the software lifecycle.
Handin — a system for helping with the teaching of programming
Authors: Cowling A. J. , McGregor J. J. 
Published: November 2006

AbstractA system has been implemented that enables students on a programming course to hand in programs for assessment without the need for printed listings to be generated. The system test runs all submitted programs using standard sets of data, and then facilitates the marking of these programs by the staff teaching the course. The implementation of this system is described, and the experience gained from using it is discussed.
Rcs — a system for version control
Authors: Tichy Walter F. 
Published: November 2006

AbstractAn important problem in program development and maintenance is version control, i.e. the task of keeping a software system consisting of many versions and configurations well organized. The Revision Control System (RCS) is a software tool that assists with that task. RCS manages revisions of text documents, in particular source programs, documentation, and test data. It automates the storing, retrieval, logging and identification of revisions, and it provides selection mechanisms for composing configurations. This paper introduces basic version control concepts and discusses the practice of version control using RCS. For conserving space, RCS stores deltas, i.e. differences between successive revisions. Several delta storage methods are discussed. Usage statistics show that RCS's delta method is space and time efficient. The paper concludes with a detailed survey of version control tools.
Implementation techniques for prolog databases
Authors: Clocksin W. F. 
Published: November 2006

AbstractAll clauses comprising a Prolog program are stored in a database from which they can be removed later. Other long‐term data structures are represented as clauses and are also stored and removed from the same database. Implementation techniques for the manipulation of clauses are not well known, and a lack of information has led to incorrect and incomplete implementations. Further previously unresolved issues are apparent when considering the storage of compiled clauses. We describe the way database manipulations are performed in Prolog‐X, a new compiler‐based Prolog system. We also introduce a new technique for storing the source form of compiled clauses.
Dynamic storage allocation: Experiments using the c language
Authors: Gai Silvano , Mezzalama Marco 
Published: November 2006

AbstractThe paper discusses the problem of dynamic storage allocation (DSA) using C in a VMS environment. The problem is studied in a specific context, i.e. fault simulation of logic circuits. However, owing to its intrinsic generality, the adopted solution can be effectively applied to a large number of similar situations. It is shown how the use of standard C‐functions for dynamic memory allocation result unacceptable for efficiency reasons and different implementation strategies to solve the problem are presented.
Experiences with writing library software for an attached processor
Authors: Pryce J. D. 
Published: November 2006

AbstractThe Floating Point Systems AP120B attached processor (AP) offers a Fortran system which is aimed at making the machine an easy‐to‐use, low‐cost ‘number cruncher’. We report on experience of writing library mathematical software for a PRIME system with an AP120B. An ordinary differential equation code was chosen because it exemplifies a common requirement: the user supplies a subroutine that, on an AP system, forms part of the code executing on the AP. This turned out to be hard to organize conveniently on this system. We discuss the program design, and the deficiencies of the AP120B system that make it less promising than it appears for general scientific computation, and make suggestions concerning the design and implementation of the support software for attached processors.
Management of block‐structured programs
Authors: Marsland T. A. 
Published: November 2006

AbstractExperience with a technique for compiling subsets of the procedural elements of AlgolW programs is described. The method does not require modifications to the compiler, but does presume the existence of a random access file system. Complete management of the user's source and object files is provided by supplementary directory and environment files. Because of its nature, the basic method should be equally applicable to other block‐structured languages, such as Pascal, which also require recompilation of the whole program whenever a small change is made.
Mos: A multicomputer distributed operating system
Authors: Barak Amnon , Litman Ami 
Published: November 2006

AbstractThis paper describes the goals and the internal structure of MOS, a Multicomputer distributed Operating System. MOS is a general‐purpose time‐sharing operating system which makes a cluster of loosely connected independent homogeneous computers behave as a single‐machine UNIX system. The main goals of the system include network transparency, decentralized control, site autonomy and dynamic process migration. The main objective in the design of the system was to reduce the complexity of the system, while maintaining good performance. The internal structure of the system can be characterized by modularity, a high degree of information hiding, hierarchical organization and remote procedure calls.
Software concurrency in real time control systems: A software nucleus
Authors: Sears Ken H. , Middleditch Alan E. 
Published: November 2006

AbstractThis paper gives the rationale for the design of a nucleus to support real time control applications. In particular, mechanisms for communication between concurrent tasks are reviewed and analysed in the context of this application area. Finally, although no implementation is discussed in detail, techniques which have proved useful in implementing this nucleus on three different machines are described.
A VLSI interactive layout editor (VILE)
Authors: Allen G. H. , Perry S. 
Published: November 2006

AbstractA description of an interactive geometric editor for the layout of very large scale NMOS integrated circuits is presented. The implementation of the VLSI Interactive Layout Editor (VILE) using an HP2648A Graphics Terminal connected to a mainframe computer is described. The command language for the user‐computer interface is described, and to demonstrate the use of the editor an example of an integrated circuit layout is documented.