From: Bob Hathaway <objsys@netcom.com>
Subject: FAQ (Part 1 of 2)
Keywords: FAQ
Organization: Object Systems
Date: Sat, 23 Jan 1993 07:10:36 GMT

Hello Netters,

I'm posting this incomplete FAQ (we're still not done arguing yet) because,
unfortunately, I'm leaving Object Systems (and my ultimate C++ superset) for
this hot little company doing even more dynamic and profound things in the
object model.  The FAQ will still undergo major revision.  Anyway, I should
be able to pick up from there a little later...

bob
objsys@netcom.com

P.S.  Thanks for the many encouraging letters.  They help me to continue
working on the FAQ whenever I can...


COMP.OBJECT FAQ
Version: -1.0.2 (PRE-DRAFT RELEASE - REQUEST FOR COMMENTS)
Date:    1/22/1993

Author:
  Bob Hathaway
  Object Systems
  objsys@netcom.com

Anonymous FTP Site for FAQ: YTBA
Anonymous FTP Site for comp.object: ???

Copyright January 10, 1992 by Bob Hathaway.
Permission is granted to freely copy and distribute this document but only at
no cost to others and with the exception of a nominal distribution fee, if
any.  No sale, resale or reprinting is granted without the explicit written
permission of the author.

Contributors:  Stewart Clamen, Mike DeVaney, Paul Johnson, Ronald C. Schultz,
  Bill Kinnersley, Piercarlo Grandi and many others whose names and
  contributions will be added soon.

Objective:
  In the spirit of other FAQs, to provide a simple document to answer the most
  frequently asked and recurring questions and to allow new users to understand
  frequently discussed topics and terms used in comp.object.   This should
  bring new comp.object readers and/or writers to at least an introductory
  level of comprehension as soon as possible.  Other goals (hopes) are to
  provide a quick and current reference on available systems such as object-
  oriented languages, CASE, OODB and etc. and to provide good references to
  current and relevant texts.

Disclaimer:
  This document does not reflect the opinions of the author's or any
  contributor's companies.  There are no explicit or implicit guarantees
  implied by this document.

BASICS:
  What Is an Object?
  What Is Object Encapsulation (or Protection)?
  What Is a Class?
  What Is a Meta-Class?
  What Is Infinite Regress?
  What are MOPs and Reflection?
  What Is Inheritance?
  What Is Multiple Inheritance?
  Does Multiple Inheritance Pose any Additional Difficulties?
  What Is Dynamic Inheritance?
  What Is Shared (Repeated) Inheritance?
  Why use Inheritance?
  Why Don't Some People Like Inheritance?
  What Is Specialization/Generalization/Overriding?
  What Is the Difference Between Object-Based and Object-Oriented?
  Is a Class an Object?
  Is an Object a Class?
  What Is a Method? (and Receiver and Message)
  What Are Multi-Methods?
  Can I use Multi-Methods in C++?
  What Is OOP?
  What Is OOA/OOD (and where can I get what I need on it)?
  Where Did Object-Orientation Come From?
  What Are the Benefits of Object-Orientation?
  What other FAQs are available?

TYPING:
  What Is Polymorphism?
  What Does Polymorphism Boil Down To in Object-Oriented Programming Languages?
  What Is Dynamic Binding?
  Is There a Difference Between Being a Member or Instance of a Class?
  What Is This I Read About ML and Functional Programming Languages?
  What Is the Difference Between Static and Dynamic Typing?
  What Is the Separation Between Type and Class?
  What Are Generics and Templates?

KINDS OF OO:
  What Is the "Classical" Object-Oriented Paradigm?
  What Is the "Delegation/Prototyping" Object-Oriented Paradigm?
  Are There any Others Paradigms?

GENERAL:
  What are the Major Languages in Object-Oriented Programming Today?
  What are Object-Oriented Databases?
  What are Object-Oriented Operating Systems?
  What Are the Current Object-Oriented Methodologies?
  What Is the OMG/ORA/...?
  Why Is Garbage Collection a Good Thing?

COMMONLY ASKED LANGUAGE SPECIFIC QUESTIONS:
  What Is Downcasting?
  What are Virtual Functions?

ANNOTATED BIBLIOGRAPHY

APPENDIXES
  APPENDIX A  VIPS
  APPENDIX B  Object-Oriented Databases and Vendors
  APPENDIX C  Object-Oriented Languages and Vendors
  APPENDIX D  Object-Oriented CASE (OOA/D/P Tools) and Vendors
  APPENDIX E  Anonymous FTP sites
  APPENDIX F  Magazines, Journals and Lewsletters


BASICS
======

Suggested Readings:
  [Booch 91]
  Others to be added...

What Is an Object?

There are many definitions of an object, such as found in [Booch 91, p77]:
"An object has state, behavior, and identity; the structure and behavior of
similar objects are defined in their common class; the terms instance and
object are interchangeable".  This is a "classical languages" definition, as
defined in [Coplien 92, p280], where "classes play a central role in the
object model", since they do not in prototyping/delegation languages.  
"The term object was first formally applied in the Simula language, and
objects typically existed in Simula programs to simulate some aspect of
reality" [Booch 91, p77].  Other definitions referenced by Booch include
Smith and Tockey [see Booch 91]: "an object represents an individual,
identifiable item, unit, or entity, either real or abstract, with a well-
defined role in the problem domain." and Cox[Ref]: "anything with a crisply
defined boundary".  Booch goes on to describe these definitions in depth.

In symbolic languages, such as Smalltalk and Lisp-based systems, variables are
loosly bound to objects, and can be viewed as labels referring to objects.

The implementation of objects could be categorized into descriptor-based,
capability-based, and simple static-based approaches.  Descriptor-based
approaches (e.g. Smalltalk handles) allow symbolic programming, capability-
based approaches are found in object-oriented databases and operating systems
(object id's) and simple static approaches are found in languages such
as C++.

Below is a simple example of statically typed objects from a conventional
procedural programming point of view intended to show new users one of the
simplist cases of objects in terms of something they may already be familiar
with, conventional programming (and BTW, object-oriented programming is
procedural because of its functional/behavioral interfaces and implementations
(see methods)):

Simple statically-typed objects can be viewed as instances of a record type,
whose record fields are called instance variables (Smalltalk) or member data
(C++).  The record (class) may also contain operations which are called
methods (Smalltalk) or member functions (C++) which are equivalent to a
function taking an object of the record type, called the receiver, as the
first parameter.  The receiver is called self (Smalltalk) or this (C++).
Members will denote both instance variables and methods.  Inheritance is
roughly equivalent to a loosly coupled variant record, with derived classes
as variant parts and with multiple-inheritance concatenating several records
to serve as a base.  Pointers, references and access types are simple examples
of symbolic programming, where pointer objects are not tightly bound to the
objects they denote.  Since most symbolic languages are statically typeless
(or just "typeless") but have dynamic types, an untyped pointer (such as void*
in C++) and an embedded dynamic type scheme must be used in conventional
languages to fully emulate symbolic programming.

The terms method/member function, instance variable/member data, subclass/
derived class, parent class/base class, and etc. will be used interchangeably.
As pointed out in [Stroustrup 91, p197], the base/derived class terminology
may be preferable to the sub/super-class terminology, and is preferred in
this document also.

Delegation/prototyping languages have a more flexible kind of object which
can play the role of classes in classical languages.  Since there is no
separate class construct in these languages, they are referred to as single-
hierarchy, or 1 Level systems.  Objects contain fields, methods and delegates
(pseudo parents), whereas classical object-oriented languages associate
method, field and parent definitions with classes (and only associate state,
and class with objects).  Typical 1 Level objects can contain any number of
fields, methods and parents and any object can be used as a template/exemplar,
thus performing the classical role of a class.  In typical prototyping
systems, parents (as any other member) can be added dynamically, providing
dynamic multiple inheritance.  It is common in such systems for an object to
"become" another kind of object by changing its parent.  An good example is a
window becoming an icon, since window and icon objects display different
behavior.  Delegation refers to delegating the search for an attribute to
a delegate, and is therefore more of a pure message passing mechanism than
inheritance.

1 Level systems therefore provide the most flexible and powerful capabilities.


What Is Object Encapsulation (or Protection)?

Some languages permit arbitrary access to objects and allow methods to be
defined outside of a class (as in CLOS, but with voluntary restrictions)
giving users complete access to objects.  However most object-oriented
languages provide a well defined interface to their objects thru classes.
C++ has a very general protection mechanism with public, private and protected
members.  Public members (member data and member functions) may be accessed
from anywhere.  A Stack's Push and Pop methods will be public.  Private
members are only accessible from within a class.  A Stack's representation,
such as a list or array, will usually be private.  Protected members are
accessible from within a class and also from within subclasses (also called
derived classes).  A Stack's representation could be declared protected
allowing subclass access.

For another example, Smalltalk's class instance variables are not accessible
from outside of their class (they are not only private, but invisible).
Smalltalk's methods are all public (can be invoked from anywhere), but a
private specifier indicates methods should not be used from outside of the
class.  All Smalltalk instance variables can be accessed by subclasses (this
helps with abstract classes and overriding).


What Is a Class?

There are many definitions of a class, such as [Booch 91, p93], "a group, set,
or kind marked by common attributes or a common attribute; a group division,
distinction, or rating based on quality, degree of competence, or condition"
and Booch's definition in the context of object-oriented design "A class is a
set of objects that share a common structure and a common behavior."  "A
single object is simply an instance of a class."

In more pragmatical programming terms, a Class is a specification of structure
(instance variables), behavior (methods), and inheritance (parents, or
recursive structure and behavior).  As pointed out above, classes can also
specify access permissions for clients and derived classes.


What Is a Meta-Class?
 
A Meta-Class is a class' class.  If a class is an object, then that object
must have a class (in classical OO anyway).  Compilers provide an easy way to
picture Meta-Classes.  Classes must be implemented in some way; perhaps with
dictionaries for methods, instances, and parents and methods to perform all
the work of being a class.  This can be declared in a class named "Meta-Class".
The Meta-Class can also provide services to application programs, such as
returning a set of all methods, instances or parents for review (or even
modification).  In Smalltalk, the situation is more complex.  To make this
easy, refer to the following:

1 Level System
  All objects can be viewed as classes and all classes can be viewed as
  objects (as in Self).  There is no need for Meta-Classes because objects
  describe themselves.  Also called "single-hierarchy" systems.
2 Level System
  All Objects are instances of a Class but these are not accessible to
  programs (no Meta-Class except for in the compiler and perhaps for type-safe
  linkage, as in C++).  Also called "dual-hierarchy" systems.
3 Level System
  All objects are instance of a class and all classes are instances of
  Meta-Class.  The Meta-Class is a class and is therefore an instance of
  itself (really making this a 3 1/2 Level System).  This allows classes to
  be first class objects and therefore classes are available to programs.
5 Level System
  What Smalltalk provides.  Like a 3 Level System, but there is an extra level
  of specialized Meta-Classes for classes.  There is still a Meta-Class as in 
  a 3 Level System, but as a class it also has a specialized Meta-Class, the
  "Meta-Class class" and this results in a 5 Level System: 
    object
    class
    class class (Smalltalk's Meta-Classes)
    Meta-Class
    Meta-Class class


What Is Infinite Regress?

In the authors opinion, a myth.  The story goes a class has a Meta-Class,
which must also have a Meta-Meta-Class, which must also have a
Meta-Meta-Meta-Class ...  The trick is to have a loop at the end, as with a
Meta-Class pointing to itself, or to have a "Meta-Class - Meta-Class class"
loop (as in Smalltalk).


What Are MOPs and Reflection?

MOP is an acronym for Meta-Object Protocol.  This is a system with
Meta-Classes accessible to users.  An introspective protocol provides a read
only capability (e.g. what is this object's class, give info on this class,
etc.) and an intercessory protocol provides a write capability which allows
system modification (e.g. add the following method or instance to this class,
perform inheritance this way, etc.).  Because inheritance can be used to
perform differential changes, intercessory protocols allow users to not only
define new frameworks but to specialize existing system frameworks
differentially without affecting them and their extant objects.  Thus, many
frameworks can interoperate together simultaneously.

"Reflective" systems are systems with MOPs (not to be confused with reflexive
systems, which often refer to systems implemented in terms of themselves, or
bootstrapped).


What Is Inheritance?

Inheritance is a relationship between classes where one class is the
parent (or base) class of another.  Inheritance can be used as an
is-a-kind-of relationship or for differential programming.  Inheritance
also doubles for assignment compatibility (see What is the difference
between Type and Class?).  

An example of the is-a-kind-of (is-a can be used synonymously, but is often
used to show the "object is-a class" instantiation relationship.  In classical
OO, is-a-kind-of is a relationship between classes only) relationship is as
follows:

                               Computer
                              /    |     \
                       Mainframe  Mini    Personal
                        /    \    ...       /   \
                  Data Proc  Scientific   PC    Workstation

Class hierarchies are subjective and usually drawn with the parent class on
top, but more demanding graphs (as is often the case in [Rumbaugh 91]) often
allow any topology, with the head of an arrow indicating the parent (base)
class and the tail indicating the subclass (derived) class.

Differential programming is the use of inheritance to make a small change to
a class.  Creating a subclass to alter a method or to add a method to
a parent class is an example of differential programming.

A Parent class is called a base class and a subclass is called a derived
class in C++, these terms are used interchangeably here.


What Is Multiple Inheritance?

Multiple Inheritance occurs when a class inherits from more than one parent.


Does Multiple Inheritance Pose any Additional Difficulties?

Yes, it does.  Any name can be simply resolved to a class member with single
inheritance by simply accessing the first name encountered for data members
and for accessing the first signature match (or ambiguity) encountered for
methods (at least one way, C++ hides some member functions).  Since several
parents can declare a member, which to choose becomes an issue.  Eiffel forces
derived classes to rename parent members that conflict.  Self prioritizes
parents.  CLOS merges member "slots" (instance variables) with the same name
into a single slot.  C++ declares an error iff a conflict arises (but a class
qualifier can be used to explicitly disambiguate).


What Is Dynamic Inheritance?

Dynamic inheritance refers to the ability to add, delete, or change parents
from objects (or classes) at run-time.  1 Level Systems typically provide
dynamic inheritance.  In many systems these parents can be any object; however,
so objects acting as classes are often "cloned" to provide unshared or unique
attributes.


What Is Shared (Repeated) Inheritance?

Multiple Inheritance brings up the possibility for a class to appear as a
parent more than once in a class graph (repeated inheritance), and there is
then a potential to share that class.  Only one instance of the class will
then appear in the graph (as is always the case in CLOS, because all *members*
with the same name will be shared (receive a single slot) with the greatest
common subtype as its type.  C++ provides an alternative, where only parents
specified as virtual (virtual bases) are shared within the same class lattice,
allowing both shared and non-shared occurrences of a parent to coexist.  All
"features" in Eiffel (C++ members) of a repeated parent that are not to be
shared must be renamed "along an inheritance path", else they are shared by
default.  This allows a finer granularity of control but requires more work
for parents with many fetaures.


Why Use Inheritance?

Inheritance provides for code and structural reuse.  In the above Computer
class diagram, all routines and structure available in class Computer are
available to all subclasses throughout the diagram.  All attributes available
in Personal computers are also available to all of its subclasses.  This kind
of reuse takes advantage of the is-a-kind-of relationship.

With differential programming, a class does not have to be modified if it is
close to what's required; a derived class can be created to specialize it.
This avoids code redundancy, since code would have to be copied and modified
otherwise.


Why Don't Some People Like Inheritance?

Some people complain that inheritance is hierarchical (which is what most
object-oriented languages provide).  They would also like to see more
operations available (set operations are quite common in specialized systems).
These are really language dependent features commonly found in object-oriented
languages which are then associated with the term "inheritance" (although
they don't need to be).  Some don't like the coupling of classes (as in Jade),
but in the author's opinion many of their complaints are easily answered.
In systems that provide inheritance, inheritance provides a simple and elegant
way to reuse code and to model the real world in a meaningful way.

Others complain multiple inheritance is too complicated because it brings up
the issues of shared bases and member conflict resolution.  But most modern
systems support Multiple Inheritance by employing semantic resolution
strategies, and many consider MI to be highly desirable.


What Is Specialization/Generalization/Overriding?

To create a subclass is specialization, to factor out common parts of
derived classes into a common base (or parent) is generalization [Booch 91,
p56].  Overriding is the term used in Smalltalk and C++ for redefining a
(virtual in Simula and C++) method in a derived class, thus providing
specialized behavior.  All routines in Smalltalk and Eiffel are overridable
(although in Eiffel they must be "redefined" in a derived class).  Whenever
a method is invoked on an object of the base class, the derived class method
is executed overriding the base class method, if any.  Overriding in Simula
is a combination of overloading and multi-methods because parameters do not
have to be declared.


What Is the Difference Between Object-Based and Object-Oriented?

Object-Based Programming usually refers to objects without inheritance
[Cardelli 85] and hence without polymorphism, as in '83 Ada and Modula-2.
Proposed '93 Ada and Modula-3; however, support inheritance and polymorphism.
[Cardelli 85, p481] state "that a language is object-oriented if and only if
it satisfies the following requirements:
  - It supports objects that are data abstractions with an interface of named
    operations and a hidden local state.
  - Objects have an associated type [class].
  - Types [classes] may inherit attributes from supertypes [superclasses].

These definitions are also found in [Booch 91, Ch2].  A more modern definition
includes single hierarchy languages and perhaps object id's for unique objects.
Object id's support the more modern notion of relocatable, persistent and
distributed objects that can even migrate across machines.


Is a Class an Object?

In C++ no, because C++ classes are not instances of an accessible class (a
Meta-Class) and because C++ classes are not accessible to programs.  Classes
are objects in 3 Level Systems and above because classes have Meta-Classes
and can therefore be accessed in the same way as any other object.  But
classes play a dual role, because objects can only be declared to be instances
of a class.  In 1 Level (single hierarchy) systems, all classes are objects,
so to speak.


Is an Object a Class?

In a Level 3 System and above yes, but only instances of a Meta-Class
are Classes.  Instances of a Class (ordinary objects) are not classes.
However, all objects may be classes in single hierarchy systems, since any
object may act as a class (provide object instantiation).  If done directly,
this object may be shared among many class graphs.  To get the effect of a
typical parent (e.g. if instance variables are shared), the class object
is usually cloned and then made a parent.


What Is a Method? (and Receiver and Message)

A method is a function or procedure which is defined in a class and can
access the internal state of an object of that class to perform some
operation.  It can be thought of as a procedure with the first parameter
as the object to work on.  This object is called the receiver, which is the
object the method operates on.  The following are some common notations for
invoking a method, and this invocation is called a message (or message
passing):

  receiver.message_name(a1, a2, a3)   
  receiver message_name: a1 parm1: a2 parm3: a3

Selector would be another good choice for message_name in the above examples,
although the keywords (or formal parameter names, like named parameters) are
considered part of the selector in Smalltalk.

A method implements behavior, which is defined by [Booch 91, p80]:

  Behavior is how an object acts and reacts, in terms of its state changes
  and message passing.


What Are Multi-Methods?

In Multi-Methods all parameters are used in the selection of a method
(multiple-polymorphism).  The name comes from CLOS, a language with both
static and dynamic typing.  CLOS does not distinguish a receiver and
typically associates a method with the classes of all specialized parameters.
While the notion of multi-methods originally comes from such loosly coupled
methods and classes, the idea also applies to classical object-oriented
languages.  Statically-typed languages such as C++ place restrictions on
parameters, so that overriding methods must have identical signatures with the
methods they substitute.  If this restriction is dropped, a Multi-Method
capability is available.  With Multi-Methods, a single overridable function
declared in a base class may have several functions overriding it in a derived
class differentiated only by their formal argument types.  Therefore multi-
methods require both static and dynamic typing, because no formal argument
differentiation is possible without static types and no actual argument
differentiation would be possible without dynamic types.

There is some concern about the efficiency of run-time method selection
as can occur with multi-methods.  However, static analysis optimizations are
commonly available in the literature, potentially providing a single static
selection in certain cases.  But coupling the two cases of unknown selectors
(as found in CLOS and other dynamic languages) and several possible known
selectors together with the undecidability of dynamic types at run-time
renders dynamic typing and run-time selection (or checking) as unavoidable in
the general case [a point often mistaken in comp.object].


Can I use Multi-Methods in C++?

Yes, but you'll need to embed a dynamic typing scheme to do it.  With
dynamic types in place, an overriding method in a derived class can explicitly
check argument types in a switch statement and invoke the desired method
[Coplien 92].  Future FAQs should contain more detail.


What is OOP?

OOP stands for Object-Oriented Programming, the usual programming/hacking and
etc. most programmers think of.


What Is OOA/OOD (and where can I get what I need on it)?

  See also "What Are the Current Object-Oriented Methodologies?", the
  Annotated Bibliography, and APPENDIX D  Object-Oriented CASE (OOA/D/P Tools)
  and Vendors.

OOA and OOD stand for Object-Oriented Analysis and Object-Oriented Design,
respectively.  To generalize (since these terms differ between systems),
OOA analyzes the problem domain in terms of objects and classes, while OOD
reflects the system to be built in the same terms.  The usual progression is
from OOA to OOD to OOP.  Since classes and objects are used in all phases,
the process is often referred to as seamless, meaning there is no conceptual
or even actual gap or hiatus between them as is often the case in other
software development methodologies.

OOA and OOD differ from OOP in that the notations are graphical instead of
the usual textual declarative form.  This allows easier visualization and
makes dependencies more explicit.  For example, an association is an annotated
and labeled line connecting classes in an OOA or OOD diagram, but is often
a pointer declaration (or an instance of another class) in OOP ([Rumbaugh 91]
explicitly addresses the implementation of associations in several sections).

An OO problem domain has many realizations, or differing OOAs.  An OOA has
many realizations, or differing OODs, but a similar notation is often used
for the two.  An OOD also has many realizations, or differing OOPs, but allows
a selection from among various languages for implementation (choosing the best
language to implement the design).  But some, such as Bjarne Strostrup, don't
like OOA and OOD getting too far from OOP (implementation independent), for
fear that great discrepancies could occur between OOD and OOP by losing sight
of the implementation language, which in some cases is predetermined.


Where Did Object-Orientation Come From?

Simula was the first object-oriented language because it provided facilities
such as classes, inheritance, and dynamic typing back in 1967 (in addition to
its Algol-60 subset).  Simula 1 was a simulation language, and the later
general-purpose language Simula 67 is now referred to as simply Simula.
Smalltalk was the next major contributor which included classes, inheritance,
a nice environment and a powerful dynamic typing mechanism.


What Are the Benefits of Object-Orientation?

Reuse, quality, an emphasis on modeling the real world (or a "stronger
equivalence" with the RW than other methodologies), a consistent and seamless
OOA/OOD/OOP package, naturalness (our "object concept") and etc.


What Other FAQs Are Available?

There are also FAQ's for comp.lang.c++, comp.lang.eiffel, and comp.lang.clos
(more should be added soon).


TYPING
======

  References
    [Booch 91]		Small Section on Typing.
    [Cardelli 85]	Discussion on Object-Oriented Typing.
    [Kim 89, ch1]	Discussion on Some Research Topics.

What Is Polymorphism?

For a Brief Answer:
Polymorphism is the ability of an object to assume or become many different
forms of object and for these various forms to exhibit explicit phenotype-
like expression.  Inheritance (or delegation) specifies slightly different or
additional structure or behavior for an object, and these more specific or
additional attributes of an object of a base class when assuming or becoming
an object of a derived class characterizes object-oriented polymorphism.  This
is a special case of parametric polymorphism, which allows an object to assume
or become any object (possibly satisfying some implicit or explicit type
constraints (parametric type), or a common structure) and not just objects of
derived classes.

For a More Detailed Answer:
"Poly" means "many" and "morph" means "form".  The homograph polymorphism has
many uses in the sciences, all referring to objects that can take on or assume
many different forms.  Computer Science refers back to Strachey's original
definitions of polymorphism, as divided into two major forms, parametric and
ad-hoc.  "Parametric polymorphism is obtained when a function works uniformly
on a range of types; these types normally exhibit some common structure.  Ad-
hoc polymorphism is obtained when a function works, or appears to work, on
several different types (which may not exhibit a common structure) and may
behave in unrelated ways for each type."  Parametric polymorphism is also
referred to as "true" polymorphism, whereas ad-hoc polymorphism isn't.
These definitions are functional in nature, whereas the brief answer
is a more object-oriented definition.

Another definition of polymorphism is proposed by Cardelli and Wegner;
however, they tie parametric polymorphism to static typing which leads
to generics, a static implementation technique.  The original definitions
do not have any such restriction and so the author feels their definitions
are not as general as the original ones.  [Cardelli 85] does; however, give
a good discussion on object-orientation and on the separation between type
and class, as is typically found in the modern formal type systems based on
the typed lambda calculus notation.

Inclusion polymorphism can refer to subtyping, or having at least as much
or more than is required.  Since derived classes inherit structure and
behavior from base classes, such inheritance is an example of inclusion
polymorphism with respect to representation.  An example of inclusion
polymorphism with respect to assignment (and initialization) occurs when 
object types may be specified statically and assignment is based on actual
object membership in that type (often of the CLOS is-a-member-of form in OO).
Emerald is an example of an object-oriented language that uses inclusion
polymorphism to cover the general parametrically polymorphic case, since
Emerald has a separation between type and class.  They refer to this as
"best-fitting" types.


What Does Polymorphism Boil Down to in Object-Oriented Programming Languages?

In C++, virtual functions provide polymorphism.  This is because a formal
object (pointer or reference (or such parameter)) is polymorphically assignment
compatible with any derived class.  Is this polymorphism in itself?  Objects
can take on objects of different forms (the derived classes), but of what use
is it?  To make any difference, the differing forms must have some effect.  In
dynamically typed languages, actual objects are passed messages and will
respond in whatever way the actual object has defined (usually starting
from its most derived class and working its way up).  But for static objects,
a virtual function is invoked.  This is the stored method from the derived
class that overrode the virtual method from its base class, providing
specialized behavior for the formal object; and hence, polymorphism.


What Is Dynamic Binding?

Dynamic binding has two forms, static and dynamic.  Static dynamic binding
is found in statically-typed languages such as C++, in virtual functions.
When a class with virtual functions is used, it is not known which
function will be called at run-time since a derived class may override
the function, in which case the overriding function must be called.
Statically determining all possibilities of usage is undecidable.  When
the complete program is compiled, all such functions are resolved (statically)
for actual objects. Formal object usage must have a consistent way of accessing
these functions, as achieved thru vtables of function pointers in the actual
objects (C++) or equivalent, providing statically-typed dynamic binding.

The run-time selection of messages is another case of dynamic binding, meaning
lookup is performed (bound) at run-time (dynamically).  Various optimizations
exist for dynamic lookup to increase efficiency.


Is There a Difference Between Being a Member or Instance of a Class?

Yes (but be careful of context).  To use C++ terminology, an actual object
is defined to be an instance of exactly one class (in classical OO), called
its most derived class.  That actual object is called the complete object.
An actual object is a member of (CLOS terminology) several classes, including
all of the classes its declared (or most derived) class inherits from.  With
static typing, if a formal object is made to refer to an actual object, that
actual object must be a member of the formal object's class.

This provides a good example of differing definitions among object-oriented
languages, since a member is defined as above in CLOS, but a member of a class
is one of its instance variables in C++.


What Is the Difference Between Static and Dynamic Typing?

Static typing means that there is type information used at compile-time.
It is also often used to refer to languages that are strongly typed, that
is no type information is needed at run-time.  Static typing is therefore
more efficient and reliable, but loses power.  Typical restrictions include
only allowing a common set of base class functions (or any common functions
for the more general parametric polymorphic case) to be available on formal
objects and a lack of multi-methods; both of which are overcome with dynamic
typing.

Many languages provide dynamic typing: Smalltalk, Self, Objective-C, and etc.
A limited dynamic typing scheme, called RTTI (Run Time Type Identification),
is even being considered for the C++ standard.


What Is This I Hear About ML and Functional Programming Languages?

ML, Milner's Language, is a functional programming language with a statically
typed polymorphic type system.  We've already discussed why static typing is
weaker than dynamic typing and the same applies to ML.  ML doesn't use
inheritance for polymorphism; unlike OO languages, but provides a kind
of inclusion polymorphism by allowing assignment compatibility for any object
that can *at least* satisfy the required type constraints of a formal object,
so no inheritance is required.  This is "true" or "pure" statically (or
strongly) *checked* parametric polymorphism, by Strachey's definitions.

Smalltalk is an example of a dynamically-typed symbolic language which does
not check types during assignment (and hence for parameters) and therefore
provides parametric polymorphism without static constraints.


What Is the Separation Between Type and Class?

In many OO languages, classes are used for assignment compatibility.  This
forces all matching objects to inherit (transitively) from any formal object's
class.  This insures that all operations to be performed on any formal object
are satisfied by any matching object (and ultimately by any actual object).

By separating type and class (just one way of putting it), any matching object
must satisfy the operations or type constraints of a formal object, but do not
have to do so by an inheritance relation.  There are several ways of
implementing inheritance on the "typing" side, one is to simply allow reuse of
parent types and require all operations in the formal type graph to be present
in any actual object.  Inheritance on the representation side is what most
object-oriented programmers think of, because representation classes usually
double for parametric-style typing.

Formal type systems (such as found in ML), Emerald/Jade and trellis/Owl all
possess a separation between type and class.


What are Generics and Templates?

Generics (or Templates in C++) refer to the ability to parameterize types
and functions with types.  This is useful for parameterized classes and
polymorphic functions in statically typed languages such as Ada, C++, Eiffel,
and etc.  Generics are orthogonal to inheritance, since types (and classes)
may be generically parameterized.  Generics provide for reusability in
programming languages.  An example is a Stack with a generically
parameterized base type.  This allows a single Stack class to provide
many strongly checked instantiations such as a Stack of ints, a Stack
of any fundamental or user defined type, or even a Stack of Stacks of ....

While generics have many advantages, limitations include its static nature
(which is an advantage for strong typechecking but a disadvantage for run-time
flexibility which either isn't present or potentially causes dynamic
compilation (leading to a time/space/static efficiency tradeoff)), and sources
are like inlines and create source code dependencies and usually expand code
size (unlike a single-body parametrically polymorphic implementation found in
dynamically-typed languages).  Generics are also a special static case of 
type variables.

All functions are generic in statically-typed parametrically-polymorphic
languages.  One such popular language is ML, in which all functions are
implicitly generically instantiated.


KINDS OF OO:
============

  References
    [Coplien 92]    Covers C++, symbolic, exemplar (single-hierarchy), etc.
    [Kim 89]	    Covers many OO systems.


What Is the "Classical" Object-Oriented Paradigm?

This refers to the usual class and object model.  Its any 2+ level system
as described above under Meta-Classes [Coplien 92].


What Is the "Delegation/Prototyping" Object-Oriented Paradigm?

This is the 1 Level System as Described under Meta-Classes.  Delegation
refers to the delegating of responsibility and can be applied to
inheritance.  When a derived class does not have a desired attribute,
it "delegates" responsibility to one of its base classes.  In delegation
systems, each object has a delegate list instead of a parent list. Thus,
delegation's original intention was not for inheritance but was for
message passing systems where an object could delegate responsibility of
a message it couldn't handle to objects who potentially could (its delegates).
Any object can be added to the delegate list, giving dynamic inheritance (of
a sort).  Typically, delegation and prototyping languages also have "part
inheritance" in which fields and methods can be added and deleted from
objects.  This makes for easy "prototyping", which allows for objects to be
constructed piece by piece at run-time.


Are There any Others Paradigms?

There are many alternatives in OO.  Emerald/Jade provides one, where
inheritance is replaced with a roughly equivalent form where reuse occurs at a
finer degree of granularity, the method and instance variables.

CLOS has a looser coupling of methods to classes and doesn't distinguish a
receiver, but modules can help make up the difference.


GENERAL
=======

References to be added..

What Are the Major Languages in Object-Oriented Programming Today?

Statically-Typed:
  C++
  Eiffel

Dynamically-Typed:
  Smalltalk
  Self
  Objective-C

Both:
  CLOS


What Are Object-Oriented Databases?

Object-Oriented Databases are databases that support objects and classes.
They are different from the more traditional relational databases because
they allow structured subobjects, each object has its own identity, or
object-id (as opposed to a purely value-oriented approach) and because of
support for methods and inheritance.  It is also possible to provide
relational operations on an object-oriented database.  These databases allow
all the benefits of object-orientation, as well as the ability to have a
strong equivalence with object-oriented programs, an equivalence that would be
lost if an alternative were chosen, such as a relational database.

Another way of looking at Object-Oriented Databases is as a persistent object
store with a DBMS.


What Are Object-Oriented Operating Systems?

Object-Oriented Operating Systems support objects all the way down to
to the machine.  They are almost always distributed systems, allowing
objects to be passed freely between machines.  They are capability-based
since objects, and hence system resources, can only be accessed if a
capability to them is available to programs.


What Are the Current Object-Oriented Methodologies?

An excellent review of available Methodologies recently appeared in CACM/
September 1992/Vol.35, No.9, pp35, "A Research Typology for Object-Oriented
Analysis and Design".  The Process and Representation Methodologies/Notations
surveyed are:
  Alabiso
  Bailin
  Booch
  Coad/Yourdon
  Gorman and Choobineh
  Iivari
  Kappel
  Lieberherr et al.
  Meyer
  Rumbaugh et al.
  Shlaer and Mellor
  Wirfs-Brock et al.


What Is the OMG/ORA/...?

Contact Person: To be added
FTP Site:	To be added

The Object Management Group (OMG) is an international software industry
consortium with two primary aims:

(*) promotion of the object-oriented approach to software engineering
    in general, and

(*) development of command models and a common interface for the development
    and use of large-scale distributed applications (open distributed
    processing) using object-oriented methodology.

In late 1990 the OMG published its Object Management Architecture
(OMA) Guide document. This document outlines a single terminology for
object-oriented languages, systems, databases and application
frameworks; an abstract framework for object-oriented systems; a set
of both technical and architectural goals; and an architecture
(reference model) for distributed applications using object-oriented
techniques.  To fill out this reference model, four areas of
standardization have been identified:

1) the Object Request Broker, or key communications element, for
   handling distribution of messages between application objects in
   a highly interoperable manner;

2) the Object Model, or single design-portability abstract model for
   communicating with OMG-conforming object-oriented systems;

3) the Object Services, which will provide the main functions for
   realising basic object functionality using the Object Request Broker -
   the logical modeling and physical storage of objects; and

4) the Common Facilities will comprise facilities which are useful in
many application domains and which will be made available through OMA
compliant class interfaces.


Why Is Garbage Collection a Good Thing?

  From: Paul Johnson (paj@gec-mrc.co.uk)

Garbage collection (GC) is a facility in the run-time system
associated with a language which will automatically reclaim objects
which are no longer used.  OO Languages which require garbage
collection include Eiffel, Smalltalk and CLOS.  C and C++ can have
garbage collection retrofitted (see [3] below).  [Ada has switchable GC,
too -bob]

Without GC programmers must explicitly deallocate dynamic storage when
it is no longer needed (in C this is done by a call to free(3)).
There are a number of problems with this:

1: Bugs due to errors in storage deallocation are very hard to find,
   although products are available which can help.

2: In some circumstances the decision about whether to deallocate
   storage cannot be made by the programmer.  Drawing editors and
   interpreters often suffer from this.  The usual result is that the
   programmer has to write an application-specific garbage collector.

3: An object which is responsible for deallocating storage must be
   certain that no other object still needs that storage.  Thus many
   modules must co-operate closely.  This leads to a tight binding
   between supposedly independent modules.

4: Libraries with different deallocation strategies are often
   incompatible, hindering reuse.

5: In order to avoid problems 3 and 4, programmers may end up copying
   and comparing whole objects rather than just references.  This is a
   particular problem with temporary values produced by C++ overloaded
   operators.

6: Because keeping track of storage is extra work, programmers often
   resort to statically allocated arrays.  This in turn leads to
   arbitrary restrictions on input data which can cause failure when
   the assumptions behind the chosen limits no longer apply.  For
   instance many C compilers limit expression nesting, identifier
   length, include file nesting and macro stack depth.  This causes
   problems for programs that generate C.

One partial solution to a lack of GC is reference counting.  In this
scheme each object keeps a count of references to it.  When this count
drops to zero the object is automatically deallocated.  However this
is inefficient (swapping two references will result in three
decrements, three increments and six comparisons) and cannot reclaim
circular data structures.  Two systems that use a reference count GC
are the Interviews C++ graphics library and the Unix file system (the
link count).

Opponents of GC reply that it introduces an overhead which is
unacceptable in some applications.  However the overhead of manual
storage deallocation is probably as high as GC.  GC algorithms are
also available with good real-time behaviour.

Further Reading:

[1] "Object-Oriented Software Construction" by Meyer puts the argument
for GC.

[2] "Uniprocessor Garbage Collection Techniques" in the proceedings of
the "1992 International Workshop on Memory Management" in the
Springer-Verlag Lecture Notes in Computer Science series.  This is an
excellent summary of the state of the art in GC algorithms.

[3] "Garbage Collection in an Uncooperative Environment" by Boehm and
Weiser.  Software --- Practise and Experience vol 18(9), pp 807-820.
Sept 1988.  This describes GC in C and C++.



COMMONLY ASKED LANGUAGE SPECIFIC QUESTIONS
==========================================

What is Downcasting?

Downcasting the term used in C++ for casting a pointer or reference to a
base class to a derived class.  This should usually be checked with an
embedded dynamic typing scheme if such a scheme is not present in the
language, such as with a typecase (Modula-3) or inspect (Simula) construct.
In C++, it is even possible to use conversion functions to perform some
checks.


What are Virtual Functions?

Look under "Dynamic Binding" and "Polymorphism".


ANNOTATED BIBLIOGRAPHY

[Booch 87] Grady Booch.  Software Engineering with Ada.  2nd Ed.  Benjamin
 Cummings.
[Booch 87] Grady Booch.  Software Componenets With Ada, Structures, Tools,
 and Subsystems.  Benjamin Cummings.

  Booch in his early years.  Mostly object-based programming with Ada.

[Booch 91] Booch, Grady. Object-Oriented Design With Applications.

  The often referred to book on OOD.  Offers design notation and methodology.
  Brief coverage of OOA and elaborate OOD/P coverage in the applications.
  Good on basic principles and has case studies in Smalltalk, Object Pascal, 
  C++, CLOS and Ada.

  Also contains an *elaborate* classified bibliography on many areas of OO.

[Cardelli 85]  L. Cardelli and P. Wegner.  On Understanding Types, Data
 Abstraction, and Polymorphism.  ACM Computing Surveys vol. 17 (4).

 Long article on Object-Oriented Types, Data Abstraction and Polymorphism.
 Formal coverage with a type system analysis model as well.

[Coplien 92] James O. Coplien.  Advanced C++ Programming Styles and Idioms.
  Addison Wesley.

  Covers advanced C++ programming.

[Cox 87] Cox, Brad J.  Object-Oriented Programming, An Evolutionary Approach.
 Addison Wesley.

  The original book on Objective-C.  Coverage on object-oriented design and
  programming.  Also covers Objective-C implementation, even into object code.

Emerald/Jade	[Entry To Be Completed]

  The original articles on Emerald and Jade.  OO languages without
  inheritance but with abstract types and static polymorphism.  Also
  designed for distributed programming and reuse. 

[Goldberg 83], Adele Goldger and David Robson. Smalltalk-80 The Language and
 Its Implementation.  Addison Wesley.

  The original book on Smalltalk.  Covers implementation.

[Kim 89]  Won Kim and Frederick Lochovsky Editors.  Object-Oriented Concepts,
 Applications, and Databases.

  Collection of articles on advanced OO and research systems.

[Meyer 88] Meyer, Bertrand. Object-Oriented Software Construction.  Prentice
 Hall.  [Is there a new edition out?]

  The original book on Eiffel.  Coverage on object-oriented design and
  programming.


[Rumbaugh 91] Rumbaugh James, et al.  Object-Oriented Modeling and Design.
Prentice Hall.

  The often referred to book on OOA/OOD.  Introduces the "Object Modeling
  Technique (OMT) OOA/D notation and methodology.  Has case studies.

[Stroustrup 91] Ellis, M.A., Stroustrup. The Annotated C++ Reference Manual.
 Addison Wesley.

  The ARM; the original and definitive book on C++.  Serves as the ANSI
  base document for C++.  Also covers C++ implementation.

[Ungar 87] D. Ungar and R.B. Smith.  The Self Papers. [Entry To Be Completed]

  The documents on Self; a delegation/prototyping language.  Also covers
  Self implementation and optimization.




Newsgroups: comp.object