bluuebunny/crossref_metadata_2025_split huggingface dataset:
The evaluation of software systems' structure using quantitative software metrics
Authors: Henry Sallie , Kafura Dennis 
Published: November 2006

AbstractThe design and analysis of the structure of software systems has typically been based on purely qualitative grounds. In this paper we report on our positive experience with a set of quantitative measures of software structure. These metrics, based on the number of possible paths of information flow through a given component, were used to evaluate the design and implementation of a software system (the UNIX operating system kernel) which exhibits the interconnectivity of components typical of large‐scale software systems. Several examples are presented which show the power of this technique in locating a variety of both design and implementation defects. Suggested repairs, which agree with the commonly accepted principles of structured design and programming, are presented. The effect of these alterations on the structure of the system and the quantitative measurements of that structure lead to a convincing validation of the utility of information flow metrics.
Automatic generation of make dependencies
Authors: Walden Kim 
Published: November 2006

AbstractIn the UNIX environment, it is standard practice to use the make program to keep a system of interrelated modules up to date. When text files contain so‐called include statements referring to additional text files whose contents are to replace the statements, it soon becomes impractical, in a growing system, to manually maintain all make dependencies implied by these references. Therefore, the dependencies are often generated automatically from extracted include statements by various methods. However, the methods we have seen in use are too simplistic and either generate the wrong set of dependencies, or give only partial support. This paper describes an algorithm that can be used to generate make dependencies implied by include statements from a wide class of include mechanisms.
The design of an interactive graphics system for the display of meteorological fields
Authors: Hamilton J. E. M. 
Published: November 2006

AbstractWe describe a computer graphics system for the display of meteorological fields (such as plots of temperature and pressure). Much of the design effort has gone into the command processor which uses the usual command format of VERB PARAMETER = VALUE … The parameter and values are defined in terms of a tree sructure and the program searches as much of the tree as is necessary to make an unambiguous indentification of a token (where such an identification is possible). Because of this, commands can generally be abbreviated to the format VERB VALUE. This shortened form is possible even when the value of the command parameter is numerical. This is achieved by always specifying the units of numerical values (such as 5 days, 24 hours, 1000 millibars, etc.). The command format allows the user to manipulate a number of fields to form derived fields such as the difference of two pressure forecasts. The use of defaults for all parameters (which change as the user requests plots), reduces the amount of typing required to a minimum. A ‘Help’ facility aids the user in his choice of commands.
Using Ada for discrete event simulation
Authors: Bruno Giorgio 
Published: November 2006

AbstractThe process interaction approach is proposed for developing a discrete simulation environment in Ada. The introduction of simulation facilities in Ada not only concerns the classical aspect of model building, but allows a new class of problems to be tackled, that is the testing of correctness of programs intended for real‐time applications. In this paper attention is focused on the presentation of the process scheduling in the simulation context and on the definition of standard forms of interactions among processes. Simulation facilities are organized by making use of Ada's structuring concepts.
Steady‐state compilers
Authors: Cornelius B. J. , Lowman I. R. , Robson D. J. 
Published: November 2006

AbstractPassing compilers through themselves is a well known technique whose major benefit is that any improvement in code generation will result in an improved compiler. Previous reports of work in this area have mentioned that it is possible to validate the compiler by running the compiler through itself a second time and comparing the resulting binary files. This paper is designed to clarify this technique which has received little attention and is often misleadingly described.
The use of ghost variables and virtual programming in the documentation and verification of programs
Authors: Clint M. , Vicent C. 
Published: November 2006

AbstractUsing ghost variables and virtual programming, a method for documenting programs which exhibit some common characteristics is presented. The annotations required are expressed in a powerful high level assertion language. The usefulness of these annotations is illustrated by the generation of verification conditions for some small example programs written in a dialect of Pascal. Demonstrations of the correctness of these programs are also given.
Anatomy of an educational network database system
Authors: Johnson James L. 
Published: November 2006

AbstractThe construction of the systems software necessary to support arbitrary network databases is described. The software consists of two packages. First, there is a data description language compiler, which accepts a conceptual description of an arbitrary network and reduces it to a set of specialized data structures. The second component is a set of data manipulation language access routines, which are callable from an application program to store and retrieve data from the structures. The software is essentially an implementation of the CODASYL proposal, although the treatment of sets has been simplified. The main thrust of the discussion is the representation of nodes and sets of an arbitrary network by certain data structures. The software was written to provide a system on which students could practice database design problems and to illustrate systems programming techniques common in database software.
Resource monitors: A design methodology for operating systems
Authors: Pashtan Ariel , Unger Elizabeth A. 
Published: November 2006

AbstractResource manager objects are the operating system entities that manage computer system resources. In this paper we extend Hoare's and Brinch Hansen's monitor concept, and introduce a resource monitor language construct that represents a resource manager object. Resource monitors provide requesting processes with implicit synchronization, and do not require separate processes to perform the resource access operations. The resource monitor construct is compared to current language constructs used to structure operating system software. For this purpose we use an evaluation methodology that combines software complexity measurements with program performance measurements. The evaluation itself is carried out in a Concurrent Pascal‐like programming environment. The current language constructs have a software complexity that is larger by 37 to 219 per cent over the resource monitor's complexity. The run‐time synchronization overhead of programs that use current language constructs is 1.43 to 2.75 times higher than the overhead of programs that use a resource monitor.
A simulator for real‐time software debugging and testing
Authors: Huang J. C. , Ho Melody , Law Ted 
Published: November 2006

AbstractA software simulator can be built to facilitate debugging and testing of real‐time programs. This paper describes a simulator designed to operate in three modes: simulation, debugging and process monitoring. In the simulation mode, it simulates a Z80‐based microcomputer and can be used to execute programs written in the Z80‐assembler language. In the debugging mode, it provides facilities for interactive debugging on the instruction level. The simulator's unique feature is the process monitoring mode. It displays the activities among processes being executed concurrently under the control of a real‐time executive and thus allowing direct observation of dynamic program behaviour at the process level.
Register allocation and exhaustive peephole optimization
Authors: Davidson Jack W. , Fraser Christopher W. 
Published: November 2006

AbstractEmerging peephole optimizers can relieve code generators of much case analysis, but delaying code generation decisions requires register allocation algorithms that accept object code instead of the more usual intermediate code. This paper describes two programs that implement such algorithms for a retargetable optimizing compiler. In a machine‐independent fashion, they allocate and assign registers, eliminate common subexpressions (including often‐missed machine‐specific ones), identify dead variables, and define windows for the companion peephole optimizer. Their techniques for handling machine‐specific data should generalize to other optimizations as well.
Experience with remote procedure calls in a real‐time control system
Authors: Carpenter B. E. , Cailliau R. 
Published: November 2006

AbstractThis paper describes several years' practical experience with remote procedure calls as a primary tool for application software in a large and complex distributed real‐time process control system. We motivate the use of remote procedure calls as an effective technique for the use of local area networks, describe our implementation and discuss its advantages and disadvantages.
Top‐down design within a functional environment
Authors: Leith Philip 
Published: November 2006

AbstractThis paper describes a design tool for use within the INTERLISP1 environment. The design tool, DT, is based upon the design methodology described by the general term, top‐down design and is novel in that it attempts to apply this design method to a functional programming environment. Also novel is the method whereby the generation of the design can occur in parallel with the implementation of the design. This allows a design process more in accord with the needs of functional programmers.
An experiment in language design for distributed systems
Authors: Crookes D. , Elder J. W. G. 
Published: November 2006

AbstractThis paper describes a recent experiment in the design, implementation and application of a programming language designed specifically for distributed systems. The fundamental nature of such systems is used in the derivation of an experimental language, which is described and illustrated. Having outlined an implementation, the project is evaluated and some of the more significant findings are reported. In particular, the paper discusses (and argues for) an explicit language facility for expressing the distribution of a program over an actual system.
Polymorphic programming I. Another language designed on semantic principles
Authors: Harland David M. , Gunn Hamish I. E. 
Published: November 2006

AbstractWe wish to illustrate the potential of a thus far little explored avenue of programming language design–‐namely the employment of types and routines as values in their own right within the framework of an Algol. In this first paper we pay particular attention to the development of highly orthogonal self‐initializing data structures, and to the advantageous expressive power of polymorphism when combined with routine values so as to provide abstract data structures. The emphasis is on the design phase, rather than on the implementation details or precise syntactic structure of the envisaged language. A second, companion paper† discusses the design of a high‐level orthogonal abstract architecture intended to support polymorphic languages in which routines are ‘first class’ values. The relationship of the abstract machine architecture to the programming language vis‐a‐vis the ‘semantic gap’ is then discussed from the viewpoint of compiling programs which are strongly typed while exploiting polymorphism. We feel that polymorphism is essential if truly general purpose programs, software tools, are to be written easily. The research reported herein is an effort towards realizing this goal.
A hierarchical exception handler binding mechanism
Authors: Nackman Lee R. , Taylor Russell H. 
Published: November 2006

AbstractA mechanism is proposed for binding exception handlers to exceptions. Hierarchical exception classes can be defined and changed during program execution. In addition, the action taken when an exception of a particular class is raised depends upon the type of the current exception handler for that class. The mechanism can be implemented in programming languages that allow runtime determination of an identifier's binding; most dynamically scoped programming languages meet this criterion.
Polymorphic programming II. An orthogonal tagged high level architecture abstract machine
Authors: Gunn Hamish I. E. , Harlan David M. 
Published: November 2006

AbstractThis paper describes the implementation of a very powerful high level language from the standpoint of those features rarely found in other languages. These are constancy, polymorphism, user‐defined types, orthogonal data structures, and field selectors and routines as assignable values. It examines the characteristics of these features in order to show how they are implemented. They greatly influence the architecture of the underlying abstract machine which is described. Finally the paper highlights several important instructions such as those for routine calling and data structure management. It also shows how the list as a data type in a language can be exploited in the implementation of assignment and parameter passing.
Concurrent C: A programming language for distributed multiprocessor systems
Authors: Tsujino Y. , Ando M. , Araki T. , Tokura N. 
Published: November 2006

AbstractRecent advances in hardware technology have made the construction of multiprocessor systems economically feasible. This paper describes a new programming language (Concurrent C) suitable for distributed systems which are networks of loosely connected processors, each with its own local storage. Concurrent C is the extended version of the programming language C, incorporating features for parallel processing and interprocess communications.
Dedicated, distributed and portable operating systems: A structuring concept
Authors: Valdorf G. 
Published: November 2006

AbstractPrimarily economic reasons have created a growing need for the development of operating systems providing support for existing and newly developed structurally different hardware systems–‐operating systems which(a) implement functionally different problem‐oriented solutions without imposing the need of developing problem‐invariant functions repeatedly (‘operating system family’)(b) work not only in a local environment, but also co‐operate with one another in an interconnected hardware system, thus appearing to the user as only one big operating system(c) are portable among structurally different hardware systems independent of one another (‘autonomous systems’), as well as among structurally different interconnected hardware systems (‘networks’)We present some principles of a structuring concept which seems to be a suitable means of developing operating systems with the specified characteristics in an economic and controlled manner.
A language independent error recovery method for LL(1) parsers
Authors: Spenke Michael , Muhlenbein Heinz , Mevenkamp Monika , Mattern Friedemann , Beilken Christian 
Published: November 2006

AbstractAn efficient and systematic LL(1) error recovery method is presented that has been implemented for an LL(1) parser generator. Error messages which provide good diagnostic information are generated automatically. Error correction is done by discarding some input symbols and popping up some symbols from the parsing‐stack in order to restore the parser to a valid configuration. Thus, symbol deletions and insertions are simulated. The choice between different possible corrections is made by comparing the cost of the inserted (popped) symbols with the reliability value of the recovery symbol (the first input symbol that is not discarded). Our concept of reliability is based on the observation that input symbols differ from each other in their ability to serve as recovery points. A high reliability value of a symbol asserts that it was probably not placed in the input by accident. So it is reasonable not to discard that symbol but to resume parsing. This is done even if a string with high insert‐cost has to be inserted before that symbol in order to fit it to the part of the program that has already been analysed. The error recovery routine is invoked only when an error is detected. Thus, there is no additional time required for parsing correct programs. Error‐correcting parsers for different languages, including Pascal, have been generated. Some experimental results are summarized.
QS: A tool for general data input
Authors: Dewey M. E. 
Published: November 2006

AbstractThis paper describes QS, a program which inputs data in a very general format. QS interprets a script, which contains text to be used to prompt the user, and commands which collect the data from the user. This apparently simple description hides an idea of great power, and in this paper examples are provided of the use of the program in three areas. (1) A system for producing questionnaires and psychiatric interview schedules relies on the program to provide a data validation system which is automatically updated to keep pace with changes to the schedules. (2) The program provides a general purpose patient interviewing package. Most current systems are specific to a particular interview, but new interviews can be administered by QS simply by changing the script, which is much simpler than writing a new program. (3) The program also provides a means of presenting multiple choice self assessment examinations, or programmed instruction to students. Again any set of questions can be set, just by writing a new scriptThe design of the program is discussed with reference to the criteria of simplicity, ease of writing and maximum recycling of existing software. The advantages of the tools approach to software design are stressed.
The starmod distributed programming kernel
Authors: Leblanc Thomas J. , Gerber Robert H. , Cook Robert P. 
Published: November 2006

AbstractThis paper describes the design and implementation of a kernel for the distributed programming language StarMod. The distributed programming kernel was written in a subset of StarMod supported by a concurrent programming kernel. Kernel issues addressed include process representation, I/O device management, signal semantics, system utilities, network communication and the implementation of high‐level language communication primitives. We conclude with a summary of our experiences in the development of a ‘bare machine’ kernel for a network of microprocessors.
P/CL: A flexible input processor
Authors: Arciszewski H. F. R. , Van Gasteren E. M. 
Published: November 2006

AbstractAn interactive program inevitably has a need for a user interface which exceeds the simple combination of a write and a read statement. This is necessary to prevent a program abort due to an input error from the side of the user. Also it is desirable to allow for more advanced types of input than single characters or numbers. For these reasons a general‐purpose input package has been developed which allows for sophisticated command‐driven programs while offering the programmer as well as the user an easy‐to‐use interface. The structure of the package is described and examples of its use are given.
Avoiding trickle‐down recompilation in the Mary2 implementation
Authors: Rain Mark 
Published: November 2006

AbstractProgramming languages which support separate but not independent compilation are prone to a problem called trickle‐down recompilation. These languages, which include Ada, Modula and others as well as Mary2,1 permit a compilation unit to refer at compile time to objects declared in another, imported, compilation unit. When the exporting compilation unit is recompiled for any reason, its exported interface may change, and so the importing compilation units which are the clients of that interface must be recompiled. These recompilations in turn force others, and so onMany recompilations are in fact innocuous, in that they may change the run‐time behaviour of the recompiled unit but do not alter the exported interface. This paper describes the implementation of that portion of the Mary2 language system which performs just those recompilations actually necessary and avoids redundant recompilations. The methods described are applicable to the implementation of any other language which enforces version control across compilations.
Operating system support for sharing writable control store
Authors: Winner R. I. , Reed L. B. 
Published: November 2006

AbstractThe design of a portable, production‐quality dynamic microprogramming system is given. The system is an extension to UNIX; it allows multiple users easily to time‐share the writable control store on a Perkin‐Elmer 3220. Each process may have its own microcode support, known as a microimage; processes may share microimages. Microimages are managed either in an optional software cache in kernel memory or in user memory where they are subject to secondary memory swapping. The physical loading of the WCS is accomplished in on‐demand fashion in the sense that only the first attempt to enter control store during a given scheduling quantum can cause a WCS fault. Users are prevented from erroneously entering control store by separate management of the control store entry points. The paper provides sufficient detail to allow other UNIX and similar systems to adopt this approach. Performance effects of WCS contention add from about 0.5 to 1 per cent overhead to the jobs, and the use of vertical migration has improved job run times up to 50 percent. This system has been in use for over a year and provides the main support for ongoing research into vertical migration.
An interactive assembly level debugging system
Authors: Panchapakesan S. , Subramanian S. , Venkateswaran H. 
Published: November 2006

AbstractAn interactive assembly level debugging system has been developed to facilitate program development on an INTEL 8080A/8085 based microcomputer. It has features such as decoding machine level instructions into the assembly language, relocating programs in memory, changing instructions interactively at assembly level etc. This paper deals with the design of the assembly level debugging system and the various facilities and features it provides. The debugging system requires only 4.5K bytes of RAM besides the memory requirements of the application program that has to be debugged.
The NMFECC cray time‐sharing system
Authors: Fong Kirby W. 
Published: November 2006

AbstractThe National Magnetic Fusion Energy Computer Center (NMFECC) at the Lawrence Livermore National Laboratory (LLNL) has implemented a simple, yet powerful interactive operating system, the Cray Time‐Sharing System (CTSS), on a Cray‐1 supercomputer. CTSS augments the multi‐programming batch facilities normally found in supercomputer systems with many of the interactive services typical of interactive minicomputer systems. This paper gives some of the historical background leading to CTSS and gives an overview of the system that emphasizes the strong points or unusual features such as multiple channels, decentralized control of resources, priorities and program scheduling, system recovery, and on‐line documentation.