data type in the sense of Hoare describes the class of admissible representations (or implementations), that a specification should define such a class rather than a single algebra, and that the abstract data type should be identified with the final algebra in this class. This idea, though not intended, gave rise to some confusion and separated those who believed in initial semantics from those who believed in final semantics. The fundamental criticism in the initial algebra approach was the following: the "abstraction-function" should map the representations to the abstract data type (which makes it final), and not the other way around. But it seems that this controversy was purely a misunderstanding (not by Wand himself), since the initial homomorphism from the initial algebra to the algebras of the specification is not intended to be the "abstraction function", nor its counter part, the "representation function". Instead it models the highly desirable property of initial algebras as realizing the specification in a certain "minimal" way, usually expressed by the principles "no confusion" and "no junk". The final algebra semantics of specifications better fits the intentions of algebraic implementations, and of "behavioral abstraction". The latter was introduced already in 1976 by Giarratana, Gimona, and Montanari (see /GGM 76/) and was motivated by the behavior notion of finite automata theory. Final algebra semantics of algebraic specification has been intensively studied by many authors (see /Kl 83/ for an overview) but is not equally unified and developed as initial algebra semantics. Beside the final algebra approach there are data type specification techniques which originate from the theory of recursive equations (see /Lo 81/, /Kl 83/, /BMSi 84/), and which are studied in view of the assertion calculus for program verification, or in respect to evaluation strategies and complexity. It was early discovered that simple algebraic specifications, which consist of listings of sort symbols, operation symbols, and equations, are in their pure f.orm not appropriate for writing down specifications of larger software systems. Roughly speaking, in this regard they correspond to assembly code and not to structured programs of high level languages. This observation gave rise to the development of the specification language CLEAR by Burstall and Goguen (see /BG 77/ and /BG 80/), which is the first specification language conceptually based on algebraic specifications and their semantics. Among others, a concept of parameterized specifications is incorporated for an appropriate structuring of larger specifications and a modular design of software systems. This first algebraic specification language has considerably influenced the development of the theory of algebraic specifications and the design of other specification languages (see the bibliographic notes in the appendix of this volume).
[1]
J. A. Goguen,et al.
Completeness of many-sorted equational logic
,
1981,
SIGP.
[2]
Claude Kirchner,et al.
Incremental Construction of Unification Algorithms in Equational Theories
,
1983,
ICALP.
[3]
Martin Wirsing,et al.
Structured Algebraic Specifications: A Kernel Language
,
1986,
Theor. Comput. Sci..
[4]
Robin Milner,et al.
A Calculus of Communicating Systems
,
1980,
Lecture Notes in Computer Science.
[5]
Friedrich L. Bauer,et al.
Abstrakte Datentypen: Die algebraische Spezifikation von Rechenstrukturen
,
1982,
Inform. Spektrum.
[6]
Hartmut Ehrig,et al.
Parameter Passing in Algebraic Specification Languages
,
1981,
Theor. Comput. Sci..
[7]
Peter Padawitz.
Correctness, completeness, and consistency of equational data type specifications
,
1983
.
[8]
Peter Padawitz,et al.
Parameter-Preserving Data Type Specifications
,
1987,
J. Comput. Syst. Sci..
[9]
P. J. Higgins.
Algebras with a Scheme of Operators
,
1963
.
[10]
B. Kutzler,et al.
Bibliography on Abstract Data Types
,
1983,
Informatik-Fachberichte.
[11]
Werner Fey.
From Requirements to Design Specification
,
1982,
ADT.
[12]
Hartmut Ehrig,et al.
Stepwise Specification and Implementation of Abstract Data Types
,
1978,
ICALP.
[13]
Hans-Jörg Kreowski.
Algebraische Spezifikation von Softwaresystemen
,
1980,
Software Engineering.
[14]
Stephen N. Zilles,et al.
Programming with abstract data types
,
1974,
SIGPLAN Symposium on Very High Level Languages.
[15]
Peter Raulefs,et al.
Initial and Terminal Algebra Semantics of Parameterized Abstract Data Type Specifications With Inequalities
,
1981,
CAAP.
[16]
Hartmut Ehrig,et al.
Parameter passing commutes with implementation of parameterized data types
,
1982
.
[17]
Klaus Bothe.
A Comparative Study of Abstract Data Type Concepts
,
1981,
J. Inf. Process. Cybern..
[18]
Jacques Loeckx,et al.
Algorithmic Specifications of Abstract Data Types
,
1981,
ICALP.
[19]
Hartmut Ehrig,et al.
Algebraic Implementation of Abstract Data Types
,
1982,
Theor. Comput. Sci..
[20]
Jan A. Bergstra,et al.
On the Power of Algebraic Specifications
,
1981,
MFCS.
[21]
Fernando Orejas.
Passing Compatibility is almost Persistency
,
1984,
ADT.