Showing papers on "Specification language published in 1984"

Logical sensor systems

Abstract: Multisensor systems require a coherent and efficient treatment of the information provided by the various sensors. We propose a framework, the Logical Sensor Specification System, in which the sensors can be defined abstractly in terms of computational processes operating on the output from other sensors. Various properties of such an organization are investigated, and a particular implementation is described.

An Expansive View of Reusable Software

Abstract: The present crisis in software development forces us to reconsider the fundamental ways in which programming is done. One often quoted solution is to exploit more fully the idea of reusable software. It is the purpose of this paper to examine this concept in all of its forms and to assess the current state of the art. In addition to its usual meaning of reusable code, reusability includes reusable design, various forms of specification systems. so-called application generators, and systems for prototyping. We examine each approach from the perspective of the practicing engineer, and we evaluate the work in terms of how it may ultimately improve the development process for large-scale software systems.

Programs are predicates

Abstract: A computer program is identified with the strongest predicate describing every relevant observation that can be made of the behaviour of a computer executing that program. A programming language is a subset of logical and mathematical notations, which is so restricted that products described in the language can be automatically implemented on a computer. The notations enjoy a number of elegant algebraic properties, which can be used for optimizing program efficiency. A specification is a predicate describing all permitted observations of a program, and it may be expressed with greatest clarity by taking advantage of the whole language of logic and mathematics. A program P meets its specification S iff [Note: Equation omitted. See the image of page 475 for this equation.]. The proof of this implication may use all the classical methods of mathematics and logic. These points are illustrated by design of a small language that includes assignments, conditionals, non-determinism, recursion, input, output, and concurrency.

Building specifications in an arbitrary institution

Abstract: A set of operations for constructing algebraic specifications in an arbitrary logical system is presented. This builds on the framework provided by Goguen and Burstall's work on the notion of an institution as a formalisation of the concept of a logical system for writing specifications. We show how to introduce free variables into the sentences of an arbitrary institution and how to add quantifiers which bind them. We use this foundation to define a set of primitive operations for building specifications in an arbitrary institution based loosely on those in the ASL kernel specification language. We examine the set of operations which results when the definitions are instantiated in an institution of first-order logic and compare these with the operations found in existing specification languages. The result of instantiating the operations in an institution of partial first-order logic is also discussed.

The Relation between Logic Programming and Logic Specification

Abstract: Formal logic is widely accepted as a program specification language in computing science. It is ideally suited to the representation of knowledge and the description of problems without regard to the choice of programming language. Its use as a specification language is compatible not only with conventional programming languages but also with programming languages based entirely on logic itself. In this paper I shall investigate the relation that holds when both programs and program specifications are expressed in formal logic. In many cases, when a specification completely defines the relations to be computed, there is no syntactic distinction between specification and program. Moreover the same mechanism that is used to execute logic programs, namely automated deduction, can also be used to execute logic specifications. Thus all relations defined by complete specifications are executable. The only difference between a complete specification and a program is one of efficiency. A program is more efficient than a specification.

Reusability Through Program Transformations

Abstract: We describe a methodology and supporting programming environment that provide for reuse of abstract programs. Abstract programs are written using notations and constructs natural to the problem domain in a language realized by syntactic extension of a base language. Program transformations are employed to refine an abstract program into its concrete counterpart. We discuss the use of the methodology in the setting of rapid prototyping and custom tailoring.

GEST — A Modelling and Simulation Language Based on System Theoretic Concepts

Abstract: GEST is the first model and simulation specification language Specifications of the model and the experiment are totally separated The modelling world view is based on the axiomatic system theory of Wymore which provides an excellent basis for simulation modelling and symbolic model processing This chapter has two aims: 1) To present the GEST language and the robust and rich modelling paradigm it provides even for non-simulation application areas, as well as 2) to foster design and development of other GEST-like modelling and simulation languages which would provide other modelling formalisms within comprehensive modelling and simulation systems

Logical routing specification in office information systems

Abstract: A message management system is an office information system for managing structured messages, integrating the facilities of computer-based message systems and database management systems, and adding to them the capability of "intelligent" handling of messages. This allows the office information system to support messages tha t can use information about themselves (such as structure and content) or about the system to effect their own processing. Logical routing of messages in an office information system is a function that can benefit from such intelligent processing. A framework and language are introduced for the specification of logical routing for messages in an office information system. By associating routing specifications with message types, the system assumes the responsibility both for evaluating the current message instance state to yield the next destination for the instance and for forwarding the instance. The user is freed from the need to direct explicitly each instance of a message type. The routing specifications are based on a variety of criteria, including message instance state and system characteristics. A routing specification language is described, with examples, and an implementation for a distributed workstation environment is outlined.

Design and implementation of an extendible integrity subsystem

Abstract: Tnls paper presents a powerful integrrty subsystem, which is implemented in the SABRE database system. The specification language is simple. Tne enforcement algorithm is general, in particular, it handles referential dependency and temporal assertions. Specialized strategies efficiently treat each class of assertions. The system automatically manages integrity checkpoints. Also, an efficient method is described for processing assertions involving aggregates. An analysis exhibits the value of the algorithms. It 1s shown that, in general, this method is better than the query modification method for domain assertions. Measures have also been done for giving the cost added for controlling integrity in comparison with the cost of the request itself.

Some principles of good language design: with especial reference to the design of database languages

Abstract: 1. D a t a b a s e l a n g u a g e s (" q u e r y l a n g u a g e s ") c e t h a t c u r r e n t d a t a b a s e l a n g u a g e s h a v e b e e n d e s i g n e d in a c c o r d a n c e w i t h any such p r i n c i p l e s. The p u r p o s e of t h i s n o t e is to t r y to pull t o g e t h e r a list of such p r i n c i p l e s , to s e r v e as a r e f e r e n c e for d a t a b a s e l a n g u a g e d e s i g n e r s (and any o t h e r s w h o m i g h t be i n t e r e s t e d). T h e list is (o b v i o u s l y) not t a k e n f r o m any o n e p l a c e but r a t h e r is c u l l e d f r o m a v a r i e t y of s o u r c e s , i n c l u d i n g c o m p u t e r s c i e n c e f o l k l o r e and " c o n v e n t i o n a l w i s d o m ". One g e n e r a l p o i n t t h a t is w o r t h s t a t i n g at the o u t s e t is t h e f o l l o w i n g (p a r a …

SLAN-4-A software specification and design language

Abstract: SLAN-4 ("Software Language-4") was developed to meet the need for a formal tool for specifying and designing large software systems. It provides language constructs for algebraic and axiomatic specifications and also pseudocode constructs for the design step. A major design goal was to ease subsequent refinements of a (given) specification. The design can start with a very informal specification, which can be implemented later using lower level concepts. This paper gives an overview of the SLAN-4 syntax and semantics. It concentrates on the most important aspects of: abstract data types, algebraic specification of abstract data types, and axiomatic specification of modules. Because the pseudocode part of SLAN-4 consists mainly of control structures similar to those in modern high-level programming languages, this element of the language is not separately described. The paper includes an example of how to use SLAN-4, and also the experiences gained in using the language to formally specify a real-world software product of about 18 000 lines of code written in an IBM internal high-level language.

Design of Ada Systems Yielding Reusable Components: An Approach Using Structured Algebraic Specification

Abstract: Our experience with design of Ada1 software has indicated that a methodology, based on formal algebra, can be developed which integrates the design and management of reusable components with Ada systems design. The methodology requires the use of a specification language, also based on formal algebra, to extend Ada's expressive power for this purpose. We show that certain requirements for the use of Ada packages which cannot be expressed in Ada can be expressed in algebraic specification languages, and that such specifications can then be implemented in Ada.

Formal specification and development of an ada compiler - a vdm case study

Abstract: The Vienna Development Method (VDM) has been employed by Dansk Datamatik Center (DDC) on a large-scale, industrial Ada compiler development project. VDM is a formal specification and development method in that it insists on the initial specifications and all design steps being expressed in a formal (mathematically based) notation.This paper gives an overview of how VDM was used in the various steps of the DDC Ada project, and we guide the reader through the steps involved from the initial formal specification of Ada down to the actually coded multipass compiler. Finally we report on the quantitative and qualitative experiences we have gained, both as regards the technical suitability of VDM for the project and as regards the implications on software management and quality assurance.

The ASSPEGIQUE Specification Environment - Motivations and Design

Abstract: In this paper we describe ASSPEGIQUE, an integrated environment for the development of large algebraic specifications and the management of a specification data base We focus on what motivated us when designing this environment, some crucial design choices and the specific CIGALE parser tool which is extensively used in ASSPEGIQUE

How to Implement a System for Manipulation of Attributed Trees

Abstract: The transformation of attributed trees is a very elegant and powerful method to deal with problems like code optimization in compilers, language-based editors, theorem proving, source-to-source translation (such as high level programming language to high level programming language, high level intermediate language to low level intermediate language) and translation of natural languages The specification language OPTRAN has been designed to describe transformations statically Transformations, which logically belong together, are collected in modules A system for transforming attributed trees is generated separately for each of those modules Such a system mainly consists of an attribute evaluator, a tree analyser, a transformer and an attribute reevaluator

Expert systems and other new techniques in mt systems

Abstract: Our MT systems integrate many advanced concepts from the fields of computer science, linguistics, and AI: specialized languages for linguistic programming based on production systems, complete linguistic programming environment, multilevel representations, organization of the lexicons around "lexical units", units of translation of the size of several paragraphs, possibility of using text-driven heuristic strategies.We are now beginning to integrate new techniques: unified design of an "integrated" lexical data-base containing the lexicon in "natural" and "coded" form, use of the "static grammars" formalism as a specification language, addition of expert systems equipped with "extralinguistic" or "metalinguistic" knowledge, and design of a kind of structural metaeditor (driven by a static grammar) allowing the interactive construction of a document in the same way as syntactic editors are used for developing programs. We end the paper by mentioning some projects for long-term research.

Programming as a mathematical exercise

Abstract: This paper contains a formal framework within which logic, set theory and programming are presented together. These elements can be presented together because, in this work, we no longer regard a (procedural) programming notation (such as PASCAL) as a notation for expressing a computation; rather, we regard it as a mere extension to the conventional language of logic and set theory. The extension constitutes a convenient (economical) way of expressing certain relational statements. A consequence of this point of view is that the activity of program construction is transformed into that of proof construction. To ensure that this activity of proof construction can be given a sound mechanizable foundation, we present a number of theories in the form of some basic deduction and definition rules. For instance, such theories compose the two logical calculi, a weaker version of the standard Zermelo-Fraenkel set theory, as well as some other elementary mathematical theories leading up to the construction of natural numbers. This last theory acts as a paradigm for the construction of other types such as sequences or trees. Parallel to these mathematical constructions we axiomatize a certain programming notation by giving equivalents to its basic constructs within logic and set theory. A number of other non-logical theories are also presented, which allows us to completely mechanize the calculus of proof that is implied by this framework.

A forward inference engine to aid in understanding specifications

Abstract: An important part of understanding a specification is recognizing the consequences of what is stated. We describe a program that can help a user acquire this understanding. It does this by deriving interesting, though not deep consequences of a set of input axioms, while avoiding (a typically much larger set of) uninteresting consequences. The heuristics for obtaining that effect are described and justified. The program has been used in a symbolic evaluator that helps a user to understand and debug specifications written in the Gist specification language.

Limited domain systems for language teaching

Abstract: This abstract describes a natural language system which deals usefully with ungrammatical input and describes some actual and potential applications of it in computer aided second language learning. However, this is not the only area in which the principles of the system might be used, and the aim in building it was simply to demonstrate the workability of the general mechanism, and provide a framework for assessing developments of it.

Prolog as a simulation language

Abstract: Prolog is a rather new language and is very different from traditional languages. Prolog is favored by the Japanese for their Fifth Generation Computer Systems. The acronym PROLOG is derived from PROgramming in LOGic and emphasizes the derivation of the language from predicate logic. Prolog can be considered as a general purpose very high level language, best suited for general symbol manipulation, intelligent and flexible database handling or problems, where some kind of search is required. Examples of application areas are computer aided design, database and “knowledge-base” management, natural language processing and rapid prototyping.It is the purpose of this paper to demonstrate, how Prolog can be used as a tool in a simulation project.The paper consists of two parts: a survey of the language Prolog and a description of T-Prolog, a Prolog based simulation language, using a process interaction approach.

Formal data base specification: an eclectic perspective

Abstract: Logical, algebraic, programming language, grammatical and denotational formalisms are investigated with res pect to their applicability to formal data base speci fication. On applying each formalism for the purpose that originally motivated its proposal, it is shown that they all have a fundamental and well integrated role to play in different parts of the specification process. An example is included to illustrate the methodological aspects.

A specification language for one-pass semantic analysis

Abstract: A new language is introduced for the specification of semantic analysis of programming languages. The language is based on the concept of one-pass attribute grammars. Various extensions of this basic formalism are incorporated in the language, including disciplined global variables, facilities for symbol processing, and features supporting semantic error detection and recovery. To encourage the writing of declarative specifications the language is nonterminal-oriented, in contrast to the production-oriented languages traditionally used in compiler writing systems.

Menu-based natural language understanding

Abstract: Menu-Based Natural Language Understanding is a new approach to building natural language interfaces. It retains the main goals of natural language systems: flexibility, expressive power, learnability and mnemonicity. However, it solves most of the problems inherent to conventional natural language systems. All queries are understood by the system, interface generation is much simpler, and less computing power is required. Many interfaces have been built using the menu-based natural language technology.

Some Thoughts on Algebraic Specification

Abstract: This paper presents in an informal way the main ideas underlying our work on algebraic specification. The central idea, due to Goguen and Burstall, is that much work on algebraic specification can be done independently of the particular logical system (or institution) on which the specification formalism is based. We also examine the nature of specifications and specification languages, the problem of proving that a statement follows from a specification, the important notion of behavioural equivalence, and the evolution of programs from specifications by stepwise refinement. Although many of the issues discussed are motivated by technically complicated problems, in this paper the technicalities have been suppressed in an attempt to make the ideas more accessible. The same ideas are presented with full technical details in [ST 85c].

Phoan: An intelligent system for distributed control synthesis

Abstract: Phoan is an experimental system for the specification and synthesis of control software over suitably restricted domains; its initial application domain is control software for distributed telephone systems. Phoan provides the developer with an example-based specification language, which it translates into an internal representation language based on rules and constraints. Phoan reasons at the representation level to ensure that the system definition is coherent and consistent with independent models of the target domain. Phoan synthesizes the final control structures and their associated protocols by transformation from the internal representation. The implementation of Phoan is currently in progress.