Showing papers on "Specification language published in 1973"

A data flow language for operating systems programming

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

Mathematical semantics of SNOBOL4

Abstract: This paper analyzes the semantics of the programming language SNOBOL4, following the mathematical approach proposed by D. Scott and C. Strachey. The study aims at clarifying a rather unusual semantic structure, and at demonstrating that the mathematical approach can provide a natural and usable formal specification of a practical programming language.

Computer system simulation with ASPOL

Abstract: ASPOL (A Simulation Process - Oriented Language) is a simulation language developed specifically for computer system simulation. Its process control and synchronization facilities derive from, and function similiarly to, those developed in the designs of computer operating systems. Consequently, ASPOL provides a natural vehicle for simulating such systems. Other important features of ASPOL include facilities for defining and operating on sets of entities, thus simplifying the modeling of parallel systems (multiprocessors, multiple disk drives, etc.), and macro facilities, which provide language extensibility.This paper describes the ASPOL simulation constructs—processes, events, facilities, and storages—and then illustrates their use in a simple model of a time-sharing system with a paged memory. The ASPOL macro facilities then are described in brief, and a simple example of how they may be used to construct a higher-level computer simulation language is given.

Idiolectic language-analysis for understanding doctor-patient dialogues

Abstract: A programming language is described which is designed to simplify the construction of computer programs to analyze English. This system attempts to merge the best features of pattern matchers and the phrase structure approach to language analysis. Several practival problems which occur in dealing with such a system are described.

A microprogramming language for the MLP-900

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

SNOBOL4 as a language for bootstrapping a compiler

Abstract: The programming language SNOBOL4 is evaluated for the task of bootstrapping the compiler for a new language. Based on the results of an actual project, SNOBOL4 was found to have adequate power to write the bootstrap, but could not produce an acceptably efficient translator.

Introduction to the SYMBOL 2R programming language

Abstract: The SYMBOL programming language (SPL) is not only an important feature of the SYMBOL 2R Computer System, but also was the starting point for the design of the system. SPL was designed as a general-purpose, higher-level programming language. After the language design was completed, the hardware of the SYMBOL computer was then designed to provide a hardware implementation of the language.This paper is intended primarily to provide a general overview of SPL as context for the companion papers (1,3,6). The reader is referred to (5) for a complete description of SPL, to (2) for a discussion of the design decisions involved in the creation of SPL, and to (4) for an overview of the entire SYMBOL project.

A general-purpose high-level language machine for minicomputers

Abstract: In the course of our investigations into the design of translator writing systems (compiler-compilers), it has been established [2] that a certain set of “semantic primitives” can adequately express the major portion of the semantics of programs written in any of the several common high-level languages (e.g., PL/I, ALGOL W). It was also observed that each of these semantic primitives, while representing frequently-used high-level language constructs, corresponds to predictable sequences of machine-language instructions in the object code of programs.Similarly, other authors have noted that conventional computer instruction sets are less than satisfactory as target languages for high-level language programs and have offered, as a solution to this problem, hardware or firmware processors designed specifically for programs written in a particular high-level language—the machine language and the programming language are essentially identical. The best known early example of such a processor is Helmut Weber's microprogrammed implementation of the EULER language on an IBM 360/30. [5] More recently, Burroughs Corporation has produced the B1700, a computer that has a microprogrammed language processor for each of several languages, the appropriate one of which is loaded into control memory to interpret a given program. [6,7] Such processors show significant speed increases over conventional computers of comparable basic speed in executing programs written in their particular language, but are too specialized to execute other languages efficiently. Therefore we have conjectured that, by designing a computer organization which implements a set of semantic primitives similar to Lancaster's via microprogramming, one instruction per primitive (so that the work required by a DO statement, for example, is performed in the firmware rather than in the software), we can achieve speed increases approaching those of the single-language processors, while retaining the flexibility characteristic of conventional computer organizations. This paper describes those primitives which we have chosen for initial implementation, and presents some preliminary results on the speedups obtained.

Design and Implementation of a Multi-Level System Using Software Modules,

Abstract: : A mechanism for holding programs in syntactic form was desired for use by systems which operate on other programs: program verifiers, automatic programming systems, and specialized text editors. The mechanism was designed using the software module specification language of D.L. Parnas, and implemented in SAIL, an Algol-like language on the PDP 10. It is suggested that specifications assist in both the design and implementation process. (Author)

A portable language for system development

Abstract: The design and implementation of a system development language which is economical to implement is described Both macro processing and compiling techniques are used to translate it The advantages and disadvantages of using such a language are discussed together with the main problems met in its implementation © 1973 Wiley Periodicals, Inc

A conceptually based sentence paraphraser.

Abstract: This report describes a system of programs which performs natural language processing based on an underlying language free (conceptual) representation of meaning. This system is used to produce sentence paraphrases which demonstrate a form of understanding with respect to a given context. Particular emphasis has been placed on the major subtasks of language analysis (mapping natural language into conceptual structures) and language generation (mapping conceptual structures into natural language), and on the interaction between these processes and a conceptual memory model.

Conditional syntactic specification

Abstract: In this paper, the shortcomings of Backus Naur specification of the syntactic properties of programming languages are investigated and a method for the specification of context-sensitive properties is suggested. Based on the notation of the tree structures of the Vienna Definition Language [Lu 1], samples of descriptions of context-sensitive grammars are presented as sets of conditionals which operate over the derivation trees of context-free specifications in BNF grammars to eliminate the extra-lingual features. The method is also extended to provide a syntactic specification of the default attributes of a language by the description of modifications which are to be made to the parsed form (syntactic tree) of instances of the language. For the purposes of example, a mini-language (ML 5/2) is presented. This paper exemplifies the problems of parameter passing and provides examples of the context-sensitive conditions of matching procedure calls and their declarations as well as matching parameters and their corresponding arguments.

GLOSS: A high level machine

Abstract: A program of a high level language can be executed either by applying a suitable high level machine to the program or by translating the program to an equivalent program in another language for which a machine exists. Constructing a high level machine for each language is an interesting solution, but such a solution requires the construction of many machines and also does not enable the semanticist to compare programming languages. Using an existing conventional machine whose machine language is the target language of a translator provides an un-interesting solution which also does not allow the semanticist to easily compare programming languages.If we use a high level machine, such as GLOSS, whose machine language is the target language of a translator, then we can write a translator which merely rearranges syntax and does not lose any semantics. Such a solution is interesting to the semanticist if a large class of programming languages can be translated into this high level machine by syntax rearrangement because the high level machine can serve as a medium of programming language comparison.

Control extension in a recursive language

Abstract: Techniques for language extension are of interest today as a means for language design experimentation without language proliferation. Attention thus far has been focused on methods for data structure definition and manipulation. The problem of program control extensibility has been recognized by workers in the field but less thoroughly treated. This paper outlines an approach to control extensibility applicable on the source language level to appropriate programming languages.

Specifications and programs for computer software validation

Abstract: Three software products developed during the study are reported and include: (1) FORTRAN Automatic Code Evaluation System, (2) the Specification Language System, and (3) the Array Index Validation System.

Specification languages for control programs

Abstract: This study (1) describes an approach to the formal specification of control programs based on the generalized concept of binding From this viewpoint, the individual operations of a control program may be described by a graphic specification language [related to mem-theory (2)], whose statements are pairs of graphs depicting the original and final binding states of system elements A global view of interrelationships and dynamic behavior of the system may be described by an extension of Petri-nets (3, 4) depicting the flow of system elements from one state of local binding to anotherA rational approach to the design of a new programming language must begin with an analysis of the “meanings” that are to be expressed; an appropriate, compilable syntax can then be developed around this skeleton Consequently, we seek to identify, the characteristic features of operating system programming, and in particular those that differentiate these programs from conventional ones

Hierarchical language definition

Abstract: This paper describes a project for the hierarchical definition and implementation of languages. In the spirit of structured programming [1] and in analogy to the hierarchical construction of operating systems [2,3] we define high level languages, which are suitable for the design of operating and other software systems, in several levels of abstraction. In particular, we describe in this paper how an intermediate, machine independent basic language can be used to express the actions of a given high level language in terms of simple actions of the basic language. In conjunction with a translator writing system, this allows a compact and readable formal definition of the syntax and semantics [4,5] of the high level language, which is in fact a description of the compiler which translates this language into the basic language. This definition is independent of a particular computer, however, an implementation of the basic language must be furnished. We intend to use the basic language to describe modules which are embedded in a general system for multiple processes. The language consists of a kind of macro instructions most of which can be implemented in a straight forward manner. Some more complicated instructions, such as primitives for inter-process communication, can be implemented through a hierarchical construction process [2,3] as indicated in section III (see also figure 1).