Showing papers on "Specification language published in 1980"

Formal specification as a design tool

Abstract: The formulation and analysis of a design specification is almost always of more utility than the verification of the consistency of a program with its specification Good specification tools can assist in this process, but have generally not been proposed and evaluated in this light In this paper we outline a specification language combining algebraic axioms and predicate transformers, present part of a non-trivial example (the specification of a high-level interface to a display), and finally discuss the analysis of this specification

Notes on Type Abstraction (Version 2)

Abstract: This paper, which was initially prepared to accompany a series of lectures given at the 1978 NATO International Summer School on Program Construction, is primarily tutorial in nature. It begins by discussing in a general setting the role of type abstraction and the need for formal specifications of type abstractions. It then proceeds to examine in some detail two approaches to the construction of such specifications: that proposed by Hoare in his 1972 paper "Proofs of Correctness of Data Representations," and the author's own version of algebraic specifications. The Hoare approach is presented via a discussion of its embodiment in the programming language Euclid. The discussion of the algebraic approach includes material abstracted from earlier papers as well as some new material that has yet to appear. This new material deals with parameterized types and the specification of restrictions. The paper concludes with a brief discussion of the relative merits of the two approaches to type abstraction.

A General Transition Model for Protocols and Communication Services

Abstract: Different approaches have been used for the formal specification and verification of communication protocols. This paper explains the approach of nsing a general transition model which combines aspects of finite state transition diagrams and programming languages. Different ways of structuring a protocol into separate modules or functions are also discussed. The main part of the paper describes a method for exactly specifying the communication service provided by a protocol. Two aspects of a service specification are distinguished: 1) the local properties which characterize the interface through which the service may be accessed, and 2) the global properties which describe the "end-to-end" communication characteristics of the service. It is shown how the specification method is related to the general transition model for protocol specification. Verification is discussed briefly with emphasis on the use of invariant assertions in the context of finite state as well as programming language protocol descriptions. The discussed topics are demonstrated with examples based on the HDLC classes of procedures and the X.25 Virtual Circuit data transmission service.

Retrospective on high-level language computer architecture

Abstract: High-level language computers (HLLC) have attracted interest in the architectural and programming community during the last 15 years; proposals have been made for machines directed towards the execution of various languages such as ALGOL,1,2 APL,3,4,5 BASIC,6,7 COBOL,8,9 FORTRAN,10,ll LISP,12,13 PASCAL,14 PL/I,15,16,17 SNOBOL,18,19 and a host of specialized languages. Though numerous designs have been proposed, only a handful of high-level language computers have actually been implemented.4,7,9,20,21 In examining the goals and successes of high-level language computers, the authors have found that most designs suffer from fundamental problems stemming from a misunderstanding of the issues involved in the design, use, and implementation of cost-effective computer systems. It is the intent of this paper to identify and discuss several issues applicable to high-level language computer architecture, to provide a more concrete definition of high-level language computers, and to suggest a direction for high-level language computer architectures of the future.

First-order identities as a defining language

Abstract: Inverting the adage that a data type is just a simple programming language, we take the position that a programming language is, semantically, just a complex data type; evaluation of a program is just another operation in the data type. The algebraic approach to data types may then be applied. We make a distinction between specification and modelling, and we emphasize the use of first-order identities as a specification language rather than as a tool for model-building. Denotational and operational semantics are discussed. Techniques are introduced for proving the equivalence of specifications. Reynolds' lambda-calculus interpreter is analyzed as an example.

Towards a theory for abstract data types

Abstract: A rigorous framework for studying immutable data types having nondeterministic operations and operations exhibiting exceptional behavior is developed. The framework embodies the view of a data type taken in programming languages, and supports hierarchical and modular structure among data types. The central notion in this framework is the definition of a data type. An algebraic and behavioral approach for defining a data type is developed which focuses on the input-output behavior of a data type as observed through its operations. The definition of a data type abstracts from the representation structure of its values as well as from the multiple representations of the values for any representation structure. A hierarchical specification language for data types is proposed. The semantics of a specification is a set of related data types whose operations have the behavior captured by the specification. A clear distinction is made between a data type and its specification(s). The normal behavior and the exceptional behavior of the operations are specified separately. The specification language provides mechanisms to specify (i) a precondition for an operation thus stating its intended inputs, (ii) the exceptions which must be signalled by the operations, and (iii) the exceptions which the operations can optionally signal. Two properties of a specification, consistency and behavioral completeness, are defined. A consistent specification is guaranteed to specify at least one data type. A behaviorally complete specification ''completely'' specifies the observable behavior of the operations on their intended inputs. A deductive system based on first order multi-sorted predicate calculus with identity is developed for abstract data types. It embodies the general properties of data types, which are not explicitly stated in a specification. The theory of a data type, which consists of a subset of the first order properties of the data type, is constructed from its specification. The theory is used in verifying programs and designs expressed using the data type. Two properties of a specification, well definedness and completeness, are defined based on what can be proved from it using different fragments of the deductive system. The sufficient completeness property of Guttag and Horning is also formalized and related to the behavioral completeness property. The well definedness property is stronger than the consistency property, because the well definedness property not only requires that the specification specifies at least one data type, but also captures the intuition that it preserves other specifications used in it thus ensuring modular structure among specifications. The completeness property is stronger than the sufficient completeness property, since in addition to the requirement that the behavior of the observers can be deduced on any intended input by equational reasoning, it also requires that the equivalence of the observable effect of the construc

Design principles of an office specification language

Abstract: Office automation, interpreted most generally, is the utilization of technology to improve the productivity and quality of office work. This concept encompasses a wide range of devices, technologies, tools, and systems. One of its most powerful instances is the notion of an automated office information system. This is a software-intensive, computer-based system that seeks to support (and where appropriate, to automate) an entire office procedure, rather than simply to improve the performance of individual office tasks. However, there is a major impediment to the realization of such systems: because of their application-oriented and office-specific character, they are extremely costly to construct. One of the major reasons for this cost is that office systems analysts lack any tools or methodologies to employ in the process of determining and expressing the requirements of an automated office system. An office specification language is used to describe in a natural yet precise fashion the operation of an office system; its use can improve the process of constructing the system in a number of ways. In this paper, we set forth an approach to the design of office specification languages and present an overview of the major concepts in OSL, one such language that we are developing.

Studies in Extensible Programming Languages

Abstract: : The work is a study of two topics in the development of an extensible programming language, i.e., a high level language with powerful definitional facilities so designed that the language can be extended and thereby tailored for use in a wide variety of computer applications. The first topic is a theoretical treatment of an extension facility for syntax. It generalizes the notion of context-free grammars to allow the syntax of a language to be a function of its generated strings. It studies the formal properties of such grammars and presents an efficient algorithm for parsing their languages. The second topic of this work is a study of the design and formal specification of a base language on which an extensible language system can be built. It employs a formal definition to present a base language, examines the constraints on the design of such language, and discusses how these constraints shape the language. The language includes one extension facility, that for data types; the facility, its design, and its relation to similar facilities in other languages are analyzed.

PHRAN - A Knowledge-Based Natural Language Understander

Abstract: We have developed an approach to natural language processing in which the natural language processor is viewed as a knowledge-based system whose knowledge is about the meanings of the utterances of its language. The approach is oriented around the phrase rather than the word as the basic unit. We believe that this paradigm for language processing not only extends the capabilities of other natural language systems, but handles those tasks that previous systems could perform in a more systematic and extensible manner.We have constructed a natural language analysis program called PHRAN (PHRasal ANalyzer) based in this approach. This model has a number of advantages over existing systems, including the ability to understand a wider variety of language utterances, increased processing speed in some cases, a clear separation of control structure from data structure, a knowledge base that could be shared by a language production mechanism, greater ease of extensibility, and the ability to store some useful forms of knowledge that cannot readily be added to other systems.

RLL-1: A Representation Language Language

Abstract: : The field of AI is strewn with knowledge representation languages. The language designer typically designs that language with one particular application domain in mind; as subsequent types of applications are tried, what had originally been useful features are found to be undesirable limitations, and the language is overhauled or scrapped. One remedy to this bleak cycle might be to construct a representation language whose domain is the field of representational languages itself. Toward this end, we designed and implemented RLL-1, a frame-based Representation Language Language. The components of representation languages in general (such as slots and inheritance mechanisms) and of RLL-1 itself, in particular, are encoded declaratively as frames. By modifying these frames, the user can change the semantics of RLL-1's components, and significantly alter the overall character of the RLL-1 environment. Often a large Artificial Intelligence project begins by designing and implementing a high-level language in which to easily and precisely specify the nuances of the task. The language designer typically builds his Representation Language around the one particular highlighted application (such as molecular biology for Units (Stefik), or natural language understanding for KRL (Bobrow & Winograd) and OWL (Szolovits, et al.)). For this reason, his language is often inadequate for any subsequent applications, except those which can be cast in a form similar in structure to the initial task. What had originally been useful features are subsequently found to be undesirable limitations. Consider Units' explicit copying of inherited facts or KRL's sophisticated but slow matcher.

Specification of Abstract Data Types in Modula

Abstract: The programming language MODULA is extended to permit the formal specification of the structure and functional capabilities of modules. This makes true hierarchical programming possible in MODULA by allowing programmers of higher level parts of a system to ignore completely the internal structure of lower level modules and to rely entirely on the specifications of the capabilities of these modules. An example is included to illustrate this technique. We show that our specification mechanisms are sufficiently powerful to support formal verification rules for modules that have disjoint representations for abstract objects.

Operator identification in ADA: formal specification, complexity, and concrete implementation

Abstract: In ADA [I], [~, operator names (i.e. identifiers for subprograms, literals, and operator symbols) can be overloaded. This means they denote more than one operator (i.e. subprogram, constant, or operation). (In addition, there are syntactic constructs (such as indexed components, e.g. a(il,...,ik) ) which have several semantic meanings (e.g. function call, indexing an array, qualifying an aggregate, ...) depending on their context.) For each expression, the ambiguities which arise with respect to types and operators have to be resolved according to the overloading rules in ADA. This process is called the operator identification process, and is distinguished from the name identification process which precedes it and associates all possible meanings with an operator name according to the visibility rules.

A process oriented simulation model specification and documentation language

Abstract: We present a language for specifying and documenting discrete event simulation models, designed to facilitate communication during model design, implementation and maintenance. The systems from which models are developed are viewed as collections of communicating elements. Each element is specified separately in a module consisting of attributes, axioms and a scenario. The model's specification consists of each model element's specification and some systemwide attributes and axioms. Synchronization among model elements (model dynamics) is specified within the model elements rather than globally. Each language control structure has a monitor associated with it. Appropriate changes are made in the model's state in response to a monitor's sensing an attribute change. The language contains a library of specifications for common simulation model entities such as the priority queue. The syntax and semantics of the language are presented through examples. Examples of a library specification and a model specification are included.

A rule-based approach to ill-formed input

Abstract: Though natural language understanding systems have improved markedly in recent years, they have only begun to consider a major problem of truly natural input: ill-formedness. Quite often natural language input is ill-formed in the sense of being misspelled, ungrammatical, or not entirely meaningful. A requirement for any successful natural language interface must be that the system either intelligently guesses at a user's intent, requests direct clarification, or at the very least, accurately identifies the ill-formedness. This paper presents a proposal for the proper treatment of ill-formed input. Our conjecture is that ill-formedness should be treated as rule-based. Violation of the rules of normal processing should be used to signal ill-formedness. Meta-rules modifying the rules of normal processing should be used for error identification and recovery. These meta-rules correspond to types of errors. Evidence for this conjecture is presented as well as some open ~]estions.

A case study in specifying the semantics of a programming language

Abstract: On and off over the period of about a year I have worked on a semantic specification for the C programming language My objective was to construct a readable and precise specification of C, aimed at compiler writers, maintainers, and language pundits. This paper is a report on the project.

Abstract Data Types: A Retrospective and Prospective View

Abstract: This paper presents a retrospective view of the last decade's research in a number of related areas: programming methodology, formal semantics, program specification and verification, and programming languages. The synergistic effect of these threads of research is especially evident in the area called abstract data types, and this area is taken as the focus of the paper. After reviewing some of the history and status of the area, some important open problems are identified.

A Basis for the Constructive Approach to Programming.

Abstract: Although programming is a difficult and creative activity, useful strategies and heuristics exist for solving programming problems We analyse some of the most fundamental and productive among them; their knowledge and conscious application should help the programmers in constructing programs, both by stimulating their thinking and by helping them to recognise classical situations The precise framework for the analysis is provided by the specification language Z For editorial reasons the description in some sections of this paper has had to be curtailed

A proposal for information systems design and management

Abstract: This paper is a global presentation of solutions for IS design and management.We believe that every solution proposed to a design problem implies that the designer disposes of a design theoretical model, a language for specification, a design method and tools that help him to apply the design method.We define such a quartet (model,language, method, tools) in order to satisfy IS design and management. Furthermore the scope of the approach developed for IS design is to integrate the definition of the data structure, of the program structure and of the synchronization.This paper is more model and language oriented.

Automatic Verification of Serializers.

Abstract: : This thesis is concerned with the problem of controlling concurrent access to shared data. A language construct is proposed to enforce such control; a specification language is defined to describe the formal requirements of such control; and verification techniques are given to prove that instances of the construct satisfy their specifications. The techniques are justified in terms of the definition of the construct and the definition of the specification language. Results are given for a program that implements a number of the techniques, illustrated by verifying several versions of the readers-writers problem. Interactions between instances of the construct are discussed in the context of a simple file system. (Author)

A Database Foundation for Process Specifications

Abstract: : A language suitable for system specification should allow a specification to be based on a cognitive model of the process being described. In part, such a language can be obtained by properly combining certain conceptual abstractions of data models with reference and control concepts designed for programming languages. Augmenting the resulting language with formal versions of several natural language constructs further decreases the cognitive distance between specifications of large systems and the modelled world. Several core elements of such a specification language are developed in this report. Emphasis is placed on modes of expression, such as declarative constraints an temporal reference, which are derived from natural language but are not available in existing formal languages.

APL as a Software Design Specification Language

Abstract: A proposed extension of APL as a software design tool is presented. The approach of system specification using a programming language is compared to the non-programming language system PROPLAN presented by Pengilly (1975). Illustrative examples given by Pengilly are translated into the extended APL format. Advocating the adoption of a programming language in software design is not intended to exclude the use of natural language or other formalisms and documentation aids such as HIPO which are commonplace in a software engineering environment. However, the importance and even necessity of specification languages which, when used in a design, can enhance the process of verifying correctness is increasing. This concern is further supported by the reliability that 'no programming philosophy will improve software reliability if the underlying system specifications are erroneous or have been incorrectly translated' (Belford and Taylor, 1976). Thus the selection or development of a software design language is inextricably intertwined with the specification verification problem. Falkoff (1976) has suggested the following criteria for the choice of a formal design language:

A Case Study of Abstract Implementations and Their Correctness

Abstract: A new implementation concept for algebraic specification languages supports hierarchical programming mainly because it provides a semantical basis for correctness proofs. "Abstract programs" describe syntactically how data and operations of a lower level data type should represent those of an upper level type. Dependent on these programs a general semantical construction transforms the lower level type into an implementation of the upper level type. The implementation is correct if the result of this construction coincides with the semantics of the upper level type. Therefore this concept involves a clear distinction between the syntactical and the semantical part of an abstract implementation. Although the syntax of such an implementation always supplies a "freely generated" semantics, the concept also admits the use of other (algebraic) models which often ease correctness proofs.

Language use: A performance model

Abstract: A model for language use or performance is given which is essentially independent of the standard theories for language acquisition and competence (the knowledge of language). Comparisons with computer models for language understanding are provided. It is suggested that basic research in human language comprehension must precede construction of new artificial intelligence models.