Showing papers on "Specification language published in 1971"

BLISS: a language for systems programming

Abstract: A language, BLISS, is described. This language is designed so as to be especially suitable for use in writing production software systems for a specific machine (the PDP-10): compilers, operating systems, etc. Prime design goals of the design are the ability to produce highly efficient object code, to allow access to all relevant hardware features of the host machine, and to provide a rational means by which to cope with the evolutionary nature of systems programs. A major feature which contributes to the realization of these goals is a mechanism permitting the definition of the representation of all data structures in terms of the access algorithm for elements of the structure.

A language extension for graph processing and its formal semantics

Abstract: A simple programming language “extension,” Graspe, for processing directed graphs is defined. Graspe consists of a type of directed graph data structure and a set of primitive operations for manipulating these structures. Graspe may be most easily implemented by embedding it in a host language. Emphasis is placed both on Graspe itself and on its method of definition. Commonly, the definition of a language involves definition of the syntactic elements and explanation of the meaning to be assigned them (the semantics). The definition of Graspe here is solely in terms of its semantics; that is, the data structures and operations are defined precisely but without assignment of a particular syntactic representation. Only when the language is implemented is assignment of an explicit syntax necessary. An example of an implementation of Graspe embedded in Lisp is given as an illustration. The advantages and disadvantages of the definition of a language in terms of its semantics are discussed.

Reflections on a systems programming language

Abstract: A particular systems implementation language, Bliss, has been in active use at Carnegie-Mellon for over two years. At this point the language has been used for several compilers, a conversational programming system, an i/o support system, a discrete event simulation system, and other diverse applications. The authors, together with others, have been responsible for the design, implementation, evolution, and evaluation of the language. Drawing on the past two years' experience this paper attempts a critical evaluation of the language - its failures as well as its successes - with an eye toward the development of future systems implementation languages.

An algol-like assembly language for a small computer

Abstract: In a classic paper1 Wirth describes a language which combines the readability of ALGOL 60 with the flexibility and degree of control of a conventional assembly language. This paper gives an outline of a similar language for a small 16-bit computer—the Honeywell DDP-516. Implementing the compiler in its own language by recoding an ALGOL version of the compiler has shown that the language is suitable for large systems. With the compiler written in a high-level language, many enhancements have been possible even though these were not envisaged in the original coding This use of the language clearly demonstrated that a high-level assembly language can be a very effective tool for a small machine as well as for computers like the 360 series.

Experiments with a natural language problem-solving system

Abstract: Development work on a computer program call­ ed HAPPINESS which solves basic probability prob­ lems phrased in English is presented. Emphasis is placed on (1) the application of heuristics to the examination of input language structure for the purpose of determining those phases richest in semantic content (2) the piecewise construction of combinatorial form­ ulas for problem solution The language analysis is accomplished in sever­ al discrete stages, involving simple sentence trans­ formation, keyword and semantic scanning, and syn­ tactic analysis based on a simplified context-free grammar. The descriptor list result of this analy­ sis is used as the basis for a four-stage solution procedure. A description of the implementation, and a dis­ cussion of its limitations, extensions, and applica­ tions, is also given.

Brief survey of languages used for systems implementation

Abstract: 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.

Complexity of formal translations and speed-up results

Abstract: The purpose of this paper is to give a model for the study of quantitative problems about formal translations from one programming language into another, as well as derive some initial results about the speed of programs produced by translations. The paper also contains a new speed-up result which shows that in any computational complexity measure there exist functions which have arbitrarily large speed-ups but that the size of the speed-up programs must grow non-computably fast.

A system modeling language translator

Abstract: The structure of the design automation language is examined and the sections of a system specification which can be translated independently of one another are identified. The ability to do incremental translation of changes in a system specification is demonstrated. The tables required for translator operation are defined and an algorithm for generating the required tables from a design language system specification is presented. The procedure for minimization of the system specification prior to logic circuit realization and a method for realization of the various sections of the system specification are described.

The structure and operation of a design language compatible simulator

Abstract: Logic design language provides a powerful tool for digital system specification. When coupled with automated logic design techniques the result is an extremely efficient mechanism for system realization. However, before any design process can be considered complete, the design integrity must be verified and some measure of system performance must be obtained. It is the function of the design language simulator to provide the capability for design verification and performance evaluation. This paper describes the structure and operation of a simulator compatible with the design language of Baray and Su. The overall structure of the simulator is discussed and the data base required by the simulator is specified. An algorithm is presented for extracting the data base information from the design language specification. Finally, the simulator run time environment is examined closely so as to identify the mechanisms which give rise to efficient operation in terms of both execution time and memory space requirements.

A language based problem-solver

Abstract: Language learning and language use play central roles in problem-solving. It is argued here that a rigidly built-in language will not serve the needs of problem-solving. To use language as significantly as in human problem-solving it is necessary to design language processors specially suited to the task. The procesBoi should use language as a medium for describing situations so that their similarities are recognized. Recognition of such similarity would enable the system to respond to new situations with forms of response known to be appropriate in similar, familiar situations. The design and implementation of a problem-solving system based on this principle are described. This system exhibits some capability to learn and use a language, and to solve problems.

Automata: a teaching aid for mathematical machines

Abstract: This paper discusses a practical programming language specially designed to aid teachers and students of Computer Science courses which deal with mathematical machines. The first section outlines the motivation for developing such a language in the Computer Science curriculum. Next the criteria which were used to design the language are listed. The characteristics of Automata, the interpreter of this language, are discussed next. Concluding remarks note the results of using Automata as a teaching aid in three Computer Science courses at the Pennsylvania State University. The User's Guide to Automata is attached as the Appendix.

R2: a natural language question-answering system

Abstract: A large number of systems involving computers require a high degree of man-machine interaction. In these systems the capability of the computer to process natural language information would be extremely useful as that eliminates the need for the user to learn various formal languages for the purpose of interaction.

A short presentation of the main features of AEPL - an extensible programming language

Abstract: AEPL is a programming system designed as a tool for the implementation of problem-oriented languages. It is based on a small number of simple but powerful concepts described briefly below. The AEPL system is not yet implemented at the present time; it has been used, however, to define - on paper - a language for the manipulation of graphs. The extensibility of the system stems from the ability to create new data types and from the ability to modify some of the language structures dynamically (syntax and associated semantic as well as some control structures).