There are two major ways of structuring data in programming languages. The first and common one, used for example in Pascal, can be said to derive from standard branches of mathematics. Data are organized as Cartesian products (i.e., record types), disjoint sums (i.e., unions or variant types), and function spaces (i.e., functions and procedures). The second method can be said to derive from biology and taxonomy. Data are organized in a hierarchy of classes and subclasses, and data at any level of the hierarchy inherit all the attributes of data higher up in the hierarchy. The top level of this hierarchy is usually called the class of all objects; every datum is an object and every datum inherits the basic properties of objects, e.g., the ability to tell whether two objects are the same or not. Functions and procedures are considered as local actions of objects, as opposed to global operations acting over objects. These different ways of structuring data have generated distinct classes of programming languages, and induced different programming styles. Programming with taxonomically organized data is often called objectoriented programming, and has been advocated as an effective way of structuring programming environments, data bases, and large systems in general. The notions of inheritance and object-oriented programming first appeared in Simula 67 (Dahl, 1966). In Simula, objects are grouped into classes and classes can be organized into a subclass hierarchy. Objects are similar to records with functions as components, and elements of a class can appear wherever elements of the respective superclasses are expected. Subclasses inherit all the attributes of their superclasses. In Simula, the issues are somewhat complicated by the use of objects as coroutines, so that communication between objects can be implemented as message passing between processes. Smalltalk (Goldberg, 1983) adopts and exploits the idea of inheritance, with some changes. While stressing the message-passing paradigm, a
[1]
Kristen Nygaard,et al.
SIMULA: an ALGOL-based simulation language
,
1966,
CACM.
[2]
John C. Reynolds,et al.
Towards a theory of type structure
,
1974,
Symposium on Programming.
[3]
Robin Milner,et al.
A Theory of Type Polymorphism in Programming
,
1978,
J. Comput. Syst. Sci..
[4]
L. Morris,et al.
Computing cyclic list structures
,
1980,
LISP Conference.
[5]
John C. Reynolds,et al.
Using category theory to design implicit conversions and generic operators
,
1980,
Semantics-Directed Compiler Generation.
[6]
David A. Moon,et al.
The Lisp Machine manual
,
1981,
SGAR.
[7]
M. Simi,et al.
Semantics of Inheritance and Attributions in the Description System Omega
,
1981
.
[8]
L. Steels.
ORBIT: An Applicative View of Object-Oriented Programming
,
1982,
ECICS.
[9]
J. Fairbairn,et al.
Ponder and its type system
,
1982
.
[10]
Frank J. Oles,et al.
Type Algebras, Functor Categories, and Block Structure
,
1986
.
[11]
Hassan Aït-Kasi,et al.
Outline of a Calculus of Type Subsumption
,
1983
.
[12]
Gordon D. Plotkin,et al.
An ideal model for recursive polymorphic types
,
1984,
Inf. Control..
[13]
José Meseguer,et al.
Equality, Types, Modules and Generics for Logic Programming
,
1984,
ICLP.
[14]
Nancy McCracken,et al.
The Typechecking of Programs with Implicit Type Structure
,
1984,
Semantics of Data Types.
[15]
Renzo Orsini,et al.
GALILEO: a strongly-typed, interactive conceptual language
,
1985,
TODS.
[16]
Luca Cardelli,et al.
On understanding types, data abstraction, and polymorphism
,
1985,
CSUR.