bluuebunny/crossref_metadata_2025 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.
A generalized approach to document markup
Authors: Goldfarb C. F.
Published: November 2005

Text processing and word processing systems typically require users to intersperse additional information in the natural text of the document being processed. This added information, called “markup,” serves two purposes:

1. it separates the logical elements of the document; and

2. it specifies the processing functions to be performed on those elements.
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.
Construction of a transportable, multi-pass compiler for extended Pascal
Authors: Hansen G. J. , Shoults G. A. , Cointment J. D.
Published: November 2005

This paper describes the implementation of an extended Pascal compiler on the TI 990 minicomputer, the TI 980 minicomputer, and the IBM System 370. The compiler was designed to be as machine independent as possible; the parser and machine independent optimizer are parameterized so they are identical at the source code level for all machines. The paper describes the language modifications and extensions to Pascal, the parser, the optimizer, and the code generators. In addition, the intermediate language utilized is discussed at length.
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.
The use of transition matrices in a recursive-descent compiler
Authors: Pleban Uwe F.
Published: November 2005

Transition matrices are a well-known tool for the construction of bottom-up compilers. This paper discusses the use of transition matrices in the recursive-descent compiler for the structured assembly language PL/85. In this compiler, a transition matrix (TM) is a self-contained module which can recursively invoke other TMs. TM invocation and exit and state transitions are handled by a microcoded interpreter. It is shown that our use of TMs made the compiler easy to implement and maintain, considerably reduced the space requirements for the parser, and resulted in a reliable, efficient and flexible compiler with good error handling capabilities.
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.
Prolog - the language and its implementation compared with Lisp
Authors: Warren David H D , Pereira Luis M. , Pereira Fernando
Published: November 2005

Prolog is a simple but powerful programming language founded on symbolic logic. The basic computational mechanism is a pattern matching process (“unification”) operating on general record structures (“terms” of logic). We briefly review the language and compare it especially with pure Lisp. The remainder of the paper discusses techniques for implementing Prolog efficiently; in particular we describe how to compile the patterns involved in the matching process. These techniques are as incorporated in our DECsystem-10 Prolog compiler (written in Prolog). The code it generates is comparable in speed with that produced by existing DEC10 Lisp compilers. We argue that pattern matching is a better method for expressing operations on structured data than conventional selectors and constructors - both for the user and for the implementor.
LL versus LR parsing with illustrations from ALGOL 68
Authors: Hunter R. B. , McGettrick A. D. , Patel R.
Published: November 2005

The relative merits of LL and LR parsing methods are compared, particular reference being made to ALGOL 68. The fact that LR methods can be applied to a wider class of languages does not seem to give them a significant advantage in practice.
Towards the design of a super-language of ALGOL 68 for the Standard Prelude (Excerpt)
Authors: Grune Dick
Published: November 2005

The problems concerning SIZETY definitions in an Unabridged Machine-Independent Standard Prelude for ALGOL 68 are examined and tentative solutions are given.
Using procedures in list processing
Authors: Rayward-Smith V. J.
Published: November 2005

In many situations the atoms in a list can require a considerable amount of storage space or can be difficult to evaluate. When handling algorithms which only refer to a few atoms of a list much time and space can be wasted if the whole list is stored. In this paper an attempt is made to store lists as procedures which are only evaluated if absolutely necessary. The difficulties which arise when programming such a list processor in Algol 68 are caused by inherent scoping problems. A solution is presented for linear lists together with an example based on the processing of an infinite list.
Minicomputer programming languages
Authors: Gorman Walter , Broussard Michael
Published: November 2005

Reduced hardware costs have made high level languages for minicomputers a necessity. A survey of some of the languages available (FORTRAN, BASIC, FOCAL, PL-11, C, SPL, MPL, PLM, and BCPL) demonstrates the current need for a simple, portable, and readable minicomputer language.
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 design laboratory
Authors: Vickery Christopher
Published: November 2005

Sophisticated design aids are available to help automate microprogram development both for large, complex computers and for microprocessor-based systems. These aids include procedures for source code verification, object code generation, microprogram simulation, and interactive debugging. For various reasons, such aids are generally not well-developed for microprogrammable minicomputers. This paper describes a microprogramming laboratory developed for the Interdata 85 minicomputer which uses both the minicomputer itself as well as the time-sharing and batch facilities of a large computer center. Experience with the laboratory has shown that the facility for interacting with a microprogram is as important as the availability of complete diagnostic information. The argument is made that design automation aids for microprogramming minicomputers could be produced efficiently from standardized assembly and simulation programs.
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.
Treating failure as state
Authors: Wong L. , Ooi B. C.
Published: November 2005

Typical failure handling schemes for statement based (or imperative) languages are not very satisfactory. A bold simple alternative is suggested in this report. The new scheme allows failure to be treated at more appropriate time and place.
A theory of organization
Authors: Issendorff H. Von
Published: November 2005

The theory of organization deals with the representation and treatment of processing structures and their realization. It offers an algebra, which in particular is qualified for a unified description of soft- and hardware. The term replacement rules coming along with the algebra allow to change a processing structure in a variety of ways. In particular, there are order changing rules allowing to generate any representation between the minimum order of dataflow and the maximum order of a sequence. Moreover, conversion rules can be specified for the transformation of conventional programming languages into the (language of the) algebra. The same is possible for the conversion of Boolean algebra. Finally, a circuit description language can be derived from the algebra, which seems to be well suited for VLSI-layout. Part 1 of this paper covers a general introduction to the subject and the notions, the relations, and the algebra on which the theory of organization is based. Part 2 deals with nondeterminism and communicating processes, presents the conversion rules for a subset of Pascal and for Boolean expressions and introduces the circuit description language.
VisiCLANG—a visible compiler for CLANG
Authors: Resler D.
Published: November 2005

This paper describes a visible compiler for the CLANG language. VisiCLANG shows on-screen, in various text windows, all aspects of the CLANG compiler as it compiles and executes a user's program. This allows someone who is learning the techniques of compiler construction to see the inner workings of a simple recursive-descent compiler.
Representing control in the presence of first-class continuations
Authors: Hieb R. , Dybvig R. Kent , Bruggeman Carl
Published: November 2005

Languages such as Scheme and Smalltalk that provide continuations as first-class data objects present a challenge to efficient implementation. Allocating activation records in a heap has proven unsatisfactory because of increased frame linkage costs, increased garbage collection overhead, and decreased locality of reference. However, simply allocating activation records on a stack and copying them when a continuation is created results in unbounded copying overhead. This paper describes a new approach based on stack allocation that does not require the stack to be copied when a continuation is created and that allows us to place a small upper bound on the amount copied when a continuation is reinstated. This new approach is faster than the naive stack allocation approach, and it does not suffer from the problems associated with unbounded copying. For continuation-intensive programs, our approach is at worst a constant factor slower than the heap allocation approach, and for typical programs, it is significantly faster. An important additional benefit is that recovery from stack overflow is handled gracefully and efficiently.
Task granularity analysis in logic programs
Authors: Debray Saumya K. , Lin Nai-Wei , Hermnegildo Manuel
Published: November 2005

While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the “granularity” of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.
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.
The design and implementation of a very high level language for literary scholars
Authors: Levison Michael
Published: November 2005

A very high level language is outlined which has been designed to allow literary scholars to perform operations such as the extraction of data from texts, the construction of concordances and the siting of manuscript fragments. An efficient implementation is described, and some possible enhancements suggested.
The use of abstract data types to simplify program modifications
Authors: Linden Theodore A.
Published: November 2005

If a program is structured using abstract data types as the basic unit of modularity, then that program is much easier to extend or modify. This thesis is illustrated by the staged development of a program to compute prime numbers based on the sieve of Eratosthenes. This paper includes an extensive introduction to the concept of abstract data types and can be used as a tutorial survey. It includes discussions on the use of abstract data types in connection with recent approaches to data abstractions, heirarchical structure, and program design. Abstract data types are an extension and modification of the traditional concept of data type. An abstract data type defines not only a data representation for objects of the type but also the set of operations that can be performed on objects of the type. Furthermore, the abstract data type can protect the data representation from direct access by other parts of the program.
The System for Business Automation (SBA)
Authors: Zloof Moshe M. , de Jong S. Peter
Published: November 2005

The System for Business Automation (SBA) is a system within which application experts—non-programmers—can describe and execute their applications on a computer. This paper describes the programming language part of the system. This language is a superset of Zloof's Query-by-Example. In Query-by-Example the user retains the perception of manual table manipulation by programming within two-dimensional skeleton tables displayed on the screen. In SBA the user programs within skeletons of more general business entities such as tables, forms, charts, etc. Within these displays the user programs his application as a series of Query-by-Example operations. This system can also run in a part manual, part automated manner, thus permitting fast initial use of the computer together with gradual automation of the business.
A data type encapsulation scheme utilizing base language operators
Authors: Wells Mark B. , Cornwell Fred L.
Published: November 2005

A data type encapsulation scheme in which the “space” operations are expressed naturally in terms of the base language operators is described. The scheme results from a conceptual separation of operators and procedure calls in the base language and produces a language of considerable expressive power. The scheme has been implemented and several examples are given.
A review of two-dimensional programming languages
Authors: Wells Mark B.
Published: November 2005

Everyday mathematical language, as it appears on the printed page for instance, non-trivially makes use of two dimensions. This paper discusses various technical aspects of programming languages which utilize such natural symbolism. First, some terminology which is and can be useful in describing these systems is presented. Then, the man-machine interface in relation to two-dimensional languages in general is examined. This is followed by an historical survey of particular languages, including a brief description of their two-dimensional characteristics. Finally, a review of the analysis problem for such languages is given.
Progress in MIRFAC
Authors: Gawlik H. J.
Published: November 2005

The paper describes the main design objectives and salient features of the MIRFAC programming language, and includes an account of some of the recent developments. Particular emphasis is laid on the “two-dimensional” features and examples, taken mainly from user programmes, are given which demonstrate the power of these features both in programming and in the printing of algebraic output.
The Assistant Mathematician
Authors: Saylor Jean
Published: November 2005

This paper describes an experimental interactive graphics system called The Assistant Mathematician (TAM). TAM is a prototype computational aid for non-programmers, particularly engineers or scientists, that uses ordinary two-dimensional mathematical notation as its language. The system includes an arithmetic interpreter, incorporating an extensive set of arithmetic operators on constants, variables, and arrays, that accepts hand-printed graphic (two-dimensional) input from a data tablet and supplies two-dimensional output via a projection display system. TAM is one of a class of potential interactive graphics systems useing natural language to improve man-machine communication.
Two-dimensional characteristics of HAL, a language for spaceflight applications
Authors: Miller James S.
Published: November 2005

A contribution to software quality is realized in the HAL language implementation by distinguishing the source-language input format from that of the listing produced by the compiler. The two-dimensional features of the source text may be fully supplied by the compiler, and include natural expression of subscripts and exponents of variables, and distinctive marking of data types and organizations.
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.
Correctness of a compiler for a Lisp subset
Authors: London Ralph L.
Published: November 2005

Excerpts of a proof of correctness of a running Lisp compiler for the PDP-10 computer are given. Included are the rationale for presenting this proof and a discussion of an actual extension of the proof to another compiler.
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.
Extensible language - where are we going
Authors: Cheatham T. E.
Published: November 2005

It has now been several years that work in that area of programming languages and systems which we at this conference choose to call “Extensible Languages” has been going on. Indeed it has been a few years since “Extensible Languages” were being touted as the “wave of the future” and promised for delivery “tomorrow.” There are clearly many at this conference who feel that we are still not there - that we have a long way to go in basic research and development of extensible languages and their host facilities; I do not share this opinion. Rather, I think that in a very strong sense “we have arrived” - that there exist languages and host systems which fulfill the goals of extensibility. I would cite, as one example the ECL systems discussed in several other papers in these proceedings. (see [2], [3])

This is not to suggest that the problem is completely solved. Indeed, there is a great deal of work still necessary to tune, adjust, adapt, and exploit the languages and systems now just becoming available. However, it is my position that further
research
in extensible language, per se, is probably destined to yield only marginal results until such time as a significant period of exploitation has clearly pinpointed issues with which a new wave of extensible language research might attempt to contend.
Brief survey of languages used for systems implementation
Authors: Sammet Jean E.
Published: November 2005

This paper provides a brief survey of languages used for developing operating systems. The paper discusses the issues involved in deciding on the use of a higher level language, including the technical, management, psychological factors, and the advantages and disadvantages. The major part of the paper discusses specific languages which have been used, and the major systems which have been developed using them. General comments and future trends are indicated, with a discussion of desirable characteristics, the non-universality of a single systems programming language, system specification languages, machine independence, and operating system writing systems. An appendix lists languages known to have been used for writing either compilers and/or operating systems, and indicates references for them.
Current systems implementation languages
Authors: Slimick John
Published: November 2005

One user's experience with five current systems implementation languages is outlined stressing virtues and vices of each; the five are: FORTRAN, PASS, GOGOL, XPL, and PL360. Some criteria for future systems implementation languages are suggested; the most crucial features of a systems implementation language are (1) access to the “real” machine, (2) compatibility with existing software, (3) linguistic structure, and (4) predictability of code generator and storage management.
A survey of the systematic use of macros in systems building
Authors: Farber David J.
Published: November 2005

Assemblers with macro capabilities have been available for over ten years. There has been a limited number of mainly unpublished systematic uses of such capabilities in the construction of a variety of systems. This paper will cover a number of these cases. We will examine the features of the macro systems which allowed their usage as well as the method used in the system implementation. We will comment on the effect on efficiency and flexibility that the use of this facility has produced.
Language for Systems Development
Authors: Bergeron R. Daniel , Gannon John D. , Dam Andries van
Published: November 2005

Well-designed efficient systems programming languages are an absolute necessity if programmers are to keep pace with the demand for systems. This paper presents briefly some criteria to be applied to the design of a general purpose systems programming language and a description of the Language for Systems Development that is being implemented at Brown University for the IBM S/360. The paper is a revised and condensed version of a much larger survey paper [3]. The research and writing of this paper and the design of LSD were partially supported by a National Science Foundation grant (No. GJ-181) and by Brown University. We would like to acknowledge the help and invaluable suggestions given us by Richard Wexelblat of Bell Laboratories, Robert Balzer of the RAND Corporation, John Brackett and Douglas Ross of Softech, Inc., and Robert Rosin of the State University of New York at Buffalo. Special thanks should be given to Paul Knueven of Digital Equipment Corporation who helped initiate the entire effort and has been a source of help and encouragement through many iterations. The authors would also like to thank Frank Tompa of the University of Toronto and Diane Shecter who were among the original designers of LSD.
The System Language for Project SUE
Authors: Clark B. L. , Horning J. J.
Published: November 2005

Project SUE is writing a complete operating system for the IBM System/360 family of computers in a language designed especially for that purpose. The System Language was designed from the following premises: (a) it must facilitate nicely structured programs and data; (b) it must be readable; (c) it must actively assist in the detection and isolation of errors; (d) it must be compilable into efficient code; (e) it must allow the programmer precise control over the emission of instructions and allocation of storage; (f) it must be easily modifiable; (g) it must have an efficient compiler; and (h) it must be easily implementable. Although the resulting language is very much a product of the Project SUE environment, some of its features may be of more general interest.
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.
XVF
Authors: Stephens Kurt
Published: November 2005

Object serialization and object inspector user interfaces are concerns that can be orthogonally implemented using introspection via meta-object protocols (MOP). The C++ language lacks a formal meta-object protocol, although some are available as source pre-processors. A full MOP is not necessary for many classes of problems where basic introspection is useful. This paper describes a technique: extensible visitation of objects as a basic introspection primitive.
ML
F
Authors: Le Botlan Didier , Rémy Didier
Published: November 2005

We propose a type system ML
F
that generalizes ML with first-class polymorphism as in System F. Expressions may contain second-order type annotations. Every typable expression admits a principal type, which however depends on type annotations. Principal types capture all other types that can be obtained by implicit type instantiation and they can be inferred.All expressions of ML are well-typed without any annotations. All expressions of System F can be mechanically encoded into ML
F
by dropping all type abstractions and type applications, and injecting types of lambda-abstractions into ML
F
types. Moreover, only parameters of lambda-abstractions that are used polymorphically need to remain annotated.
Iterative-free program analysis
Authors: Ogawa Mizuhito , Hu Zhenjiang , Sasano Isao
Published: November 2005

Program analysis is the heart of modern compilers. Most control flow analyses are reduced to the problem of finding a fixed point in a certain transition system, and such fixed point is commonly computed through an
iterative procedure
that repeats tracing until convergence.This paper proposes a new method to analyze programs through
recursive graph traversals
instead of iterative procedures, based on the fact that most programs (without
spaghetti
GOTO) have well-structured control flow graphs,
graphs with bounded tree width
. Our main techniques are; an algebraic construction of a control flow graph, called
SP Term
, which enables control flow analysis to be defined in a natural recursive form, and the
Optimization Theorem
, which enables us to compute optimal solution by dynamic programming.We illustrate our method with two examples; dead code detection and register allocation. Different from the traditional standard iterative solution, our dead code detection is described as a simple combination of bottom-up and top-down traversals on SP Term. Register allocation is more interesting, as it further requires optimality of the result. We show how the Optimization Theorem on SP Terms works to find an optimal register allocation as a certain dynamic programming.
Call-by-value is dual to call-by-name
Authors: Wadler Philip
Published: November 2005

The rules of classical logic may be formulated in pairs corresponding to De Morgan duals: rules about & are dual to rules about
V
. A line of work, including that of Filinski (1989), Griffin (1990), Parigot (1992), Danos, Joinet, and Schellinx (1995), Selinger (1998,2001), and Curien and Herbelin (2000), has led to the startling conclusion that call-by-value is the de Morgan dual of call-by-name.This paper presents a dual calculus that corresponds to the classical sequent calculus of Gentzen (1935) in the same way that the lambda calculus of Church (1932,1940) corresponds to the intuitionistic natural deduction of Gentzen (1935). The paper includes crisp formulations of call-by-value and call-by-name that are obviously dual; no similar formulations appear in the literature. The paper gives a CPS translation and its inverse, and shows that the translation is both sound and complete, strengthening a result in Curien and Herbelin (2000).
FORTRAN programming standards
Authors: Lee Godfrey , Boreham Tim , Minns Bob , Smith Fred , Soderstrom Rick
Published: November 2005

In April of 1978, the FORTRAN programming standards were developed as part of an overall corporate standard on system development. The standards were put into practice immediately on a project that involved three senior programmers, one intermediate programmer, three junior programmers, and a hundred-odd programs. We were pleasantly surprised that the programmers adopted the standards with little effort, even those who were not indoctrinated into the structured programming environment. Also, all the objectives stated in the introduction were more than adequately met.We hope that you will find this useful in your FORTRAN applications.
Toward relaxing assumptions in languages and their implementations
Authors: Shaw Mary , Wulf Wm. A.
Published: November 2005

Language implementors frequently make pre-emptive decisions concerning the exact implementations of language features. These decisions constrain programmers' control over their computations and may tempt them to write involuted code to obtain special (or efficient) effects. In many cases, we can distinguish some properties of a language facility that are essential to the semantics and other properties that are incidental. Recent abstraction techniques emphasize dealing with such distinctions by separating the properties that are necessary to preserve the semantics from the details for which some decision must be made but many choices are adequate. We suggest here that these abstraction techniques can be applied to the problem of pre-emptive language decisions by specifying the essential properties of languages facilities in a skeleton based language and defining interfaces that will accept a variety of implementations that differ in other details.
Indenting for the compiler
Authors: Leinbaugh Dennis W.
Published: November 2005

A simple indentation rule, indent statements from the control statement they belong to, is sufficient to express a program's block structure without the use of compound statements or closing keywords. This is proven using a PASCAL-like language (using indentation instead of BEGIN-END blocks). Using indentation alone means a programmer need not give two independent specifications of a program's block structure, thus reducing effort and eliminating a potential source of errors.
On the great big substitution problem
Authors: Blatt D. W. E.
Published: November 2005

The middle ground between text editors and string processing languages is examined. A minor but nontrivial extension to SNOBOL is outlined to enable it to perform efficiently in this arena. A side effect is the provision of a virtual storage facility for long strings.
Procedure semantics and language definition
Authors: Bradshaw Franklyn T. , Ernst George W. , Hookway Raymond J. , Ogden William F.
Published: November 2005

Semantics for procedures and their calls is proposed which describes two cases often considered to be outside contemporary programming languages: distributed computing and procedure calls that contain aliases. It is argued that this semantics should be used as the basis of programming language definition because it is simple, intuitive and unifies these seemingly different cases. To support this argument, a verification rule for procedure calls with aliases is given which is no more complicated than those found in the literature. This verification rule is possible only because it is based on the proposed semantics.
Nested sublanguages of Algol 68 for teaching purposes
Authors: Pagan Frank G.
Published: November 2005

Two sequences of nested sublanguages of Algol 68 suitable for use in teaching introductory programming are proposed. "A68/k" is a sequence of twelve sublanguages suitable for use in an educational context where the learning of Algol 68 per se is considered important. "SA/k" is a sequence of eight sublanguages suitable for use in a context where the aim is to teach the principles of good programming with minimal concern for the purely linguistic aspects. SA/k is claimed to be superior to other teaching languages such as Pascal.
Compact chart
Authors: Hanata Syuetsu , Satoh Tadamasa
Published: November 2005

This paper describes an improved flow chart notation, Compact Chart, developed because the flow chart conception is effective in constructing program logics, but the conventional notation for it is ineffective.By introducing the idea of separation of control transfer and process description, Compact Charting gives an improved method of representing and understanding program logics.
File handling in programming languages
Authors: Gobin Marc A.
Published: November 2005

Many programming languages allow the use of files. In Fortran, ALGOL60 and a few other programming languages file handling is not developed. In COBOL, PL/1, RPG, and partially in ALGOL68 a more or less complete set of instructions is provided for file handling. In the reference manuals for these languages the different elements of the file handling aspects are generally very confusing, because implementation restrictions do not allow a smooth orthogonal design of all these aspects. The aim of this article is to give a clear definition of all these aspects.A first paragraph states the three aspects considered. These are explained and developed in the following paragraphs. In a fifth part a summary is given of the desired operations on files, followed by a short description of an actual implementation. Some conclusions are drawn in a last paragraph.