bluuebunny/crossref_metadata_2025_split huggingface dataset:
Z - the 95% program editor
Authors: Wood Steven R. 
Published: November 2005

Recently much attention has been focused on structure-oriented program editors that have specific knowledge about the syntax and semantics of a particular programming language [1, 4, 5, 18]. These editors provide many desirable features for editing programs. However, the user interface is constrained by the syntax and semantics of the target language, and editing operations that are simple in a text editor can be quite complicated in a structure-oriented editor. In addition, the user has an editor that is limited to a single language and must use a different editor for text editing. Existing implementations of structure-oriented editors use a parse-tree representation for a program along with a supporting lexical analyzer, parser, and pretty-printer; this representation significantly complicates the implementation of an editor.
We believe that the most natural representation of programs is text and that the editor should be able to take advantage of the same visual cues that programmers use to understand their programs. With a text-oriented model of program structure, the editor is both a program editor and a document editor. As a program editor it provides features to support many different programming languages, such as LISP, APL, PASCAL, and BLISS. As a document editor it provides basic word-processing functions such as text justification and spelling correction. A text orientation considerably simplifies the design of the editor and presents the user with a simple but powerful model of program structure. This paper describes a text-oriented display editor called Z. Z is the production editor in the Yale Computer Science Department.
Etude and the folklore of user interface design
Authors: Good Michael 
Published: November 2005

Research in user interface design is like the weather—everybody talks about it, but nobody does anything about it. While this isn't strictly true, the great majority of guidelines for user interface design that one is likely to come across are based on the experience or gut feelings of a particular designer. These are better than nothing, but they are made less useful since 1) a particular recommendation could be based on factors unique to the designer's own system, 2) the population for whom the particular system is intended is either not described in detail or is not a generalizable sample of computer users, 3) designers' gut feelings are notoriously inaccurate sources for human factors guidelines. Thus the main body of recommendations available to the designer of a new system is more in the category of folklore than of readily accepted engineering principles.
So long as one recognizes these limitations, it is still very helpful to consider the recommendations one finds in the literature when designing a new system. Some of these are based on experimental evidence, while others are repeated often enough and with so little opposition that their utility is better than average. In this paper, I will show how these principles have been applied in designing the Etude text processing system. After summarizing the major ideas behind the design of Etude, I will focus on several specific areas of user interface design, comparing Etude's approach with the appropriate recommendations from the folklore. I will conclude by briefly describing a forthcoming experiment which is intended to determine if adherence to the folklore has in fact produced a system that is easy to use.
An annotated bibliography of background material on text manipulation
Authors: Reid Brian K. , Hanson David 
Published: November 2005

This is the first ACM conference specifically devoted to text manipulation, but there have been good papers and books on the topic published in the past. To help define the state of the field as of the time of this first conference, we have assembled this small annotated bibliography listing classic or important past work on text manipulation, including material on text editing, document formatting, typography, graphic communication, writing style, string and pattern matching, and other problems of interest to researchers in this field. Ben Schneiderman of the University of Maryland and Chris Fraser of the University of Arizona have provided us with some of the annotations of papers on text editing.
In a bibliography like this one it is impossible to include every relevant paper, or even every important paper. We in general have chosen to include those that have been influential, are widely available, and are also reasonably current. We have additionally included a number of papers and books that supply background knowledge about relevant applications areas that might not be widely known to computer scientists.
Compiler design for efficient code generation and program optimization
Authors: Rudmik A. , Lee E. S. 
Published: November 2005

This paper describes the design of a compiler for an extended PASCAL with particular emphasis on code generation and optimization. The design objectives are: compiler reliability, code generator portability and object code efficiency.
Designing a compiler to meet the above objectives usually requires compromises in the design. To achieve the objective of compiler reliability, one frequently tries to simplify the compiler design in order to reduce the complexity that must be mastered in the implementation. Unfortunately, the objective of producing efficient code conflicts with the objective of simplifying the compiler design. The design presented in this paper attempts to maximize the attainment of these objectives with minimal compromises.
Practical LR error recovery
Authors: Graham Susan L. , Haley Charles B. , Joy William N. 
Published: November 2005

We present a practical, language independent mechanism for error recovery in LR parsers. The method is easy to implement in existing parser generators. It uses only the normal parse tables and a small amount of symbol cost information. It is possible to use compressed parse tables with the method, as well as other LR augmentations such as precedence and associativity declarations. The method is efficient enough to be used in environments where space and time are at a premium.
Our method utilizes a number of previous error recovery ideas: forward moves in the input after detection of errors to incorporate right context, recovery choice based on weighted costs, and the use of special productions to indicate major productions in the grammar for error recovery. The method also makes use of semantic information in choosing between possible recovery actions.
We have implemented the method in a production Pascal translator which has been in use for instruction at a number of universities for two years. We report here on measurements of our system on a standard data base of Pascal programs with errors.
An integrated microprocessor support software system
Authors: Braun Christine L. 
Published: November 2005

As the commercial use of microprocessors increases, the need for various support software tools arises. These tools include assemblers to aid in the creation of programs, and digital simulators to aid in their checkout. Raytheon's Automatic Micro Processor Support (RAMPS) system is an integrated set of support software programs designed to take advantage of the microprogrammable aspect of the target processor.
There are three main components of the RAMPS system - a micro-assembler, a macro-assembler, and a digital simulator. In addition there is a control system, through which the user communicates with all parts of the system. RAMPS is designed to be independent of the particular macro-instruction set determined by the micro-program, insofar as is possible. Thus, it is a versatile system which can be used with any of the various macro-instruction sets developed for the target machine.
The RAMPS system is written in FORTRAN and runs on the CDC 6700 computer under the KRONOS 2. 1 Operating System. Designed to support a Raytheon-built microprocessor, its flexibility has already been demonstrated by adaptation to two new, architecturally similar, microprocessors.
A microprogramming language for the MLP-900
Authors: Oestreicher Donald R. 
Published: November 2005

This paper describes a language, for programming a microprocessor, which combines the features of assembly languages with those of higher-level languages. The goal of the language design was to provide a convenient microprogramming language for the MLP-900 microprocessor project at USC/Information Sciences Institute.
This goal was accomplished by designing a language with careful consideration of the hardware instruction set. Additionally, the language was constrained not to implicitly affect the machine state at runtime. These considerations provided freedom and low-level control for the programmer. The compiler needed some flexibility to allow for higher-level language forms. This flexibility was provided by allowing the language to produce several microinstructions for each language statement.
This project is sponsored by the Advanced Research Projects Agency. This work is directed toward an ARPANET-based sharable resource as a means of exploring computer architecture, language development and special purpose processor design, all of which are of particular relevance to DOD selection and use of computer equipment.
The design of a procedureless programming language
Authors: Goldsmith Clair W. 
Published: November 2005

The programming of digital computers has been a major concern of mainframe manufacturers, academicians, computer users and software product manufacturers since the first marketable computers were produced. Most often, the machine execution order has been explicit at the level at which the machine is programmed.
This paper takes as a premise that source statement ordering does not have to describe machine execution order. It describes a specific procedureless programming language that requires no ordering of the source program. This language includes primitives for performing calculations on sets. In this language statements are not executable. They are rules for defining sets. The paper concludes with a discussion of the usefulness of the language for a typical programming application.
Recursive definitions of partial functions and their computations
Authors: Cadiou J. M. , Manna Zohar 
Published: November 2005

The object of this paper is to present a syntactic and semantic model for recursive definitions, and to study the relation between their computed functions and their fixpoints. The recursive definitions that we consider are syntactic generalizations of those introduced in [2] by Kleene and in [5] by McCarthy.
Each recursive definition yields two classes of fixpoint partial functions (“fixpoints over D υ {ω}” and “fixpoints over D”), and a class of computed partial functions obtained by applying different computation rules to the recursive definition. In this work we first describe the relations between the computed functions and the fixpoints over D υ {ω} (Theorem 1), and between the computed functions and the fixpoints over D (Theorem 2). Our main interest is in the class of fixpoints (over D or D υ {ω}) which are also computed functions of the recursive definition.
The correctness of numerical algorithms
Authors: Hull T. E. , Enright W. H. , Sedgwick A. E. 
Published: November 2005

Structured programming and the use of assertions are two basic techniques needed in organizing proofs of the correctness of algorithms. These techniques can be combined with theorems in numerical analysis to produce proofs of the correctness of numerical algorithms.
A simple algorithm for finding the sum of n numbers is first used to show how assertions can be modified to take account of the effect of roundoff. A so-called backward error analysis then leads to a proof that the algorithm is correct in the sense that it produces exact results for slightly perturbed problems. Alternative points of view are possible, and one of the distinguishing features of numerical algorithms is that there usually are a number of different senses in which one might want to prove them correct.
Two other more substantial algorithms, one for solving linear algebraic equations and one for solving differential equations, are then used to show how structured programming and the use of assertions can be combined with error analyses of fairly complicated numerical processes to provide proofs of correctness. One of these algorithms involves roundoff error while the other is affected primarily by truncation error.
The description and the structure of ALGOL N
Authors: Yoneda N. 
Published: November 2005

ALGOL 68 has been designed as a powerful successor of ALGOL 60. It is a monumental language, but we regret the complexity of it and its description. This has been the primary motivation for our designing ALGOL N, a more viable successor of ALGOL 60, as powerful as ALGOL 68, and yet described in a much simpler way.
Some characteristics of ALGOL N will now be given. The letter 'N' is short for 'Nippon', which means 'Japan' in Japanese.
1. An easy-to-grasp meta-language for the syntax description is devised. It is logically equivalent to BNF, but the whole syntax can be compactified by its use. Thus the syntax of ALGOL N (see Appendix) is even shorter and easier to understand than the BNF syntax of ALGOL 60. There are a number of extensions to the strict language just as in ALGOL 68.
2. The semantics is described with rigor, partly in prose of mathematical clarity, and otherwise, in the form of simple programs in a semantics description language called the 'core language'.

3. Basic data types are
effect, real, bits, string,
and
reference
from which types of
array
-style,
structure
-style, and
procedure
-style are compounded. The result of a completed elaboration of an expression is (aside from possible side effects) a 'quantity' of some 'mode' with which some value of a fixed type is associated. The type specifies a machine-independent domain of values such as the domain of real numbers, while the mode prescribes the behavior of a quantity upon assignment of a value (e.g. rounding). Coercion is avoided by this system without tears.

4. The treatment of operators is generalized so that the unified notion 'formula' covers term, factor, assignment statement, for-statement, conditional expression, etc. This together with the feature that, in specifying a type, any sample expression having an established type may be used, makes the mode-indication in ALGOL 68 only a special case of 0-ary operator.
An overview of the ECL programming system
Authors: Wegbreit Ben 
Published: November 2005

The ECL programming system has been designed as a tool for tackling 'difficult' programming projects. That is projects on which existing languages could be used only with considerable waste in machine or programmer time.
Such projects include much of the frontier of computer technology; whenever several application areas are conjoined and whenever solution of a problem requires linguistic development—in algorithmic notation or information structures. Examples range from the management of large scale distributed data bases to applied artificial intelligence.
A model of extensible language systems
Authors: Notley M. G. 
Published: November 2005

At the present time the subject of extensible languages appears to suffer from the lack of any central coherent framework to knit together the many pieces of individual work that are being done. This paper is an attempt, therefore, to fill that lack.
What appears to be required is some central conceptual model or paradigm of languages and language extensibility onto which framework we can hang all these pieces of work.
This paper, therefore, contains of four main points:-
* The description of a very simple model of formal machine languages and their operation.
* A discussion of the generality of this model.
* A discussion of the usefulness of this model for the study of extensible languages.
* An illustration of the application of the model by reference to an on-going implementation at the IBM (UK) Scientific Centre.
MENELAUS
Authors: Woolley John D. 
Published: November 2005

The research described below deals with measurement of efficiency characteristics of extensible languages having very small cores. Bell's language Proteus [1] was chosen as an object of study since it is a member of this class and moreover, contains quite general schemes for syntactic and semantic extensibility. I have implemented a Proteus interpreter in Fortran on an XDS Sigma 5, incorporating changes to Bell's original implementation as well as those of Harris [2].
An obvious serious concern in using small core languages is the efficiency of their translation and execution. This efficiency derives from two main sources: the implementation of the core language on a given machine and the implementation of the extended language(s) onto the core. The former problem is solvable by direct implementation in hardware or microprogramming and will not be considered further. The second problem we wish to consider at greater length.
The LRLTRAN language as used in the FROST and FLOE time-sharing operating systems
Authors: Du Bois Pierre J. , Martin Jeanne T. 
Published: November 2005

Implementation of operating systems in high level languages is desirable when the responsibility for systems generation extends over a volatile configuration of dissimilar machines. The attendant advantages include rapid development, ease of conversion for new hardware, and self-documentation permitting more viable use of personnel.
The scope of a high level language capable of expressing a complex operating system should be broad enough to embrace an ability to deal with variable field length data, both in arrays and as tabled entries, a powerful decision-making capability and some ability to dictate efficient object code generation.
LRLTRAN provides these capabilities and others which, though of lesser significance, contribute to the ease of program development. This language has made it possible to produce the FROST and FLOE operating systems for the CDC-6600 and CDC-7600 computers, respectively, and to design and code an operating system for forthcoming hardware.
ACM SIGPLAN history of programming languages conference ALGOL 60 language summary
Authors: Gries David 
Published: November 2005

The term ALGOL is reported to have sprung from “ALGOrithmic Language”. Many forget, however, that ALGOL is the second brightest star in the constellation Perseus and part of an eclipsing binary. ALGOL exhibits a variation in light, which is caused by the fact that once every 69-odd hours it is partially eclipsed by a dark body, its partner star, for about 10 hours. But note that ALGOL always manages to regain its brilliance. ALGOL and its eclipsing companion (could it be FORTRAN?) are miles and miles apart (about 6,000,000).
ALGOL 60 and FORTRAN are both algebraic languages designed primarily for writing programs to solve numerical problems. Both have simple variables and arrays, declarations, assignment statements, conditional and iterative statements, and procedures (subroutines).
The FORTRAN Language
Authors: Galler Bernard A. 
Published: November 2005

The FORTRAN language was intended to be a vehicle for expressing scientific and mathematical computation, while allowing efficient object code to be produced. Since there was an emphasis on scientific computation in FORTRAN and FORTRAN II, little provision was made for heterogeneous data structures. Only arrays of up to three dimensions were possible, and they had to be declared explicitly:
DIMENSION ALPHA (10,15), BETA (12)
Input and output statements allowed a little more flexibility, in that provision was made for controlling the format of information read from or written to the outside world (as opposed to reading or writing binary information on disk or tape):
WRITE (5,200) MTH, BETA, Y
200FORMAT (6H MONTH, 13, 8H; QUOTAS, 12F4.0, 10H; FORECAST, F 6.2 )
The development of the General Purpose Simulation System (GPSS)
Authors: Gordon Geoffrey 
Published: November 2005

The General Purpose Simulation System (GPSS) is a programming system designed for the simulation of discrete systems. These are systems that can be modeled as a series of state changes that occur instantaneously, usually over a period of time. Complexities in their analysis arise because there are many elements in the system, and there is competition for limited system resources. The simulation technique uses numerical computation methods to follow the system elements through their changes of state, and predicts properties of the system from measurements on the model.
GPSS came into existence rapidly, with virtually no planning, and surprisingly little effort. It came rapidly because it filled an urgent need that left little time for exploring alternatives. The lack of planning came from a happy coincidence of a solution meeting its problem at the right time. The economy of effort was based on a background of experience in the type of application for which the language was designed, both on the part of the designer and the early users.
The development of the SIMULA languages
Authors: Nygaard Kristen , Dahl Ole-Johan 
Published: November 2005

The organizers of this conference have told us that we should write at least 25 pages of manuscript, but that we may produce as many pages more as we wanted. Perhaps they did not envisage the possible consequences, but we have taken their words at face value.This paper has implied a vast amount of work and archeological activities. We are grateful to SIGPLAN for defining a task to which resources had to be allocated by our institutions and which forced us to write down an account of our work from 1961 to 1971. While we are writing this preface, those years are very much alive to us. We realize that we lived through this period in a state of semimadness, a combination of very hard work, frustration, and euphoria.
Afterword
Authors: Wexelblat R. L. 
Published: November 2005

The formal proceedings of the ACM SIGPLAN History of Programming Languages Conference are to be published in a volume containing not only the papers, but edited transcriptions of the keynote speech, the discussions following each paper, and other relevant material.
In this way, the organizers of the conference hope to provide a permanent archive of information on the early stages of the development of those languages which have proven their value through long and continued use.