NetNews Usenet Archive 1992 #31/NN_1992_31.iso/spool/comp/object/4670

Text File | 1992-12-29 | 33.7 KB | 810 lines

Newsgroups: comp.object
Path: sparky!uunet!wupost!csus.edu!netcom.com!objsys
From: Bob Hathaway <[e-mail]>
Subject: A Pre-Release FAQ
Message-ID: <[e-mail]>
Keywords: FAQ
Sender: [e-mail] (Object Systems)
Organization: Object Systems
Date: Tue, 29 Dec 1992 04:23:55 GMT
Lines: 798

Hello All,

This is 4 hours worth of FAQ.  I expect for it to double to triple in
size and scope before a true release is out.  Any comments and/or suggestions
are most welcome; after all, this should be everyone's FAQ soon.

Again, this is a pre-release draft FAQ and is not quite ready for
distribution.  It is targeted to newcomers to comp.object; I plan to add
some more sophisticated stuff later.

E-mail is preferred unless there is something which should be reconciled
publicly.

I think my opinions are appropriate, if you don't, send e-mail as to why.
There is much to be elaborated on, especially on available systems:
CASE, OODBMS, Languages, VIPs, and etc. (even OOOS).  Appendices are even
possible if there are enough replies/systems to fill them.

The GENERAL and COMMONLY ASKED LANGUAGE SPECIFIC QUESTIONS sections should
grow many times over as well.  Suggestions?

I plan to add a section on OO methodologies, but am not sure how much detail
should be present.

Also, are there any other relevant FAQ's out there that should be referenced?
I have only two: comp.lang.c++ and comp.lang.eiffel.

bob
[e-mail]

P.S.  Its a start!




COMP.OBJECT FAQ
Version -1.0.0 (PRE-DRAFT RELEASE - REQUEST FOR COMMENTS)

Bob Hathaway
Object Systems
12/28/1992
Anonymous FTP Site: YTBA

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?
  What Is Inheritance?
  What Is Multiple Inheritance?
  Does Multiple Inheritance Pose any Additional Difficulties?
  What Is Dynamic Inheritance?
  What Is Shared Inheritance?
  Why use Inheritance?
  Why Don't Some People Like Inheritance?
  What Is Specialization/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?
  Where Did Object-Orientation Come From?
  What Are the Benefits of Object-Orientation?
  What other FAQs are available?

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

KINDS OF OO:
  What Is the "Classical" Object-Oriented Paradigm?
  What Is the "Delegation/Prototyping" Object-Oriented Paradigm?

VIPS:
  Who/What Is Booch?
  Who/What Is Rumbaugh et al?
  Who/What Is Bjarne Stroustrup?
  Who/What Is Adele Goldberg?

GENERAL:
  What are the Major Languages in Object-Oriented Programming Today?
  What are Object-Oriented Databases?
  What are Object-Oriented Operating Systems?
  What Object-Oriented CASE Tools are available?
  What Are the Current Object-Oriented Methodologies?
  What Is the OMG/ORA/...?

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

Annotated Bibliography


BASICS
======

What Is an Object?

Simply put, an object is a variable.  In classical object-oriented programming,
this variable has a type (called a class) defining its structure and
operations (called methods) which may be performed on the object.  Classes
also define inheritance for objects.

For a rough equaivalence to conventional programming:
Objects are roughly equivalent to a variable with a record type, with the
fields of the record 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 a variable 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.

The terms method/member function, instance variable/member data, subclass/
derived class, parent class/base class, and etc. will be used interchangeably.

As in conventional programming, variables (henceforth referred to as objects)
may store values and are said to have state.  This is in opposition to
single-assignment programming, where they do not.

Delegation/prototyping languages have a more flexible kind of object which
plays the role of both objects and classes (a 1 Level System).  Here,
objects are classes and classes are objects.  Objects contain fields,
methods and parents, whereas classical object-oriented languages associate
method, field and parent definitions with classes (and only associate
state, inherited state, and class with objects).  1 Level objects can
contain any number of fields, methods and parents and any object can be used
as a class.  In Self, a parent can be distinguished from an instance variable
by only a star, in which case default method and instance selection occurs for
that member.  Such parent members can also be added dynamically, providing
dynamic inheritance.


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 class
protection.  This could also be called class encapsulation since object
encapsulation is defined within the class.  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.


What Is a Class?

A Class is a specification of structure (instance variables), behavior
(methods), and inheritance (parents).  Its like a record or struct type
declaration.  As pointed out above, it can also include access permissions
(specifiers).


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; 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 are classes and all classes are objects (as in Self).
  There is no need for Meta-Classes because objects describe themselves.
2 Level System
  All Objects have a Class, but these are not accessible (no Meta-Class
  except for in the compiler and perhaps for type-safe linkage, as in C++).
3 Level System
  All objects have 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 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 have a Meta-Meta-Class, which must 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?

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).  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.


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" 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 et al.) 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 is 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.  CLOS and Self choose
the leftmost parent member to match first.  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 or delete parents from
objects (or classes) at run-time.  1 Level Systems provide dynamic
inheritance because they satisfy the above.  In the author's opinion; however,
this is in an unstructured form because such systems allow any object (even
globals) to become a parent even if shared across unrelated class graphs.
Inheritance can simply refer to the usual parent/subclass relationship.
Object cloning is a more reliable form of simple inheritance in such
systems.


What Is Shared Inheritance?

Multiple Inheritance brings up the possibility for a class to appear as a
parent more than once in a class graph, 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.  Parent duplicates are discarded only for CLOS's precedence list).
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.


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 compliants 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 conflict resolution.  The author's opinion
is in accord with most modern systems, which support Multiple Inheritance,
that these issues are not difficulties but simply constructs to be supported.
There are clearly no ambiguities, just resolution strategies.


What is Specialization/Overriding?

To create a subclass is specialization, to factor out common parts of
derived classes into a common base (or parent) is generalization.  Overriding
is the term used in C++ for redefining a (virtual) method in a derived class,
thus providing specialized behavior.  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.


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

Object-Based programming usually refers to abstract data types, which are
objects without inheritance (and hence without polymorphism).  Object-Oriented
is therefore: Object-Based + Inheritance + Polymorphism.


Is a Class an Object?

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


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 1 Level Systems, since any object
may become a class.  If done directly, this object may be shared among many
class graphs.  To get the effect of a real parent, the object is usually
cloned and then made a parent so a fresh non-shared copy is available.


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 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.method(a1, a2, a3)   and   receiver method a1 parm1: a2 parm3: a3


What are multi-methods?

Multi-Methods simply mean that all parameters are used in the selection
of a method.  The name comes from CLOS, a language with both static and
dynamic typing.  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, you have
a Multi-Method capability (also referred to as multiple-polymorphism).  With
Multi-Methods, a single virtual function declared in a base class may have
several functions overriding it in a derived class differentiated only by
their formal argument types.  Multi-Methods therefore require dynamic typing.


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 explicitly switch to the
desired method.  See Coplien for details.


What is OOP?

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


What is OOA/OOD?

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.  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.  OOA and OOD also 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.


Where did Object-Orientation Come From?

Simula was the first object-oriented language because it provided classes
back in the late 1960's.  It was originally used as a simulation language,
with inheritance being used to model the world.  Smalltalk was the next major
contributor with inheritance, a nice environment and a powerful dynamic
typing mechanism.


What are the Benefits of Object-Orientation?

Reuse, an emphasis on modeling the real world, a consistent and seamless
OOA/OOD/OOP package, naturalness (we form an "object concept" at an early
age and therefore work with and understand objects quite well), etc.


What other FAQs are available?

There are FAQ's for comp.lang.c++ and comp.lang.eiffel (that the author is
aware of).


TYPING
======

Is there a difference between being a member or instance of a class?

Yes.  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 object is called the complete object.  An object is a member
of (CLOS terminology) several classes, including all of the classes its
declared (or most derived) class inherits from.  If a formal object is
made to refer to an actual object, the actual object must be a member of
the formal object's class.


Whats 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, but loses power.  Typical restrictions include only allowing
a common set of base class functions to be available on formal objects
and from within base classes, and a lack of multi-methods; both of which are
overcome with dynamic typing.

Many languages provide dynamic typing: Smalltalk, Self, Objective-C.
A limited dynamic typing scheme, called RTTI, 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 language which does not check
types and 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 is Polymorphism?

In a nutshell, polymorphism is the ability for an object to be a placeholder
(or formal object) for many different objects, and for that formal object to
behave differently based on the actual object present.  Derived classes
specialize base classes with slightly different behavior, and this specialized
behavior of derived classes characterizes object-oriented polymorphism.
This is a special case of parametric polymorphism, which allows any object
(possibly satisfying type constraints, or a common structure) to be substituted
for formal objects, and not just derived classes.

For a more detailed answer:
This is the age old question.  Poly means many and morph means shape.  The
homograph polymorphism has many uses in the sciences, all referring to objects
that can take on 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."

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 authors feel their definitions
are not as general as the original ones.  C+W do; however, give a good
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 inclusive
polymorphism with respect to representation.

"Bounded" is perhaps a good term for requiring class membership for assignment
compatibility, but in the author's opinion these terms should be defined when
their meaning is not obvious, at least for the present.


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 in its class).
But for static objects, a virtual function is invoked.  This is the stored
method from the derived class that overrode the virtual method, 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.  Trying
to statically determine 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 dynamically-bound
polymorphism.

Messages can also be dynamically bound, meaning lookup is performed (bound)
at run-time (dynamically).  Various optimizations exist for dynamic lookup to
increase efficiency.


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 C++.  But this
facility only provides limited (or static) polymorphism, since only static
language facilities are still available to the instantiated generic.  Another
limitation is that generic sources (or at least intermediate forms) must be
available and subsequently compiled, precluding separate compilation (and thus
creating source code dependencies) and potentially causing the high overhead
of avoidable compilation at run-time (dynamic compilation).  Tradeoffs are
therefore involved.

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


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

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.


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 the term 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.  Any
object can be added to the delegate list, giving dynamic inheritance (but
in the author's opinion, in an "unstructured" form).  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.


VIPS
====

Who is Booch?

Grady Booch has been an object-oriented Ada advocate for some time.  He's
written books such as Software Engineering with Ada, Software Components
with Ada, and OOD with Applications.  The first two are what he calls
Object-Based and the second is primarily Object-Oriented and all use
OB and OO notations and methodologies.  His last notations are often
referred to as simply the "Booch" method or notation and his company,
Rational, provides automated support with a tool named "Rose".

Who is Rumbaugh et al?

Runbaugh et al is Rumbaugh, Blaha, Premerlani, Eddy and Lorenson.  They are
from GE's R&D Center and Have an OOA/OOD notation/Methodology called the
"Object Modeling Technique".  It is a rather formal and complete method
which is often discussed and referred to.


Who is Bjarne Stroustrup?

Bjarne invented C++, a C++ superset, which has probably gained the most
widespread use of any object-oriented language.


Who is Adele Goldberg?

Adele is one of the founders of Smalltalk.  David Robson is another.  They
are most well know because of their text, "Smalltalk-80 The Language and
its Implementation".  Smalltalk was invented by a group at Xerox PARC.


GENERAL
=======
What are the Major Languages in Object-Oriented Programming Today?
  C++
  CLOS
  Eiffel
  Smalltalk
  Self
  Objective-C


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, they are simply more
complex.  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 accesses if a
capability is accessible to programs.


What Object-Oriented CASE Tools are available?

Many Object-Oriented Case Systems have recently appeared.
  List

What are the Current Object-Oriented Methodologies?

An excellent review of the Methodologies employed 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
  Livari
  Kappel
  Lieberherr et al.
  Meyer
  Rumbaugh et al.
  Shlaer and Mellor
  Wirfs-Brock et al.


What Is the OMG/ORA/...?

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.



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.  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

Emerald/Jade
C++ ARM
OOSC (Meyer-Eiffel)
OOP (Cox)
Self Papers
Booch (SEWA, SCWA, OODWA)
Rumbaugh et al. (OOM&D)
CLOS paper
Goldberg, Robson "Smalltalk-80 TLAII"
Coplien, Advanced C++
Cardelli & Wegner
Strachey