bluuebunny/crossref_metadata_2025 huggingface dataset:
The Trellis programming environment
Authors: O'Brien Patrick D. , Halbert Daniel C. , Kilian Michael F.
Published: November 2005

The Trellis programming environment supports programming in Trellis/Owl, an object-based language with multiple inheritance and compile-time type-checking. Trellis is composed of a number of integrated tools that share a common programming environment database. It is a highly interactive, easy-to-use programming environment, providing various programming aids, incremental compilation, and good debugging support. Trellis is both integrated and open-ended.

Trellis was specifically designed to support the object-oriented programming methodology. Thus it provides tools to manage the use of types and inheritance. Trellis takes advantage of the strong-typing features of the Trellis/Owl language to provide more support for the programmer by keeping track of cross-references and inconsistencies in code.
A pragmatic system for shared persistent objects
Authors: Merrow Thomas , Laursen Jame
Published: November 2005

This paper describes a system for sharing information in the form of objects among users of the Smalltalk-80 programming environment. The system, called Coral3, is pragmatic in that it was developed to meet the needs of specific applications. This paper describes the expectations for the system, presents factors influencing the design, outlines the implementation of Coral3, and raises questions about object-oriented database systems in general.
Class modification in the GemStone object-oriented DBMS
Authors: Penney D. Jason , Stein Jacob
Published: November 2005

We are currently designing a class modification methodology for GemStone. We describe the current status of the design. We choose from two basic approaches and then introduce those aspects of GemStone necessary for an understanding of the paper. After defining a set of invariants for GemStone databases, we discuss specific class modification operations in terms of maintaining these invariants. We next discuss several issues that impact class modification. These issues include concurrency and authorization, and lead to difficult choices.
Concepts and experiments in computational reflection
Authors: Maes Pattie
Published: November 2005

This paper brings some perspective to various concepts in computational reflection. A definition of computational reflection is presented, the importance of computational reflection is discussed and the architecture of languages that support reflection is studied. Further, this paper presents a survey of some experiments in reflection which have been performed. Examples of existing procedural, logic-based and rule-based languages with an architecture for reflection are briefly presented. The main part of the paper describes an original experiment to introduce a reflective architecture in an object-oriented language. It stresses the contributions of this language to the field of object-oriented programming and illustrates the new programming style made possible. The examples show that a lot of programming problems that were previously handled on an ad hoc basis, can in a reflective architecture be solved more elegantly.
Experience with CommonLoops
Authors: Kempf James , Harris Warren , D'Souza Roy , Snyder Alan
Published: November 2005

CommonLoops is an object-oriented language embedded in Common Lisp. It is one of two such languages selected as starting points for the Common Lisp Object System (CLOS) which is currently being designed as a standard object-oriented extension to Common Lisp. This paper reports on experiences using the existing Portable CommonLoops (PCL) implementation of CommonLoops. The paper is divided into two parts: a report on the development of a window system application using the CommonLoops programming language, and a description of the implementation of another object-oriented language (CommonObjects) on top of the CommonLoops metaclass kernel, paralleling the two aspects of CommonLoops: the programming language and the metaclass kernel. Usage of the novel features in CommonLoops is measured quantitatively, and performance figures comparing CommonLoops, CommonObjects on CommonLoops, and the native Lisp implementation of CommonObjects are presented. The paper concludes with a discussion about the importance of quantitative assessment for programming language development.
Active objects in hybrid
Authors: Nierstrasz O. M.
Published: November 2005

Most object-oriented languages are strong on reusability or on strong-typing, but weak on concurrency. In response to this gap, we are developing
Hybrid
, an object-oriented language in which objects are the active entities. Objects in Hybrid are organized into
domains
, and concurrent executions into
activities
. All object communications are based on remote procedure-calls. Unstructured
sends
and
accepts
are forbidden. To this the mechanisms of
delegation
and
delay queues
are added to enable switching and triggering of activities. Concurrent subactivities and atomic actions provided for compactness and simplicity. We show how solutions to many important concurrent problems, such a pipelining, constraint management and “administration” can be compactly expressed using these mechanisms.
MELDing data flow and object-oriented programming
Authors: Kaiser Gail E. , Garlan David
Published: November 2005

MELD combines concepts from data flow and object-oriented programming languages in a unique approach to tool reusability. MELD provides three units of abstraction — equations, classes and features — that together allow sufficient options for granularity and encapsulation to support the implementation of reusable tools and the composition of existing tools in parallel (
i.e.
, interleaved) as well as in series.
Modules and type checking in PL/LL
Authors: Thorelli Lars-Erik
Published: November 2005

The type system of a programming language system PL/LL is described. PL is a simple object oriented programming language and LL is a language for composing PL modules into programs. The goals of the PL/LL system are to enable the programming of efficient object-oriented computations and to provide the powerful linking language LL for facilitating the construction of large programs. The goal of the type system is to ensure efficient and secure object handling through a combination of static and dynamic type checking, and to preserve this property across module boundaries. The solution is based on (i) the module and linking concepts of LL, (ii) a language construct in PL for the safe creation of linked data structures, and (iii) a limited form of type polymorphism and type unification.
CLAM- an open system for graphical user interfaces
Authors: Call Lisa A. , Cohrs David L. , Miller Barton P.
Published: November 2005

CLAM is an object-oriented system designed to support the building of extensible graphical user interfaces. CLAM provides a basic windowing environment with the ability to extend its functions using dynamically loaded C++ classes. The dynamically loaded classes allow for performance tuning (by transparently loading the class in either the client or the CLAM server) and for sharing of new functions.

In addition to the traditionally layering of output abstractions, CLAM allows the programmer to easily layer input abstractions. The input functions include providing distributed upward calls through the layers, an light weight processes to support asynchronous input.

CLAM is currently running under 4.3BSD UNIX on a MicroVax-II workstation.
The design and implementation of distributed Smalltalk
Authors: Bennett John K.
Published: November 2005

Distributed Smalltalk (DS) is an implementation of Smalltalk that allows objects on different machines to send and respond to messages. It also provides some capability for sharing objects among users. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. Distributed Smalltalk is currently operational on a network of Sun workstations. The implementation includes an incremental distributed garbage collector and support for remote debugging, access control, and object mobility. This paper concentrates on the important design issues encountered and some of the more interesting implementation details. Performance measurements of the current implementation are included.
Transparent forwarding: First steps
Authors: McCullough Paul L.
Published: November 2005

Traditional object-oriented systems tend to be single-user. As we move from personal to interpersonal computing, we must look for ways to extend our programming paradigms. This research extends the Smalltalk-80 system to send messages transparently to objects residing on remote machines. We discuss two models for remote message sends, describe our current implementation, and suggest areas for future research.
OTM: Applying objects to tasks
Authors: Hogg John , Weiser Steven
Published: November 2005

OTM is a concurrent object language presently being implemented at the University of Toronto. It provides a novel, simple and powerful way of structuring
tasks
or collections of operations. This paper describes the concurrency control features of OTM, which include external termination of tasks. An example demonstrates how the language can be used to cleanly and concisely control cooperating objects.
Experience and evolution of concurrent Smalltalk
Authors: Yokote Yasuhiko , Tokoro Mario
Published: November 2005

ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features:

Upper-compatibility with Smalltalk-80.

Asynchronous method calls and
CBox
objects yield concurrency.

Atomic objects have the property of running one at a time so that it can serialize the many requests sent to it.

Through experience in writing programs, some disadvantages have become apparent related to concurrency control and the behavior of a block context. In this paper, these issues are re-examined in detail, and then the evolution of the solutions for overcoming these shortcomings is described along with the model of computation in ConcurrentSmalltalk. New features are explained with an example program. The implementation of the ConcurrentSmalltalk virtual machine is also presented along with the evaluation of it.
Techniques for improving language-based editors
Authors: Horgan J. R. , Moore D. J.
Published: November 2005

Syned is a working language-based editor which includes a complete parser for editing the C language. The design ideas which permit parsing in Syned also result in the solution of several important language-based editor problems. We describe these ideas in sufficient detail to make them accessible to others.
The Poe language-based editor project
Authors: Fischer C. N. , Johnson Gregory F. , Mauney Jon , Pal Anil , Stock Daniel L.
Published: November 2005

Editor Allan Poe (Pascal Oriented Editor) is a full-screen language-based editor (LBE) that knows the syntactic and semantic rules of Pascal. It is the first step in development of a comprehensive Pascal program development environment.

Poe's design began in 1979; version 1 is currently operational on Vax 11s under Berkeley Unix and on HP 9800-series personal workstations. Poe is written in Pascal, and is designed to be readily transportable to new machines. An editor-generating system called Poegen is operational, and much of the language-specific character of Poe is table-driven and retargetable.
Viewing a programming environment as a single tool
Authors: Delisle Norman M. , Menicosy David E. , Schwartz Mayer D.
Published: November 2005

Programming environments support the creation, modification, execution and debugging of programs. The goal of integrating a programming environment is more than simply building tools that share a common data base and provide a consistent user interface. Ideally, the programming environment appears to the programmer as a single tool; there are no firewalls separating the various functions provided by the environment. This paper describes the techniques used to integrate Magpie, an interactive programming environment for Pascal. Display windows, called browsers, provide a consistent approach for interacting with the Pascal source code or the execution state of the program. Incremental compilation allows the programmer to specify debugging actions in Pascal, eliminating the need for a separate debugging language.
Arcturus
Authors: Standish Thomas A. , Taylor Richard N.
Published: November 2005

The Arcturus system demonstrates several important principles that will characterize advanced Ada programming support environments. These include conceptual simplicity, tight coupling of tools, and effective command and editing concepts. Arcturus supports interactive program development and permits the combined use of interpretive and compiled execution. Arcturus is not complete however, as practical, mature environments for Ada must also support the development, analysis, testing, and debugging of concurrent programs. These issues are currently being explored. Arcturus, therefore is a platform for experimental exploration of key programming environment issues. This paper focuses primarily on the current system, describing and illustrating some of its components, while issues less fully developed are more briefly described.
GNOME
Authors: Garlan David B. , Miller Philip L.
Published: November 2005

Structure editors have frequently been used as powerful and unifying interfaces for programming environments in computer science research settings. Few, however, have found their way into common use. GNOME is an attempt to channel the experience gained in the use of structure editing for software development environment research of the Gandalf Project into a practical novice programming environment. Based on a
family
of structure editors, it is currently being used to teach programming to undergraduates at Carnegie-Mellon University. This paper describes the GNOME environment, recounts lessons learned in adapting structure editors to novice programmers, and discusses its effectiveness as a teaching environment.
The SAGA project
Authors: Campbell Roy H. , Kirslis Peter A.
Published: November 2005

The SAGA (Software Automation, Generation, and Administration) project is investigating formal and practical aspects of computer-aided support for the software lifecycle [Campbell and Richards, 81]. The goal of the project is to design a practical software development environment that supports and aids management of all major phases of the lifecycle. This paper presents requirements for a software development environment and shows how they are guiding the specification and design of the SAGA project. We review the goals of the project, and give an overview of the organization, design, and status of the major components of the SAGA software development system for which prototypes have been built. These components include a table-driven LR parser-based language-oriented editor, a discussion forum, a source code control system, and an incremental compilation facility.
The Darwin software-evolution environment
Authors: Minsky N. , Borgida A.
Published: November 2005

The main goal of the Darwin software development environment is to establish a rigorous authorization-based discipline which can be used to impose constraints on the structure and operations of software systems as well as on their process of development Such constraints might be desirable to serve the following needs:

• The need to provide support and enforcement for such software engineering techniques as informationhiding, data abstraction and modularization, even when these techniques are not offered by the programming language itself.

•The need to support rules which govern the real enterprise being served by the system, and which must be invariant of the evolutionary behaviou of the system.

• The need to enforce managerial policies concerning the process of system development itself.
Phoan
Authors: DeTreville John
Published: November 2005

Phoan is an experimental system for the specification and synthesis of control software over suitably restricted domains; its initial application domain is control software for distributed telephone systems. Phoan provides the developer with an example-based specification language, which it translates into an internal representation language based on rules and constraints. Phoan reasons at the representation level to ensure that the system definition is coherent and consistent with independent models of the target domain. Phoan synthesizes the final control structures and their associated protocols by transformation from the internal representation. The implementation of Phoan is currently in progress.
Monitoring in a software development environment
Authors: Snodgrass Richard
Published: November 2005

A monitor is an important component of a software development environment. The information collected and processed by a monitor is vital for debugging and tuning programs, and is useful to compilers performing selective optimization. A relational database, extended to incorporate time, is introduced as an appropriate representation of dynamic information concerning a program's execution
. TQuel,
a language permitting high level queries about a program's behavior, is briefly described. Measurements of an initial implementation of the relational monitor show that it can efficiently support the conceptual viewpoint of a dynamic database of a program's behavior.
Document structure and modularity in mentor
Authors: Donzeau-Gouge V. , Kahn G. , Lang B. , Mélèse B.
Published: November 2005

Mentor is a structured document manipulation system. It has been used for several years as a program development and maintenance environment.

Its main characteristics are:

it is both interactive and programmable,

it is parameterized by the language to be manipulated,

it can manipulate several languages at the same time, as well as multi-lingual documents.

it is open to and from the outer system,

it is extensible.

The current development of Mentor reflects our belief that a major component of programming is the maintenance of large documents of a varied nature: specifications, programs, manuals, progress reports, documentation, etc... In addition, information of various kinds, and in different languages, is often mixed in a single document, and one may have to extract this information selectively upon request (e.g. text, examples and formal specification in a manual, or instructions, comments and assertions in a program).
Preliminary experience with a configuration control system for modular programs
Authors: Estublier J. , Ghoul S. , Krakowiak S.
Published: November 2005

This paper describes some preliminary experience gathered during the implementation and early use of a program composition and version control system. This system has been designed and implemented as a part of the Adele research project, a programming environment for the production of modular programs (Estublier 83). This project has four main components: a) a program editor, interpreter and debugger; b) a parameterized code generator; c) a user interface; d) a program base, the subject of this paper. The current version of this environment has been developed on a Multics system.

The program base, including the system composition and version control mechanisms, has been used for six months, notably for its own development and maintenance.
US&R
Authors: Vitter Jeffrey Scott
Published: November 2005

US&R (which stands for
Undo, Skip, & Redo
) is a new interactive approach to user recovery that offers significant advantages over current Undo/Redo packages. In the US&R package, a SKIP or REDO command may be ambiguous, in which case US&R enumerates the logical interpretations of the command and prompts the user both textually and graphically for the desired choice. US&R also allows new commands to be executed during the redo process. With US&R, novices can perform recoveries that might be difficult or impossible to do with other systems; experienced users can take even greater advantage of its functionality. US&R's data structure organizes the recovery information in a natural tree-like fashion that is easy to implement in a variety of interactive settings, including text editors, graphics layout systems, algorithm simulators, and program development systems.
Integral-C—a practical environment for C programming
Authors: Ross Graham
Published: November 2005

Integral C
1
is an industrial grade integrated programming environment for C programming on an engineering workstation. A single interactive tool replaces a syntax checking editor, a compiler, and a source-level debugger. Its multi-window user interface allows program editing and animated source level debugging, tailored to the needs of a C programmer. The compiler accepts standard C code and reacts to editing changes with function-level incremental compilation. Compilation is done without prompting to maintain the client program in a ready-to-run state. Emitted code is instrumented to catch run-time errors and to permit fine grained debugging. Debugging support code is written in C in a 'workspace', which grants it direct access to a local scope while keeping it separate from the client program.
Engineering VAX Ada for a multi-language programming environment
Authors: Mitchell Charles Z
Published: November 2005

DIGITAL's VAX
™
Ada

r

is a validated, production-quality implementation of the full Ada language that is well-integrated into the VMS
™
operating system environment on VAX systems. The programming support environment consists of an Ada compiler, an Ada program library manager, and a multi-language programming environment including a variety of tools which all work together. The Ada compiler has many features which allow full access to the underlying operating system and hardware and which permit the use of Ada in mixed language programs in the VAX/VMS Common Language Environment. The Ada program library manager provides Ada-specific features to reduce manual bookkeeping by programmers and to support programming projects. Some of the available multi-language tools include a source code tracking system, a language-sensitive editor, a symbolic debugger, a performance and test coverage analyzer, and a test system manager.
Rapidly evolving software and the OVERSEE environment
Authors: Wartik Steven
Published: November 2005

During its lifetime, a software system will sometimes need to “rapidly evolve,” that is, undergo a quick set of changes. Making the changes rapidly is difficult, especially if one's software development policies are rigorous; the need for test reports, signatures, etc., seems to create interminable delays. In this paper, we argue that much of the problem stems not from such policies, but from a lack of consideration to information flow in software environments. We present a configuration management environment called OVERSEE, and discuss how it helps solve the problems of information flow.
Editing and compiling whole programs
Authors: Cooper Keith D , Kennedy Ken , Torczon Linda , Weingarten Alan , Wolcott Mary
Published: November 2005

The IR
n
programming environment pays systematic attention to the problems entailed in developing, debugging, and optimizing large programs. This paper reviews the principal mechanisms provided by IR
n
to support large programs. It describes the structure used to represent large programs and the tools that manipulate this structure. It also explores the way that the IR
n
compiling system handles whole programs: performing interprocedural analysis, removing redundant modules, and generating customized procedure linkages.
StarLite, a visual simulation package for software prototyping
Authors: Cook Robert P , Auletta Rihard J
Published: November 2005

We describe a software prototyping environment implemented on the Lilith computer. By isolating hardware dependencies, the environment supports the development and testing of concurrent and distributed algorithms on a host as well as on the target hardware. A library of generic devices, which includes clocks, disks and EtherNets, is provided to support experimentation. The paper describes how any programming language can be extended to provide such an environment by adding subroutine packages for concurrent programming, simulation, and window management.
AWB-ADE: an application development environment for interactive, integrated systems
Authors: Childs Carolyn , Vokolos Filippos I
Published: November 2005

The AWB Application Development Environment (AWB-ADE) is a collection of UNIX
*
based software tools within an architecture that facilitates the development of new interactive, integrated software systems with significant productivity gain. The main characteristic of this environment is that it encourages a high degree of reusability, especially at the architecture and program level, and it provides facilities for the development of software through rapid prototyping. Further, it is an environment with an open architecture and as such it can easily be extended to meet the variety of needs of its diverse user community.
Implementing a user interface as a system of attributes
Authors: King Roger , Hudson Scott
Published: November 2005

In a syntax directed editor, or programming environment using a graphical user interface, how do you keep the display and other aspects of the user interface up to date with changes to the underlying abstract syntax tree? This paper addresses this question by showing how existing incremental attribute evaluation techniques can be combined with graphical techniques to allow a user interface to be managed automatically as a system of attributes. In a nutshell, presentations can be described and implemented by small pseudocode fragments for a special purpose graphics pseudomachine. The control and composition of these code fragments, and hence the presentations which they implement, is done as an attribute computation.
A structural approach to the maintenance of structure-oriented environments
Authors: Staudt Barbara J , Krueger Charles W , Garlan David
Published: November 2005

A serious problem for programming environments and operating systems is that existing software becomes invalid when the environment or operating system is replaced by a new release. Unfortunately, there has been no systematic treatment of the problem; current approaches are manual, ad hoc, and time consuming both for implementers of programs and for their users. In this paper we present a new approach. Focusing on a solution to the problems for structure-oriented environments, we show how automatic converters can be generated in terms of an implementor's changes to formal descriptions of these environments.
On the structure of structure-oriented editors for different applications
Authors: Engels G , Nagl M , Schafer W
Published: November 2005

The paper describes the experiences we got from the implementation of a series of syntax-directed editors within an incremental and integrated software development environment. The implementation of all editors is based on the same conceptual ideas for specification and realization which is called graph technology. It is specific for the project a part of which we describe here. Using graph technology yields a very similar software architecture for all editors. We explain the development of such a standard architecture and also outline some specific differences resulting from the corresponding application areas.
A foundation for programming environments
Authors: Reppy J H , Gansner E R
Published: November 2005

Recent work on generating tools and techniques have significantly eased the design and construction of programming environments (PEs). Concurrently, advances in workstation hardware have enhanced both the potential capabilities and performance of PEs. We argue that, to capitalize on these two developments, various deficiencies in traditional languages and operating systems must be avoided. To this end, we have developed Pegasus, a system to serve as a software foundation for the construction and execution of PEs. It consists of a concurrent functional programming language, the run-time support for this language, and a core library of standard tools and utilities. We present a discussion of Pegasus, its current state, and directions for future development.
Global common subexpression elimination
Authors: Cocke John
Published: November 2005

When considering compiler optimization, there are two questions that immediately come to mind; one, why and to what extent is optimization necessary and two, to what extent is it possible.

When considering the second question, one might immediately become discouraged since it is well known that the program equivalency problem is recursively unsolvable. It is, of course, clear from this that there will never be techniques for generating a completely optimum program. These unsolvability results, however, do not preclude the possibility of ad hoc techniques for program improvement or even a partial theory which produces a class of equivalent programs optimized in varying degrees.

The reasons why optimization is required seem to me to fall in two major categories. The first I will call “local” and the second “global”.
Optimization aspects of compiler- compilers
Authors: Cheatham T. E. , Standish Thomas A.
Published: November 2005

A decade of experience with prototype versions of compiler-compilers, some of which have been successful and some of which have not been so successful, leads us to the conclusion that we can now engineer good compiler-compilers which can generate efficient compilers that generate efficient object code. This paper reviews the experience with compiler-compilers, documents reasons for believing that some compiler-compilers are good, and advocates the importation of compiler-compiler techniques by commercial firms and the production of well-engineered compiler-compilers as commercial products. Some unanswered questions about compiler-compiler techniques are explored in relation to the newly emerging discipline of software engineering.
Compilation of optimized syntactic recognizers from Floyd-Evans productions
Authors: Haynes H. R. , Schutte L. J.
Published: November 2005

Floyd-Evans productions are becoming increasingly popular as the metalanguage to be used in describing the syntactic analysis phase of programming language processors. Techniques for compiling optimized syntactic recognizers from Floyd-Evans productions are presented. Such recognizers promise to yield significant gains in recognition speed with no increase in storage requirements when compared to table-driven interpretive recognizers. The compiled recognizers can be described in terms of macros that are essentially machine-independent.
Local optimizations
Authors: Bagwell John T.
Published: November 2005

Some local optimizations (as opposed to global optimizations} are presented and a suitable one-pass compiler design for using them is shown. Optimizations shown are divided into machine dependent and independent classes with examples of each. There is some discussion of a subscript calculation technique which is an improvement over the usual technique, and a discussion of the best way to raise a quantity to a known small constant power by inline code. Various register allocation criteria are mentioned.
Optimization problems in extensible compilers
Authors: Bolas Bruce J.
Published: November 2005

Some observations are made about the special problems of optimization in compilers for extensible languages. Different kinds of extension are defined, and their impact on the processes of compiler optimization are briefly discussed. The problems of achieving good optimization for such languages are related to the problems of formalizing the definition of programming languages in general.
Optimization of error recovery in syntax-directed Parsing algorithms
Authors: LaFrance Jacques E.
Published: November 2005

The syntactic error recovery of automatically generated recognizers is considered with two related systems for automatically generating syntactic error recovery presented, one for a Floyd production language recognizer, the other for a recursive descent recognizer. The two systems have been implemented for a small language consisting of a subset of ALGOL. When compared with each other and with a commercial ALGOL compiler, the results indicate that automatically generated syntactic error recovery can exceed the performance of reasonable hand-coded error recovery.
Optimization for an array computer
Authors: Millstein Robert E.
Published: November 2005

The unconventional design of the ILLIAC-IV requires unconventional optimization techniques. Conventional techniques focus on the program. Since conventional hardware executes one instruction at a time, greater efficiency is obtained by reducing the number of instructions executed. Elimination of common subexpressions and literal computations, removal of locally invariant computations, reduction of operator strength, etc. are all methods of restructuring a program to allow greater efficiency. This focus on the program is not sufficient for the ILLIAC-IV. Efficient use of an array of processors depends upon the data being stored so as to permit parallel execution on many data streams. Further, the inability of each processor to access more than 2K of memory requires the use of routing commands for inter-processor communication. Hence, optimization on an array computer requires restructuring of the data as the primary area of effort. Such restructuring includes, for example, an extension to the skewed storage method which permits any slice of any array to be accessed in parallel and, further, to be aligned with an other slice by a uniform route. (A slice of an n-dimentional array A is the vector {A(c
l
,..., c
i−l
, j, c
i+l
,..., c
n
: m
i
≤ j ≤ M
i
, c
k
constant}.)
Report of session on semantics
Authors: Dennis Jack B.
Published: November 2005

This session was devoted to consideration of the potential value of ideas in formal semantics for application to the specification and implementation of operating systems, and the benefits and issues that would arise from such use.

Jack Dennis introduced the session by noting that formal definitions of programming languages, such as the definition of PL/I in the Vienna Definition Language, are intended to serve two major practical objectives: 1) to ensure consistent interpretation of language constructs between computer systems so programs may be readily transferred; 2) to provide a standard with respect to which the correctness of implementations may be tested and verified. In contemporary systems user or application programs usually depend, for correct operation, on system facilities for file manipulation, communication, concurrent processing, and controlled access to data and procedures, as well as the linguistic constructs of conventional programming languages. Thus the same practical objectives for application of formal definition techniques hold for operating systems as for programming languages.
Report of session on structured programming
Authors: Liskov Barbara , Freiburghouse Robert
Published: November 2005

The session on structured programming was both interesting and lively, and many aspects of structured programming were discussed. Conspicuous by its absence was a debate on the use of
goto
's; chairman Bob Freiburghouse requested that this topic be avoided, since it has been thoroughly discussed elsewhere.

To provide a common frame of reference for the discussion, Barbara Liskov opened the session with a presentation providing a definition of structured programming. The text of the presentation is given in the next section. The remaining sections contain summaries of the most interesting discussions, organized by topics.
GLOSS
Authors: Herriot Robert G.
Published: November 2005

GLOSS is a machine and language for modeling the semantics of programming languages. GLOSS is not intended to be a tool for mathematical proofs. Instead it is intended to provide an easily read graphical notation in which programming language structures and transformations (operators) can be specified. Johnston's Contour Model [Jl] has a similar intention, but GLOSS has a more flexible structure. Because the human eye can perceive a graphical notation more readily than a mathematical or programmatical notation, GLOSS and Johnston's Contour Model are more elucidating than the Vienna Definition Language [L1].

GLOSS has seven
primitive objects
:
integer
objects,
bit string
objects,
character string
objects,
reference
objects,
vector
objects,
record
objects, and
constructor
objects. Integers, bit strings, character strings, and references have their usual meanings. A vector is an ordered set of objects indexed from zero. A record is an unordered set of two tuples, each of whose first component is an identifier (character string) and whose second component is an object. The identifier is used to select its associated object. All of the above objects have a type such as integer, bit string, etc. and a value which is the object itself. A constructor object permits the formation of a new type of object.
A short discussion of interprocess communication in the sue/360/370 operating system
Authors: Holt Richard C. , Grushcow Marc S.
Published: November 2005

This paper presents the interprocess communication/synchronization scheme used in the SUE operating system. This scheme is based on a tree structure of processes which are called “facilities” and three primitive operations: Facility Call, Accept Facility Call, and Complete Facility Call. These primitives are implemented by a small “Kernel” which is the basis of the operating system.
The two-level approach to data definition and space management in the LIS system implementation language
Authors: Ichbiah J. D. , Rissen J. P. , Heliard J. C.
Published: November 2005

It has often been remarked that surprisingly few parts of the algorithms which define an operating system require the use of unsafe, low-level language features {1}. Nevertheless, the lack of safety inherent in these parts will propagate to the whole system if an appropriate methodology is not used. It seems desirable to structure programs in such a way that parts with different safety levels are clearly separated and identifiable. The LIS solution to this problem involves the use of two language levels which are used in separate contexts. The general language is a Pascal-like language with the safety that this implies {2, 3}. On the other hand, the use of unsafe features is restricted to so-called
implementation parts
associated with each declaration level of the program.

Several authors {4, 5, 6} have pointed out the advantages of having a two-step data definition, namely, a first step concerned with the semantic properties and a second dealing with the effective realization. In what follows we present the LIS approach to this question and show that the safety levels inherent to these two steps are different. The second step requires implementation specifications which appear in implementation parts.
Abstract machines and software design
Authors: King J. C.
Published: November 2005

A recent trend in operating system design [1,2,6,7] is to consider the design as a hierarchy of abstract machines. The problem is viewed as constructing a “users' machine” from a given hardware machine by means of software. Rather than do this in one large step, a progression of abstract machines are defined starting at the hardware machine and ending with the users' machine. Each new machine is “built from” the earlier machines, adding to their capabilities.

This approach appears to be a strong positive step toward bringing more discipline to the software development process. Liskov [6, 7] carefully documents the advantages. She also tries to establish formal rules to guide the process and relates this approach to structured programming [3, 8].
A data flow language for operating systems programming
Authors: Kosinski Paul R.
Published: November 2005

This paper describes a graphical programming language based on the concept of pure data flow sequencing of computations. Programs in this language are constructed through function definition and composition, and are based on the primitive notions of iteration, recursion, conditional expression, data replication, aggregation and selection, and the usual arithmetic and logical operations. Various useful programming devices such as the DO loop and, surprisingly, the memory cell are defined in terms of these primitives. Programs in this language are determinate in operation unless indeterminism is explicitly introduced. The utility of this language for designing and implementing operating systems is discussed.
Proving the adequacy of protection in an operating system
Authors: Linden Theodore A.
Published: November 2005

The best that can be expected from traditional debugging and testing techniques is that the number of bugs will be reduced to a tolerable level. However, programs that either implement or relate to protection in an operating system are examples of programs for which: 1) the number of residual bugs that can be tolerated is
zero;
2) it is necessary to know, or at least have convincing objective evidence, that the number of bugs is indeed zero; and 3) the concern extends to bugs which would not arise under normal circumstances and which may be very difficult to find either by testing or by normal use.
Tasking in standard PL/I
Authors: MacLaren M. Donald
Published: November 2005

This paper describes the treatment of asynchronous processing in “Standard PL/I” and how it is related to the “old language”. By “Standard PL/I” we mean the language being developed by American National Standards Institute Committee X3J1 and European Computer Manufacturers Association Committee TC10. Currently this language is scheduled for publication as a proposed standard in December 1973. By the “old language” we mean that subset of IBM's PL/I which the standards committees took as the starting point for their work. In the area of asynchronous processing, the development from old language to Standard PL/I was carried out by X3J12, the language development subcommittee of X3J1.
Programming languages for operating systems.
Authors: McKeag R. M.
Published: November 2005

This paper outlines some of the things that an operating system designer looks for in a programming language.

This working paper was submitted to the A.C.M. SIGPLAN/SIGOPS Interface Meeting held at Savannah, Georgia from 9th to 12th April 1973.
Transferability and translation of data
Authors: Merten Alan G. , Sibley Edgar H.
Published: November 2005

Data translation is defined as the process whereby data stored in a form that can be processed on one computer (the source file) can be translated into a form (target file) which can be used by the same or different processing systems on a possibly different computer. The research approach is to develop a generalized methodology of data translation and within this framework to design and implement a specific prototype translator.

The current methodology for translating data and files from one system to another typically consists of writing file translation programs. This method, which involves writing a new program for each file to be translated, is often referred to as
manual file translation
. Because of the machine level detail required, these translation programs are typically written in assembly language. As a result, the programming time is large.
A Kernel System for information system development, evolution, and operation
Authors: Mills Harlan D. , Wilson Max L.
Published: November 2005

We believe that the current boundaries and distinctions between operating systems, data base management systems (both “host language” and “self-contained”), programming language processors (both interpretive and compiled), programming support systems (library management, testing, and integration services), instructional systems, and certain other generalized data processing services, can and should be eliminated. That is, we believe that all these seemingly separate functions, which are currently separate for historical reasons as much as any other, can and should be addressed by a single integrated (but subsettable) “Kernel System”.

We also believe that with the proper system architecture and implementation techniques (e.g., top-down and structured programming) and with the wholesale elimination of duplicated functions, a Kernel System can be built that would address the sum total of these functions and, at the same time, remain comparable in size and complexity to a typical self-contained data base management system alone. Further, such a structured Kernel System would be much better able to support the development, continued evolution, and operation of both itself and its applications.
Programming by semantic refinement
Authors: Morris James B.
Published: November 2005

It is becoming increasingly evident that human programmers are not capable of efficiently producing reliable programs if they must be concerned initially with every detail of the final program. The approach described here is one of “semantic levels of programming”, which involves a graduated approach to the production of programs.

A common but fallacious belief of some software implementors today is that the efficient execution of software systems should be a major concern in the initial system version. In fact, the primary concern in the initial version should be the reliable operation of the system, which is closely connected with the existence of a sound, overall system design. Assuming that we recognize that there is some reasonable time from the initiation of a software system implementation project to the availability of an initial version, the philosophy of semantic refinement is based on the belief that: “If a major concern in the implementation of the initial version of a software system is efficiency, then the initial version will be unreliable.” Many systems which are initially unreliable have a way of remaining unreliable for a discouragingly long period of time.
SPECL
Authors: Udin David
Published: November 2005

The SPECL programming system is an attempt to combine the characteristics of an implementation language with those desirable for verifiability (human and mechanical) and transportability. The former requires efficient code generation and access to hardware; the latter requires a highly structured language and isolation of machine dependencies. SPECL will be embedded in the ECL programming system, which currently includes an interpreter and compatible compiler for the extensible language EL1, and a set of tools for debugging, metering, and verification. The SPECL compiler (under design) will restrict the semantics of EL1 to eliminate the need for run-time support and type checking, and couple specification of machine representation of modes and operators with the EL1 definitional mechanism to enable generation of efficient object code.
Procedural encapsulation
Authors: Zilles Stephen N.
Published: November 2005

System reliability is an important aspect of operating system construction. Because of this, a number of researchers have proposed design methodologies [e. g., 1, 2, 3] which are intended to produce more reliable software. Although the methodologies differ, there seem to be some important properties that they have in common.

One property is the decomposition of the system into components or modules which make as few assumptions as possible about the other components. We will call this the “minimal assumptions” property. Minimizing the assumptions one component makes about another component means that subsequent maintenance and extensions can be done with a smaller probability of introducing errors. A programmer is less likely to overlook critical, obscure interconnections if such interconnections are severely restricted.