Specification Of Abstract Data Types Research Articles

Testing Algebraic Data Types and Processes: A Unifying Theory

Abstract. There is now a lot of interest in program testing based on formal specifications. However, most the works in this area focus on one formalized aspect of the software under test. For instance, some previous works of the first author consider abstract data type specifications. Other works are based on behavioural descriptions, such as finite state machines or finite labelled transition systems. This paper begins by brie y recalling the principles of test data selection from algebraic data types specifications. Then, it transposes them to basic and full LOTOS. Finally it exploits this uniform framework and suggests a new integrated approach to test derivation from full LOTOS specifications, where both behavioural properties and data types properties are taken into account when dealing with processes.

The formal specification of abstract data types and their implementation in Fortran 90: implementation issues concerning the use of pointers

In this paper we continue our investigation into the development of computational-science software based on the identification and formal specification of Abstract Data Types (ADTs) and their implementation in Fortran 90. In particular, we consider the consequences of using pointers when implementing a formally specified ADT in Fortran 90. Our aim is to highlight the resulting conflict between the goal of information hiding, which is central to the ADT methodology, and the space efficiency of the implementation. We show that the issue of storage recovery cannot be avoided by the ADT user, and present a range of implementations of a simple ADT to illustrate various approaches towards satisfactory storage management. Finally, we propose a set of guidelines for implementing ADTs using pointers in Fortran 90. These guidelines offer a way gracefully to provide disposal operations in Fortran 90. Such an approach is desirable since Fortran 90 does not provide automatic garbage collection which is offered by many object-oriented languages including Eiffel, Java, Smalltalk, and Simula.

The formal specification of abstract data types and their implementation in Fortran 90

In this paper we present an approach to the development of computational science software based on the identification and specification of Abstract Data Types and their implementation in Fortran 90. Our aim is to improve upon current standards of documentation and levels of genericity of such software, and, by the use of a formal specification notation, afford the possibility of undertaking correctness proofs. We illustrate the approach by applying it to a problem which is concerned with the construction of sets of electron configurations and their angular momentum couplings; software to solve this problem is required to enhance the Graphical R-matrix Atomic Collision Environment (G RACE) graphical user interface. In particular, we show how a formal notation can be used to specify unambigously the functionality of software components and we describe the role of the formal specification from the perspective of the ADT implementor and the ADT user. Finally we show how Fortran 90, through its derived types and module facility, directly supports the encapsulation of ADTs thereby enabling the construction of better engineered software than has hitherto been possible using Fortran.

Interface language for supporting programming styles

We suggest a novel application of a formal specification language: we use it to support some programming conventions and encourage certain styles of programming. The Larch/C Interface Language (LCL) is a language for documenting the interfaces of ANSI C programs. It is designed to support a style of c programming where a program is organized around a set of software modules. Even though C does not support abstract data types, LCL supports the specifications of abstract data types, and provides guidelines on how abstract types can be implemented in C. A lint -like program checks for some conformance of C code to its LCL specification.

Two impossibility theorems on behaviour specification of abstract data types

Two kinds of finite specification of the behaviour of a counter data type are proved impossible.

Specification and testing of abstract data types

Specifications are means to formally define the behavior of a software system or a module, and form the basis for testing an implementation. Axiomatic specification technique is one of the methods to formally specify an abstract data type (ADT). In this paper we describe a system called SITE, that is capable of automatically testing the completeness of an ADT specification. In addition, an implementation of the ADT, can also be tested, with SITE providing the test oracle and a number of testcases. For achieving these two goals, the system generates an implementation of the specifications and a set of testcases from the given specifications. For testing the completeness of specifications, the generated implementation is tested with the generated testcases. For testing a given implementation, the generated and given implementations are executed with the generated testcases and the results compared. One way to utilize the system effectively is to first test the specifications and modify them until they are complete, and then use the specifications as a basis for prototyping and testing. The system has been implemented on a Sun workstation.

Generation of ADA and PL/1 prototypes from abstract data type specifications

A software system prototype is an operational model that exhibits the behavioral and structural characteristics of the desired software product. We describe a prototyping system that automatically generates compilable prototypes by transforming an abstract data type specification into a program. The prototyping system consists of two versions: a compiler on MULTICS that generates PL/1 code, and a compiler on UNIX that generates ADA code. The proposed approach allows the specification developer to investigate the behavior of the specifications and define implementation models.

A reification calculus for model-oriented software specification

Abstract This paper presents a transformational approach to the derivation of implementations from model-oriented specifications of abstract data types. The purpose of this research is to reduce the number of formal proofs required in model refinement, which hinder software development. It is shown to be applicable to the transformation of models written in META-IV (the specification language of VDM) towards their refinement into, for example, Pascal or relational DBMSs. The approach includes the automatic synthesis of retrieve functions between models, and data-type invariants. The underlying algebraic semantics is the so-called final semantics “à la Wand”: a specification “is” a model (heterogeneous algebra) which is the final object (up to isomorphism) in the category of all its implementations. The transformational calculus approached in this paper follows from exploring the properties of finite, recursively defined sets. This work extends the well-known strategy of program transformation to model transformation, adding to previous work on a transformational style for operation-decomposition in META-IV. The model-calculus is also useful for improving model-oriented specifications.

Direct Implementation System of Algebraic Specifications of Abstract Data Types.

Direct Implementation System of Algebraic Specifications of Abstract Data Types.

Behavioural Categoricity of Abstract Data Type Specifications

In this note we want to present the concept of behavioural categoricity of an abstract data type specification. Intuitively, a specification is behaviourally categoric if it captures the external views the user can have on the data type. More specifically, using this specification, it is possible to prove that two objects are equal if and only if they behave the same, or informally speaking, if and only if they implement the same black box. Providing a general algorithm for proving the behavioural categoricity of any specification is impossible because that algorithm could also decide whether a finite presentation of a group presents the trivial group or not, which Rabin proved to be undecidable. We show by an example of a specification of circular lists that the proof of the categoricity must be done carefully. In this note we want to present the concept of behavioural categoricity of an abstract type specification. Intuitively, a specification is behaviourally categoric if it captures all the external views the user can have on the data type. More specifically, using this specification, it is possible to prove that two objects are equal if and only if they behave the same, or informally speaking, if and only if they implement the same black box. Providing a general algorithm for proving behavioural categoricity of any specification is impossible, because that algorithm could also decide whether a finite presentation of a group presents the trivial group or not, which Rabin proved to be undecidable. We show by an example of a specification of circular lists, that the proof of the categoricity must be done carefully.

An operational semantics for specifications of abstract data types with error handling

A new approach to an operational treatment of errors and exceptions in specifications of abstract data types is presented. Considering a specification as a term rewriting system, we define an operational semantics and give conditions that are sufficient for its well-definedness (Church-Rosser property). Also, we give conditions that are sufficient for the termination of reduction strategies, respecting the specified error and exception handling.

Methodical specification of abstract data types via rewriting systems

A data type is often given by an informal model. Its formal specification is an important task, but also difficult and error-prone. Here a methodology for this task is presented. Its steps are, first, the election of a canonical form defining a canonical term algebra; second, a system of sound rewriting rules powerful enough to achieve the syntactical transformations of the canonical term algebra. The final translation of rewriting rules into equations is immediate. The methodology is illustrated by the detailed presentation of a simple example.

Direct Implementation of Algebraic Specification of Abstract Data Types

Algebraic specification is now an established way of formally defining abstract data types. For its practical use, however, a segment of program which conforms with the specification has to be generated. Such program segments can be manually produced and must then be verified. Code generation can also be automated, as achieved by the "direct implementation" in [8] where any data type is treated as if its functions produce, manipulate, and access tree structures. We extend these results by formalizing the choice of the appropriate data type (e.g., a tree structure) required to "implement" any given data type. This allows us to consider the formal implementation of a data type in terms of a concrete model.

On the Theory of Specification, Implementation, and Parametrization of Abstract Data Types

On the Theory of Specification, Implementation, and Parametrization of Abstract Data Types

Specification of Abstract Data Types in Modula

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.

A practical example of the specification of abstract data types

The algebra of quotient relations, a relationally complete set of operations for data base applications, is formally defined in terms of the algebraic specification technique. The process of constr...

Abstract Data Type Specification in the Affirm System

This paper describes the data type definition facilities of the AFFIRM system for program specification and verification. Following an overview of the system, we review the rewrite rule concepts that form the theoretical basis for its data type facilities. The main emphasis is on methods of ensuring convergence (finite and unique termination) of sets of rewrite rules and on the relation of this property to the equational and inductive proof theories of data types.

The algebraic specification of abstract data types

There have been many recent proposals for embedding abstract data types in programming languages. In order to reason about programs using abstract data types, it is desirable to specify their properties at an abstract level, independent of any particular implementation. This paper presents an algebraic technique for such specifications, develops some of the formal properties of the technique, and shows that these provide useful guidelines for the construction of adequate specifications.

Limits of the "algebraic" specification of abstract data types

This paper deals with the feasibility of the algebraic specification technique for abstract data types, which consists of a declaration of the operations of a data type and a finite set of "axioms" for the operations. We discuss some inherent difficulties arising from this technique and present a simple example of an abstract type for which the method cannot be applied.