Specification and Implementation of Abstract Data Types

Publisher Summary This chapter describes the specification and implementation of abstract data types (ADT). A data structure is to be identified with the operations that are applicable to it, and the only way to generate an instance of the data structure is by means of a sequence of applications of the operations. This is called data abstraction. The chapter deals with the problems associated with data abstraction, including the traversible stack syndrome, functional and procedural programming, and synchronization problems. The chapter distinguishes between the operational approach and the algebraic approach of specifications. Algebraic specifications provide clear descriptions of the computational objects in a self-contained way. An operational specification depends on a representation domain. The chapter discusses modularization, that is, the decomposition of a program into a set of functionally distinct units, and the importance of data types with respect to program correctness, and why data types should be defined in terms of operations.

[1]  John V. Guttag,et al.  Notes on Type Abstraction (Version 2) , 1980, IEEE Transactions on Software Engineering.

[2]  Mila E. Majster,et al.  Data types, abstract data types and their specification problem , 1979 .

[3]  Deepak Kapur,et al.  Specifications of Majster's traversable stack and Veloso's traversable stack , 1979, SIGP.

[4]  Peter Henderson,et al.  A lazy evaluator , 1976, POPL.

[5]  Manfred Broy,et al.  Program Development as a Formal Activity , 1981, IEEE Transactions on Software Engineering.

[6]  Stefan Sokolowski.  A Uniform Approach to Applicative and Imperative Features in Programming Languages , 1980, MFCS.

[7]  Neil D. Jones,et al.  Complexity of flow analysis, inductive assertion synthesis and a language due to Dijkstra , 1980, 21st Annual Symposium on Foundations of Computer Science (sfcs 1980).

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

[9]  Niklaus Wirth,et al.  Modula: A language for modular multiprogramming , 1977, Softw. Pract. Exp..

[10]  Craig Schaffert,et al.  CLU Reference Manual , 1984, Lecture Notes in Computer Science.

[11]  Rod M. Burstall,et al.  HOPE: An experimental applicative language , 1980, LISP Conference.

[12]  Eitan M. Gurari,et al.  The Complexity of the Equivalence Problem for Simple Programs , 1981, JACM.

[13]  Zohar Manna,et al.  Inductive methods for proving properties of programs , 1973, Commun. ACM.

[14]  James H. Morris,et al.  Types are not sets , 1973, POPL.

[15]  Stephen N. Zilles,et al.  Specification techniques for data abstractions , 1975 .

[16]  Richard G. Hamlet,et al.  Data Abstraction, Implementation, Specification, and Testing , 1981, TOPL.

[17]  J. J. Horning,et al.  Report on the programming language Euclid , 1977, SIGP.

[18]  John Darlington,et al.  A Transformation System for Developing Recursive Programs , 1977, J. ACM.

[19]  Mary Shaw,et al.  Abstraction and verification in Alphard: Defining and specifying iteration and generators , 1977 .

[20]  Manfred Broy,et al.  Abstract Data Types as Lattices of Finitely Generated Models , 1980, MFCS.

[21]  Heinrich C. Mayr,et al.  Data abstractions for database systems , 1979, TODS.

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

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

[24]  Richard J. Lipton,et al.  Social processes and proofs of theorems and programs , 1977, POPL.

[25]  James J. Horning,et al.  FP with data abstraction and strong typing , 1981, FPCA '81.

[26]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[27]  Tom Pittman,et al.  Summary of the characteristics of several "modern" programming languages , 1979, SIGP.

[28]  David W. Stemple,et al.  Human factors comparison of a procedural and a nonprocedural query language , 1981, TODS.

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

[30]  Alfs T. Berztiss.  Data abstraction, controlled iteration, and communicating processes , 1980, ACM '80.

[31]  Ellis Horowitz,et al.  The design of data type specifications , 1976, ICSE '76.

[32]  John McCarthy,et al.  Recursive functions of symbolic expressions and their computation by machine, Part I , 1960, Commun. ACM.

[33]  Mary Shaw.  Alphard: Form and Content , 1981, Springer New York.

[34]  K. Mani Chandy,et al.  Current trends in programming methodology , 1977 .

[35]  Barbara Liskov,et al.  Aspects Of Implementing CLU , 1978, ACM Annual Conference.

[36]  Ellis Horowitz,et al.  Abstract data types and software validation , 1978, CACM.

[37]  Neil D. Jones,et al.  Program Flow Analysis: Theory and Application , 1981 .

[38]  Ben Wegbreit,et al.  Proving Properties of Complex Data Structures , 1976, JACM.

[39]  Peter Wegner,et al.  Research directions in software technology , 1978, ICSE '78.

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

[41]  Edwin H. Satterthwaite,et al.  Early experience with Mesa , 1977, CACM.

[42]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[43]  Peter Henderson,et al.  Functional programming - application and implementation , 1980, Prentice Hall International Series in Computer Science.

[44]  Elliott Mendelson,et al.  Introduction to Mathematical Logic , 1979 .

[45]  Alfred V. Aho,et al.  Universality of data retrieval languages , 1979, POPL.

[46]  Elliot Soloway,et al.  Positive effects of computer programming on students understanding of variables and equations , 1980, ACM '80.

[47]  Rod M. Burstall,et al.  Proving Properties of Programs by Structural Induction , 1969, Comput. J..

[48]  Abha Moitra.  Direct Implementation of Algebraic Specification of Abstract Data Types , 1982, IEEE Transactions on Software Engineering.

[49]  Jacob Palme,et al.  New feature for module protection in SIMULA , 1976, SIGP.

[50]  P. A. Subrahmanyam.  Nondeterminism in Abstract Data Types , 1981, ICALP.

[51]  David R. Musser,et al.  On proving inductive properties of abstract data types , 1980, POPL '80.

[52]  David Lorge Parnas,et al.  A technique for software module specification with examples , 1972, CACM.

[53]  David R. Musser,et al.  Abstract Data Type Specification in the Affirm System , 1980, IEEE Transactions on Software Engineering.

[54]  William A. Wulf.  Abstract Data Types: A Retrospective and Prospective View , 1980, MFCS.