Showing papers on "Specification language published in 1982"

An Operational Approach to Requirements Specification for Embedded Systems

Abstract: The approach to requirements specification for embedded systems described in this paper is called "operational" because a requirements specification is an executable model of the proposed system interacting with its environment. The approach is embodied by the language PAISLey, which is motivated and defined herein. Embedded systems are characterized by asynchronous parallelism, even at the requirements level; PAISLey specifications are constructed by interacting processes so that this can be represented directly. Embedded systems are also characterized by urgent performance requirements, and PAISLey offers a formal, but intuitive, treatment of performance.

Formal Specification and Software Development

Abstract: No wonder you activities are, reading will be always needed. It is not only to fulfil the duties that you need to finish in deadline time. Reading will encourage your mind and thoughts. Of course, reading will greatly develop your experiences about everything. Reading formal specification and software development is also a way as one of the collective books that gives many advantages. The advantages are not only for you, but for the other peoples with those meaningful benefits.

Data Type Specification: Parameterization and the Power of Specification Techniques

Abstract: This paper extends our earlier work on abstract data types by providing an algebraic treatment of parametrized data types (eg, sets-of-(), stacks-of-(), etc), as well as answering a number of questions on the power and limitations of algebraic specification techniques In brief: we investigate the “hidden function” problem (the need to include operations in specifications which we want to be hidden from the user); we prove that conditional specifications are inherently more powerful than equational specifications; we show that parameterized specifications must contain “side conditions” (eg, that finite-sets-of-d requires an equality predicate on d), and we compare the power of the algebraic approach taken here with the more categorical approach of Lehman and Smyth

A user interface management system

Abstract: The design and construction of the user interface to interactive systems is receiving increased attention. This paper describes a user interface management system that allows a designer/developer to focus on the logical functionality of an application without the usual bookkeeping associated with a conventional programming language. The user interface management system contains two components: a special purpose, application independent dialogue specification language and a run-time interpreter that provides a number of interaction extensions not possible with procedure libraries.

Operational specification as the basis for rapid prototyping

Abstract: This paper describes a set of freedoms which both simplify the task of specifing systems and make the resulting specification more comprehensible. These freedoms eliminate the need, in specific areas, to consider: the mechanisims for accomplishing certain capabilities, the careful coordination and integration of separate operations, the costs of those operations, and other detailed concerns which characterize implementation.These freedoms are partitioned into the areas of efficiency, method, and data, and providing them has resulted in a novel formal specification language, Gist. The main features of this language are described in terms of the freedoms it affords. An overview of the language is then presented together with an example of its use to specify the behavior of a real system.

A High-Level Language for Specifying Pictures

Abstract: A programming language tha t includes special constructs for drawing pictures is discussed. The language has been designed so that programs to draw pictures can reflect the structure of those pictures. Picture elements are called boxes. They are defmed by declaring algebraic relationships tha t should exist among their significant points and requesting actions to be performed at those points. The algebraic relationships are processed by an equation solver to determine the absolute location of significant points. A new mechanism of variable reference and scope makes the expression of relationships tha t should exist among picture elements more direct than it is in conventional languages. Some common picture operations--drawing lines using a pattern, filling in areas with textures, and obscuring parts of a picture by other par ts--are all expressed readily once the mechanism for defining and using boxes is in place. The language has been implemented, and used by several authors to prepare figures for their papers and books. It was also used to prepare this paper.

The distributed programming language SR—Mechanisms, design and implementation

Abstract: SR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation.

Towards specifying and evaluating the human factors of user-computer interfaces

Abstract: Despite the current interest in user-computer interfaces, the design of a good interface remains to a great extent an art, with much argument over guidelines and principles for interface design. Pertinent information, scattered throughout the literature of psychology, graphic design. linguistics, hardware design, and under the general umbrella of computer science, is only gradually being gathered into survey publications for application by computer scientists [1,4,12,15]. Our purpose is to design a specification language which will serve as a vehicle for the design of and experimentation with user-computer interfaces. The specification language not only defines the external characteristics of the interface, but can also be analyzed to determine whether the interface meets a set of generally-accepted human factors guidelines. We believe the language is general enough to be used with principles of interface design other than those we have proposed.

Implementation of Parameterised Specifications (Extended Abstract)

Abstract: A new notion is given for the implementation of one specification by another. Unlike most previous notions, this generalises to handle parameterised specifications as well as loose specifications (having an assortment of non-isomorphic models). Examples are given to illustrate the notion. The definition of implementation is based on a new notion of the simulation of a theory by an algebra. For the bulk of the paper we employ a variant of the Clear specification language [BG 77] in which the notion of a data constraint is replaced by the weaker notion of a hierarchy constraint. All results hold for Clear with data constraints as well, but only under more restrictive conditions.

Formal Specification and Verification of Distributed Systems.

Abstract: Computations of distributed systems are extremely difficult to specify and verify using traditional techniques because the systems are inherently concurrent, asynchronous, and nondeterministic Furthermore, computing nodes in a distributed system may be highly independent of each other, and the entire system may lack an accurate global clock

GIST english generator

Abstract: This paper describes a prototype English generator which can produce English descriptions of program specifications written in Gist, a program specification language being developed at ISI. Such a facility is required because although Gist is a high level specification language, specifications written in it, like those in all other formal specification languages, are unreadable. There are several reasons for this unreadability: strange syntax; redundancy elimination; lack of thematic structure; implicit remote interactions; no representation of the motivation or rationale behind the specification; and a strict reliance on textual presentation. The current generator deals with the first two problems and part of the third. Our plans for dealing with the rest are outlined after a description of the current generator.

Formal Specification of Graphic Data Types

Abstract: Formal specification techniques and data abstractions have seen little application to computer graphics. Many of the objects and operations unique to graphics programs can be handled conveniently by def'ming special graphic data types. Not only do graphic data types provide an attractive way to work with pictures, but they also allow specification techniques for data abstractions to be employed. Algebraic axioms, because of their definitional nature, are especially well suited to specifying the diversity of types useful in graphics applications. In this paper, definitions are given for some important concepts that appear in graphics programs. Based on these definitions, some illustrative graphic data types, called point, region, geometric function, graphic transformation, and tree-structured picture, are defined and specified algebraically. A simple graphics language for line drawings is created by embedding these new data types in the language PASCAL. Using the specifications, an outline of a correctness proof for a small programming example is presented.

A Practical Approach to Identifying Storage and Timing Channels

Abstract: Recognizing and dealing with storage and timing channels when performing the security analysis of a computer system is an elusive task. Methods of discovering and dealing with these channels for the most part have been ad hoc, and those that are not are restricted to a particular specification language. This paper outlines a practical methodology for discovering storage and timing channels that can be used through all phases of the software life cycle to increase the assurance that all channels have been identified. The methodology is presented and its application to three different descriptions (English, formal specification, and high order language implementation) are discussed.

Justification of formal methods for system specification

Abstract: Recent developments in mathematics and computer science offer a sound, if unfamiliar, basis for the development of computer-controlled systems. The professional systems engineer should become as competent in these fields as he is (expected to be) in traditional mathematics and physics. The paper emphasises their application in the early phases of product development (requirements analysis and functional specification)-a prerequisite for their successful use in design and implementation. Some important aspects of 'embedded' computer systems, such as concurrency, have not been discussed because space does not allow an adequate introduction to their formal treatment

Floyd's principle, correctness theories and program equivalence

Abstract: A programming system is a language made from a fixed class of data abstractions and a selection of familiar deterministic control and assignment constructs. It is shown that the sets of all ‘before-after’ first-order assertions which are true of programs in any such language can uniquely determine the input-output semantics of the language providing one allows the use of auxiliary operators on its ground types. After this, we study programming systems wherein the data types are syntactically defined using a first-order specification language with the objective of eliminating these auxiliary operators. Especial attention is paid to algebraic specifications, complete first-order specifications; and to arithmetical computation in the context of a specified programming system.

Analysis and Specification of Office Procedures

Abstract: Conventional approaches to "office automation" focus on the lowest common denominator of office work: typing, filing, filling in forms, etc. As a consequence, the process of office systems analysis lacks tools and techniques that address the office in terms of business functions rather than as manipulation of paper artifacts. The Office Specification Language (OSL) and its associated analysis methodology have been developed as a means of implementing a functional approach to office procedure analysis and description. OSL is based on several premises derived from a study of office systems analysis at a functional level: -There exist high-level constructs common to a wide variety of disparate offices. A structured formal language built upon such standardized abstractions can be useful in helping an analyst approach, understand, and describe the operations of many offices. -Office procedures deal with (abstract) objects, not paper forms. Forms and other documents are not basic to office operations: they are mechanisms for organizing and transmitting information about some more fundamental object. Therefore office analysis should focus not on forms, but rather on the underlying business requirements that must survive any change in system implementation. -Office procedures are fundamentally simple; their apparent complexity is not inherent, but due to a myriad of special cases, historical accretions, and implementation details. Identification of a procedure''s core requirements is the framework upon which analysis should be based. Such an understanding is a prerequisite to effective reorganization of and design of support systems for office functions. OSL is postulated to be of utility for office analysis and systems design. Field tests of the language and methodology have shown that our basic approach is effective for analysis purposes, and have identified directions for further improvements.

On the Algebraic Specification of Databases

Abstract: manticl data models which often is For the conceptual level of database schemes a abstractions, static and dynamic constraints, and a functional programing language for queries and updates. The specification is analysed w.r.t. syn- tactic and semantic aspects. Then the behaviour and the implementation of database specifications are discussed. Furthermore, algebraic conditions are presented that guarantee a sound specification according to criteria evolved from database theory. necessary defini- ine is a For every specification technique it is to develop criteria for a sound database tion (/Casanova et al. Sl/). One guide1 syntactic and semantic analysis of database speci- fication in order to check whether the class of ad- mitted models Indeed meets the informal ideas in mind.

A formal method for computer design verification

Abstract: A formal computer design verification method based on Floyd's inductive assertion technique[9] is presented as an alternative or at least a supplement to simulation. The semantics of a register transfer language is defined formally. It specifies how machine variables and time change. Hardware descriptions in this language may contain assertions. The formal definition of the language can then be used for automatic verification of logical correctness and realtime performance of the design.

Mappings for rapid prototyping

Abstract: The transformational methodology for software development is adapted to perform rapid conversion of specifications into prototypes. This makes feasible testing of specifications to observe their behaviours and assuring that specifications can indeed be implemented.The approach is centered on gathering techniques to map each type of specification language construct into a reasonably efficient implementation. Instances of these constructs in an actual specification may then serve as the focal points for the conversion process.

An implementation of a code generator specification language for table driven code generators

Abstract: This paper discusses an implementation of Glanville's code generator generator for producing a code generator for a production Pascal compiler on an Amdahl 470.We successfully replaced the hand written code generator of an existing compiler with one which was produced automatically from a formal specification. This paper first outlines Glanville's original scheme, then describes extensions which were necessary for generating code for a production compiler.

A Primer for the Act-1 Language

Abstract: : This paper describes the current design for the Act-I computer programming language, and describes the Actor computational model, which the language was designed to support It provides a perspective from which to view the language, with respect to existing computer language systems and to the computer system and environment under development for support of the language The language is informally introduced in a tutorial fashion and demonstrated through examples A programming strategy for the language is described, further illustrating its use (Author)

Software specification by graph grammars

Abstract: The following paper demonstrates that programmed sequential graph grammars can be used in a systematic proceeding to specify the changes of high level intermediate data structures arising in a programming support environment, in which all tools work in an incremental and syntax-driven mode. In this paper we lay stress upon the way to get the specification rather than on the result of this process. Therefore, we give here some approach to specification engineering using graph grammars. This approach is influenced by the syntactical definition of the underlying programming language or module concept etc. to be supported but also by the idea of the user interface.

Structured assembly language programming

Abstract: For those of us who are essentially high level programmers, the intricacies and lack of structure in assembly language programs are often an insurmountable barrier to effective assembly language programming. This paper attempts to show a way to overcome this barrier. Structured pseudocode is used to solve the problem just as if the solution were to be coded in PL/I, PASCAL, ADA, or some other structured high level language. Then the structured pseudocode is “compiled” into assembly language using appropriate labels to show the structure of the assembly language program.