Abstract
This tutorial collects and elaborates arguments for distinguishing between object-oriented programming and abstract data types. The basic distinction is that object-oriented programming achieves data abstraction by the use of procedural abstraction, while abstract data types depend upon type abstraction. Object-oriented programming and abstract data types can also be viewed as complimentary implementation techniques: objects are centered around the constructors of a data abstraction, while abstract data types are organized around the operations. These differences have consequences relating to extensibility, efficiency, typing, and verification; in many cases the strengths of one paradigm are the weaknesses of the other. Most object-oriented programming languages support aspects of both techniques, not a unification of them, so an understanding of their relative merits is useful in designing programs.
Preview
Unable to display preview. Download preview PDF.
References
Abelson and Sussman. The Structure and Interpretation of Computer Programs. MIT Press, 1985.
N. Adams and J. Rees. Object-oriented programming in Scheme. In Proc. of the ACM Conf. on Lisp and Functional Programming, pages 277–288, 1988.
P. America. A behavioral approach to subtyping object-oriented programming languages. In Proc. of the REX School/Workshop on the Foundations of Object-Oriented Languages, 1990.
M. P. Atkinson and R. Morrison. Procedures as persistent data objects. ACM Transactions on Programming Languages and Systems, 7(4):539–559, 1985.
M. R. Brown and G. Nelson. IO streams: Abstract types, real programs. Technical Report 53, Digital Equipment Corporation Systems Research Center, 1989.
P. Canning, W. Cook, W. Hill, J. Mitchell, and W. Olthoff. F-bounded polymorphism for object-oriented programming. In Proc. of Conf. on Functional Programming Languages and Computer Architecture, pages 273–280, 1989.
P. Canning, W. Cook, W. Hill, and W. Olthoff. Interfaces for strongly-typed object-oriented programming. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, pages 457–467, 1989.
P. Canning, W. Hill, and W. Olthoff. A kernel language for object-oriented programming. Technical Report STL-88-21, Hewlett-Packard Labs, 1988.
L. Cardelli. A semantics of multiple inheritance. In Semantics of Data Types, volume 173 of Lecture Notes in Computer Science, pages 51–68. Springer-Verlag, 1984.
L. Cardelli, J. Donahue, L. Glassman, M. Jordan, B. Kalsow, and G. Nelson. Modula-3 report (revised). Technical Report 52, Digital Equipment Corporation Systems Research Center, Dec. 1989.
L. Cardelli and X. Leroy. Abstract types and the dot notation. Digital Equipment Corporation Systems Research Center, 1990.
L. Cardelli and J. C. Mitchell. Operations on records. Technical Report 48, Digital Equipment Corporation Systems Research Center, 1989.
L. Cardelli and P. Wegner. On understanding types, data abstraction, and polymorphism. Computing Surveys, 17(4):471–522, 1986.
C. Chambers, D. Ungar, and E. Lee. An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, pages 49–70, 1989.
W. Cook. A Denotational Semantics of Inheritance. PhD thesis, Brown University, 1989.
W. Cook and J. Palsberg. A denotational semantics of inheritance and its correctness. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, pages 433–444, 1989.
S. Danforth and C. Tomlinson. Type theories and object-oriented programming. Technical Report PP-040-87, MCC, 1987.
H. Ehrig and B. Mahr. Fundamentals of Algebraic Specification 1: Equations and Initial Semantics. Springer-Verlag, 1985.
J. Goguen and J. Meseguer. Eqlog: Equality, types, and generic modules for logic programming. In Functional and Logic Programming, pages 295–363. Prentice-Hall, 1986. An earlier version appears in Journal of Logic Programming, Volume 1, Number 2, pages 179–210, September 84.
J. Goguen, J. Thatcher, E. Wagner, and J. Wright. Initial algebra semantics and continuous algebras. J. ACM, 24(1):68–95, January 1977.
A. Goldberg and D. Robson. Smalltalk-80: the Language and Its Implementation. Addison-Wesley, 1983.
J. Graver. Type-Checking and Type-Inference for Object-Oriented Programming Languages. PhD thesis, University of Illinois, 1989.
J. Guttag. Abstract data types and the development of data structures. Communications of the ACM, 20(6):297–404, June 1977.
J. V. Guttag and J. J. Horning. An introduction to the larch shared language. In IFIP, 1983.
R. E. Johnson. Type-checking smalltalk. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, pages 315–321, 1986.
K. Kahn, E. Tribble, M. Miller, and D. Bobrow. Vulcan: Logical concurrent objects. In Research Directions in Object-Oriented Programming, pages 75–112. MIT Press, 1987.
S. E. Keene. Object-Oriented Programming in Common Lisp. Addison-Wesley, 1989.
W. R. LaLonde, D. A. Thomas, and J. R. Pugh. An exemplar based smalltalk. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, pages 322–330, 1986.
G. T. Leavens and W. E. Weihl. Reasoning about object-oriented programs that use subtypes. In Proc. of ACM Conf. on Object-Oriented Programming, Systems, Languages and Applications, 1990. to appear.
B. Liskov, A. Snyder, R. Atkinson, and C. Schaffert. Abstraction mechanisms in CLU. Communications of the ACM, 20:564–576, 1977.
B. Liskov and S. Zilles. Programming with abstract data types. SIGPlan Notices, 9(4):50–59, 1974.
D. B. MacQueen. Using dependent types to express modular structure. In Proc. of the ACM Symp. on Principles of Programming Languages. ACM, 1986.
J. C. Mitchell and G. D. Plotkin. Abstract types have existential type. In Proc. of the ACM Symp. on Principles of Programming Languages. ACM, 1985.
U. S. D. of Defense. Reference manual for the Ada programming language. ANSI/MIL-STD-1815 A, 1983.
D. Parnas. On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15:1053–1058, 1972.
D. Parnas. A technique for software module specification. Communications of the ACM, 15:330–336, 1972.
U. S. Reddy. Objects as closures: Abstract semantics of object-oriented languages. In Proc. of the ACM Conf. on Lisp and Functional Programming, pages 289–297, 1988.
D. Rémy. Typechecking records and variants in a natural extension of ML. In Proc. of the ACM Symp. on Principles of Programming Languages, pages 77–88, 1989.
J. C. Reynolds. User-defined types and procedural data structures as complementary approaches to data abstraction. In New Advances in Algorithmic Languages, pages 157–168. Inst. de Recherche d'Informatique et d'Automatique, 1975.
R. Stallman, D. Weinreb, and D. Moon. Lisp Machine Manual. MIT AI Lab, 1983.
J. Stein, editor. Random House Dictionary of the English Language. Random House, 1967.
M. Wand. Complete type inference for simple objects. In Proc. IEEE Symposium on Logic in Computer Science, pages 37–44, 1987.
M. Wand. Type inference for record concatenation and multiple inheritance. In Proc. IEEE Symposium on Logic in Computer Science, pages 92–97, 1989.
N. Wirth. Programming in Modula-2. Springer-Verlag, 1983.
S. N. Zilles. Procedural encapsulation: A linguistic protection mechanism. SIGPlan Notices, 8(9):142–146, 1973.
Author information
Authors and Affiliations
Editor information
Rights and permissions
Copyright information
© 1991 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Cook, W.R. (1991). Object-oriented programming versus abstract data types. In: de Bakker, J.W., de Roever, W.P., Rozenberg, G. (eds) Foundations of Object-Oriented Languages. REX 1990. Lecture Notes in Computer Science, vol 489. Springer, Berlin, Heidelberg. https://doi.org/10.1007/BFb0019443
Download citation
DOI: https://doi.org/10.1007/BFb0019443
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-53931-5
Online ISBN: 978-3-540-46450-1
eBook Packages: Springer Book Archive