Showing papers on "Specification language published in 1981"

Principles of good software specification and their implications for specification languages

Abstract: Careful consideration of the primary uses of software specifications leads directly to three criteria for judging specifications, which can then be used to develop eight design principles for "good" specifications. These principles, in turn, result in eighteen implications for specification languages that strongly constrain the set of adequate specification languages and identify the need for several novel capabilities such as historical and future references, elimination of variables, and result specification.

Scribe: a document specification language and its compiler

Abstract: : It has become commonplace to use computers to edit and format documents, taking advantage of the machines' computational abilities and storage capacity to relieve the tedium of manual editing and composition. A distressing side effect of this computerization of a previously manual craft is that the responsibility for the appearance of the finished document, which was once handled by production editors, proofreaders, graphic designers, and typographers, is in the hands of the writer instead of the production staff. In this theses the author describes the design and implementation of a computer system for the production of documents, in which the separation of form and content is achieved. A writer prepares manuscript text that contains no mention of specific format; this manuscript text, represented in a document specification language, is processed by a compiler into a finished document. The compiler draws on a database of format specifications that have been prepared by a graphic designer, producing a document that contains the author's text in the designer's format. To simplify the knowledge representation task in the document design database, the document preparation task was parameterized into approximately one hundred independent variables, and the formatting compiler is controlled by changing the values of those variables. The content of the document design database is primarily tables of variable names and the values to be assigned to them. To enable substantial feedback from actual users for validating the design, parameterization, and general utility of such an approach, the resulting computer system was built as a production-quality program and documented as a piece of software rather than as an experiment.

Executable requirements for embedded systems

Abstract: An approach to requirements specification for embedded systems, based on constructing an executable model of the proposed system interacting with its environment, is proposed. The approach is explained, motivated, and related to data-oriented specification techniques. Portions of a specification language embodying it are introduced, and illustrated with an extended example in which the requirements for a process-control system are developed incrementally.

A Specification Language

Abstract: This paper gives an informal presentation of the language currently used at the Programming Research Group. Oxford University for documenting the specification and the design of computer systems. The language is an extension of conventional set theoretical notation. The extensions are simple syntactical conventions and shorthands, which are introduced in order to improve the writebility and readability of specifications. The main aim in the development of this new language has been to provide a uniform notation and a formal framework for reasoning and proving properties about computer systems. The language (in its current form) has been shown to meet this aim (e.g. [Sufrin. 1]).

Programming in Constructive Set Theory: Some examples

Abstract: @y e List(A) (Perm(x,y) & Sorted(y)) which is read “for all lists x, there is a sorted permutation y of x”. We can prove that this proposition is true, using the rules of the language to construct a program for the task. If the proposition were not true, it would be impossible to find a program for it and we would have had an impossible task. The types of Constructive Set Theory can be seen as a specification language for the programs, but of course there is only one language, avoiding the complexity of mixing a programming language with a logical language.The similarity (or rather: identity) between a mathematical proof of a given proposition and a program for a given task suggests that programming should be similar to the mathematicians activity of finding proofs. We have illustrate d this with an example of how a proof of the Euclidean division theorem yields a program to compute the quotient and the remainder between two natural numbers.The paper contains a description of the language. Since all programs in the language terminate, the proof rules and the semantics are simple. We give some examples of programming with lists and reasoning about the programs. We also define the Ackermann function.

Algebraic Denotational Semantics Using Parameterized Abstract Modules

Abstract: This paper describes a method for giving structured algebraic denotational definitions of programming language semantics. The basic idea is to use parameterized abstract data types to construct a directed acyclic graph of modules, such that each module corresponds to some feature of the language. A "feature" in this sense is sometimes a syntactic construction, and is sometimes a more basic language design decision. Our definitions are written in the executable algebraic specification language OBJT. Among the advantages of our approach are the following: it is relatively easier to understand the definitions because they are organized into modules and use flexible user-definable syntax; it is also relatively easy to modify or to extend the definitions, not only because of the modularity, but also because of the use of parameterization; it is possible to debug the definitions by executing test cases, which in this case are programs; the definitions are relatively compact; and they impose relatively little implementation bias. This paper illustrates these points with the definition of a modest programming language with integer and boolean expressions, blocks, iteration, conditional, input and output, and side-effect-only procedures, which can be assigned to variables and passed as parameters.

Lilith: A personal computer for the software engineer

Abstract: The personal work station offers significant advantages over the large-scale, central computing facility accessed via a terminal. Among them are availability, reliability, simplicity of operation, and a high bandwidth to the user. Modern technology allows to build systems for high-level language programming with significant computing power for a reasonable price.At the Institut fur Informatik of ETH we have designed and built such a personal computer tailored to the language Modula-2. This paper is a report on this project which encompasses language design, development of a compiler and a single-user operating system, design of an architecture suitable for compiling and yielding a high density of code, and the development and construction of the hardware. 20 Lilith computers are now in use at ETH.A principal theme is that the requirements of software engineering influence the design of the language, and that its facilities are reflected by the architecture of the computer and the structure of the hardware. The module structure is used to exemplify this theme. That the hardware should be designed according to the programming language, instead of vice-versa, is particularly relevant in view of the trend towards VLSI technology.

On the power of algebraic specifications

Abstract: We study the expressive power of different algebraic specification methods. In contrast to (nonhierarchical) initial and terminal algebra specifications which correspond to semicomputable and cosemicomputable algebras, hierarchical specifications - as e.g. in the specification language CLEAR - allow to specify hyperarithmetical algebras and are characterized by them. For partial abstract types we prove that every computable partial algebra has an equational hidden enrichment specification and discuss the power of hierarchical partial algebras. Finally we give an example of the specification of a simple nondeterministic programming language.

The design of Edison

Abstract: This paper describes the considerations behind the design of the programming language Edison including the reasons why a large number of well-known language featuges were excluded. It also discusses the linguistic problems of writing a concise language report.

Parameter Passing in Algebraic Specification Languages

Abstract: In this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied (matrix (int)) or a nested (bintree (string ())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration.

Formal techniques for the specification and verification of protocols

Abstract: This dissertation presents a language suitable for the specification of communications protocols. This language can be translated into an algebraic data type specification formalism, which allows properties of protocols to be proved using semi-automated support. As an example, two complex protocols, namely a connection establishment protocol actually being used in practice, and a protocol for concurrency control in distributed data bases, are specified and certain properties proved. A logical design error in the connection establishment protocol is also uncovered.

Information Flow Analysis of Formal Specifications

Abstract: A method is given to enumerate the flows between variables in systems specified in a non-procedural language. It finds all flows that would exist according to a deductive theory of information flow. It is presented in the form of an attribute grammar for the specification language. The effect of system invariants is discussed.

A knowledge-based approach to language processing: a progress report

Abstract: We present a model of natural language use meant to encompass the language-specific aspects of understanding and production. The model is motivated by the pervasiveness of nongenerative language, by the desirability of a language analyzer ana a language production mechanism to share their knowledge, and the advantages of knowledge engineering features such as ease of extention and modification. This model has been used as the basis for PHRAN, a language analyzer, and PHRED, a language production mechanism. We have implemented both these systems using a common knowledge base; we have produced versions of PHRAN that understand Spanish and Chinese with only changing the knowledge base and not modifying the program; and we have implemented PHRAN using the query language of a conventional relational data base system, and compared the performance of this system to a conventional LISP implementation.

Formal specification and verification of a connection establishment protocol

Abstract: This paper presents an exercise in the verification of a connection establishment protocol. A specification language named SPEX, tailored for the needs of communications protocols, is proposed, and its relation to a semi-automated verification system, AFFIRM, is discussed. This language is then used to specify a connection protocol currently being used. Certain errors are uncovered by analysis using the verification system. However, the major portion of the protocol's operation are shown to be correct.

Specification and synthesis of synchronizers

Abstract: The formalism of Temporal Logic has been suggested to be an appropriate tool for expressing the semantics of concurrent programs. This thesis is concerned with the application of temporal logic to the specification and synthesis of synchronizers. A very high level specification language founded on temporal logic is introduced. This language is designed for expressing properties required among operations accessing shared resources in a concurrent environment. The language posseses constructs for expressing properties such as mutual exclusion of operation execution, priority among operations, invariance of resource state, and scheduling disciplines. Each of the above is expressed independent of the others, resulting in modular specifications. Statements in the language possess appropriate temporal semantics. This facilitates analysis of a set of specifications for possible inconsistencies. An algorithm is designed for systematically synthesizing code for a synchronizer from given specifications. Constraints on each type of access to the shared resource are derived by applying meaning preserving transformation rules to the high-level specifications. Code is generated in a specific target language utilizing knowledge pertaining to synchronization primitives in that language. The resulting synchronizer is synthesized so as to service requests according to the scheduling discipline specified. Examples of several standard synchronization problems are expressed in this specification language. Feasibility of the synthesis algorithm is demonstrated by providing an implementation to automatically generate resource controllers for a simulation of Applicative Multi Processor System (AMPS).

Combining Graphics and a Layout Language in a Single Interactive System

Abstract: Layout languages provide users with the capability to algorithmically define cells. But the specification language is so non-intuitive that it is impossible to debug a design in that language, one must plot it. Interactive graphics systems, on the other hand, allow the user to debug in the form in which he sees the design, but severely restrict the language he may use to express the graphics. For example, he cannot express loops or conditionals. What is really needed is a single interactive system that combines layout language and graphic modifications to the data. This paper describes just such a system.

Methodology for the Specification of Software Systems: From Formal Requirements to Algebraic Design Specifications

Abstract: Algebraic specifications of abstract data types and software systems have been studied mainly with respect to the design phase and stepwise refinement towards implementation up to now. This paper shows how to extend the algebraic specification techniques to obtain also a methodology for systematic software development from the requirements to the design Phase. This methodology is based on parameter passing techniques for parameterized specifications with requirements where the notion of requirements is general enough to cover general predicate formulas and different kinds of integrity and consistency constraints.

Generation of dataflow graphical object code for the Lapse programming language

Abstract: Of the many proposals for parallel computer architectures, dataflow systems offer perhaps the greatest potential parallelism at the hardware level. However, it is unreasonable to expect users to exploit this parallelism at such a low level, and it is necessary to provide high level programming facilities which allow the user the abstract freedom of expression he requires, whilst permitting efficient use of the hardware. It has been noticed that single-assignment languages are particularly well-suited to dataflow machines, yet exhibit most of the familiar, useful features of conventional high level languages. This paper considers some aspects of code generation from the single-assignment language Lapse for the Manchester prototype dataflow computer. The syntax of Lapse, which resembles Pascal, is introduced, and code generation templates are presented. Some possible optimisations of flowgraph code are discussed, particularly in the implementation of arrays.

A Transformational Derivation of a Parsing Algorithm in a High-Level Language

Abstract: This paper presents a detailed algorithm derivation scenario, using correctness preserving source-to-source transfonnations. The algorithm derived is the Cocke-Younger nodal spans parsing algorithm. We describe a high-level SETL-like specification language, and give a partial correctness formalism and a set of transformation rules which enable the combination of algorithms whose partial correctness has already been established.

Firmware engineering: methods and tools for firmware specification and design

Abstract: Microprogramming has become the means of implementing the machine language instructions of a conventional computer. In the future, the vertical migration of functions from the software levels of a system to the microprogramming level may become equally important. The vertical migration of functions of a computer is undertaken to realize architectures having improved performance, functionality, reliability, or data security. The increased volume of microcode brought about by vertical migration tends to increase the complexity of the firmware development process and calls for a firmware engineering discipline that provides tools for the design and specification, implementation, validation, and maintenance of firmware. We present a rationale for the specification and procedural design of firmware based on the use of an appropriately defined specification language. The features of such a language and the supporting software system are outlined and demonstrated by the example of an existing APL-based firmware development system.

Building Data Base Management Systems Through Formal Specification

Abstract: Using the ANSI/SPARC concept of a three level architecture for data base management systems, a relational data base system is formally specified. The formal specification technique used is VDM and it is illustrated how the various VDM features contribute to a concise but in its abstraction level easily adjustable description. At first the external conceptual and internal levels and their data manipulation languages are discussed separately. Then the mapping properties of the data base management system which has to transform external user requests into their internal executable form are investigated. In practice many restrictions are placed on the insert and update operations that can be used on the external view of the data base system. Through our formal specification, we are able to show that many of these restrictions can be relaxed without violating the integrity, security and consistency constraints of the DBMS.

Specifying and proving properties of sentinel processes

Abstract: This paper presents a technique for specifying and verifying properties of “sentinels”—a high-level language construct for synchronizing access to shared resources. Statements in the specification language possess formal temporal semantics. As a prelude to proving the correctness of sentinels, the semantics of constructs used in sentinels is given. The proof technique involves showing that the temporal behavior of a sentinel conforms to that defined by the specification. The methodology is illustrated by applying it to a typical synchronization problem.

OBJ-1, A Study in Executable Algebraic Formal Specification.

Abstract: : The goal of this research has been to develop a formal and executable algebraic specification language which can be used to specify a variety of application programs, such as database systems, compilers and interpreters for programming languages, and business systems. An advantage of formality in this context is that each specification has a unique unambiguous meaning, so that it is actually meaningful to ask whether or not a given program in fact satisfies a given specification. An advantage of executability is that test cases can be run directly on the specification, to examine properties of programs before they are written, and to help in debugging specifications. The latter is important because large specifications, like large programs, are usually wrong as first written. We have been investigating the utility of a number of potential advantages of the algebraic approach, including the following: Achievement of a high level of modularity in a natural way; Achievement of a high level of abstraction in a natural way; The possibility of executing test cases; User definition of data types and control structures, using any desired syntax, including pre-fix, post-fix, and 'mix-fix' operators, as well as coercions; The specification of error and exception conditions, as well as their handling, and recovery; The use of parameterized abstract modules as a method for structuring specifications; Algorithms for checking consistency and other desirable properties of specifications (e.g., the Knuth-Bendix algorithm); and Provision of a completely rigorous semantics for all these features.

Towards a practical specification language

Abstract: Recognition of the value of formal specifications in the design and verification of large software systems is becoming more widespread. Specification languages themselves, however, are difficult to develop in part because of the inherent conflict between the goals of clarity and formalism required by these languages. This paper discusses the role of specification languages, examples of specifications in two currently implemented languages, AFFIRM and SPECIAL, and makes some suggestions towards a more practical specification language.