Universal Realization, Persistent Interconnection and Implementation of Abstract Modules

Our methodology for the abstract specification of (classes of) objects parallels traditional algebraic ADT specifications in many ways. We believe that our approach clarifies the essential difference between data abstraction and object abstraction. It stresses the connection of the behavior of objects with sequences of messages while maintaining the essence of state as an overt but completely abstract entity. While we abstract away from details about state, we do not regard it as a hidden sort as in [GM87] — the presence or absence of state is not transparent. Effective integration of the state concept into formal specification enhances an intuitively natural match of the abstraction with implementation details. The idea of viewing state as a hidden argument captures intuition better since its connection with the visible operations is concealed but not completely severed. The approach we suggest begins with categorizing the methods according to their dependence and effect on the internal state of an object and making those categories an explicit part of the specification. Specifications of the state transition functions are associated with the side-effect inducing methods and provide an abstract description of each of them and the states. Once the state behavior is established, descriptions of the state-dependent methods can be pursued. Because of the role of states in overall behavior, our specifications are intended to distinguish objects only if they have observable behavior which differs. Thus we prefer the final algebra interpretation [GH78, Kam83, Wan79] over the initial algebra view [GTW78]. Of course, the state-independent methods constitute an ordinary ADT and can be specified by well established means. We wish to describe object behavior and hence seek to avoid differentiation of objects based on their internal structure. Hence two states are equivalent (indistinguishable) provided that if we start with two objects, one in each of these states, then for every sequence of messages ending with a selector message, both objects return the same result — that is, the two objects are indistinguishable by any external means. In the ADT literature this is known as the " final algebra " view. Since our approach results in an ADT-style description of a collection of functions, ADT analysis concepts generally apply. For instance, " sufficient completeness " for terms whose primary operation is a selector remains a property of interest. The primary difference to be accounted for is with the State domain which is represented by sequences of side-effect …

[1]  Edsger W. Dijkstra,et al.  Notes on structured programming , 1970 .

[2]  Lawrence Robinson,et al.  An example of hierarchical design and proof , 1978, CACM.

[3]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[4]  Hartmut Ehrig,et al.  A Kernel Language for Algebraic Specification and Implementation , 1983, ADT.

[5]  Joseph A. Goguen,et al.  The Semantics of CLEAR, A Specification Language , 1979, Abstract Software Specifications.

[6]  Hartmut Ehrig,et al.  Parameter Passing in Algebraic Specification Languages , 1981, Theor. Comput. Sci..

[7]  Ugo Montanari,et al.  Observability Concepts in Abstract Data Type Specifications , 1976, MFCS.

[8]  Hartmut Ehrig,et al.  Algebraic Theory of Parameterized Specifications with Requirements , 1981, CAAP.

[9]  James W. Thatcher,et al.  Data Type Specification: Parameterization and the Power of Specification Techniques , 1982, TOPL.

[10]  Joseph A. Goguen,et al.  Abstract Errors for Abstract Data Types , 1977, Formal Description of Programming Concepts.

[11]  Joseph A. Goguen,et al.  Mathematical Representation of Hierarchically Organized Systems , 1970 .

[12]  Peter Raulefs,et al.  Initial and Terminal Algebra Semantics of Parameterized Abstract Data Type Specifications With Inequalities , 1981, CAAP.

[13]  Ulrich L. Hupbach Abstract Implementation of Abstract Data Types , 1980, MFCS.

[14]  Hans-Dieter Ehrich,et al.  On Realization and Implementation , 1981, MFCS.

[15]  Lawrence Robinson,et al.  The SRI International Hierarchical Development Handbook. Volume II. The Languages and Tools of HDM. , 1979 .

[16]  C. A. R. Hoare,et al.  Proof of correctness of data representation , 1975, Language Hierarchies and Interfaces.

[17]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[18]  Jesse B. Wright,et al.  Automata in General Algebras , 1967, Inf. Control..

[19]  Samuel N. Kamin Final Data Types and Their Specification , 1983, TOPL.

[20]  J. A. Goguen,et al.  Completeness of many-sorted equational logic , 1981, SIGP.

[21]  Jean Benabou,et al.  Structures algébriques dans les catégories , 1968 .

[22]  George Gratzer,et al.  Universal Algebra , 1979 .

[23]  Law Fw FUNCTORIAL SEMANTICS OF ALGEBRAIC THEORIES. , 1963 .

[24]  Samuel N. Kamin Final data type specifications: a new data type specification method , 1980, POPL '80.

[25]  Mitchell Wand,et al.  Final Algebra Semantics and Data Type Extensions , 1979, J. Comput. Syst. Sci..

[26]  John V. Guttag,et al.  The specification and application to programming of abstract data types. , 1975 .

[27]  Robin Milner,et al.  An Algebraic Definition of Simulation Between Programs , 1971, IJCAI.