Object-Oriented Programming Versus Abstract Data Types

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.

[1]  Craig Schaffert,et al.  Abstraction mechanisms in CLU , 1977, Commun. ACM.

[2]  William R. Cook,et al.  Interfaces for strongly-typed object-oriented programming , 1989, OOPSLA '89.

[3]  Jens Palsberg,et al.  A Denotational Semantics of Inheritance and its Correctness , 1989, OOPSLA.

[4]  John C. Mitchell,et al.  F-bounded polymorphism for object-oriented programming , 1989, FPCA.

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

[6]  Examples L. Parnas,et al.  A Technique for Software Module Specification with , 1972 .

[7]  Craig Chambers,et al.  An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes , 1989, OOPSLA '89.

[8]  Luca Cardelli,et al.  Operations on records , 1989, Mathematical Structures in Computer Science.

[9]  Ralph E. Johnson,et al.  Type-checking Smalltalk , 1986, OOPLSA '86.

[10]  José Meseguer,et al.  Equality, Types, Modules, and (Why not ?) Generics for Logic Programming , 1984, J. Log. Program..

[11]  Wilf R. LaLonde,et al.  An exemplar based Smalltalk , 1986, OOPLSA '86.

[12]  David A. Moon,et al.  The Lisp Machine manual , 1981, SGAR.

[13]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[14]  Mitchell Wand,et al.  Type inference for record concatenation and multiple inheritance , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[15]  David B. MacQueen.  Using dependent types to express modular structure , 1986, POPL '86.

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

[17]  James J. Horning,et al.  An Introduction to the Larch Shared Language , 1983, IFIP Congress.

[18]  John V. Guttag,et al.  Abstract data types and the development of data structures , 1976, Software Pioneers.

[19]  Ronald Morrison,et al.  Procedures as persistent data objects , 1985, TOPL.

[20]  Stephen N. Zilles,et al.  Programming with abstract data types , 1974, SIGPLAN Symposium on Very High Level Languages.

[21]  Gary T. Leavens,et al.  Reasoning about object-oriented programs that use subtypes , 1990, OOPSLA/ECOOP '90.

[22]  Gerald J. Sussman,et al.  Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.

[23]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[24]  Mitchell Wand,et al.  Complete Type Inference for Simple Objects , 1987, LICS.

[25]  Uday S. Reddy,et al.  Objects as closures: abstract semantics of object-oriented languages , 1988, LISP and Functional Programming.

[26]  I. G. BONNER CLAPPISON.  Editor , 1960, The Electric Power Engineering Handbook - Five Volume Set.

[27]  Jens Palsberg,et al.  A Denotational Semantics af Inheritance and its Correctness , 1989 .

[28]  Joseph A. Goguen,et al.  Initial Algebra Semantics and Continuous Algebras , 1977, J. ACM.

[29]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Inf. Comput..

[30]  José Meseguer,et al.  EQLOG: Equality, Types, and Generic Modules For Logic Programming , 1986, Logic Programming: Functions, Relations, and Equations.

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

[32]  Stephen N. Zilles.  Procedural encapsulation: A linguistic protection technique , 1973 .

[33]  Scott Danforth,et al.  Type theories and object-oriented programmimg , 1988, CSUR.

[34]  Justin O. Graver,et al.  Type checking and type inference for object-oriented programming languages , 1989 .

[35]  Luca Cardelli,et al.  Abstract Types and the Dot Notation , 1990, Programming Concepts and Methods.

[36]  Didier Rémy,et al.  Type checking records and variants in a natural extension of ML , 1989, POPL '89.

[37]  Jonathan Rees,et al.  Object-oriented programming in scheme , 1988, LFP '88.

[38]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[39]  中野 真宏,et al.  "The Random House Dictionary of the English Language"に於ける新語の実例 , 1968 .

[40]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[41]  Professor Dr. Niklaus Wirth,et al.  Programming in Modula-2 , 1982, Springer Berlin Heidelberg.

[42]  Stuart Berg Flexner,et al.  The Random House Dictionary of the English Language and the Poetry of Tina Darragh , 2020, Dictionary Poetics.

[43]  Hartmut Ehrig,et al.  Fundamentals of Algebraic Specification 1: Equations and Initial Semantics , 1985 .

[44]  John C. Mitchell,et al.  Abstract types have existential type , 1988, TOPL.

[45]  Juris Hartmanis,et al.  The Programming Language Ada Reference Manual American National Standards Institute, Inc. ANSI/MIL-STD-1815A-1983 , 1983, Lecture Notes in Computer Science.

[46]  John C. Mitchell,et al.  Abstract types have existential types , 1985, POPL.

[47]  Daniel G. Bobrow,et al.  Vulcan: Logical Concurrent Objects , 1987, Research Directions in Object-Oriented Programming.