Comp.Object FAQ Version 1.0.9 (04-02) Announcement

2 views
Skip to first unread message

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/announce
Last-Modified: 04/02/95
Version: 1.0.9

This announces the April version 1.0.9 of the Comp.Object FAQ! It has many
new questions, entries, and updates and has several very up-to-date appendices
on object-oriented methodologies and systems, with a new Appendix on commercial
Object-Oriented Libraries and Systems. This document may very well comprise
the latest and most up-to-date collection of object-oriented systems and terms
in the world today!

I'd also like to pay attention to a related new free hypertext journal on
Object Technology called Object Currents. There are many references to the
comp.object FAQ and it provides a great opportunity to keep up with Object
Technology and contribute as authors! There are many world-class columnists
and authors with unique contributions *as well as* many of the best articles
from the very best of the OO Journals placed on the Web. So please take a look
at:
http://www.sigs.com/objectcurrents

The first three interviews are with Grady Booch, James Rumbaugh, and Ivar
Jacobson and a Steve Mellor interview is in the works. Robert Martin has been
providing a Newsgroup Dialog and columnists include Watts Humphrey, Bertrand
Meyer, Michael Chonoles, Francois Bancilhon, David Shang, and Michael Spertus
along with an editorial by yours truly. This last month's Editor's Corner is
on Metasystems and Reflection, so check it out! The April Issue went up
on 4/1.

>I will try to update the FAQ monthly with system entries and information from
>the net. I have a new TQM system in place which should proceed from the
>old Level 1 to Level 5 in no time - not hard for a one man job. *Many*
>thanks to the patience of those sending system updates and corrections,
>my new system should provide fast acknowledgement, inclusion (within a few
>weeks) and tracking, and 6 sigma quality should provide essentially defect
>free performance for the FAQ. Perhaps I'll even go for ISO 9000 certification!

Well, now that that system has been shelved for 1 year its about time to
update it! A great example of a good OOA/D system with no time for
implementation. But that should change very soon! It's the volunteer
efforts that suffer the most when in a (prolonged) time crunch, but with
a new book coming out that should change. And with a new 4GL hypertext
system in place it will be ***much*** easier.

Sending comments, suggestions, additions, updates, corrections, and new
systems and site entries is strongly encouraged and should be directed to
the author at r...@geodesic.com.

The FAQ is posted to the comp.object, comp.answers and news.answers newsgroups
and is available via anonymous ftp from zaphod.uchicago.edu and rtfm.mit.edu,
although new versions may take a short period of time to be installed.

Anonymous FTP Sites and Hypertext Server:
anon...@zaphod.uchicago.edu:/pub/CompObj8.faq(.Z) (128.135.72.61)
anon...@rtfm.mit.edu:/pub/usenet/comp.object/*_Part_* (18.181.0.24 Tmp)
http://iamwww.unibe.ch/~scg/OOinfo/FAQ/index.html (new IAM location)

Mail Server: (See also section 1.24)
mail mail-...@rtfm.mit.edu
Subject:
send usenet/comp.object/*

Zaphod is preferred over rtfm for anonymous ftp retrieval, as it provides a
single file. Rtfm contains the FAQ as posted.

To use the hypertext system, see APPENDIX E, entries 27.

Comp.Object Archive:
A workable comp.object archive is now available on the www, with much thanks
to Markus A. Beckmann, beck...@informatik.mathematik.uni-mainz.de.
http://aaimzb.mathematik.uni-mainz.de/Personal/Mitarbeiter/comp.object.idx.html

Again, a short period of time may be required to retrieve the latest version
from anonymous ftp, allowing the posted version to propagate and get out as
quickly as possible.

Thank you to the many people who have contributed their time and effort to
help this document spread the word about object-oriented technology and
available systems! It is hoped it will be most useful in that endeavor.

Best Regards!
Bob

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part2
Last-Modified: 04/02/96
Version: 1.0.9

OOA and OOD stand for Object-Oriented Analysis and Object-Oriented Design,
respectively. OOA strives to understand and model, in terms of object-oriented
concepts (objects and classes), a particular problem within a problem domain
(from its requirements, domain and environment) from a user-oriented or domain
expert's perspective and with an emphasis on modeling the real-world (the
system and its context/(user-)environment). The product, or resultant model,
of OOA specifies a complete system and a complete set of requirements and
external interface of the system to be built, often obtained from a domain
model (e.g. FUSION, Jacobson), scenarios (Rumbaugh), or use-cases (Jacobson).

[Shlaer 88] is often credited as the first book on OOA, although their method
adds OO techniques to the traditional structured analysis principles of Yourdon
and Constantine. Their complete approach ([Shlaer 88, 92]) consists of
information modeling and recursive design, or OOA/RD and represents a recent
addition to the structured analysis family (as does Martin and Odell).
[Yourdon 92] provides a critique, although may only refer to their earlier
work. Many other methodologies including Rumbaugh's OMT, Martin and Odell's
OOA/D, and many others, also share common ground with SA and other existing
analysis methodologies with such constructs as associations (E-R), functional
models, and even DFD's. Booch, Jacobson, and Wirfs-Brock are examples of OO
methodologies representing a greater departure from the conventional
"structured" techniques, with greater emphasis on objects. OOram [Reenskaug
91] provides support and emphasis on types and roles as guiding principles,
which is quite powerful. [Booch 94] presents a methodology which is an
evolutionary step beyond the first edition by incorporating a collection of the
best features from several of the major OO methodologies, as does HP's new
FUSION methodology.

A new Unified Modeling Language (previously Unified Method) is now being worked
on by Grady Booch, James Rumbaugh, and Ivar Jacobson at Rational Software which
should be made into a public standard, perhaps to be adopted by the OMG. The
.8 docs can be found online from the Rational home page, http:/www.rational.com.

The usual progression is from OOA to OOD to OOP (implementation) and this
Universal Process Model roughly corresponds to the Waterfall Model [Royce 70].
See [Humphrey 89] and [Yourdon 92] for a few of many discussions on software
life-cycle models and their use. Humphrey also details Worldy and Atomic
Process Models for finer grained analysis and design in the Defined Process
(see below) and discusses other alternatives to the task oriented models. He
also provides the following critisisms on the Waterfall Model which had led to
Boehm's seminal work on the Spiral Model:

* It does not adequately address changes
* It assumes a relatively uniform and orderly sequence of development steps
* It does not provide for such methods as rapid prototyping or advanced
languages

Modern OO methodologies directly address these points and emphasize the
incremental, iterative, evolutionary, concurrent and situational nature of
software development. [Boehm 86] presents a seminal spiral life-cycle model
with a risk-driven incremental prototyping approach. [Booch 91, 6.1]
proposes a "round-trip gestalt" design with analyze-design iterations and
an overall system perspective and [Berard 93] proposes an (incremental)
"parallel-recursive design" with analyze-design-implement-test iterations.
[Coad 91b] presents the following development cycle breakdown:

Waterfall-
Analysis
Design
Programming

Spiral-
Analysis, prototyping, risk management
Design, prototyping, risk management
Programming, prototyping, risk management
[Boehm, 1988]

Incremental-
A little analysis
A little design
A little programming
Repeat
[Gilb, 1988]

[Author's note: The spiral model is often incremental and may waterfall if
called for.]

Since classes and objects are used in all phases of the OO software life-cycle,
the process is often referred to as seamless, meaning there is no conceptual
gap between the phases as is often the case in other software development
methodologies, such as the analysis (DFD's) to design (structure charts) to
programming gaps found in traditional structured analysis and design.
Seamlessness together with naturalness is a big advantage for consistency.

A 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 Stroustrup, 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. See also
[Stroustrup 91].

From a greater perspective, the SEI has developed the Capability Maturity Model
(CMM), a process-based TQM model for assessing the level of an organization's
software development and which is often required of government contractors
in the US [Humphrey 89]. The CMM also serves as a 5 level improvement process
by specifying steps for organizations to progress to the next level, ultimately
leading to statistical (process) control and sustained improvement. Watts S.
Humphrey is now working on the Personal Software Process (PSP), a scaled down
version of the CMM for individuals [Humphrey 95]. Next should follow a team-
based software process (TSP?). Other CMM's in the works at the SEI include a
personnel management CMM (PM-CMM).

Level 1: Initial: Every project is handled differently; ad hoc and chaotic.
Level 2: Repeatable: Every project is handled similarly.
Level 3: Defined: Standard processes are defined and used for all projects.
Level 4: Managed: A measurable basis for all improvements to the process.
Level 5: Optimizing: Emphasis on defect prevention and optimizing/continually
improving the process.

CMM documentation is available online from: http://ricis.cl.uh.edu/CMM and
ftp.sei.cmu.edu/pub/cmm/

See also:
Kitson, D.H. and Masters, S. "An Analysis of SEI Software Process Assessment
Results 1987-1991", CMU/SEI-92-TR-24

Humphrey, W., Snyder, T. and Willis, R. "Software Process Improvement at
Hughes Aircraft", IEEE Software, July 1991

Dion, R., "Elements of a Process Improvement Program," IEEE Software, July
1992.

"Concepts on Measuring the Benefits of Software Process Improvement,"
CMU/SEI-93-TR-9.

See also [Yourdon 92], [Wilkie 93], and [Booch 94] for discussions on this
often cited model. There is also an ISO 9000 standard [ISO] applicable to
software quality and ami working group in Europe helping to creat the ISO
SPICE [Rout 95] standard (among other work), which is similar in scope to
the CMM. To join the ami mailing list email to:
ami-r...@aut.alcatel.at
with the following message:
subscribe firstname, lastname, e-mail address.

Object-oriented analysis now includes "Enterprise Modeling" [Martin 92], also
found in [Jacobson 92], and along with recent business process "reengineering"
efforts places information systems within an organizational perspective by
modeling entire organizations or a large part of them, with the information
processing system and software products development as integrated components.
[Yourdon 92] even calls for "global modeling"!


1.22) Where Did Object-Orientation Come From?
----------------------------------------------

Simula was the first object-oriented language providing objects, classes,
inheritance, and dynamic typing in 1967 (in addition to its Algol-60 subset).
It was intended as a conveyance of object-oriented design. 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
including classes, inheritance, a high-powered graphical environment and a
powerful dynamic typing mechanism (although these existed to some extent in
Simula). Self is somewhat of a Smalltalk-based next generation language, as is
BETA a followup to Simula (by its original designers).

[Meyer 88] contains a brief summary and history of Simula and Smalltalk, among
other OO languages.


1.23) 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"), resistance to change,
encapsulation and abstraction (higher cohesion/lower coupling), and etc.

On resistance to change, system objects change infrequently while processes
and procedures (top-down) are frequently changed, providing object-oriented
systems with more resilient system organization.

[Harmon 93]:
Faster development
Increased Quality
Easier maintenance
Enhanced modifiability

[Booch 94]:
Exploit power of OOPs
Reuse of software and designs, frameworks
Systems more change resilient, evolvable
Reduced development risks for complex systems, integration spread out
Appeals to human cognition, naturalness


1.24) What Other FAQs Are Available?
-------------------------------------

FAQ's are cross-posted to news.answers and are archived on anonymous ftp from:

rtfm.mit.edu:/pub/usenet (also usenet-by-hierarchy, etc.)

rtfm archives several FAQs pertinent to OO (alternative/original sites are listed).

comp.lang.ada ajpo.sei.cmu.edu:public/comp-lang-ada/cla-faq[12]
comp.lang.beta ftp.daimi.aau.dk:pub/beta/faq/beta-language-faq.txt
comp.lang.c++ sun.soe.clarkson.edu:pub/C++/FAQ [128.153.12.3]
comp.lang.clos
comp.lang.eiffel ftp.cm.cf.ac.uk:/pub/eiffel/eiffel-faq
comp.lang.modula3
comp.lang.oberon
comp.lang.objective-c http://www.marble.com/people/dekorte/Objective-C/objc.html
comp.lang.sather ftp.ICSI.Berkeley.EDU:pub/sather [not on rtfm]
comp.lang.scheme ftp.think.com:/public/think/lisp/scheme-faq.text
comp.lang.smalltalk xcf.Berkeley.EDU:misc/smalltalk/FAQ/SmalltalkFAQ.entire
comp.object zaphod.uchicago.edu:/pub/CompObj8.faq(.Z) (also www)
comp.object.logic ftp.cs.cmu.edu:(2)prg_1.faq,prg_2.faq [128.2.206.173]
comp.software-eng

Notes:
1) xcf.Berkeley.EDU is 128.32.138.1
2) /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/prolog/
3) BETA FAQ www (most current): http://www.daimi.aau.dk/~beta/FAQ
http://www.daimi.aau.dk/~beta/info
Email: in...@mjolner.dk with body: send BETA beta-faq
4) Modula-3: ftp.vlsi.polymtl.ca:pub/m3/m3-faq.ps.
http://froh.vlsi.polymtl.ca/m3/m3-faq.html.
Archives: gatekeeper.dec.com:pub/DEC/Modula-3/comp.lang.modula3
Newsgroup relay mailing list; message to m3-re...@src.dec.com
5) comp.lang.eiffel archive: http://www.cm.cf.ac.uk/CLE/archive_index.html

See APPENDIX E:60 for a CDROM with Internet FAQs.

A new C++ libraries FAQ is posted monthly to comp.lang.c++ and should be on
rtfm soon. Contact cpp...@trmphrst.demon.co.uk. It contains anonymous ftp
sites and commercial libraries and may be merged with this FAQ eventually.

Many FAQs are also available from mail-servers, however most can be accessed by
the rtfm mail-server. Mail to mail-...@rtfm.mit.edu with help and index in
the body with no leading spaces and on separate lines for more information.

Example Unix Command (will retrieve this FAQ in about 26 pieces (and growing)):


mail mail-...@rtfm.mit.edu
Subject:
send usenet/comp.object/*

There is also a great ftp site for sci.virtual-worlds on:
stein.u.washington.edu (140.142.56.1)
- home of sci.virtual-worlds, huge faq w/ great info!
- if unable to use try ftp.u.washington.edu
/public/virtual-worlds

[While VR may not be directly related to comp.object, it is most interesting!
- The Author]


SECTION 2: TYPING
==================

There are many definitions of type (and class and related concepts). Many
authors define the terms as applied by their particular approach or language,
however we shall proceed in the face of this diversity.

References
[Blair 89] Some Typing Topics.
[Booch 91] Small Section on Typing.
[Cardelli 85] Discussion on Object-Oriented Typing.
[Gunter 94] Theoretical Aspects of Object-Oriented Programming.
[Kim 89, ch1] Discussion on Some Research Topics.


2.1) What Is Polymorphism?
---------------------------

Polymorphism is a ubiquitous concept in object-oriented programming and is
defined in many ways, so many definitions are presented from: Websters',
Author, Strachey, Cardelli and Wegner, Booch, Meyer, Stroustrup, and Rumbaugh.
Polymorphism is often considered the most powerful facility of an OOPL.

> Webster's New World Dictionary:

Polymorphism 1. State or condition of being polymorphous. 2. Cryall.
crystallization into 2 or more chemically identical but
crystallographically distinct forms. 3. Zool., Bot. existence of an
animal or plant in several forms or color varieties.

polymorphous adj. having, assuming, or passing through many or various forms,
stages, or the like. Also, polymorphic. [<Gk polymorphous multiform]


> Author's Definition:

Polymorphism is the ability of an object (or reference) to assume (be replaced
by) or become many different forms of object. 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
(or type) 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 (or reference) to assume or become any
object (possibly satisfying some implicit or explicit type constraints
(parametric type), or a common structure), with this common structure being
provided by base classes or types (subclass and subtype polymorphism,
respectively).

"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 to Strachey's original
definitions of polymorphism, as divided into two major forms, parametric and
ad-hoc. Cardelli and Wegner followup with another classification scheme,
adding inclusion polymorphism for subtyping and inheritance.


> Strachey's Original Definition [Strachey 67]:

"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 (apparent polymorphism).


> Cardelli and Wegner's Definition [Cardelli 85]:

C+W refine Strachey's definition by adding "inclusion polymorphism" to model
subtypes and subclasses (inheritance). Strachey's parametric polymorphism is
divided into parametric and inclusion polymorphism, which are closely related,
but separated to draw a clear distinction between the two forms, which are then
joined as specializations of the new "Universal" polymorphism.

|-- parametric
|-- universal --|
| |-- inclusion
polymorphism --|
| |-- overloading
|-- ad hoc --|
|-- coercion

Polymorphic Languages: some values and variables may have more than one type.

Polymorphic Functions: functions whose operands (actual parameters) can
have more than one type. [...] If we consider a generic function to be
a value, it has many functional types and is therefore polymorphic.

Polymorphic Types: types whose operations are applicable to operands of more
than one type.

Parametric Polymorphism: a polymorphic function has an implicit or explicit
type parameter which determines the type of the argument for each
application of that function.

Inclusion Polymorphism: an object can be viewed as belonging to many different
classes that need not be disjoint; that is, there may be inclusion of
classes.

The two forms of "Universal Polymorphism", parametric and inclusion are closely
related, but are distinct enough in implementation to justify separate
classifications.

Parametric polymorphism is referred to as generics. Generics can be syntactic,
where each instantiation creates a specialized version of the code allowing
fast running execution, but in a "true polymorphic system", only a single
implementation is used.

On inheritance is subtype polymorphism:
"Subtyping on record types corresponds to the concept of inheritance
(subclass) in languages, especially if records are allowed to have functional
components."

Author's Notes:
Implicit parametric polymorphism can be implemented with type inferencing
schemes [Aho 85]. ML is prototypical in providing this facility.

Inclusion polymorphism is common and is found in languages such as Simula,
Ada95, C++, CLOS, Eiffel and etc. (subclass polymorphism). Smalltalk also
uses inclusion polymorphism; its used in declaring classes, and subclass
polymorphism is used in practice but not enforced. For inheritance, inclusion
polymorphism specifies an instance of a subclass can appear wherever an
instance of a superclass is required. For subtyping (subtype polymorphism),
the same applies because all operations required by the supertype are present
in the subtype (subtype is subset of supertype). Cardelli and Wegner view
classes as sets of objects (resulting in subtype objects are a subset of
supertype objects, or an extensional view), as contrasted with a feature based
(intensional) approach (where subtypes are supersets of (contain) supertypes).
MI provides an interesting example here, as it is set intersection with an
extensional view and set union with an intensional view. Details are left as
an exercise for the reader.

Ada generics and C++ templates provide explicit syntactic generics. While
Ada may infer some actual generic parameters (operations) and C++ doesn't
require explicit instantiation of its template functions, formal generic
parameters must still be declared and many bodies are generated.

Inclusion polymorphism can refer to subtyping, or having at least as much or
more than required. Since derived classes can inherit structure and behavior
from base classes, such inheritance is an example of inclusion polymorphism
with respect to representation (subclassing). An example of inclusion
polymorphism with respect to assignment (and initialization, or replacement if
viewed in an almost symbolic way) occurs when object types may be specified and
assignment is based on actual object membership in that type (often of the CLOS
is-a-member-of form in OO). Emerald provides another example of an object-
oriented language using inclusion polymorphism with respect to replacement;
however, inclusion is with respect to subtyping only with abstract types
("bounded quantification" by C+W. C+W's parameters are subtype polymorphic
but lose the inherent type). Any object possessing all required operations is
acceptable and no inheritance relation is required (subtype polymorphism).
They refer to this as "best-fitting" types [Black 86]. The original Trellis/
Owl also had such a facility but with two separate inheritance hierarchies,
although it was abandoned in favor of a single class-based approach for
simplicity. See also section 2.7.

[As inclusion polymorphism covers both subtype and subclass polymorphism,
perhaps IP could be further divided in C+W's above classification.]


> Booch's Definition [Booch 91, p. 517]:

polymorphism A concept in type theory, according to which a name (such as a
variable declaration) may denote objects of many different classes that are
related by some common superclass; thus, any object denoted by this name is
able to respond to some common set of operations in different ways.

Booch also has several sections devoted to polymorphism.

[The author notes Booch's definition above is clearly in the context of
conventional, classical OO and subclass polymorphism.]


> Meyer's Definition [Meyer 88, sect. 10.1.5 Polymorphism]:

"Polymorphism" means the ability to take several forms. In object-oriented
programming, this refers to the ability of an entity to refer at run-time to
instances of various classes. In a typed environment such as Eiffel, this is
constrained by inheritance: ...

[The Author notes Meyer has a following section 10.1.7 on Static Type,
dynamic type, which is relevant, but claims "... there is no way the type
of an object can ever change. Only a reference can be polymorphic: ...".
Meyer is clear between the concept and the Eiffel realization in his
polymorphism definition above, but here neglects the "becomes" facility
as found in several dynamically typed OO languages such as Actors, CLOS,
Self and Smalltalk, which allows an object (and not just a reference) to
change its class.]


> Stroustrup's Definition [Stroustrup 90, p. 209]:

The use of derived classes and virtual functions is often called "object-
oriented programming". Furthermore, the ability to call a variety of
functions using exactly the same interface - as is provided by virtual
functions - is sometimes called "polymorphism".

[The Author notes this is a functional view of polymorphism (as provided in
C++). [Stroustrup 91, p. 136] has an example of polymorphism with void *'s,
but a newer template function is incomparably preferable, as implied in
[Stroustrup 90, ch 14]]


Rumbaugh's Definition [Rumbaugh 91, p. 2]:

"Polymorphism" means that the same operation may behave differently on
different classes.


2.2) What Does Polymorphism Boil Down To In OO Programming Languages?
----------------------------------------------------------------------

In C++, virtual functions provide polymorphism. This is because a polymorphic
object (pointer or reference (or such parameter)) is assignment compatible with
any object of a 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, polymorphic objects are passed messages and will
respond in whatever way the 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 polymorphic object; and hence, polymorphism. This common pure
statically typed example is, of course, an example of inclusion polymorphism,
subclass polymorphism to be more specific (see section 2.1). Pure statically
typed subtype polymorphism, as provided in Emerald, can be implemented
similarly [Black 86].


2.3) What Is Dynamic Binding?
------------------------------

Dynamic binding has two forms, static and dynamic. Statically-typed dynamic
binding is found in languages such as C++ (virtual functions) and Eiffel
(redefinition). It is not known which function will be called for a virtual
function at run-time because 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 (this is really just defining simple
function pointers with static typechecking in the base class, and filling them
in in the derived class, along with offsets to reset the receiver).

The run-time selection of methods is another case of dynamic binding, meaning
lookup is performed (bound) at run-time (dynamically). This is often desired
and even required in many applications including databases, distributed
programming and user interaction (e.g. GUIs). Examples can be found in
[Garfinkel 93, p80] and [Cox 91, pp 64-67]. To extend Garfinkels example with
multiple-polymorphism, a cut operation in an Edit submenu may pass the cut
operation (along with parameters) to any object on the desktop, each of which
handles the message in its own way (OO). If an (application) object can cut
many kinds of objects such as text and graphical objects, multiple-polymorphism
comes into play, as many overloaded cut methods, one per type of object to be
cut, are available in the receiving object, the particular method being
selected based on the actual type of object being cut (which in the GUI case is
not available until run-time).

Again, various optimizations exist for dynamic lookup to increase efficiency
(such as found in [Agrawal 91] and [Chambers 92]).

Dynamic binding allows new objects and code to be interfaced with or added to
a system without affecting existing code and eliminates switch statements.
This removes the spread of knowledge of specific classes throughout a system,
as each object knows what operation to support. It also allows a reduction in
program complexity by replacing a nested construct (switch statement) with a
simple call. It also allows small packages of behavior, improving coherence
and loose coupling. Another benefit is that code complexity increases not
linearly but exponentially with lines of code, so that packaging code into
methods reduces program complexity considerably, even further that removing
the nested switch statement! [Martin 92] covers some of these issues.


2.4) Is There A Difference Between Being A Member Or Instance Of A Class?
--------------------------------------------------------------------------

Yes (but be careful of context). To use C++ terminology, an object (not
a reference) is defined to be an instance of exactly one class (in classical
OO), called its most derived class. An object not directly contained in any
other is called the complete object [Stroustrup 90]. An object is a member
of several classes, including all of the classes its declared (or most derived)
class inherits from. With static typing and inclusion polymorphism based on
class, if a polymorphic object (or reference) is made to refer to an object,
that object must be a member of the polymorphic object's class.

This also 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++.


2.5) What Is The Difference Between Static And Dynamic Typing?
---------------------------------------------------------------

Static typing refers to types declared in a program at compile-time, so no type
information is available on objects at run-time. Dynamic typing uses the
inherent types of polymorphic objects, keeping track of the types of objects at
run-time. Statically typed dynamic binding is a compromise (usually
implemented with tables of function pointers and offsets), and is how
statically-typed OO languages provide polymorphism. Some approaches provide
both static and dynamic typing, sometimes with static typing providing type-
safe programs and dynamic typing providing multiple-polymorphism [Agrawal 91]
[Mugridge 91]. See also section 2.3.

Static typing is 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 subtyping or parametric polymorphic
cases) to be available on formal objects and a lack of multiple-polymorphism
(see section 1.19), 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. A similar facility to safe
downcasting (historically known as type narrowing), the thrust of RTTI, can
also be found in recent versions of Eiffel.

See section 3.4 for a categorization of common OO languages by type system.


2.6) What Is This I Hear About ML And Functional Programming Languages?
------------------------------------------------------------------------

ML, Metalanguage, is a functional programming language with a strongly typed
polymorphic type system [Wikstrom 87]. Russell (see Appendix E) is a more
recent functional language and Haskell [Hudak 92] provides a more modern and
"pure" example. Section 2.5 discusses why static typing has less power/
flexibility than dynamic typing and the same applies to ML (although see the
appendixes for an experimental dynamic extension to ML, Alcool-90 and [Cardelli
85] for a proper placement of ML's type system). ML doesn't use inheritance
for polymorphism; unlike OO languages, but provides the prototypical example of
parametric polymorphism, so no inheritance is required. This is "true" or
"pure" statically (or strongly) checked parametric polymorphism, by Strachey's
(and Cardelli and Wegner's) definitions.

Smalltalk is an example of a dynamically-typed language which does not check
types during assignment (and hence for parameters) and therefore provides
parametric polymorphism without static constraints (by Strachey's definition).
However, Smalltalk's style uses inclusion polymorphism in practise and
inheritance for subclassing (representation).


2.7) What Is A Separation Between Type And Class (Representation)?
-------------------------------------------------------------------

For a short answer:
Subtype Polymorphism, as opposed to Subclass Polymorphism, is the best answer
in OO. Parametric polymorphism is a related concept where this is also true,
but is of a different flavor (and usually requires object attributes by use.
See also section 2.1).

A type can be considered a set of values and a set of operations on those
values. This can insure type-safe programming. However, the representation of
types (classes in OO) can be separated from the notion of type allowing many
representations per type while still maintaining reasonable type-safety.

In many languages, a type has a single representation insuring all operations
performed on that type are well defined (statically bound) and providing for
efficiency by taking advantage of that representation wherever used. In many
OO languages, subclassing and dynamic binding provides for greater flexibility
by providing object specialization. However, in many OO languages classes are
used for assignment compatibility forcing an assigned object to inherit
(transitively) from any polymorphic object's class (inclusion polymorphism
based on class, or subclass polymorphism). This insures all operations to be
performed on any polymorphic object are satisfied by any replacing objects.
This also insures all types share a common representation, or at least a
common base interface specification.

By separating type from class, or representation (or perhaps separating class
from type, by the aforementioned definition of type), a replacing object must
satisfy the operations or type constraints of a polymorphic object (subtype
polymorphism) but are not required to do to do so by an inheritance relation
(subclass polymorphism), as is typical in most OOPLs. Dropping this
restriction is somewhat less type-safe, because accidental matches of method
signatures can occur, calling for greater care in use. [Black 86] discusses
this issue in Emerald. The same issue arises in parametric polymorphism
(generics/templates), as any method matching a required signature is accepted,
calling for careful matching of actual and formal generic parameters. The
difference between static and dynamic binding in OO and dynamic binding and
subtyping seems similar. A possible loss of semantic integrity/similarity is
contrasted with greater power.

It is possible to specify desired abstract properties of type specifications
with mechanisms similar to Eiffel's pre-, post-, and invariant conditions.
This helps to insure the semantic integrity of replacing objects and their
behavior. [Liskov 93] provides a recent exposition.

Abstract classes ([Stroustrup 91] and [Meyer 88]) in typing provide a facility
similar to subtype polymorphism; however, ACs require type compatible classes
to inherit from them, providing a subclass polymorphism facility, and ACs can
also specify representation. Subtyping is therefore most useful to avoid
spreading knowledge of classes throughout a system, which is a high priority
for loosely coupled modules and in distributed programming [Black 87].

The formal type system found in [Cardelli 85], Emerald/Jade [Black 86] and
[Raj 89], original trellis/Owl, an experimental C++ extension (See Appendix E,
Signatures), Sather (originally Eiffel-based), and an Eiffel superset
[Jones 92] are all examples of OO systems providing subtype polymorphism.
Functional languages such as ML, Russell, and Haskell provide a separation with
pure parametric polymorphism (as is also commonly found in OO languages in
addition to inclusion polymorphism).

See also [Cook 90], "Inheritance Is Not Subtyping", for a formal approach.


2.8) What Are Generics And Templates?
--------------------------------------

Short Answer: Parametric Polymorphism (although various implementations
provide various subsets).

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 as found in languages such as Ada, C++, Eiffel, and
etc., although these are "syntactic" or restricted forms [Cardelli 85].
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 instantiations such as a Stack of ints, a Stack of any fundamental
or user defined type, or even a Stack of Stacks of ... Another example is
a polymorphic sort function taking a base type with a comparison operator.
The function can be called with any type (containing a comparison operator).
See [Booch 87b] for several examples in Ada and [Stroustrup xx] and [Murray
93] for examples in C++.

While generics have many advantages, typical limitations include a static
nature, which is an advantage for strong typechecking but a potential
disadvantage when causing dynamic compilation (leading to a time/space
efficiency tradeoff), and sources can cause inlining and create source code
dependencies and expand code size (unlike a single-body or "true"
parametrically polymorphic implementation. Generics can also be viewed as a
special case of type variables.

Functions are typically generic in statically-typed parametrically-polymorphic
languages. One such popular functional language is ML, in which all functions
are generic. Russell and Haskel are more modern variants (references are
forthcoming, however see APPENDIX E).


SECTION 3: GENERAL
===================

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


3.1) What Is The "Classical" Object-Oriented Paradigm?
-------------------------------------------------------

This refers to the usual class and object model. Its any 2+ level system
as described in section 1.4. See also [Coplien 92].


3.2) What Is The "Delegation/Prototyping" Object-Oriented Paradigm?
--------------------------------------------------------------------

See [Kim 89, ch 1,3].

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 primary emphasis is
on message passing where an object could delegate responsibility of a message
it couldn't handle to objects that 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, although the term "prototyping" in the context of
delegation languages usually refers to objects serving as prototypes for
object instantiation, or exemplars.

Next's NextStep OS provides delegation using Objective-C, providing an example
of delegation in a class-based language [Garfinkel 93].


3.3) Are There Any Other Object-Oriented Paradigms?
----------------------------------------------------

There are many alternatives in OO. Emerald/Jade ([Black 86] and [Raj 89])
provides one, where inheritance is replaced with a roughly equivalent form
where reuse occurs at a finer degree of granularity - method and instance
variables - with subtype polymorphism making up the difference.

CLOS [Kim 89, ch 4] has a looser coupling of methods to classes and doesn't
distinguish a receiver, but packages can help make up the difference.

Object Specialization [Sciore 89] is an example of a hybrid approach between
delegation and classical systems, where parent classes have an extra level
of indirection and inheritance hierarchies are specified on a per object/class
basis.


3.4) What Are The Major Object-Oriented Programming Languages Today?
---------------------------------------------------------------------

Statically-Typed:
Add 1 To Cobol giving Cobol with Objects.
C++
Classic-Ada
Dragoon
Emerald/Jade
Java (comp.lang.java, http://java.sun.com/, Java Report & Conf:
http://www.sigs.com, See Anon FTP)
Object Pascal
Trellis/Owl

Dynamically-Typed:
Actors Languages
C+@
Flavors
Python (new WWW, see http://www.python.org/)
Self
Smalltalk

Both:
Actor
Ada95
BETA
C++ (With RTTI)
Cecil
CLOS
Eiffel
Modula-3
Objective-C (http://www.marble.com/people/dekorte/Objective-C/objc.html)
Sather


3.5) What Are Object-Oriented Databases And Persistence?
---------------------------------------------------------

See also Appendices B and E and the comp.database.object newsgroup.
Refs to be included in future FAQs.

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. OODBs 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, as
with a purely relational database.

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

Persistence is often defined as objects (and their classes in the case of
OODBs) that outlive the programs that create them. Object lifetimes can be
viewed as a hierarchy, with locals/automatics having the shortest default
lifetime and objects stored indefinitely in an OODB (which are persistent)
having the longest. Persistent object stores do not support query or
interactive user interface facilities, as found in a fully supported OODBMS.

Appendix B also contains references for object-oriented interfaces to
relational databases and see APPENDIX E, Papers, Persistent Operating Systems.

From the net:
From: dbms...@aol.com (DBMSfacts)
Subject: ODMG Gopher and Web Addresses
Date: 24 Oct 1994 13:10:02 -0400

The Object Database Management Group (ODMG) has set up Gopher and Web
Servers at the following addresses:

Gopher: gopher.odmg.org, port 2073
WWW: http://www.odmg.org:3083

These are still under construction. What you can find right now are
addresses and contact information for ODBMS vendors, ODMG membership
information, updates to Release 1.1 of The Object Database Standard:
ODMG-93 along with ODL lex and yacc files. In the future, we will be
adding more links to related sites, bibliographies, and a FAQ for ODBMSs.

If you cannot access these servers, but would like information on the
ODMG, send an email message to in...@odmg.org and you will receive an
automated reply.

Doug Barry
ODMG Executive Director


3.6) What Are Object-Oriented Operating Systems?
-------------------------------------------------

Refs to be included in future FAQs. See also Appendix E.

Object-Oriented Operating Systems provide resources through objects, sometimes
all the way down to to the machine (OO architectures are found at the bottom).
They are almost always distributed systems (DOS or DPOS), allowing objects to
be passed freely between machines. They are typically capability-based since
objects, and hence system resources, can only be accessed if a capability to
them is available to programs.

Here are some abstracts taken from several postings to the net. This list is
by no means exhaustive.

Apertos (Meta-Object-based Mikro-Kernel. See Appendix E, Papers:28)
Chorus Micro-kernel (written in C++, COOL, See Appendix E, Papers:63)
Choices (research OS, UofI, C++, supports SVR4, See Appendix E, Papers)
GEOS (GeoWorks', written in Object Assembler, OO superset of 8086)
Mach (CMU, supports BSD 4.3, really message-based)
NachOS (written in C++, OS teaching/learning OS)
Ouverture Project (ESPRIT funded OMG IDL defines inter-module interfaces)
Peace (OO family-based parallel OS, See Appendix E, General)
SOS
Spring (Sun, written in C++)
PenPoint OS (Go, written in C++)

For the Spring Papers (free), Contact:
Sun Microsystems Laboratories, Inc.
M/S 29-01
2550 Garcia Avenue
Mountain View, CA USA 94043

See also APPENDIX E, PAPERS, Persistent Operating Systems entry.

From: whi...@oberon.Meakins.McGill.CA ()

Insight ETHOS: On Object-Orientation in Operating Systems
ISBN 3 72811948 2

This thesis covers the design of an extensible object-oriented
operating systems. The language used was Oberon-2. It includes
a generalization of the Rider/Carrier principle, Object Directories
as well as basic OS issues such as memory, file, tasking management.
It covers extensible objected-oriented programming from hardware up.
It reviews other designs such as Clouds and Choices which where written
It reviews other designs such as Clouds and Choices which where written
on C++. [[ The lack of type-tests in C++ was a problem in other designs.]]
ETHOS was implemented as an operating system for the Ceres computers
at the ETH.


3.7) What Are The Current Object-Oriented Methodologies?
---------------------------------------------------------

Here is a list of OOSE Methodologies:

Berard [Berard 93]
BON [Nerson 92]
Booch [Booch 94]
Coad/Yourdon [Coad 91]
Colbert [Colbert 89]
de Champeaux [de Champeaux 93]
Embley [Embley 92]
EVB [Jurik 92]
FUSION [Coleman 94]
HOOD [HOOD 89]
IBM [IBM 90,91]
Jacobson [Jacobson 92]
Martin/Odell [Martin 92]
Reenskaug (OOram, was OORASS) [Reenskaug 91]
ROOM [Selic 94]
Rumbaugh et al. [Rumbaugh 91]
Shlaer and Mellor [Shlaer 88 and 92]
Wasserman [Wasserman 90]
Winter Partners (OSMOSYS) [Winter Partners]
Wirfs-Brock et al. [Wirfs-Brock 90]

Further Ideas And Techniques:
Meyer [Meyer 88]
Stroustrup [Stroustrup 91]

See APPENDIX D for CASE systems supporting these methodologies (several from
the originators themselves).

See also section 1.21 for a discussion on OOA/OOD and etc.

Summaries and comparisons will be provided in future FAQs. Suggestions for
inclusion of other major or new methodologies should be sent to the FAQ author.

Here are some comparison studies posted to the net:

Arnold, P., Bodoff, S., Coleman, D., Gilchrist, H., Hayes, F., An Evolution of
Five Object Oriented Development Methods, Research report, HP Laboratories,
June 1991

de Champeaux, Dennis and Faure, Penelope. A comparative study of object-
oriented analysis methods. Journal of Object Oriented Programming (JOOP), pp
21-32. Vol.5, No. 1, 3/4-92

Fichman R.G. & Kemerer C.F. OO and Conventional Analysis and Design
Methodologies. Computer, Oct 1992, Vol 25, No. 10, p 22-40

Fichman, Robert and Kemerer, Chris. Object-Oriented and Conventional Analysis
and Design Methods - Comparison and Critique. IEEE-Comp, Oct, 1992, pp 22-39.
OOA, OOD, conventional analysis, conventional design, DeMarco SA, Yourdon SA,
Bailin OO requirements specification, Coad-Yourdon OOA, Shlaer-Mellor OOA,
Yourdon-Constantine SD, Martin information engineering design, Wasserman OOSD,
Booch OOD, Wirfs-Brock responsibility-driven design.

The following 2 reports are out of print.

[van den Goor et.al., 1992]
G. van den Goor, S. Hong and S. Brinkkemper,
A Comparison of Six Object-oriented Analysis and Design Methods. Report
Center of Telematics and Information Technology, University of Twente,
the Netherlands, and Computer Information Systems Department, Georgia
State University, Atlanta, USA, 1992, 163 pages.

[Hong et.al. 1992]
S. Hong, G. van den Goor, S. Brinkkemper, A Formal Approach to the
Comparison of Object Oriented Analysis and Design Methodologies, Hawaii
International Conference on System Sciences (HICSS) (IEEE Computer Society
Press, Hawaii) 1993, Vol. IV, pp. 689-698.

[From Shuguang...] readers may download the paper if they want, though they
may continue to request hard copies. We are currently extending the paper
to compare ten OO methods and should be available shortly.
My URL is: http://cis.gsu.edu/~shong

===================================================================
* Shuguang Hong, Ph.D. cis...@gsusgi2.gsu.edu *
* Computer Information Systems Dept. Tel: (404)651-3887 *
* College of Business Administration Fax: (404)651-3842 *
* Georgia State University *
* Atlanta, GA 30302-4015 www: http://cis.gsu.edu/~shong/ *
===================================================================

Monarchi, David and Puhr, Gretchen I. A Research Typology for Object-Oriented
Analysis and Design. CACM/September 1992/Vol.35, No.9, pp35.

[Wilkie 93] summarizes, compares, and provides examples of Booch, Wirfs-Brock,
Hood, Coad and Yourdon, Winter Partners, Shlaer and Mellor, Jacobson,
Wasserman et al, Rumbaugh, Reenskaug et al, and Colbert.

Wirfs-Brock, R.J. and Johnson, R.E., "Surveying Current Research in Object-
Oriented Design," The Communications of ACM, (33, 9) Sept. 1990, pp. 104-1124.

Fowler, M. "Describing and Comparing Object-Oriented Analysis and Design
Methods," In Object Development Methods, Carmichael, A. ed., SIGS Books,
(1994), pp.79-109.
A new version is going to be published soon. Contact the author
<10003...@compuserve.com> for details on its availability'.

Also commercially available:

An Evaluation of Object-Oriented Analysis and Design Methodologies (9)
J. Cribbs, C Roe, S. Moon
SIGS Books
(212) 274-0640
$149.

Object-Oriented Methodology Comparison Study (10 methodologies)
Berard, Booch, Coad/Yourdon, Colbert, Embley, IBM, Martin/Odell, Rumbaugh,
Shlaer/Mellor, Wirfs-Brock. Also contains refs to several previous studies.
Berard Software Engineering
101 Lakeforest Blvd., Suite 360, Gaithersburg, MD 20877
Contact Person: Jim Youlio
Phone: 301-417-9884
Fax: 301-417-0021
email: in...@bse.com

[Hong et.al. 1992], [van den Goor et.al., 1992]
The authors have prepared a revision (See above) that includes the following OO
methods:

Booch, G. - Object-oriented analysis and design with applications, 1994.
Champeaux, D. de - Object-oriented system development, 1993.
Coad, P., and Yourdon, E. - Object-oriented analysis (2nd edition), 1991a.
Coad, P., and Yourdon, E. - Object-oriented design, 1991b.
Coleman, D. - Object-oriented development, the Fusion method, 1994.
Henderson-Sellers, B. and Edwards, J.M. - Methodology for Object-oriented
Software
Engineering of Systems, draft manuscript, 1994.
Jacobson, I. - Object-oriented software engineering, 1993.
Martin, J., Odell, J. - Object-oriented analysis and design, 1992.
Martin, J., Odell, J. - Principles of object-oriented analysis and design,
1993.
Rumbaugh, J. et.al. - Object-oriented modeling and design, 1991.
Shlaer, S., Mellor, S.J. - Object-oriented systems analysis: Modeling the
world in states, 1992.
Wirfs-Brock, R. et.al. - Designing object-oriented software, 1990.

We are currently approaching publishers for the publication of this report
as a book. This book should be out in the spring of 1995.

If you are interested in obtaining this book you can send an e-mail to
Sjaak Brinkkemper (sj...@cs.utwente.nl), which we will forward to the
publisher.

The authors, regretfully, cannot supply ftp, postscript, TEX, or
whatsoever.


3.8) What Is the OMG/OMA/ORB/CORBA?
------------------------------------

Contents:
(3.8.1) Contact Information
(3.8.2) OMG Summary
(3.8.3) Mail Server Access
(3.8.4) OMG Publications
- First Class (Bi-Monthly Newsletter)
- Object Management Architecture Guide (OMA)
- The Common Object Request Broker: Arch. and Spec. (Corba)
- Pricing
(3.8.5) Implementations (Brief)
(3.8.6) Implementation Descriptions
(3.8.7) Books, Articles, And Literature


3.8.1 Contact Information
__________________________

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part3
Last-Modified: 04/02/96
Version: 1.0.9

Contact Person: Richard Soley (technical director) so...@omg.com

FTP Sites:
omg.org:pub/*
omg.org:pub/NEC_DII/93-1-2.tar... *CORBA (DII) (corba.ps.Z)
omg.org:pub/OMG_IDL_CFE_1.2/bin* idl.SunOS4.x, idl.Solaris2.x
claude.ifi.unizh.ch:under pub/standards/spec CORBA Spec
WWW:
http://www.omg.org/
http://conf4.darpa.mil/corba-ada/ORBs.html
http://www.acl.lanl.gov/sunrise/DistComp/Objects/corba.html
http://www.cs.wustl.edu/~schmidt/corba.html
http://www.dstc.edu.au/AU/research_news/omg/corba.html

Headquarters: Marketing Office:
492 Old Connecticut Path 3823 Birchwood Drive
Framingham, MA 01701 Boulder, CO 80304
Tel: 508-820-4300 Tel: 303-444-8129
Fax: 508-820-4303 Fax: 303-444-8172


3.8.2 OMG Summary
__________________

From: so...@emerald.omg.ORG (Richard Mark Soley)
Subject: OMG

In answer to your general question about the OMG, here's a brief overview.
Feel free to call, fax or email for more information.

-- Richard Soley
Vice President & Technical Director
Object Management Group, Inc.
and coincidentally, MIT '82, SM '85, PhD '89 (EECS)

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.

The OMG adoption cycle includes Requests for Information and
Proposals, requesting detailed technical and commercial availability
information from OMG members about existing products to fill
particular parts of the reference model architecture. After passage
by Technical and Business committees to review these responses, the
OMG Board of Directors makes a final determination for technology adoption.
Adopted specifications are available on a fee-free basis to members and
non-members alike.

In late 1991 OMG adopted its first interface technology, for the Object
Request Broker portion of the reference model. This technology, adopted
from a joint proposal (named "CORBA") of Hewlett-Packard, NCR Corp.,
HyperDesk Corp., Digital Equipment Corp., Sun Microsystems and Object
Design Inc. includes both static and dynamic interfaces to an inter-
application request handling software "bus."

Unlike other organizations, the OMG itself does not and will not
develop nor sell software of any kind. Instead, it selects and promulgates
software interfaces; products which offer these interfaces continue to be
developed and offered by commercial companies.

In order to serve OMG membership interested in other object-oriented systems
arenas besides the distributed system problem, the Group supports Special
Interest Groups for discussion of possible standards in other areas. These
groups at present are:

1) Object Oriented Databases;
2) OO Languages;
3) End-User Requirements;
4) Parallel Processing;
5) Analysis & Design Methodologies;
6) Smalltalk; and
7) Class Libraries.

Any company, university/research institution or individual, whether
end-user or vendor, can become a member of this body. Administrative
details are given at the end of this paper.


3.8.3 Mail Server Access
_________________________

Information via Mail Server:
Send the following commands in a letter to the mail server.

mail omg_s...@omg.org
help (how to use file server)
index (return a list of all available files)
get <file> (get files returned by index)
log <info> (logs info on server)
address <e-mail address) (use this address instead of sender)
list <directory> [match] (index a directory, pattern 'match' files)
size <segment size> (max file size to send)

list mail
list docs
get docs/doclist.txt
get docs/91-12-1.ps CORBA spec [although it looks a little old]


Recommended (from the net):

mail omg_s...@omg.org
Subject:
help
index
list
list mail
list docs
get docs/doclist.txt


3.8.4 OMG Publications
_______________________

Below is from omg.org:pub/CORBA


> First Class (Bi-Monthly Newsletter)

First Class is OMG's non-commercial bi-monthly 28-page
newsletter. First Class provides current information on Object
Technology developments, both technically and commercially. First
Class offers an open editorial forum on numerous Object
Technology topics and issues. This publication features
commentaries from software industry leaders, informative user
case histories, OT training information and the latest object-
oriented product announcements. All OMG activities and the
ongoing development of the Object Management Architecture are
regularly reported.


> Object Management Architecture Guide (OMA)

The members of the OMG have a shared goal of developing and using
integrated software systems. These systems should be built using
a methodology that supports modular production of software;
encourages reuse of code; allows useful integration across lines
of developers, operating systems and hardware; and enhance long-
range maintenance of that code. As an organization, OMG believes
that the object-oriented approach to software construction best
supports their goals. The OMA publication outlines the
groundwork for technology response to Request for Proposals (RFP)
and the adoption of specifications.


> The Common Object Request Broker: Arch. and Spec. (Corba)

The CORBA, as defined by the OMG's Object Request Broker (ORB),
provides the mechanisms by which objects transparently make
requests and receive responses. The ORB provides interoperability
between applications on different machines in heterogeneous
distributed environments and seamlessly interconnects multiple
object systems. The Common Object Request Broker Architecture and
Specification described in this published document is a self-
contained response to the Request for Proposals (RFP) issued by
the ORB Task Force of the OMG.

> Pricing

[Here's why you don't see the specifications posted to the net or available via
ftp! These are from the list of literature and periodicals listed in
omg.org:pub/CORBA]

o I would like a one year subscription to First Class
______ for $40 U.S., ______ for $50 outside U.S.

o I would like to order ______ copy(s) of the Object Management
Architecture (OMA) Guide for $50 each.

o I would like to order ______ copy(s) of the CORBA for $50 each.

o [Combinations]

Contact docu...@omg.org or omg_do...@omg.org for more of the same...


3.8.5 Implementations (Brief)
______________________________

> DEC ObjectBroker Version 2.5 (Version 2.1 was ACA)
Full implementation of OMG CORBA 1.1. Digital's ObjectBroker is a 100 %
compliant implementation of CORBA and is available on these platforms:
IBM AIX, IBM MVS(port in progress), HP-UX, Macintosh, MS-Windows 3.1, NT,
OSF/1, SunOS, ULTRIX, Digital VAX/VMS, Digital OpenVMS
Contact:
Andrew Comas
co...@nyo.dec.com (212) 856-2507
Digital Equipment Corporation.
ObjectBroker
110 Spit Brook Road
Nashua, New Hampshire 03062-2698

> DOME - The C++ Object Request Broker
runs on VAX/VMS, Unix, PC
http://www.octacon.co.uk/onyx/external/oot.co.uk
Anon ftp: ftp.octacon.co.uk/external/oot/domedemo.exe; also from http.

> HP ORB Plus and HP Distributed Smalltalk
Full implementation of the OMG CORBA 1.1 Object Request Broker. Also DOMF.
Hewlett-Packard
Distributed Computing Group
19447 Pruneridge Avenue
Cupertino, CA 95014-9974 (USA)
Ian Fuller i...@cup.hp.com (408) 447-4722

> HyperDesk (Westborough MA) HD-DOMS, rich_...@hyperdesk.com
Runs on SPARC, HP/UX, IBM RS-6000, Data General Aviion, MS-Windows (client
API only), NetWare (planned, Novell owns part of HyperDesk).

> IBM SOM (System Object Model)
Available on AIX and OS/2. See Distributed Computing Monitor, March 93 for
a detailed review.

> ILU (free, see APPENDIX E entry 59)
Object RPC compatible with OMG CORBA 1.2 spec (will compile OMG IDL and
generate OMG compliant code for OMG-specified languages).
parcftp.parc.xerox.com:/pub/ilu/ilu.html

> IONA Technologies, Dublin Orbix, in...@iona.ie
First full and complete implementation of OMG's CORBA.

> NCR 'Cooperative Frameworks' -- a Distributed Object Foundation
(1) C++ ORB toolkit consisting of over 300 C++ classes and runtime libraries
(2) CORBA 1.1 toolkit

> ORBELINE - The SMART Object Request Broker - PostModern Computing
Complete implementation of CORBA. Free academic; com. eval licence avail.
SunOS 4.x, Solaris 2.3, and OSF/1 versions of ORBeline available; will
consider making other platforms available if enough interest. See Appendix E.
http://www.pomoco.com/

> ROLSCH CONSULTING (RC-ORB)
Implements ORB spec, DOS/Windows 3.1, 12 user license: $99.
Ref: Datamation, LOOK AHEAD Section, August 1. German Company.


> SUITESOFTWARE (SuiteDOME)
- an open system, standards compliance, object-oriented architecture,
support for heterogeneous environments, support for Remote Data Access
(RDA), Remote Procedure Calls (RPC), Message-Oriented Middleware (MOM),
and Object Request Broker (ORB).

> Sun DOE

> Tivoli

> CS Dept. University of Zurich, Switzerland. maf...@ifi.unizh.ch
The ELECTRA Toolkit (not finished)


3.8.6 Implementation Descriptions
___________________________________

The OMG also has a (Corporate) Membership list and "known CORBA supporters"
list with their info package.


> The ELECTRA Toolkit

CS Dept. University of Zurich, Switzerland. maf...@ifi.unizh.ch
The ELECTRA Toolkit

Subject: ORB Implementations
Date: Tue, 4 May 1993 13:12:36 +0200 (MET DST)
From: Silvano Maffeis <maf...@ifi.unizh.ch>

something like an Object Broker, but it is *not* CORBA compatible (yet).
Electra is a research project and not available yet.

Its a toolkit for building failure resilient, distributed applications
in C++. It supports object-groups, virtual synchrony, multithreading
etc. Electra is based on the HORUS toolkit (which is "the new ISIS
implementation" developed at Cornell, Ithaca NY.)
An overview paper to electra is available from:
ftp.ifi.unizh.ch: pub/techreports/electra.ps.Z


> HD_DOMS

HD-DOMS (HyperDesk Distributed Object Management System). A
CORBA-compliant DOMS. Includes a GUI API driver for prototyping and
exercising objects, a bundled object database for persistent object
storage, a Kerberos-based authentication service, a location service, a
set of base classes to speed development, and a test script language.
Revision 1.0 has been shipping since beginning of '92. Revision 1.1
(which includes support for CORBA's static client interface) is available
now, and a NetWare version is in the works. Submitted a C++ language
mapping for IDL to the OMG recently.

HyperDesk Corporation
2000 West Park Drive
Westboro, MA 01581
(508)366-5050


> HP ORB Plus and HP Distributed Smalltalk

============================================================================
SUBJECT: HP INTRODUCES DISTRIBUTED-COMPUTING SOLUTION FOR BUILDING
SCALABLE, OBJECT-ORIENTED APPLICATIONS
DATE: September 27, 1993
----------------------------------------------------------------------------

PALO ALTO, Calif.--(BUSINESS WIRE) via First! -- Hewlett-Packard Company
today introduced a distributed-computing solution for building scalable,
object-oriented applications.

With HP ORB Plus, programmers can develop scalable, object-based
applications that can be distributed throughout the enterprise. HP also
introduced an enhanced version of HP Distributed Smalltalk.

HP ORB Plus and HP Distributed Smalltalk are major components of HP's
overall distributed-computing strategy, which is designed to give customers
integrated, desktop access to enterprise-wide information and resources in
distributed heterogeneous systems environments. Of all computer companies,
HP believes it is best positioned to help customers take advantage of
distributed computing. HP provides a wide variety of distributed-computing
products, understands how to help customers adopt new technology for maximum
business benefit, and offers worldwide support and training programs,
ranging from analysis and design to deployment.

HP ORB PLUS: CORBA AND DCE COMBINED

HP ORB Plus is the only environment that combines the complete CORBA 1.1
specification from the Object Management Group with the DCE standard from
the Open Software Foundation(tm) as its transport mechanism. DCE is
designed to let developers write one application and then deploy it --
without modification -- on any other system that supports DCE. HP ORB Plus
reduces the complexity of developing distributed applications so programmers
can concentrate on the application itself without needing to know multiple
operating systems, networking protocols or where application objects are
stored.

The DCE (Distributed Computing Environment) standard provides an
integrated set of services that can be used separately or together to
provide a distributed computing environment that's easy to administer. The
CORBA (common-object-request-broker architecture) specification provides a
standard for how objects (in applications, repositories or class libraries)
make requests and receive responses across a distributed network.

HP ORB PLUS DETAILS

HP ORB Plus consists of several components: the Distributed Object
Management Facility (DOMF), object services, developers' and administrative
tools, and sample applications. HP's DOMF provides a location-transparent
object-communication mechanism across heterogeneous networks by using the
DCE standard. This object- enabling technology specification was jointly
developed with SunSoft. By following a common specification, HP and SunSoft
have made it easier for their customers to port applications between their
platforms.

In addition, HP is working with IBM to integrate HP's DOMF with IBM's
System Object Model with extensions for distribution. This integration will
eventually provide users with complete scalability, portability and
interoperability of distributed applications across HP and IBM platforms.
This is part of the companies' planned approach toward a standards-based,
"plug-and-play" object-oriented environment. This will give developers,
system administrators and end users language-neutral, enterprise-wide,
heterogeneous support for building, managing and using distributed object-
oriented applications.

"We're so convinced of the value of object technology that we're staking
our entire company on it," said Richard Tanler, president and chief
executive officer of Information Advantage, Inc. "Our object-based
applications for retailers provide the means to a competitive business edge.
We plan to use HP ORB Plus to develop new object-based products that
retailers can distribute to end users throughout headquarters, all chain
stores, and warehousing and distribution operations."

HP DISTRIBUTED SMALLTALK 2.0

In a related announcement, HP introduced Version 2.0 of HP Distributed
Smalltalk. This toolset works with VisualWorks from ParcPlace Systems to
provide programmers with a rapid development environment for creating and
running distributed applications. These applications can use object
databases (currently OpenODB from HP and Gemstone from Servio) as their
storage mechanism to facilitate the reuse of objects.

Applications built using HP Distributed Smalltalk currently run without
modification on HP, Sun and IBM UNIX(R) system-based workstations. They
also will run on Apple Macintosh computers and on any PC running the Windows
3.1 or Windows NT operating systems from Microsoft(R) Corp., once
VisualWorks 2.0 is released (expected within two months.)

New HP Distributed Smalltalk 2.0 features include the following:

-- easier deployment, with the ability to run multiple HP
Distributed Smalltalk-based applications on a single system;
-- up to 400 percent increased performance, through quicker
sending and receiving of remote messages, and reusable
object libraries;
-- run-time version, for full production deployment; and
-- easier development, with remote object browsing so
developers can find and use objects more quickly.

TECHNICAL DETAILS AND AVAILABILITY

HP's DOMF includes the object request broker, interface- definition-
language compiler, static and dynamic invocation interface and interface
repository. In addition to these OMG-specific features, most developers
writing distributed, object-oriented applications require additional
interfaces to use objects effectively. So developers don't need to create
their own, HP has supplied several object-service interfaces for developers
to use. That's why HP ORB Plus includes OMG interfaces and implementations
for properties, life cycle, associations, event notification and naming.

HP's limited release of HP ORB Plus to key developers is designed so that
customer input can be incorporated into the product early in its development
cycle. The initial version will work with the C++ programming language.
For the generally available Developer's Kit, C++, C and Smalltalk
interoperability is planned so objects written in different languages can be
combined into one application. The Developer's Kit is scheduled to be
available mid- 1994; prices will be announced then. HP ORB Plus runs on the
HP Apollo 9000 Series 700 workstations and HP 9000 Series 800 business
servers.

Hewlett-Packard Company is an international manufacturer of measurement
and computation products and systems recognized for excellence in quality
and support. The company's products and services are used in industry,
business, engineering, science, medicine and education in approximately 110
countries. HP has 94,900 employees and had revenue of $16.4 billion in its
1992 fiscal year.

EDITORIAL CONTACTS:
Hewlett-Packard Company
Lynne Hanson, 408/447-1415, Cupertino, Calif.
Jill Kramer, 408/447-4275, Cupertino, Calif.

==================
For more information about HP ORB Plus, contact Kathy Litch
(lit...@apollo.hp.com).

For more information about HP Distributed SmallTalk, contact
Jerry Boortz (jerry_...@hp4000.desk.hp.com).


> Iris RDOM

From: rc...@cs.cornell.edu (Robert Cooper)
Subject: Re: DCE vs. CORBA
Reply-To: rc...@isis.com
Product: Isis Reliable Distributed Object Manager(tm) (RDOM)
Company: Isis Distributed Systems, Inc., Ithaca NY, USA.

Isis RDOM(tm) is a fault tolerant distributed ORB platform for reliable
multi-lingual object-oriented applications. RDOM provides an "object group"
paradigm for constructing complex applications out of collections of
cooperating objects. RDOM is built on top of the Isis Distributed
Toolkit(tm). RDOM provides interfaces from Smalltalk (Parcplace),
Objective-C, and C++, and runs on most Unix workstations. RDOM is currently
not CORBA compliant, but will be brought to compliance during 3Q93.

Status:

RDOM has been at beta test sites since January. General release of
the Smalltalk and Objective-C language interfaces is expected in June.
The C++ interface in August. Customers include AMD, Consilium and Swiss
Bank Corp).

> Object-Oriented Technologies DOME

Product: DOME - Distributed Object Management Environment

Company: Enquiries: in...@oot.co.uk
Object Oriented Technologies Ltd,
1st Floor, Lawrence House, 1A Morrell St, Leamington Spa, England CV32 5SZ
Telephone: +44 (0) 1926 833488 Fax: +44 (0) 1926 883370.

Short Description:
DOME provides heterogenous distribution across many platforms
and networks, including:
UNIX, Windows, Windows NT, OS/2, OSF/1 (AXP), OpenVMS,
SunOs, Solaris, HP-UX, SGI Unix, Stratus FTX,
TCP/IP, NetBIOS, XTI
As a fully peer-to-peer product DOME can be used to build systems
using any combination of the above.

Long Description:
DOME is an ORB toolkit for the production of user-configured
ORBs and servers. It is a multi-threaded high performance ORB
suitable for use in large scale commercial systems and embedded
real-time systems.

DOME is non-intrusive, meaning that the application development
is separated from the means of distribution and the problem of
distributed object management; this allows the application to
be built and tested on a single machine using local resources.
Existing software can also be incorporated easily, providing
integration for legacy systems.

DOME is constructed as a C++ class library, from which ORBs
can be configured and constructed to best suit the runtime
environment. This provides great flexibility since new classes
can be derived from existing ones and the resulting configurations
implemented to user-specific requirements.

Database distribution can be as simple persistent files,
RDBMSs, OODMS, or a combination of these.

DOME has a CORBA-conformant interface, and is CORBA 1.0 compliant
with the following divergences -
additions:
- full C++ binding,
- integral support for GUI development,
- network monitoring & analysis,
- transaction management,
- location broking,
- enhanced security;
ommissions:
- dynamic invocation, which is seen as detrimental to performance
and network security; however, DOME does allow stream operators
to perform the same function.

DOME was first released in August 1993; version 2 in May 1994.


> ORBELINE - The SMART Object Request Broker

ORBeline is a complete implementation of OMG's Common Object Request
Broker Architecture (CORBA). ORBeline goes beyond the standard
specification to provide a SMART communication framework allowing
you to easily develop large distributed applications that are robust,
scalable, flexible and maintainable. ORBeline incorporates PostModern's
proven communication framework that links thousands of nodes.

See Appendix E:65 for a complete description and anon FTP info.


> Orbix

Orbix
Iona Technologies Ltd.
8-34 Percy Place
Dublin 4
Ireland

The latest release of Orbix, Version 1.2, includes an Object Loader function
for the first time, as well as an upgraded Interface Repository, a new
approach to filtering, and more code examples to guide programmers.

Orbix was launched in June 1993 as the first full and complete implementation
of the Object Management Group's (OMG's) Common Object Request Broker
Architecture (CORBA) standard. With Orbix, programmers can develop
distributed, object oriented applications following a consistent and
straightforward, standards-based model.

With Orbix Version 1.2 IONA has added the ability to dynamically load objects
at runtime through its Object Loader function. This enables developers to more
easily integrate Orbix applications with existing data stores be they
traditional flat file databases, relational databases or object oriented
databases.

The improved Interface Repository is an integral part of IONA's CORBA
implementation. The Interface Repository operates as a dynamic browser which is
populated with all objects or services available at runtime keeping programmers
informed of the functions, attributes and characteristics of objects and
services.

In version 1.2 IONA has also extended the whole approach to filtering of
requests, and has made it easier for users to integrate Orbix with their
security systems providing for improved reliability of distributed systems
built using Orbix. IONA has also extensively extended the number, and scope, of
code examples it ships with the product to help developers learning how to use
the system.

IONA released Orbix for SunSoft Solaris and SunOS at the Object World
exhibition in San Francisco, Calif., June 1993. Since then it has rolled
out versions of Orbix for Microsoft Windows NT, Silicon Graphics IRIX and
HP/UX. IONA demonstrated a version of Orbix for Microsoft Windows 3.1 at
Object World in London, England last October. Orbix for Microsoft Windows
3.1 is now in beta. In January 1994, IONA and SunSoft Inc. signed an
agreement to align their implementations of CORBA. The two companies
demonstrated interoperability between IONA's Orbix running on Microsoft
Windows 3.1 and SunSoft's Distributed Objects Everywhere (DOE) on Solaris.

In addition Orbix-TP, integration with Tuxedo for transaction processing, has
just entered beta testing. Work is underway on Orbix-FT, integration with
the Isis distributed system, will deliver a fault-tolerant ORB.

Paul Hickey, tel: +353-1-6686522
Iona Technologies Ltd., fax: +353-1-6686573
8-34 Percy Place, email: p...@iona.ie
Dublin 4
Ireland

Availability
------------

The full Orbix availability and release schedule looks like:

Operating System C++ Compiler Release
Date
-------------------------------------------------------
SunOS 4.1 SPARCompiler 2.1 NOW
SunOS 4.1 SPARCompiler 3.0.2 NOW
SunOS 4.1 Lucid 3.1 NOW
SunOS 4.1 GNU 2.5.8 NOW
Solaris 2.x SPARCompiler 3.0.2 NOW
Solaris 2.x SPARCompiler 4.0 NOW
Solaris 2.x GNU 2.5.7 NOW
IRIX 4.0.5H Native NOW
IRIX 5.x Native NOW
HP-UX Native NOW
Microsoft Windows NT Visual C++ NOW
Microsoft Windows NT Borland NOW
Microsoft Windows 3.1 Visual C++ In Beta
IBM AIX C Set++ 4th Qtr
OSF/1 DEC C++ 4th Qtr
SCO Native 4th Qtr
UnixWare Computer Innovations 4th Qtr
Ultrix DEC C++ 4th Qtr

Release of Orbix on OS/2 is also imminent.

Documents Available from IONA
-----------------------------

electronic mail server - ser...@iona.ie
anonymous ftp file server - ftp ftp.iona.ie
World Wide Web - http://www.iona.ie/


> NCR 'Cooperative Frameworks' -- a Distributed Object Foundation

From: Randy Volters <randy....@columbiasc.ncr.com>
Subject: re-post: NCR Cooperative Frameworks (new phone no.)

November 19, 1993

NCR ANNOUNCES BETA AVAILABILITY
OF 'Cooperative Frameworks' --
a Distributed Object Foundation

Product Background -
NCR Cooperative Frameworks(TM) were first released for sale
in 10/1991 as "the frameworks" part of the NCR COOPERATION(TM)
product, and are based on NCR's submission to OMG.
Cooperative Frameworks release 3.0 makes the product
available apart from COOPERATION.

Product Description -
Cooperative Frameworks is a distributed object foundation
for building computing applications and services on networks
of heterogeneous computers.

Cooperative Frameworks consists of an integrated suite of
C++ class libraries that:

- defines and implements a comprehensive enterprise
architecture and methodology for creating
distributed implementations of C++ classes over
networks

- allows customers to build and use object services
over a network

- supports TCP/IP, NetBIOS, Lan Manager NetBEUI and
OSI protocols, X.25

NCR Cooperative Frameworks currently has two portable ORB
toolkits (others are planned for future release) --
(1) C++ ORB toolkit consisting of over 300 C++ classes and
runtime libraries

(2) CORBA 1.1 toolkit Both are for:

- wrapping existing databases and legacy
applications for improved availability
and maintainability on systems of heterogeneous
computers, operating systems and networks

- building next-generation, object-oriented,
distributed computing applications for
networks of heterogeneous computers, operating
systems and network operating systems

Cooperative Frameworks come with predefined object services
for implementing distributed systems:

- Naming - network implementation of X.500 directory
provides object naming service

- Logging - provides local and server based error
logging

- Fine-grain Data Management - class libraries are
designed around fine grained objects, developers can
build distributed objects as large or as small as
needed

- Persistence - the same object stream model for
communication between internal ORB functions is used to
support object persistence. Persistent objects can be
files, relational or object databases

- Dynamic Service Location - provides a mechanism for
registering services and entities in a distributed
system and invoking targeted services based on service
characteristics -- rather than names

- Dynamic Service Activation - provides a mechanism for
object activation when method invocations are required,
and deactivation when not needed

- Event Service (Release 3.1) - Implements an OMG/JOSS
compliant event service

- Network Configuration Tools - simplifies creation of
directory entries required for cross domain operation
in a multiple domain heterogeneous network.

NCR Cooperative Frameworks run on multiple UNIX platforms,
including HP-UX, Sun Solaris, NCR 3000 UNIX and NCR
StarServer UNIX SVR4; and on MS Windows 3.1. Cooperative
Frameworks has been demonstrated on Novell NetWare v3.11,
and was originally developed on MS OS/2 v1.x. Development
environments supported include CFRONT and C++ Workbench from
NCR, HP Softbench Sun SPARCworks and Borland IDE.

Implementation - implementation is for client/server system
architectures as a set of DLL and shared libraries

Languages used for IDL mapping - IDL bindings for C, (or
object services can be implemented directly in C++)

Release date - Release 3.0 is available now to early
developers with general availability set for December, 1993;
Release 3.1 will be available to early developers 1Q 1994
with general availability set for 2Q 1994

Product interoperability - Full interoperability between NCR
Cooperative Framework implementations on supported platforms
is available now; interoperability with selected CORBA 1.1
ORBs and CORBA 2.0 ORBs is planned

Company Name -
NCR Corporation (An AT&T Company)

Address -- Software Products Division-Columbia
3245 Platt Springs Road
West Columbia SC 29170

Phone
(803) 939-7500
FAX
(803) 939-7745
Contact Name
Randy Volters, Sr. Product Manager
Cooperative Frameworks
Email: Randy....@ColumbiaSC.NCR.COM
Ext. 7774

Company Description -
NCR, AT&T's computer business, brings computing and
communications solutions together to provide people easy
access to information and to each other -- anytime,
anywhere.


> SUITESOFTWARE (SuiteDOME)
Overview
Variety may make life more interesting, but it only complicates the
task of connecting employees with the information they need. In a
world of heterogeneous, distributed computer systems, it's an ongoing
struggle to provide easy access to data while maintaining and
updating a collection of incompatible hardware platforms, operating
systems, applications, databases, network protocols, and the like.
To simplify the technical challenges, reduce the time and effort
required, and still be able to exploit all of an organization's
on-line data, information technology (IT) managers are turning to
middleware - run-time system software that is layered between an
application program and the operating system and that, in a
distributed, heterogeneous environment, supplies the functions that
would have been provided by the application's native operating
system.

To do this effectively, middleware must be able to interpret the
differences between operating systems, network protocols, databases,
and file systems; access and distribute data; guarantee system
security; and scale up to accommodate even the largest systems. When
middleware achieves this, it makes enterprise computing a reality.
As a result, middleware is quickly emerging as the best solution for
overcoming system incompatibilities, and middleware such as
SUITESOFTWARE's Distributed Object Management Environment (DOME)
Software System makes it possible for organizations to build large
scale, heterogeneous, distributed systems that can run virtually any
application in the enterprise, accessing virtually any data.
DOME - Covering the Enterprise
The DOME Software System is comprehensive middleware that provides
all of the essential services necessary to unify distributed
applications and data into a single system. With DOME, companies can
develop applications on any platform they choose and then easily
distribute them across heterogeneous environments throughout the
enterprise.

The DOME system can accomplish this complex task because it offers:
- an open system
- standards compliance
- object-oriented architecture
- support for heterogeneous environments
- and support for Remote Data Access (RDA), Remote Procedure
Calls (RPC), Message-Oriented Middleware (MOM), and Object Request
Broker (ORB).
o Open System
DOME is an open system that provides an interface between all of a
customer's applications, making it possible to share information
between new and legacy applications. DOME provides a solution today
and its open platform structure accommodates future technologies.
o Standards Compliant
DOME is compliant with the following standards:
- OMG/CORBA
- SAG
- MOMA
- ISO
- OLE Microsoft
- CCITT X.500
- Kerberos 5.4 (Security)
DOME allows message transfer from one object to another object,
provides the ability to find an object, register an object, register
the message interface to an object, and dynamically invoke an object.
DOME also provides object services beyond the Object Request Broker
(ORB) and contains a directory and name service that provides more
functionality than specified by the X.500 standard. Because DOME goes
beyond what many of the standards require, it makes the task of
creating distributed applications, especially in very large
distributed environments, even easier.
SUITESOFTWARE is a member of various standards groups and conforms
its products to industry standards as they are adopted.
o Object-Oriented Architecture
Because DOME's architecture is object-oriented, there are significant
benefits.
- True messaging for workflow management and EDI
- Queue- and bus-based (rather than send-based) design provides
store-and-forward, broadcasting, and subscribing functionality
- Full recovery capabilities
- Different levels of messaging service for positive/negative
acknowledgment and start-on-demand
- Hierarchical namespace with true domains for complete
scalability
- Concern registration and event notification
- Logical name translation for true aliasing
- Kerberos 5.4 compatible security/authentication and access
control
- Implementation of additional protocols through a
communications layer
- Co-existence of multiple development and/or production
environments on a single node
- Platform independent time services and exception handling
These beneficial functions have resulted in measurable time and labor
savings while freeing systems personnel to concentrate on critical
issues.
o Support for Heterogeneous Environments
DOME runs on the major UNIX platforms as well as in other interactive
computing environments, such as OS/2 and Windows.
DOME Software System Components
The DOME software system is composed of the core DOME product, DOME
SecurityTM, DOMEshellTM scripting and prototyping language, and the
DOME Data Manager (DDMTM) database access manager.

[...]

The DOME Data Manager is a complete relational DBMS engine that
provides access to distributed data.
Features
DDM provides autonomy for distributed data sites, but it also
supplies the means for consolidating data for specific applications.
It can read and write data across numerous DBMSs, and it makes
distributed data management transparent, so that the user never needs
to know the physical location of data, the server of access, or the
underlying vendor in order to process requests. From the user's
perspective, the enterprise is a single logical database located in
its entirety on the local machine. This is possible because DDM maps
the application's logical view of the environment into the
enterprise's physical environment of multiple nodes, disparate
operating systems, and multiple DBMSs.
DDM can manipulate data across a large number of databases and data
locations, and it is also interoperable. By conforming to the SQL
Access Group's Call Level Interface standard, DDM can interoperate
with any number of third-party GUI and CASE tools. Among the GUIs are
Powerbuilder,, Visual Basic,, and Uniface,. Among the CASE tools are
ERwin,, Popkin,, and Knowledgeware,.

? 1995 SUITESOFTWARE
DOME, DOMEshell, DOME Security, DOME Data Manager, and DDM are
trademarks of SUITESOFTWARE. All other products and product names are
copyrighted by, trademarks of, or registered trademarks of their
respective owners.
Support and Deliverables
Customer Support
SUITESOFTWARE places particular emphasis on support and continuing
education. The broad technical and business systems background of our
staff of fully trained professionals ensures "real world" responses
to problems. SUITESOFTWARE `s support staff is available by
telephone, FAX, and e-mail to help customers maximize the use of the
DOME Software System and obtain quick resolutions to problems.
Deliverables
Optical or magnetic media containing all files required to load and
execute DOME plus PostScriptTM versions of DOME documentation.
Hardcopy versions of all DOME documentation are available for a
nominal additional cost.
Configuration Requirements
Disk space and memory requirements are dependent on the installation
platform. SUITESOFTWARE sales representatives are available to help
determine configuration requirements for particular computer systems.

SUITESOFTWARE
801 East Katella Ave., Suite 210,

Anaheim, CA 92805
Telephone: (714) 938-8850

FAX: (714) 978-1840
E-mail: customer...@suite.com

3.8.7 Books, Articles, And Literature
--------------------------------------

This section is expected to grow considerably in the future.

"Distributed Object Computing With CORBA", C++ Report, July/August 1993

The Object Database Standard: ODMG-93

edited by: R.G.G. Cattell
published by Morgan Kaufmann Publishers, San Mateo, California
[Covers CORBA standards with respect to OODBs]


3.9) Why is Garbage Collection A Good Thing?
-------------------------------------------------------------------------

There are two entries on garbage collection, the first is an excellent entry
written for the FAQ by Paul Johnson and the second is from the FAQ author's
company on the necessity of garbage collection for object-oriented programming
and technique.

From: Paul Johnson (p...@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] and [4]
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, GC can perform compaction improving locality of reference.]

Further Reading:

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

[2] "Uniprocessor Garbage Collection Techniques," by Paul R. Wilson,
in Memory Management (proceedings of 1992 Int'l Workshop on Memory
Management, Sept. 1992, St. Malo, France, Yves Bekkers and Jacques Cohen,
eds.), Springer Verlag Lecture Notes in Computer Science #637.

This is an excellent summary of the state of the art in GC algorithms. This
and other papers about garbage collection are available in PostScript via
anonymous ftp (cs.utexas.edu:pub/garbage/gcsurvey.ps. [See APPENDIX E]

[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++.
ftp://parcftp.xerox.com/pub/gc/gc.html

[4] Geodesic Systems provides GC for C and C++. See http://www.geodesic.com
and Appendix G.


3.9b) Why is Garbage Collection Necessary for Object-Oriented Programming?
--------------------------------------------------------------------------
Michael Spertus
Geodesic Systems
m...@geodesic.com

There are several reasons why true object-oriented programming requires garbage
collection.

1. Manual Memory Management Breaks Encapsulation.

Program components frequently need knowledge of an entire program to
determine the last use of an object and provide deletion. This makes reuse
of the component nearly impossible. For example, methods and functions
taking a container as an argument need to know of or make assumptions
about the rest of the program to determine ownership of the objects in the
container.

Attempts to encapsulate memory management with reference counting, the "poor
man's garbage collector", are usually misguided. Reference counting has worse
performance than GC, awkward syntax, and poor semantics, which typically
include failure to reclaim cycles, inability to handle stack and static
objects, lack of polymorphism, and problems with interior pointers (e.g.
arrays and multiple inheritance). Intensive research [1] in garbage
collection has completely solved the above problems and made reference
counting an inadequate substitute for true GC.

2. Implementation Hiding is not Compatible with Manual Memory Management

Implementation hiding is a pillar of object-oriented programming,
but explicit memory management requires implementation-dependent
low-level knowledge of how memory is structured. For example, programmers
often use "copy on write" to efficiently implement pass-by-value semantics.
However, to manage memory explicitly, a program has to know if it has a copy
of an object or the object itself. Programmers sometimes use reference
counting to encapsulate copy-on-write memory management. However, this only
works well in simple cases like strings where the data is not polymorphic
and does not contain pointers.

3. Message Passing Leads to Dynamic Execution Paths

Manual memory management must make assumptions about a program's order of
execution to make a compile-time determination of the last user of an
object. While this is often possible in procedural languages, the object-
oriented paradigm of objects sending messages to each other (possibly from
different threads) makes it impossible to statically determine the last user
of an object. For example, event driven GUI programs frequently have no
clear order of execution. Other dynamic control structures, such as
exceptions, also make static analysis of memory usage at compile-time
impossible.

4. Differing Memory Management Schemes Hinder Reuse

Because no memory management scheme is universal enough for all applications,
manually managed components and libraries often use incompatible memory
management schemes. For example, there are common container libraries using
each of the following schemes:

a) Doubly specified empty and remove methods with one including a memory
delete, placing the memory management burden on the client, who must call
the appropriate method.

b) Switches indicating deletion. Many applications must clear the switch to
support long-lived data and keep track of ownership of data shared by
multiple containers, leaving many memory management issues unaddressed.

c) Value semantics store objects rather than references, inhibiting data
sharing and carrying expensive performance costs when complex objects are
copied by value.

d) Reference counting, which was already discussed.

Any components or libraries that use containers with different memory
management strategies are difficult to use with each other.


5. Garbage Collection Works

It is not enough to merely find fault with manual memory management. One also
has to show that garbage collection provides a better alternative. Early
versions of garbage collection were merely crude implementations of
mark-and-sweep that left much to be desired. However, garbage collection has
advanced as rapidly as most computer-related technologies and is now a robust,
mature technology.[1] Many object-oriented languages specify garbage
collection for all or part of their memory. Even C and C++ have at least one
commercially supported garbage collector that can transparently and
compatibly manage both new and existing programs. [2]

Garbage collected programs are usually as fast and responsive as
their manually managed brethren. [3] In fact, multi-media programmers
sometimes choose treadmill collectors [4] over hand-management because of its
superior real-time performance as manual management usually has difficulty
scheduling destructor calls smoothly. Of course, garbage collected programs
are generally more reliable and easier to develop, maintain, and reuse than
manually managed programs. Finally, garbage collection can be mixed with
manual management to provide the programmer with the broadest set of tools,
and garbage collection is much too important a tool to be absent from any
object-oriented programmer's toolbox.

References
[1] Paul R. Wilson, "Uniprocessor Garbage Collection Techniques", 1992
International Workshop on Memory Management, Springer-Verlag Lecture Notes in
Computer Science series.

[2] Geodesic Systems, Great Circle(TM) Automatic Memory Management System.
http://www.geodesic.com/GreatCircle/index.html.

[3] Detlefs, Dosser, and Zorn, "Memory Allocation Costs in Large C and C++
Programs". ftp://cs.colorado.edu/pub/techreports/zorn/CU-CS-665-93-ps.Z.

[4] Henry Baker, "The Treadmill: Real-Time Garbage Collection without Motion
Sickness". ftp://ftp.netcom.com/pub/hb/hbaker/NoMotionGC.html


3.10) What Can I Do To Teach OO To The Kids?
---------------------------------------------

Smalltalk (in its original 1972 version) was initially intended to make
computer programming easy enough for children. The idea was that manipulating
objects was something more intuitive and natural than coding procedures.

Other entries or suggestions are welcome, please send to the author of the FAQ.


3.11) What Is Available On Object-Oriented Testing?
---------------------------------------------------

[This entry was donated by Doug Shaker and is certainly a FAQ]

Testing of Object-Oriented Programming (TOOP) FAQ/Resource Summary

Posted to comp.object, comp.lang.c++, comp.lang.smalltalk and
comp.software.testing.

Last revised on 93.10.27. The most notable change is in the additions
to the Software section. Also a couple of articles added to the
Written Material section.


> What?

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part4
Last-Modified: 04/02/96
Version: 1.0.9

This is a summary of resources on the Testing of Object-Oriented
Programming that have been mentioned to me over the net, in email,
or other means. Sections include Written Material, Courses, and
Software. It is kind of like an FAQ, though it isn't organized
that way.

> Who?

I work for a Unix software house, Qualix Group, in the US. Here is
my sig:
- Doug Shaker
voice: 415/572-0200
fax: 415/572-1300
email: dsh...@qualix.com
mail: Qualix Group
1900 S. Norfolk St., #224
San Mateo, CA 94403
I am NOT a researcher on the testing of object-oriented programming.
I just collate the stuff that is sent to me by people who REALLY know
something. See the section "ACKs" at the end.

I just think it is important.

> Why?

Why is this important? If classes are really to be reused in
confidence, they must be blatantly correct. The classes must be easily
testable during initial evaluation by the client programmer. They must
also be testable under different OS configurations, different compiler
optimizations, etc. This means that testing modules must be
constructed in a way which is recognized as correct and the modules
must be shipped with the class libraries.

As soon as one major class library vendor starts to ship real test code
with their libraries, all of the other vendors will be forced, by
market pressure, to do so as well, or face market share erosion. Think
about it. If you had to recommend a class library to a committee that
was choosing a basis for the next five years of work, wouldn't you feel
safer with a class library that could be auto-tested in your
environment?


> Written Material

Berard, Edward. Essays on Object-Oriented Software Engineering.
Prentice-Hall, Englewood Cliffs, NJ. $35.
This book has two chapters on testing of object-oriented software,
focusing on how to do it.

Berard, Edward. Project Management Handbook. Must be purchased
direct from Berard Software Engineering, Ltd., 902 Wind River
Lane, Suite 203, Gaithersburg, Maryland 20878. $225.
The book focuses on the management of OOP projects. It
includes one chapter on testing OO software and one chapter
on quality assurance.

Bezier, Boris, "Software Testing Techniques", 2nd edition, Van Nostrand
Reinhold, 1990, 503pp, $43, ISBN 0-442-20672-0. While this is
not specifically about testing of OOP, it is mentioned so often
by so many people as a definitive software testing work, that
I have to mention it anyway.

Cheatham Thomas J., and Lee Mellinger, "Testing Object-Oriented
Software Systems", Proceedings of the 18th ACM Annual Computer
Science Conference, ACM, Inc., New York, NY, 1990, pp. 161-165.

Doong, Roong-Ko and Phyllis G. Frankl, "Case Studies on Testing
Object-Oriented Programs", Proceedings of the 4th Symposium on
Testing, Analysis, and Verification (TAV4), 1991, ACM, Inc.,
New York, NY, 1991, pp. 165-177.

Fiedler, Steven P., "Object-Oriented Unit Testing", Hewlett-Packard
Journal, April, 1989, pp. 69-74.

Firesmith, D.G., "Testing Object-Oriented Software", Proceedings
of 11th. TOOLS USA Conference, Santa Barbara, Aug 1993, pp 407-426.

Frankl, Phyllis G. and Roong-Ko Doong, "Tools for Testing
Object-Oriented Programs", Proceedings of the 8th Pacific
Northwest Conference on Software Quality, 1990, pp. 309-324.
One author can be reached at pfr...@polyof.poly.edu.

Graham, J.A., Drakeford, A.C.T., Turner, C.D. 1993. The Verification,
Validation and Testing of Object Oriented Systems, BT Technol
J. Vol 11, No 3. One author's email address is
jgr...@axion.bt.co.uk.

Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick,
"Incremental Testing of Object-Oriented Class Structures",
International Conference on Software Engineering, May, 1992,
ACM, Inc., pp. 68 - 80.

Hoffman, Daniel and Paul Strooper. A Case Study in Class Testing.
To be Presented at the IBM Center for Advanced Studies Fall
Conference, October 1993, Toronto. Email addresses for authors
are dhof...@csr.uvic.ca and pst...@cs.uq.oz.au. Describes an
approach to testing which the authors call Testgraphs. An
example is worked out in C++ which tests a commercial class.

Hoffman, D. M. A CASE Study in Module Testing. In Proc. Conf. Software
Maintenance, pp. 100-105. IEEE Computer Society, October 1989.

Hoffman, D.M. and P.A. Strooper. Graph-Based Class Testing. In
7th Australian Software Engineering Conference (to appear), 1993.

Klimas, Edward "Quality Assurance Issues for Smalltalk Based Applications",
The Smalltalk Report, Vol. 1, No. 9, pp.3-7. The author's
email address is "ac...@cleveland.freenet.edu".

Lakos, John S. "Designing-In Quality in Large C++ Projects" Presented
at the 10th Annual Pacific Northwest Software Quality Conference,
Portland, Oregon, October 21, 1993. Abstract:
The focus of this paper is on ensuring quality by
designing software that avoids acyclic component
dependencies. This in-turn permits incremental,
hierarchical testing. The importance of good physical
design becomes a key factor only for large and very
large projects. Intuition gained from smaller projects
leads to errors in large designs. Compile-coupling
("Insulation") is also discussed.
Copies of the postscript file can be obtained by sending email
to "john_...@warren.mentorg.com".

Leavens, G. T., "Modular Specification and Verification of
Object-Oriented Programs", IEEE Software, July 1991, pp. 72-80.

Love, Tom. Object Lessons. SIGS Books, 588 Broadway #604, New York, NY
10012. $49.
This book eloquently elucidates the need for testing of object-
oriented code and has a chapter on how it was done at Stepstone
during the first release of their initial class library.

Marick, Brian. The Craft of Software Testing, Prentice-Hall, in press.
Makes the argument that testing of object-oriented software is
simply a special case of testing software which retains state
and which is reused. The author can be reached at
in...@testing.com.

Narick, Brian. "Testing Software that Reuses", Technical Note 2, Testing
Foundations, Champaign, Illinois, 1992. Copies may be obtainable
via email. The author can be reached at in...@testing.com.

Murphy, G.C., Wong, P. 1992, Towards a Testing Methodology for
Object Oriented Systems, M.P.R Teltech Ltd. A poster at the
Conference on Object Oriented Programming Systems, Languages
and Applications ACM. Copies of this paper can be obtained
through town...@mprgate.mpr.ca.

Murphy, G. and P. Wong. Object-Oriented Systems Testing Methodology: An
Overview. Techical Report TR92-0656, MPR Teltech Ltd., October
1992.

Perry, D.E. and G.E. Kaiser, "Adequate Testing and Object-Oriented
Programming", Journal of Object-Oriented Programming,
2(5):13-19, Jan/Feb 1990.

Purchase, Jan A. and Russel L. Winder, "Debugging tools for
object-oriented programming", Journal of Object-Oriented
Programming, June, 1991, Vol. 4, No. 3, pp. 10 - 27.

Smith, M. D. and D. J. Robson, " A Framework for Testing Object-Oriented
Programs", JOOP, 5(3):45-53, June 1992.
Describes ways in which the usual approach to software testing
could be adapted for object-oriented software.
This paper, or one with the same title and authors, is
available by anonymous ftp from vega.dur.ac.uk as
"/pub/papers/foot.dvi".

Smith, M. D. and D. J. Robson, "Object-Oriented Programming - the
Problems of Validation", Proceedings of the 6th International
Conference on Software Maintenance 1990, IEEE Computer Society
Press, Los Alamitos, CA., pp. 272-281.

Taylor, David. "A quality-first program for object technology", Object
Magazine, Vol. 2, No. 2, July-August 1992, pp17-18. SIGs
Publications. The article talks some about why testing is
important for OOP and describes one quality program.

Theilen, David. "No Bugs. Delivering error free code in C and C++.",
Addison-Wesley, 1992, ISBN:0-201-60890-1.

Turner, C. D. and D. J. Robson, "The Testing of Object-Oriented Programs",
Technical Report TR-13/92, Computer Science Division, School of
Engineering and Computer Sciences (SECS), University of Durham,
England.
Includes a survey of existing literature on testing of OO
programs. Testing of OOP is compared with traditional software
testing. A state-based approach is described.
This paper is available by anonymous ftp from vega.dur.ac.uk in
/pub/papers. Get "toop.ps.Z" for A4 paper and "toopus.ps.Z" for
US letter paper formatting.

Turner, C. D. and D. J. Robson, "A Suite of Tools for the State-Based
Testing of Object-Oriented Programs", Technical Report
TR-14/92, Computer Science Division, School of Engineering and
Computer Science (SECS), University of Durham, Durham,
England. Describes a series of tools for the generation and
execution of test cases for OOP. These tools assume a
state-based testing approach.
This paper is available by anonymous ftp from vega.dur.ac.uk in
/pub/papers. Get "tools.ps.Z" for A4 paper formatting or get
"toolsus.ps.Z" for US letter formatting.

Turner, C. D. and D. J. Robson, "Guidance for the Testing of Object-
Oriented Programs", Technical Report TR-2/93, Computer Science
Division, School of Engineering and Computer Science (SECS),
University of Durham, Durham, England. Discusses different
methods of making class declarations and the implications of
those methods for testing.
This paper is available by anonymous ftp from vega.dur.ac.uk in
/pub/papers. Get "guide.ps.Z" for A4 paper formatting or get
"guideus.ps.Z" for US letter formatting.

Turner, C. D. and D. J. Robson, "State-Based Testing and Inheritance",
Technical Report TR-1/93, Computer Science Division, School of
Engineering and Computer Science (SECS), University of Durham,
Durham, England.
Discusses the implications of inheritance for testing,
particularily incremental testing.
This paper is available by anonymous ftp from vega.dur.ac.uk in
/pub/papers. Get toopinht.ps.Z" for A4 paper formatting or get
"toopinhtus.ps.Z" for US letter formatting.

Wong, P. Automated Class Exerciser (ACE) User's Guide. Technical
Report TR92-0655, MPR Teltech Ltd., September 1992.

> Courses

Berard Software Engineering, Inc. teaches a seminar on Testing of
Object-Oriented Software (TOOS). The next one scheduled that I know of
is November 8-12, in Washington. Call 301-417-9884 for details.

Quality Fractals, Inc. has a course called "Testing Object-Oriented
Software". Contact: 508-359-7273 (Box 337, Medfield, MA 02052). The
course is taught by Shel Siegel of YESS!, Inc. Contact: 916-944-1032.


> Software

There is a smalltalk class library in the Univ. of Illinois archives
which includes a simple Tester class written by Bruce Samuelson
(br...@utafll.uta.edu). It is a general superclass for application
specific classes that test non-interactive objects such as trees,
collections, or numbers. It is not suitable for testing user interface
components such as windows, cursors, or scroll bars. The filein
includes Tree classes, Tester itself, and subclasses of Tester that are
used to validate the Tree classes. For ParcPlace Smalltalk (ObjectWorks
4.1 and VisualWorks 1.0). To get it ftp the file
"/pub/st80_vw/TreeLW1.1" from st.cs.uiuc.edu.

IPL Ltd. (in the UK) has a testing tool called Cantata which allows for
testing C++, but as far as I am able to determine, it has no special
features for C++ testing. From the product literature:
Cantata allows testing to be performed in an intuitive way
making the tool exceptionally easy to use and productive in
operation. Cantata is suitable for testing software written in
either C or C++.

Cantata provides comprehensive facilities for all forms of
dynamic testing, including: functional testing, structural
testing, unit testing and integration testing. Cantata has been
specifically designed to operate in both host and target
systems and so allow full portability of tests between these
environments.
For more information contact IPL:
IPL Ltd.
Eveleigh House, Grove Street,
Bath BA1 5LR
UK
(0225) 444888
(0225) 444400 (FAX)
email: sh...@iplbath.demon.co.uk

TestCenter from CenterLine will do coverage testing of C++ (and C)
code. Also does some memory debugging (similar to Purify) and regression
testing. Highlights from CenterLine literature:
*Automatic run-time error-checking on executables to enhance quality
*Automatic memory leak detection on executables to optimize memory use
*Graphical test coverage to highlight any code not executed during test runs
*Intuitive GUI for easy test analysis
*Programmatic interface to output files and cumulative code coverage
to support batch-mode and regression testing
*No recompilation needed, resulting in quick turnaround
*Complete C and C++ language support
*Integration with leading programming tools for maximum productivity gains

MicroTech Pacific Research (mpr.ca) has a C++ class testing tool called
ACE (Automated Class Exerciser) which is available under non-disclosure
agreement. It is not currently for sale. If you are interested,
contact Paul Townsend, town...@mprgate.mpr.ca.

Software Research Inc. (625 Third St, San Francisco, CA 94107-1997,
voice: 1-415-957-1441, email: in...@soft.com) has a coverage tool for C++
that is called tcat++. It is an extension of SRI's tcat program.

Quality Assured Software Engineering (938 Willowleaf Dr., Suite 2806,
San Jose, CA 95128, voice: 1-408-298-3824 ) has a coverage tool for
C and C++ called MetaC. It also dones some syntax checking and memory
allocation checking.

A group of volunteers is building a C++ test harness for the automated
testing of C++, C and Perl programs. The system is called ETET (Extended
Test Environment Toolkit). To join the group of volunteers, send email to
etet_s...@uel.co.uk
The software is available via anonymous FTP from bright.ecs.soton.ac.uk
(152.78.64.201) as "/pub/etet/etet1.10.1.tar.Z". They are looking for
other FTP sites - sned email to the above address if you can provide
one. This is a beta release and _should_ compile on any POSIX.1 system.
As much of this work is being done by SunSoft, my guess is that the
software will have the fewest problems on SunOS or Solaris releases.

> ACKs

Thanks to the following for helping assemble this list:
Benjamin C. Cohen, bco...@scdt.intel.com
Brian Marick, mar...@hal.cs.uiuc.edu
Bruce Samuleson, br...@utafll.uta.edu
Daniel M. Hoffman, dhof...@uvunix.uvic.ca
Edward Klimas, ac...@cleveland.freenet.edu
John Graham, J.Gr...@axion.bt.co.uk
Jim Youlio, j...@bse.com
Jeffery Brown, jeffre...@medtronic.com
Lars Jonsson, kon...@etna.ericsson.se
Manfred Scheifert, ch_s...@rcvie.co.at
Mark Swanson, mswa...@mechmail.cv.com
Mary L. Schweizer, ma...@gdwest.gd.com
Michael Einkauf, Michael...@iegate.mitre.org
Paul Townsend, town...@mprgate.mpr.ca
Phyllis G. Frankl, pfr...@polyof.poly.edu
Rachel Harrison, r...@ecs.soton.ac.uk
Risto Hakli, r...@tko.vtt.fi
Russ Hopler, ru...@bse.com
Stephane Barbey, bar...@di.epfl.ch
Tony Reis, to...@hpsadln.sr.hp.com
Yawar Ali, ya...@bnr.ca


3.12) What Distributed Systems Are Available?
---------------------------------------------

The following post helps to provide some answers with at least a partial list.
See also Appendix E.

From: rma...@bcsaic.boeing.com (Bob Marcus)
Newsgroups: comp.object,comp.client-server
Subject: Distributed Computing Products Overview
Date: 17 Sep 93 00:02:40 GMT
Organization: Boeing Computer Services

DISTRIBUTED COMPUTING PRODUCTS OVERVIEW

There was a recent posting concerning the relationship between OMG's CORBA
and Distributed Transaction Processing Monitors. In general, there is a lot of
uncertainty as to how the various distributed computing tools, products and
environments might work together. Below is the outline of an eight-page
posting to the Corporate Facilitators of Object-Oriented Technology (CFOOT)
mailing list addressing these issues. Let me know if you would like a copy
of the posting and/or to be added to the CFOOT mailing list.

Bob Marcus
rma...@atc.boeing.com
-----------------------------------------------------------------------
SOME GENERAL REFERENCES FOR ADDITIONAL INFORMATION
-----------------------------------------------------------------------
MULTIPROTOCOL NETWORK TRANSPORTS

Peer Logic (PIPES)
ATT (Transport Layer Interface)
-----------------------------------------------------------------------
MICROKERNELS

OSF(Mach)
Chorus Systems (Chorus)
Microsoft (NT)
-----------------------------------------------------------------------
REMOTE PROCEDURE CALLS

NobleNet (EZ-RPC)
Netwise (Netwise-RPC)
ATT/Sun (TI-RPC)
OSF (DCE/RPC)
-----------------------------------------------------------------------
CONVERSATIONAL PROGRAMMING

IBM(Common Programming Interface-Communications)
-----------------------------------------------------------------------
MESSAGING PRODUCTS

System Strategies/IBM (MQ Series)
Horizon Strategies (Message Express)
Covia Systems(Communications Integrator)
Momentum Software(X-IPC)
Creative System Interface (AAI)
Digital (DECmessageQ)
HP (Sockets)(BMS)
IBM (DataTrade)(DAE)
Suite Software (SuiteTalk)
Symbiotics (Networks)
-----------------------------------------------------------------------
PUBLISH AND SUBSCRIBE MESSAGING

Sun(Tooltalk)
Teknekron (Teknekron Information Bus)
ISIS(Distributed News)
Expert Database Systems (Rnet)
----------------------------------------------------------------------
DISTRIBUTED COMPUTING ENVIRONMENTS

OSF/DCE
ISIS(Distributed Toolkit)
-----------------------------------------------------------------------
TRANSACTION PROCESSING MANAGERS

Unix Systems Lab (Tuxedo)
Information Management Company (Open TransPort)
NCR (TopEnd)
Transarc (Encina)
IBM/HP/Transarc (Open CICS)
-----------------------------------------------------------------------
DISTRIBUTED WORKSTATION EXECUTION SYSTEMS

Aggregate Systems (NetShare)
Platform Computing(Utopia)
ISIS(Resource Manager)
-----------------------------------------------------------------------
OBJECT REQUEST BROKERS

Hyperdesk (Distributed Object Manager)
IBM Distributed System Object Model(DSOM)
Microsoft (Distributed OLE)
Iona Technologies Ltd. (Orbix)
BBN (Cronus)
ISIS (RDOM)
Qualix (NetClasses)
Symbiotics (Networks!)
Digital(ACA Services)
Object-Oriented Technologies (SuiteDOME)
-----------------------------------------------------------------------
SYSTEM MANAGEMENT

OSF (Distributed Management Environment)
Legent
Digital Analysis (HyperManagement)
-----------------------------------------------------------------------
DISTRIBUTED DEVELOPMENT/EXECUTION PRODUCTS

Texas Instruments (Information Engineering Facility)
HP (SoftBench)
Digital (COHESIONworX)
-----------------------------------------------------------------------
DISTRIBUTED DEVELOPMENT/EXECUTION PRODUCTS

Independence Technologies (iTRAN)
Intellicorp(Kappa)
ISIS Distributed Systems (RDOM)
Early, Cloud & Company (Message Driven processor)
Expersoft(XShell)
Cooperative Solutions(Ellipse)
-----------------------------------------------------------------------


3.13) What Is The MVC Framework?
--------------------------------

MVC stands for Model-View-Controller. This framework was originally adopted
in Smalltalk to support Graphical User Interfaces. Views support graphical
interfacing, controllers handle interaction, and models are the application
objects. See [Krasner 88] and [LaLonde 90b].

From: Carl Petter Swensson <ce...@taskon.no>
Prof. Trygve Reenskaug is generally cited as being the creator of
the MVC concept. He worked with the Smalltalk group at Xerox PARC
as a visiting scientist in 78/79. During this stay at Xerox PARC
he developed the MVC. I know him well and have talked to him about
this. He confirms it, although stating that it was a collaborative
effort at Xerox PARC.

The implementation of MVC in Smalltalk-80 has since been further
developed by ParcPlace Systems.

He has worked with Smalltalk in a commercial and research
environments since then. His group at the Centre for Industral
Research in Oslo (now part of the SINTEF group) had the only
Smalltalk-78 implementation outside Xerox PARC. He is now working
with Taskon AS.

The ideas that initially gave MVC has been developed further and
is the basis of the work Trygve is currently doing on the
OOram methodology.


3.14) What is Real-Time?
------------------------

Real-time is our linear extrapolation/perception of imaginary time (along the
quantum wave function (OTU) in ten dimensions, of course).

[This section is YTBI]


3.15) What Is Available on OO Metrics?
--------------------------------------

This section is still building.

http://www.sbu.ac.uk/~csse/publications/OOMetrics.html

[Berard 93] contains an elaborate bibliography and section on OO metrics.
[Booch 94] also contains some coverage.

Also:
Object Oriented Software development
Mark Lorenz ISBN 0-13-726928-5
Prentice Hall

Software Metrics
Grady-Caswell ISBN 0-13-821844-7
Prentice Hall

Measuring Software Design Quality
Card-Glass ISBN 0-13-568593-1
Prentice Hall


From: tr...@informatik.tu-muenchen.de (Joern Trilk)
Newsgroups: comp.object,comp.lang.c++,comp.lang.smalltalk,comp.databases.object
Subject: Re: In search of OO Metrics
Date: 20 Jun 1994 14:29:27 GMT
Organization: Technische Universitaet Muenchen, Germany

>...
Here are some references:

@article{inheriting:1993,
author = {G. Michael Barnes and Bradley R. Swim},
title = {Inheriting software metrics},
journal = {JOOP},
year = {1993},
month = {Nov./Dec.},
volume = {6},
number = {7},
pages = {27-34}
}


@article{a-new-metr:1993,
author = {J.-Y. Chen and J.-F. Lu},
title = {A new metric for object-oriented design},
journal = {Information and Software Technology},
year = {1993},
month = apr,
volume = {35},
number = {4},
pages = {232-240}
}


@inproceedings{towards-a-:1991,
author = {Shyam R. Chidamber and Chris F. Kemerer},
title = {Towards a Metrics Suite for Object Oriented Design},
booktitle = {OOPSLA '91 Proceeedings},
year = {1991},
pages = {197-211}
}


@inproceedings{software-m:1992,
author = {J. Chris Coppick and Thomas J. Cheatham},
title = {Software Metrics for Object-Oriented Systems},
booktitle = {CSC '92 Proceedings},
year = {1992},
pages = {317-322}
}


@inproceedings{some-metri:1991,
author = {B. Henderson-Sellers},
title = {Some metrics for object-oriented software engineering},
booktitle = {TOOLS Proceedings},
year = {1991},
pages = {131-139}
}


@article{object-ori:1993,
author = {Wei Li and Sallie Henry},
title = {Object-Oriented Metrics that Predict Maintainability},
journal = {J. Systems Software},
year = {1993},
volume = {23},
pages = {111-122}
}


@inproceedings{workshop-r:1992,
author = {Teri Roberts},
title = {Workshop Report - Metrics for Object-Oriented Software Development},
booktitle = {OOPSLA '92 (Addendum to the Proceedings)},
year = {1992},
pages = {97-100}
}


@techreport{softwareme:1991,
author = {A. Buth},
title = {Softwaremetriken f{\"u}r objekt-orientierte Programmiersprachen}, institution = {Gesellschaft f{\"u}r Mathematik und
Datenverarbeitung},
year = {1991},
month = jun,
number = {545},
type = {Arbeitspapiere der GMD}
}


The Software Engineering FAQ lists the following references concerning
metrics for object-oriented systems:

Date: 26 Jan 1993 Originally collected by: ZUSE%DB0TUI1...@vm.gmd.de
(Horst Zuse)

a. Morris Kenneth L. Metrics for Object-Oriented Software Development
Environments (master's thesis). 1989, MIT.
b. Rocacher, Daniel: Metrics Definitions for Smalltalk. Project ESPRIT 1257,
MUSE WP9A, 1988.
c. Rocacher, Daniel: Smalltalk Measure Analysis Manual. Project ESPRIT 1257,
MUSE WP9A, 1989.
d. Lake, Al: A Software Complexity Metric for C++. Annual Oregon Workshop on
Software Metrics, March 22-24, 1992, Silver Falls, Oregon, USA.
e. Bieman, J.M.: Deriving Measures of Software Reuse in Object Oriented
Systems. Technical Report #CS91-112, July 1991, Colorado State Universty,
Fort Collins/ Colorado, USA.

Hope this helps,
Joern

----------------------------------------------------------------------
Joern Trilk Phone: ++49-89-2105-2391
Institut fuer Informatik (H1) Fax: ++49-89-2105-5296
TU Muenchen Email: tr...@informatik.tu-muenchen.de
80290 Muenchen
----------------------------------------------------------------------


Newsgroups: comp.software-eng
From: sco...@advsysres.com (Scott A. Whitmire)
Subject: Re: Any good OO metrics?
Organization: Advanced Systems Research
Date: Mon, 28 Nov 1994 05:58:29 GMT

In <3baqhn$c...@newsbf01.news.aol.com>, cjda...@aol.com (Cjdavies) writes:
>Has anyone come up with metrics that work realistically for OO
>development? The old lines of code, cyclomatic complexity and Halstead
>metrics don't work so well with OO languages such as Smalltalk (or any
>language that facilitates reuse). Also, has anyone adapted function
>points to OO languages? Any ideas would be most welcome.
>Thanks,
>Colin Davies.

Several people have been working in metrics for oo development. For a quick
synopsis, check out my article in the "Encyclopedia of Software Engineering"
edited by John Marciniak and published by John Wiley & Sons. The article
gives an overview of the work being done in the field, and what needs to be
done. It is a couple of years old now, but there really isn't that much going
on.

I did run into one book called "Object-Oriented Software Metrics" (I forget the
authors), but I didn't think much of it.

Your assessment of LOC, cyclomatic complexity, and Halsted are right on the
money.

As for function points and OO, I think you'll find two papers useful. The first
is a chapter I wrote for the "Software Engineering Productivity Handbook" edited
by Jessica Keyes and published by McGraw-Hill. It applies standard function points
to OO software. I suspect you'll find standard function points wanting. I use
an extension I developed a couple of years ago called 3D function points. I have
an electronic (plain text) version of the paper I can send if you like.

Metrics and OO development are fairly new to each other. I am working on ways to
measure such design characteristics as cohesion, coupling, complexity, similarity
and the like. I haven't been too thrilled with the work that has been done so far.
Much of it has serious theoretical and technical flaws.

Scott A. Whitmire sco...@advsysres.com
Advanced Systems Research
25238 127th Avenue SE tel:(206)631-7868
Kent Washington 98031 fax:(206)630-2238

Consultants in networking, network-based applications, and software metrics.


3.16) What Are Visual Object-Oriented Programming Systems?

See also http://union.ncsa.uiuc.edu/HyperNews/get/computing/visual.html.
There is also a comp.lang.visual and FAQ, similar to the www html above.

Visual programming is the use of graphics and graphical techniques in
computer programming. It is becoming more common to see many
approaches to visual/graphical programming languages emerging that
incorporate the object-oriented programming philisophy. Toward this
end, developers of new programming languages and programming
environments are exploring how to combine visual programming with
object-oriented programming by investigating how the basic concepts of
OOP -- data abstraction, instantiation, composition, and
specialization -- create new opportunities for programming using
visual means of construction.

A workshop on this topic was conducted at the 1993 OOPSLA, and a
workshop summary appeared as part of the 1993 OOPSLA Addendum. Several
of the presenters at the workshop developed full versions of their
presentations, which are available in book form:

Visual Object-Oriented Programming: Concepts and Environments,
Margaret Burnett, Adele Goldberg, and Ted Lewis, editors,
Prentice-Hall/Manning Publications, Englewood Cliffs, NJ, 1995.

http://www.cs.orst.edu/techpub/vlib/vlib/Visual-OOP/CARD.html

-----
Margaret Burnett . e-mail: bur...@cs.orst.edu
Assistant Professor . WWW page: http://www.cs.orst.edu/~burnett/
Computer Science Dept. .
Oregon State University .
Corvallis, Oregon 97331 USA .


3.17) What Tutorials Are Available On Object-Oriented Concepts and Languages?

Date: Thu, 25 May 95 17:31:21 EDT
From: whe...@ida.org (David Wheeler)

A list of C/C++ tutorials, including online tutorials, is maintained at:
http://vinny.csd.mu.edu/learn.html

Note that C and C++ are treated together. One of the tutorials listed is the
course: "Introduction to Object Oriented Programming Using C++", a self-paced
class within the Globewide Network Academy [GNA]; this course may be found at:
http://uu-gna.mit.edu:8001/uu-gna/text/cc/index.html

Another course listed is the Coronado Enterprises C++ Tutorial, which assumes
that the user is already familiar with C (not necessarily ANSI C). It may be
downloaded from:
anon...@oak.oakland.edu:simtel/msdos/cpluspls/cptuts22.zip
anon...@oak.oakland.edu:simtel/msdos/cpluspls/cptutt22.zip

One Ada 95 on-line tutorial is Lovelace, which is intended for those who are
already familiar with other algorithmic programming languages and are somewhat
familiar with object orientation. Lovelace is available at:
anon...@lglftp.epfl.ch:/pub/Ada/HTML/lovelace.zip
http://lglwww.epfl.ch/Ada/Tutorials/Lovelace/lovelace.html

Other Ada tutorials are listed in:
http://lglwww.epfl.ch/Ada/Tutorials/Lovelace/othert.html

The Sather home page includes a list of Sather tutorials in its "Getting
Started" section:
http://http.icsi.berkeley.edu/Sather/

The BETA language is introduced in:
http://www.daimi.aau.dk/~beta/Tutorials/BETAintroduction/BETAintroduction.html

A large list of SELF-related papers available electronically is at:
http://self.stanford.edu/papers/papers.html

The Booch design method is briefly described in
http://www.itr.ch/tt/case/BoochReferenz/

For a list of many different resources of computer-language-specific
information, see the YAHOO list of computer languages at:
http://www.yahoo.com/Computers/Languages/


SECTION 4: COMMONLY ASKED LANGUAGE SPECIFIC QUESTIONS
======================================================

4.1) What is Downcasting?
--------------------------

Downcasting is 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, although the proposed RTTI will perform checked downcasting as
its primary ability.


4.2) What are Virtual Functions?
---------------------------------

Look under "Dynamic Binding" and "Polymorphism".


4.3) Can I Use Multiple-Polymorphism Or 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 emulating
multiple-polymorphism [See Coplien 92].

For true CLOS multi-methods, the above technique implemented as a base function
(CLOS defgeneric), switching to specialized functions (CLOS methods, made
friends of all arguments) will provide the functional calling syntax, multiple-
polymorphism and access to parameters found in CLOS. This can require some
complex switching, which is somewhat mitigated when multiple-polymorphism
is implemented with virtual functions.

Future FAQs should contain more detail.


4.4) Can I Use Dynamic Inheritance In C++?
-------------------------------------------

Yes, [Coplien 92] describes a scheme where a class can contain a pointer to
a base class that can switch between its derived classes, providing a limited
form. Earlier chapters contain entries on bypassing C++'s message system and
even bypassing static linking.

Future FAQs should contain more detail.

ANNOTATED BIBLIOGRAPHY
======================

[Agrawal 91] R. Agrawal et al. "Static Type Checking of Multi-Methods".
OOPSLA 91. Object-Oriented Programming Systems, Languages, and Applications.
ACM Press. Addison Wesley.

Compile-time checking and optimizations for multi-methods.

[Aho 86] Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. Compilers:
Principles, Techniques, and Tools. Reading, MA: Addison-Wesley, 1986.

Authoritative, classic book on compilers and optimizations. Type chapter
contains section on type inferencing (using ML as an example).

[Berard 93] Edward V. Berard. Essays on Object-Oriented Software
Engineering. Prentice Hall.

Many topics on OOSE, includes coverage of OO domain and requirements
analysis.

[Black 86] A. Black et al. Object-Structure in the Emerald System. OOPSLA
'86 Conference Proceedings, SIGPLAN Notices (Special Issue), Vol. 21, n0. 11,
pp 78-86. [I believe there is a more recent article, YTBI]

The original article on Emerald. OO language without inheritance but with
abstract types and static subtype polymorphism. Also designed for
distributed programming and reuse. See article for references: Jade on
reuse [Raj 89]) and Distr. Prog.

[Black 87] A. Black, N. Hutchinson, E. Jul, H. Levyand L. Carter. Distribution
and Abstract Types in Emerald, IEEE Transactions on Software Engineering, Vol.
SE13, no. 1 Jam., pp 65-76.

Subtype polymorphism for distributed programming in Emerald [Black 86].

[Blair 89] "Genericity vs Inheritance vs Delegation vs Conformance vs ..."
Gordon Blair, John Gallagher and Javad Malik, Journal of Object Oriented
Programming, Sept/Oct 1989, pp11-17.

Recommended by a reader, but the Author has yet to review this article.

[Boehm 86] B.W. Boehm. A Spiral Model of Software Development and Enhancement.
Software Engineering Notes, Aug., vol. 11 (4), p 22.

Presents an alternative evolutionary approach to the strict waterfall software
engineering life-cycle. Now a classic, most OO methodologies now emphasize
the iterative or evolutionary approach to software development.

[Booch 87] Grady Booch. Software Engineering with Ada. 2nd Ed. Benjamin
Cummings.

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

[Booch 87b] Grady Booch. Software Components With Ada, Structures, Tools,
and Subsystems. Benjamin Cummings.

A taxonomy and collection of object-based components in Ada (includes code).
Has many examples with generics.

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

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.

[Booch 94] Grady Booch. Object-Oriented Analysis And Design With
Applications, 2nd Ed. Benjamin Cummings. ISBN 0-8053-5340-2.

The next FAQ should be updated to the second edition. All examples are now
in C++. Booch incorporates several other major methodologies including
Wirf-Brock's CRC (Class-Responsibility-Collaboration) and Jacobson's Use-
Cases.

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

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

[Chambers 92] Craig Chambers. The Design and Implementation of the SELF
Compiler, an Optimizing Compiler for Object-Oriented Programming Languages.
Dept of Computer Science, Stanford University, March 1992.

Covers type optimizations for OO compilers. See Appendix E, PAPERS.

[Chambers 93] Craig Chambers. Predicate Classes. Proceedings ECOOP '93
O. Nierstrasz, LNCS 707. Springer-Verlag, Kaiserslautern, Germany
July 1993 pp 268-296

"... an object is automatically an instance of a predicate class whenever
it satisfies a predicate expression associated with the predicate class.
The predicate expression can test the value or state of the object, thus
supporting a form of implicit property-based classification that augments
the explicit type-based classification provided by normal classes. By
associating methods with predicate classes, method lookup can depend not
only on the dynamic class of an argument but also on its dynamic value or
state. [...] A version of predicate classes has been designed and
implemented in the context of the Cecil language.

See Appendix E, PAPERS.

[de Champeaux 93] Dennis de Champeaux, Doug Lea, Penelope Faure.
Object-Oriented System Development. Addison-Wesley, ISBN 0-201-56355-X.

Covers an integrated treatment of OOA and OOD. Takes serious the
computational model of one thread per object. Gives more than usual
attention to the OOA&D micro process. Presents a unique OOD language.

[Coad 91] Peter Coad and Edward Yourdon. Object-Oriented Analysis, 2nd ed.
Englewood Cliffs, NJ. Prentice Hall.

Coad and Yourdon's OO analysis method.

[Coad 91b] Peter Coad and Edward Yourdon. Object-Oriented Design. Englewood
Cliffs, NJ. Prentice Hall.

Coad and Yourdon's OO design method.

[Coleman 94] Derek Coleman, et. al. Object-Oriented Development - The Fusion
Method. Prentice-Hall Object-Oriented Series. ISBN 0-13-338823-9

Fusion is considered to be a second generation OOAD method in that it builds
on successful components of a number of first generation methods (OMT, Booch,
CRC, Objectory, etc). However, this has been done with the requirements of
industrial software developers in mind. And so issues of traceability,
management etc. have been taken into consideration and the Method provides
full coverage from requirements through to code.

[Cook 90] W.R. Cook, W.L.Hill, P.S. Canning. Inheritance Is Not Subtyping.
Appeared in [Hudak 90] and Gunter 94].

Theoretical article on the separation between type and class, or as the
authors state between implementation inheritance and subtyping.

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

Covers advanced C++ programming and performing other more advanced and
dynamic styles of OO in C++.

[Colbert 89] E. Colbert. The Object-Oriented Software Development Method: a
practical approach to object-oriented development. Tri-Ada Proc., New York.

Presents the Object-Oriented Software development method. Has emphasis on
objects.

[Cox 86,91] 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.

Objective-C... '91 AW by Pinson and Wiener provide another good text.

[Embley 92] D.W. Embley, B.D. Kurtz, S.N. Woodfield. Object-Oriented Systems
Analysis, A Model-Driven Approach. Yourdon Press/Prentice Hall, Englewood
Cliffs, NJ.

Presents the Embley and Kurtz OO methodology.

[Garfinkel 93] Simson L. Garfinkel and Michael K. Mahoney. NeXTSTEP
PROGRAMMING STEP ONE: Object-Oriented Applications. Springer-Verlag.

Introduction to the NextStep environment and applications development.

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

The original book on Smalltalk. Covers implementation. Also known as "the
Blue Book". Out of print. Superceded by [Goldberg ??].

[Goldberg ??] Adele Goldberg and David Robson. Smalltalk-80: The Language.
Addison-Wesley.

The "Purple Book". Omits the obsolete abstract virtual machine description
from the Blue Book.

[Gunter 94] Carl A. Gunter and John C. Mitchell. Theoretical Aspects of Object-
Oriented Programming. MIT Press. ISBN 0-262-07155-X.

Highly mathematical, formal coverage of object-oriented programming;
primarily on typing.

[Harmon 93] Paul Harmon. Objects In Action: Commercial Applications Of Object-
Oriented Technologies. Jan, 1993. A-W ISBN 0-201-63336-1.

Sponsored by the OMG to summarize the use of OO technology in industry and
business, contains a brief history and summary of OO and many case studies.

[HOOD 89] HOOD Working Group. HOOD Reference Manual Issue 3.0. WME/89-173/JB.
Hood User Manual Issue 3.0. WME/89-353/JB. European Space Agency.

Presnets the HOOD (Hierarchical Object-Oriented Design) OOSE methodology.
From the European Space Agency. Based on Ada and object-based.

[Hudak 90] P. Hudak. Principles of Programming Languages. ACM Press, pp 125
-135.

Contains several articles, including [Cook 90].

[Hudak 92] Paul Hudak and Simon Peyton Jones. Haskell Report. SIGPLAN Notices.
1992, vol 27, no 5.

Haskell reference.

[Humphrey 89] Watts Humphrey. Managing the Software Process. Addison Wesley.
ISBN 0-201-18095-2

Sponsored by the Software Engineering Institute (SEI), the presented project
management model is inspired by the work of Boehm, Brooks, Deming and Juran
and represents a strong step in the direction of achieving 6 sigma defect
rate prevention and optimizing the software development process for quality,
productivity, and reliability. Presents the CMM, see section 1.21.

[Humphrey 95] Watts S. Humphrey - "A Discipline for Software Engineering",
816 pp., $47.50, 1995, Addison-Wesley (1-800-824-7799) ISBN 0-201-54610-8

A scaled down version of [Humphrey 89] for individual software engineers.
A new classic. See section 1.21.

[IBM 90,91] Various Documents from the IBM International Technical Centers:
GG24-3647-00, GG24-3641-00, GG24-3566-00, GG24-3580-00.

Present IBM's OOSE methodology.

[ISO] ISO Standards Compendium - ISO 9000 Quality Management, 5th edition. Switzerland.
ISBN 92-67-10206-0.

The complete standard. 9000-3 discusses software and 9004 is a quality management
standard.

[Jacobson 92] Ivar Jacobson, et al. Object-Oriented Software Engineering - A
Use Case Driven Approach. ACM Press/Addison Wesley.

Presents Jacobson's new OOSE methodology based on use cases.

[Jacobson 94] Ivar Jacobson. Toward Mature Object Technology. ROAD, Vol. 1,
No. 1, May-June. SIGS Publications.

Overview of OOSE's object-oriented approach. Includes specialized objects
and layering for complexity management.

[Jones 92] Rick Jones. Extended type checking in Eiffel. Journal of Object-
Oriented Programming, May 1992 issue, pp.59-62.

Presents subtype polymorphic extension to Eiffel (static typing only).

[Jurik 92] John A. Jurik, Roger S. Schemenaur, "Experiences in Object Oriented
Development," ACM 0-89791-529-1/92/0011-0189.

Presents the EVB OOSE methodology. Also: Barbara McAllister, Business
Development, EVB Software Engineering, Inc., (301)695-6960, ba...@evb.com.

[Kiczales 92] Gregor Kiczales, Jim des Rivieres, Daniel G. Bobrow. The Art
of the Metaobject Protocol. The MIT Press.

Reflection and Metaobject Protocols (MOPs). Uses a CLOS subset, Clossette,
as a foundation.

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

Collection of articles on advanced OO and research systems.

[Krasner 88] G. E. Krasner and S. T. Pope. A Cookbook for Using the Model-View-
Controller User Interface Paradigm in Smalltalk-80. JOOP, vol 1, no 3, August/
September, 1988, pp 26-49,

An early paper published on MVC.

[Lakoff 87] George Lakoff. Women, Fire, and Dangerous Things: What Categories
Reveal About The Mind. UOC Press.

An almost formal view of classification/categorization by the noted cognitive
scientist, George Lakoff. His view blasts objectivism and contends to
replace it with a subjectivist view, based on a study of humans, natural
language, and concept formation.

[LaLonde 90] Wilf R. LaLonde and John R. Pugh. Inside Smalltalk: Volume 1.
Prentice Hall.

Good introduction to Smalltalk.

[LaLonde 90b] Wilf R. LaLonde and John R. Pugh. Inside Smalltalk: Volume 2.
Prentice Hall.

Excellent coverage of MVC. However, it's based on ParcPlace Smalltalk-80,
version 2.5, which is obsolete.

[Liskov 93] Barbara Liskov and Jeannette M. Wing. Specifications and Their use
in Defining Subtypes. OOPSLA 93, pp 16-28. ASM SIGPLAN Notices, V 28, No 10,
Oct. 1993. A-W ISBN 0-201-58895-1.

Specifications on Subtype hierarchies. Helps to insure the semantic
integrity of a separate subtype system. See section 2.7.

[Madsen 93] Ole Lehrmann Madsen, Birger Moller-Pedersen, Kristen Nygaard:
Object-oriented programming in the BETA programming language. Addison-Wesley,
June 1993. ISBN 0 201 62430 3

The new and authoritative book on BETA, by the original designers. They
are some of the same designers of the Simula languages, originating OO.
Also just announced:
Object-Oriented Environments: The Mjolner Approach
Editors: Jorgen Lindskov Knudsen, Mats Lofgren, Ole Lehrmann Madsen,
Boris Magnusson
Prentice Hall: The Object-Oriented Series
ISBN: 0-13-009291-6 (hbk)

[Martin 92] James Martin and James J. Odell. Object-Oriented Analysis and
Design, Prentice-Hall, Englewood Cliffs, NJ.

Its primary purpose is to indicate how information engineering (IE) can be
evolved to accommodate OO. The analysis portion (starting at Chapter 15)
attempts to go back to 'first principles' and is based on a formal foundation.
Therefore, the IE aspect is not required. Emphasis is more on analysis than
design.

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

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


[Meyer 92] Bertrand Meyer. Eiffel: The Language. Prentice Hall. Englewood
Cliffs, NJ. 1992.

The definitive book on Eiffel by its author.

[Meyer 94] Bertrand Meyer. Reusable Software: The Base Object-Oriented
Components Libraries.

The new Eiffel class Libraries.

[Mugridge 91] Warwick B. Mugridge et al. Multi-Methods in a Statically-Typed
Programming Language. Proc. ECOOP.

Efficient implementation of Multi-Methods.

[Murray 93] Robert B. Murray. C++ Strategies and Tactics. Addison Wesley.

C++, has template examples.

[Nerson 92] Jean-Marc Nerson. Applying Object-Oriented Analysis and Design.
CACM, 9/92.

Demonstrates the basics of the BON method/notation. Nerson: ma...@eiffel.fr

[Paepcke 93] Andreas Paepcke. Object-Oriented Programming: The CLOS
Perspective. MIT Press. ISBN 0-262-16136-2.

CLOS, readable introduction to its metaobject protocol, comparisons with
other languages, uses and methodology, and implementation. Develops a
persistent object metaclass example.

[Raj 89] R.K. Raj and H.M. Levy. A Compositional Model for Software Reuse.
The Computer Journal, Vol 32, No. 4, 1989.

A novel approach aading reuse to Emerald [Black 86] without inheritance.

[Reenskaug 91] T. Reenskaug, et al. OORASS: seamless support for the creation
and maintenance of object-oriented systems. Journal of Object-Oriented
Programming, 5(6).

Presents the Object-Oriented Role Analysis, synthesis, and Structuring
OOSE methodology.

[Reenskaug 95] T. Reenskaug, et al. WORKING WITH OBJECTS: The OOram Software
Engineering Method Manning ISBN: 1-884777-10-4, PH ISBN: 0-13-452930-8.
Accolades:
"...the authors take you on a journey through object techniques filled with
examples. You will come away from this book enriched, with a sound
understanding of OT-based abstractions for modeling programs."
Richard Mark Soley, OMG
"The first method that deals realistically with reuse, and one of the few
that comes close to describing what I do when I design."
Ralph Johnson, University of Illinois
"...the first complete account of role-based methods that have proven to be
a step forward in OO design and development."


[Rout 95] T.T. Rout. Ed. Software Process Assessment: Theory and Practice. Proceedings, 2nd
International SPICE Symposium. Australian Software Quality Research Institute, Brisbane,
Australia., June 1 - 2, 1995. ISBN 0 86857 676 X.

Excellent coverage of the new SPICE standard: history, present details, goals.

[Royce 70] W. W. Royce. Managing the Development of Large Software Systems.
Proceedings of IEEE WESCON, August 1970.

Introduces the Waterfall Process Model.

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

[Sciore 89] Edward Sciore. Object Specialization. ACM Transactions on
Information Systems, Vol. 7, No. 2, April 1989, p 103.

A hybrid approach between delegation and classical OO.

[Selic 94] Bran Selic, Garth Gullekson, and Paul T. Ward. Real-Time
Object-Oriented Modeling. Published by John Wiley & Sons.
ISBN 0-471-59917-4

OO method addresses complete lifecycle needs of real-time systems. Emphasizes
executable models for early validation of requirements, architecture, and
design combined with techniques for automatic generation of implementations.
Specifically real-time with iterative and incremental development process.
Single consistent graphical modeling concepts apply uniformly to OOA/D/I.

[Shlaer 88] Sally Shlaer and Stephen J. Mellor. Object-Oriented Systems
Analysis: Modeling the World in Data.

Credited as the first book proposing an OOA method.

[Shlaer 92] Sally Shlaer and Stephen J. Mellor. Object Lifecycles: Modeling
the World in States.

An addition to [Shlaer 88], provides dynamic modeling with a state-
transition driven approach.

[Strachey 67] C. Strachey. Fundamental Concepts in programming languages.
Lecture Notes for International Summer School in Computer Programming,
Copenhagen, Aug.

Contains original, classical definition of polymorphism.

[Stroustrup 90] 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. It is meant as
a reference (including for compiler writers), not as a tutorial for
beginners. Perhaps a better ref is [Stroustrup 91].

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part5
Last-Modified: 04/02/96
Version: 1.0.9

[Stroustrup 91] Stroustrup, B. The C++ Programming Language (2nd edition).

Has the ARM, better reference for the use of C++ (recommended by bs).
Contains sections on object-oriented software engineering.

[Tasker 93] Dan Tasker. The Problem Space, Practical Techniques for
Gathering & Specifying Requirements. ISBN: 0-646-12524-9. Avail only from
author, da...@swdev.research.otc.com.au.

Object-oriented requirements definition. Hypertext. Uses Rumbaugh's OMT as
a base. See also APPENDIX D.

[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. See also APPENDIX E, PAPERS section.

[Wasserman 90] A.I. Wasserman et al. The Object-Oriented Software Design
Notation for Software Design Representation. IEEE Computer, 23(3).

Presents the Object-Oriented Structured Design (OOSD) OOSE methodology.
Traditional structured techniques to OO, hybrid containing structured
design and Booch.

[Wegner 87] Peter Wegner. "Dimensions of Object-Based Language Design",
Proceedings of OOPSLA '87, October 4-8 1987, SIGPLAN Notices
(Special Issue), V22, No 12, pp168-182, 1987.

[Wikstrom 87] Ake Wikstrom. Functional Programming Using Standard ML.
Prentice Hall, ISBN 0-13-331661-0, 1987.

ML reference.

[Wilkie 93] George Wilkie. Object-Oriented Software Engineering - The
Professional Developer's Guide. Addison Wesley.

Covers OOSE, 11 popular analysis and design methodologies with examples,
comparisons, and analysis, information systems (OODB), and case studies.

[Winter Partners] Winter Partners

A proprietary toolset (OSMOSYS) for OOA and OOD.
Winter Partners
London Office: Zurich Office:
West Wing, The Hop Exchange
24a Southwark Street Florastrasse 44
London SE1 1TY CH-8008 Zurich
England Switzerland
Tel. +44-(0)71-357-7292 Tel. +41-(0)1-386-95 11
Fax. +44-(0)71-357-6650 Fax. +41-(0)1-386-95 00

[Wirfs-Brock 90] Rebecca Wirfs-Brock, Brian Wilkerson, Lauren Wiener.
Designing Object Oriented Software, Englewood Cliffs, NJ. Prentice Hall.

Presents a "Responsibility Driven Design" (RDD) with "Class, Responsibility,
Collaboration" (CRC) technique, a modern and new OOA/OOD methodology.

[Yaoqing 93] Gao Yaoqing and Yuen Chung Kwong. A Survey of Implementations
of Parallel, Concurrent, and Distributed Smalltalk. ACM SIGPLAN Notices.
Vol 28, No. 9, Sept 93.

Covers implementations of Parallel, Concurrent, and Distributed Smalltalk.

[Yourdon 92] Edward Yourdon. Decline and Fall of the American Programmer.
YPCS.

Excellent coverage of modern software engineering practice and world-class
software development organizations.

APPENDICES
==========


APPENDIX A VIPS
================

These are individuals whose names appear in comp.object most often.
Please send recommendations for *major* VIPS often cited or referenced.

Booch, Grady <e...@rational.com>
-------------------------------

Grady Booch has been an object- based/oriented advocate for some time. He's
written books such as Software Engineering with Ada [Booch 87], Software
Components with Ada [Booch 87b], and OOA/D with Applications [Booch 91, 94].
His latest notations are often referred to as simply the "Booch" method or
notation and he is Chief Scientist at Rational, a company providing training
and automated support for the method with a tool named "Rose" (See Appendix D).
The Booch method now incorporates many modern methods, including OMT, and Dr.
Rumbaugh has recently joined forces with Grady at Rational.


Cox, Brad
---------

Founder of Objective-C, which grafts the Smalltalk facilities of an
Object id and a messaging mechanism onto C. Author of [Cox 87].


Goldberg, Adele (Alan Kay, Dan Ingalls)
----------------------------------------

One of the founders of Smalltalk (with Alan Kay and Dan Ingalls). Coauthor
of [Goldberg 83, ??], "Smalltalk-80 The Language and its Implementation".
Smalltalk was invented by a group at Xerox PARC; and a spinoff, ParcPlace, is
now marketing Smalltalk environments (see APPENDIX C).


Meyer, Bertrand <bert...@eiffel.com>
-------------------------------------

Founder of Eiffel, author of [Meyer 88]. Often posts to comp.lang.eiffel
and comp.object [what a FAQ writer notices]. His company, Interactive
Software Engineering, has a case tool called EiffelCase (see APPENDIX D).


Nygaard, Kristen (and Dahl, Ole-Johan)
--------------------------------------

Inventor of Simula, the first object-oriented programming language. Also
inventor of object oriented design, for which Simula-67 was considered an
implementation technique. Now B.B. Kristensen, O.L. Madsen, B. Moller-
Pedersen, and K. Nygaard are working on BETA, their successor to Simula.


Rumbaugh, Dr. James
-------------------

Part of Rumbaugh, Blaha, Premerlani, Eddy and Lorenson, the authors of
[Rumbaugh 91]. They all work for GE Corporate Research and Development Center
in Schenectady New York (See below) and have an OOA/OOD notation/methodology
called the "Object Modeling Technique" (OMT). It is a rather formal and
complete method often discussed in comp.object. OMTool is the name of the
CASE system provided by Martin Marietta which supports OMT. See APPENDIX D.

Recently, Dr. Rumbaugh has joined forces with Chief Scientist Grady Booch at
Rational: Rumb...@rational.com


Shlaer, Sally (and Mellor, Stephen J.)
--------------------------------------

>Sally Shlaer sa...@projtech.com
>Project Technology Training and Consulting using Shlaer-Mellor OOA/RD
>Berkeley, CA (510) 845 1484
Also: st...@projtech.com

Cofounder of the Shlaer/Mellor OOA/RD method, president of Project Technology.
As shown above, occasionally posts to comp.object [what a FAQ writer notices].


Stroustrup, Bjarne (b...@alice.att.com)
-------------------------------------

Inventor of C++, a C superset, which has probably gained the most widespread
use of any object-oriented language today. Often found in comp.lang.c++ and
comp.object.


APPENDIX B OBJECT-ORIENTED DATABASES AND VENDORS
=================================================

This is a list of available Object-Oriented databases. Thanks go to Stewart
Clamen, who's survey on schema evolution provided a good start. The list
was updated March 1996 by Tim Harvey who keeps the mini-FAQ of object and
object-relational vendors for the sister News group comp.object.databases.

Additional short entries and corrections are encouraged; please send them
to the author of the FAQ or Tim Harvey at:

Email: ti...@plaza.ds.adp.com
r...@teleport.com
Voice: (503) 294-4200, Ext. 3313

The most recent copy of Stewart Clamen's summary on available databases
support for schema evolution will be available indefinitely via anonymous
FTP from BYRON.SP.CS.CMU.EDU:/usr/anon/OODBMS/evolution-summary.

[Kim 89] covers a few of the research systems below in depth.

Starred entries also have an entry in "APPENDIX E ANONYMOUS FTP SITES".

See also section 3.5 for an Object Database Management Group (ODMG) reference.


TABLE OF CONTENTS

Extended Relational Database Model
Research Systems
POSTGRES* [marketed by Montage]
Starburst [IBM almaden, entry NYI]
Commercial Systems
Illustra
Montage [Research System POSTGRES]
Omniscience ORDBMS
Raima Database Manager/Velocis/Raima Object Manager
Total ORDB [Cincom Systems]

Object-Oriented Data Model
Research Systems
AVANCE
CLOSQL
ConceptBase*
COOL/COCOON
Encore*
Exodus*
Machiavelli
MOOD4-PC*
OBST/STONE*
Ode*
Oggetto
Orion [marketed as ITASCA, see Entry]
OTGen
PLOB
VODAK
Commercial Systems
ArtBASE
EasyDB (Basesoft Open Systems, Sweden)
GemStone
IDB Object Database
ITASCA
Matisse
NeoAccess
OBST+
O2
Objectivity/DB
ObjectStore
Ontos [formerly VBase]
Odapter/OpenODB program (HP)
OOFILE
Phyla
POET
Statice
UniSQL
Unisys Universal Repository
Versant
VisualWorks

Other Models
Research Systems
GRAS*
IRIS
Commercial Systems
IDL
Kala
Pick

Interfaces
Research Systems
Penguin
Commercial Systems
AllegroStore (Franz)
DBTools.h++
Object Gateway
Persistence
Subtleware
Synchronicity (Smalltalk)


EXTENDED RELATIONAL DB MODEL
----------------------------

Research Systems
________________


> POSTGRES (Berkeley)

POSTGRES is an extended-relational database manager that supports
inheritance, user-defined types, functions, and operators, ad-hoc
queries, time travel, a rules system, tertiary storage devices,
and very large typed objects, among other things. POSTGRES speaks
postquel, a derivative of the quel query language originally
designed at berkeley for the ingres database system. User functions
may be written in C or in postquel. C functions will be dynamically
loaded into the database server on demand, and either kind of function
may be executed from the query language.

POSTGRES and the papers that describe it are available free of charge
from toe.CS.Berkeley.EDU (128.32.149.117) in directory pub/postgres.
The code is stored in a directory named after the latest release; at
the time of this writing, that directory is postgres-v4r1. The list
of officially-supported ports is short (decstations running ultrix 4.x
and sparcstations). Unofficially, many more are supported -- people
elsewhere have done the ports and distribute their versions of the
code. The list of unofficial ports is available in pub/postgres as
file UNOFFICIAL-PORT-LIST.

On Type Evolution:
You ask explicitly about type evolution. We support schema
modification on all classes, including user classes. This means that
you can add attributes (instance slots) and methods at any time.
Further, since postgres is a shared database system, such changes are
instantly visible to any other user of the class.

The language syntax supports attribute deletion, but the system won't
do it yet. Since all data is persistent, removing attributes from a
class requires some work -- you need to either get rid of or ignore
all the values you've already stored.

Contact:
Paul Aoki <ao...@cs.berkeley.edu>

The postgres code from uc berkeley is being commercialized by
Miro Systems, Inc. [This seems to have been updated to Montage]

Contact:
paula hawthorn (pa...@miro.com)
dave segleau (da...@miro.com)


Commercial Systems
------------------

> Illustra

Illustra Information Technologies Ltd.

Illustra is an Object-Relational Database Management System (ORDBMS). It
supports SQL-3 and standard relational syntax and operations on tables.
In addition, programmers may define new classes and methods inside the
database server, and use them from client programs. Customers may build
their own class extensions, or purchase extensions called DataBlades
from Illustra and its partners. Illustra offers a wide collection of
DataBlade modules, including time series support, spatial data handling,
web publishing, document management, video and image support, and others.

Illustra originated from Postgres.

NOTE: Can use with Visual Basic.


Illustra Information Technologies, Inc.
1111 Broadway Suite 2000
Oakland, CA 94607
U.S.A.

Voice: (510) 652 8000
Fax: (510) 869 6388
Email: in...@illustra.com
sa...@illustra.com
reselle...@illustra.com
traini...@illustra.com
Web: http://www.illustra.com Note: This web server uses Illustra
OODBMS for backend.
Ftp: ftp://ftp.illustra.com

Illustra Information Technologies Ltd.
150 Minories
London EC3N 1LS
United Kingdom
Voice: 0171-264-2185
Fax: 0171-264-2193
Email: 10043...@compuserve.com


> Montage (ORDBMS) [Research System POSTGRES]

>From: ma...@montage.com (Mark Helfen)
Subject: Montage Database - brief product announcement
Followup-To: sa...@montage.com
Organization: Montage Software, Inc.
Date: Wed, 10 Nov 1993 23:05:03 GMT

The Montage object-relational database management system
(ORDBMS) is now available from Montage Software, Inc.

The Montage object-relational database management system
includes the Montage Server(tm) database engine, the Montage
Viewer(tm) -- a new visualization tool that simplifies queries of
complex data -- and Montage DataBlades(tm), specialized modules
that extend the capabilities of the database for specific applications.
Montage represents the commercialization of the seven-year
POSTGRES research project.

The Montage Server extends the relational database model through
its ability to handle complex information, and the inclusion of object-
oriented facilities and capabilities. It uses the familiar relational row-
column metaphor for all data, so that text, numbers and complex data
are all viewed, managed, manipulated and queried the same way.
The relational metaphor is extended to allow data of any size and
complexity to be stored and accessed in the way that is most
effective. SQL, used to access and manage data, is extended with
SQL3-based capabilities to allow the definition of user data types and
functions.

The Montage Viewer uses visualization technology to organize
information in visual terms -- by location, shape, color and intensity,
for example. Similar to a "flight simulator," the Montage Viewer allows
the user to visually navigate through data, refining each step by
"panning" and "zooming" with a mouse.

A DataBlade is a combination of data types and functions that are
designed to support a specific application. Text, Spatial, and Image
are the first of many DataBlades that will comprise a full-range of
industry-specific products created by Montage, third parties and
users based upon their own expertise.

o The Text DataBlade expands the database's functionality by
adding new data types and functions that manage text and document
libraries, as well as a providing a new access method (Doc-Tree)
which provides exceptional search performance for text.

o The Image DataBlade supports image conversion, storage,
manipulation, enhancement and management of more than 50 image
formats, and performs automatic conversion of formats at the user's
discretion.

o Points, lines, polygons and their spatial relationships are now
supported in the relational model with the Spatial DataBlade. The
DataBlade defines nine basic spatial types and makes over 200 SQL
functions available for use on spatial data, as well as supports the
R-Tree access method for high speed navigation of spatial data.

Montage Software was co-founded by Gary Morgenthaler of
Morgenthaler Ventures and Dr. Michael Stonebraker of the University
of California, Berkeley, . Morgenthaler is Montage Software's
chairman of the board and Stonebraker serves as the company's
chief technology officer. Morgenthaler and Stonebraker co-
founded Ingres Corporation (then called Relational Technology,
Inc.), in 1980.

FOR ADDITIONAL INFORMATION:

Montage Software Inc. can be contacted at:

email: sa...@montage.com
phone: (510) 652-8000
fax: (510) 652-9688

Mailing Address:

Montage Software, Inc.
2000 Powell Street, Suite 1405
Emeryville, CA 94608


> Omniscience ORDBMS

Omniscience Object Technology, Inc.

Omniscience ORDBMS is a light weight scalable database managment system
with a very small footprint suitable for small systems such as notebook
computers running Microsoft Windows. It is built on top of a compact
object kernal that supports programs written in SQL and Object-Oriented
programming languages. Available for most platforms. Single user
version costs $99.

Omniscience Object Technology, Inc.
3080 Olcott Street, Suite 100-C
Mountain View, CA 95054
U.S.A.

Voice: (408) 562-0799
Fax: (408) 562-0757
Email: in...@oot.com


> Raima Database Manager/Velocis/Raima Object Manager

Raima Corporation

Offer the Raima Database Manager and Velocis as well as Raima Object
Manager, a C++ programming interface/class library that lets developers
interface their application with a Raima embedded database engine.

Raima Database Manager (formerly db_VISTA) is a very efficient high
performance database engine for C and C++ developers. The proven C-API
includes over 200 functions for database manipulation and control.
Available with source, RDM supports combined relation and network model
database designs, transaction processing, and portability. Single-user
versions start at $595, and multi-user versions begin at $1995.

Velocis is an embeddable high performance, SQL client/server database
engine for C and C++ programmers. It provides high through-put
transaction processing, support for multiple API's and compliance with
industry standards including ANSI SQL, Microsoft ODBC, and SAG CLI.
Several unique features support development of very high performance,
scalable applications. Velocis is available for Windows, Windows NT,
Netware, OS/2, SCO, HP/UX, Solaris, and AIX. Prices start at $595 for
Windows Standalone.

Raima Object Manager is a class library that encapsulates object storage
and database navigation into C++ class definitions to provide a consistent,
object oriented interface to Velocis or Raima Database Manager. Combined,
Raima Object Manager and Velocis provide a comprehensive feature set for
your object oriented C++ database development. Includes source and
supports popular operating systems. Priced at $495.


Raima Corporation
1605 N.W. Sammamish Road
Issaquah, WA 98027
U.S.A.

Toll Free: 1-800-327-2462
Direct: (206) 557-0200
Email: dmo...@raima.com
Web: http://www.raima.com


> Total ORDB

Cincom Systems, Inc. produce Total ORDB, a integrated set of object
technology software products and services. Features include an
object-relational data model, ANSI SQL with object-oriented extensions.
Cost ranges from $2,400-$60,000 depending in usage.

The TOTAL ORDB that CINCOM markets is a re-badged version of the UniSQL
product, but there is a long-term technology agreement betwen the two
organizations that will allow improvements made by one to the product
to be shared with the other.

Cincom Systems also produce TOTAL FrameWork, a business application
development environment that integrates an object-relational database,
object develoment tools and workflow automation tehncology.

Cincom Systems, Inc.
Cincinnati, OH
U.S.A.

Voice: (513) 662-2300
Email: in...@cincom.com
Web: http://www.cincom.com/

OO DATA MODEL
-------------

Research Systems
________________

> AVANCE (SYSLAB)

An object-oriented, distributed database programming language. Its
most interesting feature is the presence of system-level version
control, which is used to support schema evolution, system-level
versioning (as a way of improving concurrency), and objects with their
own notion of history. System consists of programming language (PAL)
and distributed persistent object manager.

REFERENCES:
Anders Bjornerstedt and Stefan Britts. "AVANCE: An
Object Management System". Proceedings of OOPSLA88.

> CLOSQL (University of Lancaster)

Status:-
CLOSQL is a research prototype OODB designed primarily for prototyping
various schema evolution and view mechanisms based on class versioning.
The system is built using CommonLISP. It would really only be of interest
to other parties as a research tool.

Requirements:-
Common LISP including CLOS standard. The Graphical user interface requires
the Harlequin LispWorks Tool-kit. The system was built on a Sun4 and
has not been tested on any other platform.

Features:-
As a prototype, CLOSQL is not robust enough to sell. The system is single
user and does not properly support persistence - that is, the data has to
be loaded and saved explicitly. The query language is quite good
making good use of the functional nature of the environment.
Methods (LISP and query language only), class versioning and
multiple inheritance are all supported in the data model. Type checking
information is held in the database, but is NOT enforced at present. The
GUI is notable for its support for schema evolution, but otherwise rather
ordinary.

Availability:-
Probably freely available, but as the project was part funded by an
industrial partner, some consultation with them would be necessary before
the system could be released.

References:-
[1] Monk, S. R. and I. Sommerville, "A Model for Versioning of Classes
in Object-Oriented Databases", Proceedings of BNCOD 10, Aberdeen.
pp.42-58. 1992.

[2] Monk, S. "The CLOSQL Query Language". Technical report No. SE-91-15.
Computing Dept, Lancaster University, Lancaster, LA1 4YR, UK. 1991.

[3] Monk, S., "A Model For Schema Evolution In Object-Oriented Database
Systems", PhD thesis, Dept of Computing, Lancaster University, Lancaster
LA1 4YR, UK. 1992.

On Schema evolution (from original survey):
CLOSQL implements a class versioning scheme (like ENCORE), but employs a
conversion adaptation strategy. Instances are converted when there is a
version conflict, but unlike ORION and GemStone, CLOSQL can convert instances
to older versions of the class if necessary.

Aberdeen, Scotland. July, 1992.

Contacts;
Simon Monk: s...@computing.lancaster.ac.uk
Ian Sommerville: i...@computing.lancaster.ac.uk


> ConceptBase - A Deductive Object Manager for Meta Data Bases

ConceptBase is a multi-user deductive object manager mainly
intended for conceptual modeling and the coordination of design
environments. The system implements a dialect of Telos which
amalgamates properties of deductive and object-oriented languages.

Key features are

hybrid representation with frame-like objects,
semantic nets and logical specifications

unlimited extensibility by metaclass
hierarchies (useful for IRDS, schema evolution etc.)

deductive rules & integrity constraints

queries as classes with membership constraints

persistent object management with the ability to interrogate
past states of the database

ConceptBase follows a client-server architecture. Client programs
can connect to the ConceptBase server and exchange data via
interprocess communication. The X11-based ConceptBase user
interface offers a palette of graphical, tabular and textual tools
for editing and browsing the object base. The ConceptBase
programming interface allows the users to create their own
client programs in C or Prolog.

The system can be obtained for free from ftp.informatik.rwth-aachen.de in
/pub/CB/CB_3.2.4 (released 26-Apr-1994 for Sun/SPARC, SunOS 4.1.3)
/pub/CB/CB_3.3 (released 26-Apr-1994 for Sun/SPARC, Solaris 2.3)
Both versions are functionally equivalent. They only differ in the
operating system platform.Please read file /pub/CB/doc/InstallationGuide
(resp. /pub/CB/doc/InstallationGuide_3.2.4) before downloading the software.
For running the ftp version you must ask for a key by email.

Contact
ConceptBase-Team
RWTH Aachen - Informatik V
D-52056 Aachen - Germany

Tel./Fax: +49-241 80 21 501 / +49-241-8888321
email: C...@picasso.informatik.rwth-aachen.de
href="http://www.informatik.rwth-aachen.de/I5/CBdoc/cbflyer.html"


> COOL/COCOON (Ulm Universitaet)

The COCOON project was intended to extend the concepts and the
architecture of relational database management systems (DBMSs) beyond
nested relational to object-oriented ones. Based upon the nested
relational DBMS kernel DASDBS, we have built a prototype implementation
of the COCOON model. Key characteristics of COCOON are: generic,
set-oriented query and update operators similar to relational algebra
and SQL updates, respectively; object-preserving semantics of query
operators, which allows for the definition of updatable views; a
separation of the two aspects of programming language "classes": type
vs. collection; predicative description of collections, similar to
"defined concepts" in KL-One--like knowledge representation
languages; automatic classification of objects and views (positioning
in the class hierarchy); physical clustering of subobjects via the use
of nested relations as the internal storage structures; support for the
optimization of both, the physical DB design and query transformation,
by corresponding optimizers.

Project goals are:

- to develop a general formal framework for investigations of all
kinds of schema changes in object-oriented database systems
(including schema design, schema modification, schema tailoring, and
schema integration);
- to find implementation techniques for evolving database schemas,
such that changes on the logical level propagate automatically to
adaptations of the physical level (without the need to modify all
instances, if possible).

In their current paper [see below], schema evolution is used as
example of a general framework for change in OODBs, supporting change
on three levels of database objects: data objects, schema objects, and
meta-schema objects.

Contact: Markus Tresch <tre...@informatik.uni-ulm.de>


REFERENCES:
M. Tresch and M.H. Scholl. "Meta Object Management
and its Application to Database Evolution." In
_Proceedings of the Eleventh International
Conference on the Entity-Relationship Approach",
Karlsruhe, Germany, Oct 1992. Springer Verlag (to
appear).

> Encore (Brown University)
email:b...@browncs.brown.edu

Encore is an object-oriented database system targeted at large scale
software engineering applications which are involved in data modeling.
It was developed at Brown University in the late 1980s. It is notable
for its special support for long-lived (ie. cooperative) transactions,
popular in design applications, and its support for class versioning.
Objects are never converted, rather, classes are versioned, and the
user can specify filters to make old-style instances appear as new
instances to new applications (and vice versa).


References/Additional Information:

[] Mary F. Fernandez. OBSERVER: A storage system
object-oriented applications. Technical Report CS-90-27,
Brown University, Providence, RI, 1990.

[] Mark F. Hornick and Stanley B. Zdonik. A shared, segmented
memory system for an object-oriented database. ACM
Transactions on Office Information Systems, 5(1):70--95,
January 1987.

[] Andrea H. Skarra and Stanley B. Zdonik. Type evolution in an
object-oriented database. In Research Directions in
Object-Oriented Programming, MIT Press Series in Computer
Systems, pages 393--415. MIT Press, Cambridge, MA, 1987. An
early version of this paper appears in the OOPSLA '86
proceedings.

[] Andrea H. Skarra and Stanley B. Zdonik. Concurrency control
for cooperating transactions in an object-oriented database.
In Won. Kim and Frederick H. Lochovsky, editors,
Object-Oriented Concepts, Databases and Applications.
Addison-Wesley, Reading, MA, 1989.

FTP: Complete source can be found in wilma.cs.brown.edu/pub/encore.tar.Z
See also APPENDIX E.


> Exodus (University of Wisconsin)

EXODUS is a DBMS from the University of Wisconsin. An overview,
excerpted from the abstract of [CDG+90] reads:

EXODUS, an extensible database system project that is
addressing data management problems posed by a variety of
challenging new applications. The goal of the project is to
facilitate the fast development of high-performance,
application-specific database systems. EXODUS provides
certain kernel facilities, including a versatile storage
manager. In addition, it provides an architectural framework
for building application-specific database systems; powerful
tools to help automate the generation of such systems,
including a rule-based query optimizer generator and a
persistent programming language; and libraries of generic
software components (e.g., access methods) that are likely to
be useful for many application domains.

The programming language is called E, an extension of C++. [RC89]

REFERENCES:
(see "ftp.cs.wisc.edu:exodus/bibliography" for a complete list)

[CDG+90] Michael J. Carey, David J. DeWitt, Goetz Graefe,
David M. Haight, Joel E. Richardson, Daniel T. Schuh,
Eugene J. Skekita, and Scott L. Vandenberg. The EXODUS
extensible DBMS project: An overview. In Stanley B.
Zdonik and David Maier, editors, Readings in
Object-Oriented Database Systems, Data Management
Series. Morgan Kaufmann, San Mateo, CA, 1990. Also
available as WISC-CS-TR 808.

[CDRS89] Michael J. Carey, David J. DeWitt, Joel E. Richardson,
and Eugene J. Skekita. Storage management for objects
in EXODUS. In Won. Kim and Frederick H. Lochovsky,
editors, Object-Oriented Concepts, Databases and
Applications, chapter 14. Addison-Wesley, Reading, MA,
1989. After Carey et al. Object and File Management in
the EXODUS Database System, Proceedings of the Twelveth
International Conference on Very Large Data Bases,
1986.

[GD87] G. Graefe and D. DeWitt. The EXODUS optimizer
generator. In U. Dayal and I. Traiger, editors,
Proceedings of the SIGMOD International Conference on
Management of Data, San Francisco, CA, May 1987.

[RC89] Joel E. Richardson and Michael J. Carey. Persistence in
the E language: Issues and implementation. Software --
Practice and Experience, 19(12):1115--1150, December
1989.


FTP: source code, documentation and a complete bibliography can be
found at ftp.cs.wisc.edu:exodus/

See also APPENDIX E.


On Schema Evolution (from original survey):
No solution for the problem of schema evolution is provided.
Emulation is rejected by the authors, who claim that the addition of a
layer between the EXODUS Storage Manager and the E program would
seriously reduce efficiency. Automatic conversion, whether lazy or
eager, is also rejected, as it does not mesh well with the C++ data
layout. To implement immediate references to other classes and
structures, C++ embeds class and structure instances within its
referent. The resulting change in the size of the object might
invalidate remote pointer references.

Joel E. Richardson and Michael J. Carey. "Persistence
in the E language: Issues and Implementation." Appeared
in "Software -- Practice and Experience",
19(12):1115-1150, December 1989.


> Machiavelli (University of Pennsylvania)

Machiavelli is a statically-typed programming language developed
at the University of Pennsylvania. Its most outstanding innovation
is the use of conditional typing scheme in its type inference system.
It does not address type evolution.

[communication with lim...@saul.cis.upenn.edu]

[Note: Machiavelli is included in this summary because it
previously incorporated persistence in its data model.]

> MOOD4-PC: Material's/Miniature Object-Oriented Database Prototype for
NEC/IBM-PC

is an object-oriented database system(OODBS) program developed in the
course of our research project MOOD. The aim of the project MOOD is to
develop a material database system to handle raw material data which
are produced and accumulated in materials research and referred to by
material experts when they face scientific or engineering problems
where the expected behavior of particular materials in particular
environments are crucial importance. We all know that the conventional
database systems do not fulfill this requirement, though they serves
well for bibliographic databases or fact databases which deals with
the standard properties of standard materials.

MOOD4-PC is written in Arity/Prolog and available in source and
executable form via anonymous ftp from:

~/pub/mood/mood4
at mood.mech.tohoku.ac.jp [130.34.88.61]

~/pub/database/mood
at ftp.uu.net [192.48.96.9]

~/pub/computing/databases/mood
at src.doc.ic.ac.uk [146.169.2.1]

Although it is true enough to say that MOOD4 is a general purpose
OODBS, it may be appropriate to point out that MOOD4 is significantly
different from what is generally meant by the term, the
Object-Oriented Database System.

That is, OODBSs, in general, consist of two parts:

(1) Disk storage manager
(2) Database language to define and manipulate data objects to
be stored to and retrieved from the disk.

The database language of OODBS is akin to the object-oriented
programming language such as Smalltalk or C++. You can enjoy the full
versatility of these general purpose programming language in writing
application programs with the database language.

As apparent from these, OODBSs, in general, are for programmers who
write application programs which serve end users' needs. MOOD, on the
other hands, is not; it is for end users. It is provided with a user
interface named the object editor or OE in short. With OE, we can;

(1) Edit class definition objects and save them. This replaces the
data definition language.

(2) Edit data objects and save them.

(3) Create query objects, let the system select data objects which
match the queries, and browse them.

In the other words, we can do everything necessary to manage and use
database with OE. MOOD, therefore, needs no programming language and,
in fact, has none. In this regard, MOOD may better be categorized to
the OODBS application.

The architecture of MOOD as such is the consequence of the nature of
information to be dealt with in material database. If we describe the
nature with a single word, "variety" will be the one most appropriate.
No fixed data structure can handle a handful of material data because
their contents differ from one to another. The feature of OODBS
relevant here is not the intimacy with programming languages but the
flexibility of data structure which allows us to construct data
objects with a variety of structures which match the variety in the
information to be dealt with. Upon inputting and retrieving data
objects, end users are forced to face this variety in data structure
since significant information is born in the structures of individual
representations.

Yet, we say that MOOD is a general purpose OODBS. This is not in the
sense that we can develop application programs on it, but in the
sense that it generally supports the essential capabilities of OODBS;

(1) The abstract data type.

(2) The nesting of structured data objects.

(3) The class hierarchy.

(4) The inheritance of attributes along the hierarchy.

(5) Matching between objects along their structures with the
knowledge of the class hierarchy.

For additional features of MOOD4, please consult its manual available
with the program. Although they are biased to the processing of
material data (or, more generally, scientific and technical data),
MOOD with these capabilities can be used in any application domain at
least by the stage where you are to examine how well the pieces of
information of interest are represented in OODBS and how well specific
items of interest are discriminated out from the database as such.

Questions and suggestions on this software which are ever welcome
indeed may be addressed to;

Noboru Ono
Dept. of Machine Intelligence and Systems Engineering,
Faculty of Engineering, Tohoku University.
Tel:++22-216-8111,
Fax:++22-216-8156,
E-mail:o...@mood.mech.tohoku.ac.jp

> OBST/STONE (Forschungszentrum Informatik [FZI], Karlsruhe, Germany)

OBST3-4 is now available at ftp.fzi.de under /pub/OBST/OBST3-4.
(Please do not confuse this new release with the older OBST3-3.4).

Experienced users will notice that we've changed the structure of
our ftp directory tree somewhat: compressed and gzip'ed files are
now cleanly separated. By sending
echo 'info ftp_listing' | mail obst-l...@fzi.de
you will get a directory listing from our ftp server.

OBST3-4 is a major release with a new meta schema interface
that enables schema modifications. A graphical schema browser
(USE) based on tclOBST is now also available. Please note that this
new tool has not yet been tested outside the FZI and that it
is currently not part of the OBST core cdistribution.

Beside bug fixes and performance improvements, we have added support
for IBM AIX and FreeBSD and improved the installation on LINUX PCs.

We would like to thank all OBST users who have helped us by testing a
beta version of OBST, most notably:
Naresh Sharma (N.Sh...@LR.TUDelft.NL)
Michael Reifenberger (ro...@rz-wb.fh-sw.de)
Hans-Ulrich Kobialka (ko...@borneo.gmd.de)
Jean Safar (jsa...@lehman.com)
Gabor Karsai (ga...@vuse.vanderbilt.edu)
Stefan Bohm (bo...@math.uni-muenster.de)

The installation of OBST requires a C++ compiler
(GNU g++ 2.3.3/2.4.5/2.5.8, or AT&T 2.1/3.01).

The OBST graphical tools run under the X-Windows
system (currently X11R4, X11R5 and X11R6).
Installation has been tested for SunOS4.1.3 and LINUX only.

Best regards and happy OBST programming.

The OBST Team

------------------------------------------------------------------------------
README of OBST3-4
-----------------

Version: OBST3-4
Date: 11/4/94

The OBject system of STONE --- OBST
-----------------------------------

The persistent object management system OBST was developed by
Forschungszentrum Informatik (FZI) as a contribution to the STONE
project (supported by grant no. ITS8902A7 from the BMFT, i.e. the
German Ministry for Research).

OBST was originally designed to serve as the common persistent
object store for the tools in software engineering environments.


Data Model
---------

The OBST data model can be characterized by the following properties:

* Schema definition language syntactically similar to C++
* Support of multiple inheritance
* Generic classes
* Abstract classes and methods
* Distinction between public, protected, and private methods
* Redefinition of methods
* Overloading of methods

Schemas and Containers
----------------------

Schemas are compiled by the OBST schema compiler. The compilation
results are instances of classes of the meta schema. From these
instances in a next step interfaces to different programming languages
can be generated. At present the C++ language binding is implemented.

Objects are stored in so-called containers. The container an object
belongs to is determined at the time of object creation and fixed
throughout the object's lifetime. Containers are the units of
clustering, synchronization, and recovery. Objects can be referenced
by other objects across container boundaries.

Incremental Loading
-------------------

OBST provides a mechanism to incrementally load methods. This enables
programs to deal with objects whose type is defined after the program
itself has been developed. This is useful in systems that provide for
inheritance and it supports schema evolution. We used it e.g. for
programs that interpret the object base and call methods of the
found objects (for example the below mentioned browser).

Prototype
---------

Since end 1990 the first prototype of OBST is available and is shipped
to interested universities and research institutions. The current
version is publicly available via FTP (see below) since March '92.
There is a mailing list (see below) with >>100 subscribers.

The system comes with the schema compiler, a library of predefined
classes (like Set<Entity>, List<Entity>, String, ...), a graphical
object browser (more a shell than a browser), a graphical schema
designer (USE), the structurer and flattener (STF), tclOBST,
and all manuals.
For USE, STF and tclOBST see below.

Schema Evolution Support Environment (USE)
------------------------------------------

This environment consists of a graphical schema designer built with
tclOBST (see below). It can be used to inspect existing class hierarchies
and to modify these hierarchies; it allows the addition of new classes
as well as the modification of existing ones.

Structurer and Flattener (STF)
------------------------------

This is a tool to build objects from bytestrings and flatten objects
down to bytestrings. It is intended to be used when coupling UNIX
tools to the object management system. The user defines a grammar that
describes her objects. Afterwards, the structurer parses an ascii
text according to the given grammar and creates an OBST object
structure that represents the corresponding parse tree.
The flattener does the inverse transformation, that means it generates
an ascii text from a given OBST object structure according to the given
grammar.

tclOBST
-------

tclOBST is a library which provides an embedding of OBST into the
interactive tool command language tcl, developed by John Ousterhout
at the University of Berkeley.
Based on the standard tcl shells, which are also comprised in the
tclOBST distribution, tclOBST offers interactive access to the complete
functionality modelled by OBST schemata.


System Requirements
-------------------

For the prototype's installation a C++ compiler
(GNU g++ 2.3.3/2.4.5/2.5.7 or AT&T 2.0/2.1/3.01) and the
X-Windows system (currently X11R4 or X11R5) for the graphical tools
are required.
Installation is well-tried on SUN Sparc stations and should be no
problem on other UNIX machines, too. You can find a more detailed
description of the supported platforms in the README.install.OBST*.

--------------------------------------------------------------------

For more information please mail to:

Forschungszentrum Informatik (FZI)
OBST Projekt
Haid-und-Neu-Strasse 10-14
D-76131 Karlsruhe
Germany

or email to: ob...@fzi.de

Phone: ++49-721-9654-701
Fax: ++49-721-9654-709
Teletex: 721 190 fziKA

The OBST system is available via anonymous FTP from
ftp.fzi.de [141.21.4.3] and some mirror servers.

The system as well as some overview papers, documentation
(User's Guide, Language Reference Manual, Tutorial, ...),
and lots of manual pages can be found in the directory /pub/OBST.

There are mailing lists for announcing OBST enhancements,
new versions, porting hints, etc. as well as for exchanging experiences
with other OBST users.

Send a mail with content 'LONGINDEX' to obst-l...@fzi.de to learn about
the mailing lists which are currently installed:
echo LONGINDEX | mail obst-l...@fzi.de

The mailing lists are maintained by an automatic list processor.
Use 'HELP' to learn about the commands understood by this processor:
echo HELP | mail obst-l...@fzi.de

Bug reports should contain a small example program with which the
bug can be reproduced, or at least a detailed description of the
observed phenomenon. They should also mention:
o OBST version
o configuration parameters for your OBST version
(from file config.status)
o kind and version of C++ compiler
o machine
o operating system

Besides bug reports we are strongly interested in all experiences
our users make with OBST (e.g. sufficiency of data model, performance,
...) and in our users' application areas and the applications as
well. So, please don't hesitate to send us a short note.

Best regards and happy OBST programming.

The OBST Team,

Boris Boesler, Dirk Eichberg, Frank Fock, Axel Freyberg,
Michael Gravenhorst, Ingolf Mertens, Michael Pergande, Christian Popp,
Bernhard Schiefer, Dietmar Theobald, Axel Uhl, Walter Zimmer

---

BTW "Obst" is the German word for "fruit",
so have a fruitful time with OBST!


> Ode

Ode 2.0
An Object-Oriented Database

C++ Compatible, Fast Queries, Complex Application Modeling,
Multimedia Support, and more

See APPENDIX E, Databases, for description.
Note: Ode version 3.0 is now available.


> Oggetto, University of Lancaster, UK.

Developed at the University of Lancaster, UK. Summary NYI.

"Oggetto: An Object Oriented Database Layered on a Triple Store",
J.A. Mariani, The Computer Journal, V35, No 2, pp108-118, April 1992.


> IDB Object Database

Produce IDB Object Database, a distributed object database with an
interactive schema designer and browser. Supports most platforms.
Single developer's licenses range form $995-$4000. A IDB introductory
package is available for Macintosh and Windows for $99 including working
application and tutorial.

Persistent Data Systems, Inc.
P.O. Box 38415
Pittsburgh, PA 15238
U.S.A.

Voice: (412) 963-1843
Email: in...@persist.com


> ORION (Now marketed as ITASCA)

ORION was a prototype OODBMS developed at MCC, an American consortium by Won
Kim and his group. Won Kim has left MCC and formed a new company, UniSQL, in
Austin, with a new product of the same name.

See also entry under "ITASCA".

REFERENCES:

I have found nearly a dozen papers published by the ORION folks.
Overviews at various stages in its development and commercialization
can be found in:

[KBGW91] Won Kim, N. Ballou, J.F. Garza, and D.; Woelk. A
distributed object-oriented database system supporting
shared and private databases. ACM Transactions on
Information Systems, 9(1):31--51, January 1991.

[KGBW90] W. Kim, J.F. Garza, N. Ballou, and D. Woelk.
Architecture of the orion next-generation database
system. IEEE Transactions on Knowledge and Data
Engineering, 2(1):109--24, March 1990.

[KBCG89] Won Kim, Nat Ballou, Hong-Tai Chou, and Darrell Garza,
Jorge F. Woelk. Features of the ORION object-oriented
database system. In Won. Kim and Frederick H.
Lochovsky, editors, Object-Oriented Concepts, Databases
and Applications, chapter 11. Addison-Wesley, Reading,
MA, 1989.

[KBC+88] Won Kim, N. Ballou, Hong-Tai Chou, J.F. Garza,
D. Woelk, and J. Banerjee. Integrating an
object-oriented programming system with a database
system. In Proceedings of the ACM Conference on
Objected-Oriented Programming: Systems, Languages and
Applications (OOPSLA), pages 142--152, San Diego, CA,
September 1988. Published as ACM SIGPLAN Notices
23(11).
[Pointers to the previous papers documenting each of the
advanced features listed above are cited therein.]


The paper most relevant to the issue of schema evolution is the
following:

[BKKK87] J. Banerjee, W. Kim, H-J. Kim, and H.F. Korth.
Semantics and implementation of schema evolution in
object-oriented databases. In U. Dayal and I. Traiger,
editors, Proceedings of the SIGMOD International
Conference on Management of Data, San Francisco, CA,
May 1987.


You might also like to look at Kim's book, which provides a good
introduction to OODBMS, while focusing on the ORION work:

[Kim90] Won Kim. Introduction to Object-Oriented Databases.
Computer Systems. MIT Press, Cambridge, MA, 1990.


> OTGen (Carnegie Mellon University/UMass Amherst)

OTGen is a design for a system to support schema evolution in
object-oriented databases. The chief contribution of OTGen is support
for programmer extensibility of transformation functions to allow a
system to support a wide range of schema changes, not just those that
can be easily automated. While OTGen was never implemented, it is
based on the implementation of TransformGen, a system to support the
evolution of the specialized databases used by Gandalf programming
environments. For more information on OTGen and TransformGen, please
see:

Barbara Staudt Lerner and A. Nico Habermann, "Beyond Schema Evolution
to Database Reorganization", in Proceedings of the Joint ACM
OOPSLA/ECOOP '90 Conference on Object-Oriented Programming:
Systems, Languages, and Applications, Ottawa, Canada, October
1990, 67-76.

Barbara Staudt, Charles Krueger, and David Garlan, TransformGen:
Automating the Maintenance of Structure-Oriented Environments,
Computer Science Department Carnegie-Mellon University, Technical
Report CMU-CS-88-186, November 1988.

David Garlan, Charles W. Krueger, and Barbara J. Staudt, "A Structural
Approach to the Maintenance of Structure-Oriented Environments",
in Proceedings of the ACM SIGSOFT/SIGPLAN Software Engineering
Symposium on Practical Software Development Environments, Palo
Alto, California, December 1986, 160-170.

Contact:
Barbara Lerner
ble...@cs.umass.edu


ontact:
Best regards, Heiko
--
Labor fuer Kuenstliche Intelligenz Heiko Kirschke | |
Fachbereich Informatik Tel: +49 (40) 54715-612 | | ||// ||
Universitaet Hamburg Fax: +49 (40) 54715-572 | | ||\\ ||
Vogt-Koelln-Strasse 30 kirs...@informatik.uni-hamburg.de | ---------
D 22527 Hamburg Raum R017 -----------
World Wide Web: http://lki-www.informatik.uni-hamburg.de/~kirschke/home.html


> PLOB! (Hamburg University)

What is PLOB?

* The sound to be heared when a bottle of sparkling wine (champagne,
cidre, etc.) is opened.
* A system for Persistent Lisp OBjects.

Please check the first point by yourself (this can be rather
delightful); I will concentrate here on the second point. PLOB! offers
persistent objects for LispWorks Common LISP.

It is the result of my diploma thesis in computer science. Here are
some topics which I had in mind when designing PLOB! and which are
working features of it:

* Orthogonal persistency
-- Type completeness
-- Persistency independent of an object's type

* PLOB!'s data modelling adapted to Common LISP's data modelling
-- Persistent symbols
-- Persistent packages
-- Mapping between transient class metaobjects and persistent class
description objects
-- Schema evolution

* Integration of useful database functions
-- Transactions
-- Hierarchical object locking
-- Indices
-- Selection queries

* Efficency
-- Efficient object representation
-- Possibility of direct access to objects in the persistent memory

For details, see
http://lki-www.informatik.uni-hamburg.de/~kirschke/diplom/arbeit-eng.html

Contact:
Heiko Kirschke
Labor fuer Kuenstliche Intelligenz
Fachbereich Informatik
Universitaet Hamburg
Vogt-Koelln-Strasse 30
D 22527 Hamburg Raum R017
kirs...@informatik.uni-hamburg.de
Tel: +49 (40) 54715-612
Fax: +49 (40) 54715-572
World Wide Web: http://lki-www.informatik.uni-hamburg.de/~kirschke/home.html


> VODAK

Research in the framework of VODAK focuses on an extensible data
model and database programming language, an advanced transaction
odel, object-oriented query language, and support for multimedia data.

The VODAK Data Model Language VML

Usually database models lack mechanisms for extending them with
additional modeling primitives. This limitation does not allow the
adaptation of the models for specific application needs, e.g. database
integration, multimedia document handling, hypertext modeling, etc.

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part1
Last-Modified: 04/02/96
Version: 1.0.9


COMP.OBJECT FAQ
Version: 1.0.9
Date: 4/2/96


Author:
Bob Hathaway
Geodesic Systems, Inc.
Cyberdyne Systems Corporation
r...@geodesic.com
http://www.geodesic.com/people/Bob
75027...@compuserve.com

Copyright 1992-1995 Bob Hathaway
All rights reserved.

Permission is granted to freely copy and distribute this document but only
with this full header attached and at no cost to others 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.


Anonymous FTP Sites and Hypertext Server:
anon...@zaphod.uchicago.edu:/pub/CompObj8.faq(.Z) (128.135.72.61)
anon...@rtfm.mit.edu:/pub/usenet/comp.object/*_Part_* (18.181.0.24 Tmp)
http://iamwww.unibe.ch/~scg/OOinfo/FAQ/index.html (new IAM location)

Mail Server: (See also section 1.24)

mail mail-...@rtfm.mit.edu
Subject:
send usenet/comp.object/*

Zaphod is preferred over rtfm for anonymous ftp retrieval, as it provides a


single file. Rtfm contains the FAQ as posted.

To use the hypertext system, see APPENDIX E, entries 27.

Comp.Object Archive:
A new and workable comp.object archive is now available on the www, with

Object Currents:
A related and free new on-line Object resource edited by yours truly:
http://www.sigs.com/objectcurrents - Please take a look!

Contributors: Per Abrahamsen, Margaret Burnett, Edwardo Casais, Stewart
Clamen, Dennis De Champeaux, Mike DeVaney, Eric Dujardin, Piercarlo Grandi,
Tim Harvey, Brian Henderson-Sellers, Urs Hoelzle, Paul Johnson, Bill
Kinnersley, Oscar Nierstrasz, James Odell, David Wheeler, Eoin Woods, and
many others whose contributions have helped this document to fulfull its
objective of bringing object-oriented concepts and systems to everyone.

Special thanks to Object Systems, Geodesic Systems and Cyberdyne Systems for
providing the support and resources needed to make this effort possible.
Object Systems was primarily a "think tank" and producer of object-oriented
technologies, Geodesic Systems brings the latest in object-oriented theory
and technique to practical and widespread use, as does Cyberdyne.

And to kick off the new Appendix G, Commercial OO Libraries and Systems, I'm
introducing our own new product (partly developed by me:-), the Great Circle
(TM) automatic memory management system for C and C++. I've used it on
several of my own projects where it automatically fixed all memory leaks
instantly.

New formatted and submitted entries for Appendix G are most welcome.

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 OO systems, groups, texts and literature.

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

While object systems are a constantly changing and moving target with a broad
diversity of often conflicting methodologies, constructs, terminologies,
approaches, languages, implementations and etc. and comp.object has a wide
diversity of readers and writers ranging from students, professors and
researchers in academia to beginners, professionals, top-notch experts and
leaders in industry with a broad range of experience and backgrounds ranging
across many paradigms, this FAQ can certainly not aspire to satisfy all of them
completely but instead attempts to provide the most well-rounded treatment of
object-oriented concepts and realizations primarily from the mainstream and
popular authors and systems and further to provide a collection of available
systems and tools in the appendices.

Several improvements are planned for future FAQs, including a glossary.


SECTION 1: BASICS
1.1) What Is An Object?
1.2) What Is Object Encapsulation (Or Protection)?
1.3) What Is A Class?
1.4) What Is A Meta-Class?
1.5) What Is The Infinite Regress Of Objects And Classes?
1.6) What are MOPs and Reflection?
1.7) What Is Inheritance?
1.8) What Is Multiple Inheritance?
1.9) Does Multiple Inheritance Pose Any Additional Difficulties?
1.10) What Is Dynamic Inheritance?
1.11) What Is Shared (Repeated) Inheritance?
1.12) Why Use Inheritance?
1.13) Why Don't Some People Like Inheritance?
1.14) What Is Specialization/Generalization/Overriding?
1.15) What Is The Difference Between Object-Based And Object-Oriented?
1.16) Is A Class An Object?
1.17) Is An Object A Class?
1.18) What Is A Method? (And Receiver And Message)
1.19) What Are Multi-Methods And Multiple-Polymorphism?
1.20) What Is OOP?
1.21) What Is OOA/OOD (And Where Can I Get What I Need On It)?


1.22) Where Did Object-Orientation Come From?

1.23) What Are The Benefits Of Object-Orientation?

1.24) What Other FAQs Are available?

SECTION 2: TYPING
2.1) What Is Polymorphism?


2.2) What Does Polymorphism Boil Down To In OO Programming Languages?

2.3) What Is Dynamic Binding?

2.4) Is There A Difference Between Being A Member Or Instance Of A Class?

2.5) What Is This I Read About ML And Functional Programming Languages?
2.6) What Is the Difference Between Static And Dynamic Typing?


2.7) What Is A Separation Between Type And Class (Representation)?

2.8) What Are Generics And Templates?

SECTION 3: GENERAL


3.1) What Is The "Classical" Object-Oriented Paradigm?

3.2) What Is The "Delegation/Prototyping" Object-Oriented Paradigm?

3.3) Are There Any Other Object-Oriented Paradigms?

3.4) What Are The Major Object-Oriented Programming Languages Today?

3.5) What Are Object-Oriented Databases And Persistence?

3.6) What Are Object-Oriented Operating Systems?

3.7) What Are The Current Object-Oriented Methodologies?

3.8) What Is The OMG/OMA/ORB/CORBA?
3.9) Why Is Garbage Collection A Good Thing?
3.9b) Why is Garbage Collection Necessary For Object-Oriented Programming?


3.10) What Can I Do To Teach OO To The Kids?

3.11) What Is Available On Object-Oriented Testing?

3.12) What Distributed Systems Are Available?

3.13) What Is The MVC Framework?

3.14) What Is Real-Time?


3.15) What Is Available on OO Metrics?

3.16) What Are Visual Object-Oriented Programming Systems?

3.17) What Tutorials Are Available On Object-Oriented Concepts and Languages?

SECTION 4: COMMONLY ASKED LANGUAGE SPECIFIC QUESTIONS
4.1) What Is Downcasting?
4.2) What Are Virtual Functions?


4.3) Can I Use Multiple-Polymorphism Or Multi-Methods In C++?

4.4) Can I Use Dynamic Inheritance In C++?

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 NEWSLETTERS
APPENDIX G COMMERCIAL OBJECT-ORIENTED LIBRARIES AND SYSTEMS

[Another appendix on commercial object-oriented class libraries should be
added soon]


SECTION 1: BASICS
==================

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


1.1) 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: "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 91]: "anything with a crisply defined boundary"
(in context, this is "outside the computer domain". A more conventional
definition appears on pg 54). Booch goes on to describe these definitions
in depth. [Martin 92, p 241] defines: "An "object" is anything to which a
concept applies", and "A concept is an idea or notion we share that applies
to certain objects in our awareness". [Rumbaugh 91] defines: "We define an
object as a concept, abstraction or thing with crisp boundaries and meaning for
the problem at hand." [Shlaer 88, p 14] defines: "An object is an abstraction
of a set of real-world things such that:
* all of the real-world things in the set - the instances - have the same
characteristics
* all instances are subject to and conform to the same rules"
and on identifying objects: "What are the *things* in this problem? Most of
the things are likely to fall into the following five categories: Tangible
things, Roles, Incidents, Interactions, and Specifications." [Booch 91, 4.3]
covers "Identifying Key Abstractions" for objects and classes based on an
understanding of the problem domain and [Jacobson 92] provides a novel approach
to identifying objects through use-cases (scenarios), leading to a use-case
driven design. Jacobson also calls for managing complexity with specialized
object categories [Jacobson 94]:
Ordinary Objects - Typical OOPL objects
Use-Cases and Actors - Actors <--> Use-Cases <--> Object Model Objects
Megaobjects - Composite objects (~ subsystems with inheritance)
Frameworks*(Typical) - Abstract MO meant for reuse and extension
Patterns** (Typical) - Framework-like, crsp. classes and comm patterns only
Application Objects - In the Object Model
Interface - E.g. GUI
Control - Introduced in design for control purposes
Entity - Correspond to real-world objects
Component Objects - Utility and Implementation hiding objects
Utility - Set, Array, ...
Impl. Hiding - Distr. Arch., specific DBMS, OS

Unrelated to Ivar Jacobson but relevant to the topic:
* There was a Software Frameworks Assoc. and magazine until last year, but
a review of their last conference is available by email thanks to Adam
Wildavsky, send requests to ad...@panix.com.
**There is a patterns mailing list, email: patterns...@cs.uiuc.edu,
with the HEADING "subscribe".
See also st.cs.uiuc.edu for some info on patterns.
See also http://st-www.cs.uiuc.edu/users/patterns/patterns.html

The implementation of objects could roughly be categorized into descriptor-
based, capability-based, and simple static-based approaches. Descriptor-
based approaches (e.g. Smalltalk handles) allow powerful dynamic typing, as
do the capability-based approaches which are typically found in object-
oriented databases and operating systems (object id's). A "proxy" based
approach with an added layer of indirection to Smalltalk's handles is found
in Distributed Smalltalk which allows transparent, distributed, and migrating
objects [Kim 89, ch 19 and Yaoqing 93]. Simple static approaches are found in
languages such as C++, although the new RTTI facility will supply simple
dynamic typing (checked downcasting) similar to those introduced by Eiffel
in 1989 through the notion of assignment attempt, also known as type narrowing.

Descriptor-based approaches can have pointer semantics and can be statically
typeless (or just "typeless", as in Smalltalk) where references (variables)
have no type, but the objects (values) they point to always do. An untyped
pointer (such as void* in C++) and an embedded dynamic typing scheme are used
in more conventional languages to fully emulate this style of dynamically typed
programming (see sections 2.3, 4.3, and [Coplien 92]).

Below is a simple example to show a most trivial case of OO implementation.
It is primarily intended to introduce new terms. See [Cardelli 85] for
another semantic definition of OO using functions for methods and for
a view of types as sets of values.

Simple statically-typed objects (static and auto vars and temps in C++ and
expanded types in Eiffel) 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 loosely coupled variant record, with derived classes
as variant parts and with multiple-inheritance concatenating several records
to serve as a base.

A virtual member in statically typed languages is a base class member that can
be set or respecified by a derived class. This is roughly equivalent to a
pointer or function pointer in the base class being set by the derived class.
[Stroustrup 90] covers the implementation details of virtual member functions
in C++, which also involve an offset for the receiver to handle multiple-
inheritance. This is an example of dynamic binding, which replaces a
switch statement on variant parts with a single call, reducing code size
and program complexity (fewer nested programming constructs) and allowing
variants to be added without modifying client code (which causes higher defect
injection rates during maintanance and debugging).

Virtual members in dynamically typed languages are more flexible because
static typechecking requirements are dropped. See section 2.5.

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 90, 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 [Kim 89, ch3; Ungar 87, Sciore 89] have a more
flexible kind of object which can play the role of classes in classical OO
languages. Since there is no separate class construct in these languages, and
only objects, 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,
although vtables of function pointers for dynamic binding are an exception).
However, one-level objects often play the role of classes to take advantage of
sharing and often instances will simply delegate to parents to access methods
or shared state, otherwise idiosyncratic objects, a powerful and natural
concept, will result. 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 or changed dynamically, providing
dynamic multiple inheritance (or more typically simple delegation). Here, the
term "Prototype" usually refers to prototype theory, a recent theory of
classification where any object can be inherited from or cloned to serve as a
prototype for newly created instances. [The Author also uses the term for
languages providing high quality support for rapid prototyping, although this
usage is atypical] See [Booch 94, pp 154-155] for a brief discussion of
prototype theory in the context of OOA and OOD.

It is common in such systems for an object to "become" another kind of object
by changing its parent. A good example is a window becoming an icon, as
window and icon objects display different behavior (although cognitive
differences are significant too:-) Delegation refers to delegating the
search for an attribute to a delegate, and is therefore more of a pure
message passing mechanism (as with dynamic scoping) than inheritance, which
also typically specifies non-shared state when used for representation.

Chambers has proposed an interesting variation called "Predicate Classes"
[Chambers 93] as a part of his Cecil language. These classes will only be
parents when certain predicates are true. This can support a types/classes
as collections of objects view, which is the same as the types as sets of
values view taken by [Cardelli 85]. [Martin 92] provides some examples of
this view applied during OOA.

1 level systems therefore provide the most flexible and powerful capabilities.
Self is a good example of a delegation-based single hierarchy language [Ungar
87].


1.2) What Is Object Encapsulation (Or Protection)?
---------------------------------------------------

[Booch 91, p. 45] defines: "Encapsulation is the process of hiding all of the
details of an object that do not contribute to its essential characteristics."

[Coad 91, 1.1.2] defines: "Encapsulation (Information Hiding). A principle,
used when developing an overall program structure, that each component of a
program should encapsulate or hide a single design decision... The interface
to each module is defined in such a way as to reveal as little as possible
about its inner workings. [Oxford, 1986]"

Some languages permit arbitrary access to objects and allow methods to be
defined outside of a class as in conventional programming. Simula and
Object Pascal provide no protection for objects, meaning instance variables
may be accessed wherever visible. CLOS and Ada allow methods to be defined
outside of a class, providing functions and procedures. While both CLOS
and Ada have packages for encapsulation, CLOS's are optional while Ada's
methodology clearly specifies class-like encapsulation (Adts).

However most object-oriented languages provide a well defined interface to
their objects thru classes. C++ has a very general encapsulation/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. C++ also allows a
class to specify friends (other (sub)classes and functions), that can access
all members (its representation). Eiffel 3.0 allows exporting access to
specific classes.

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,
helping with abstract classes and overriding.

Another issue is per-object or per-class protection. Per-class protection
is most common (e.g. Ada, C++, Eiffel), where class methods can access any
object of that class and not just the receiver. Methods can only access the
receiver in per-object protection. This supports a subtyping model, as any
object other than the receiver is only satisfying an abstract type interface,
whereby no method or object structure can be inferred in the general case.


1.3 What Is A Class?
--------------------

A class is a general term denoting classification and also has a new meaning
in object-oriented methods. Within the OO context, a class is a specification
of structure (instance variables), behavior (methods), and inheritance
(parents, or recursive structure and behavior) for objects. As pointed out
above, classes can also specify access permissions for clients and derived
classes, visibility and member lookup resolution. This is a feature-based or
intensional definition, emphasizing a class as a descriptor/constructor of
objects (as opposed to a collection of objects, as with the more classical
extensional view, which may begin the analysis process).

Original Aristotlean classification defines a "class" as a generalization of
objects:
[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".

[Booch's definition in the context of OOD]
"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."

The intension of a class is its semantics and its extension is its instances
[Martin 92].

[Booch 94, 4.2] proposes 3 views of classification as useful in OO analysis and
design: classical categorization (common properties), conceptual clustering
(conceptual descriptions), and prototype theory (resemblance to an exemplar).
He advocates starting with the former approach, turning to the second approach
upon unsatisfactory results, and finally the latter if the first two approaches
fail to suffice.


1.4) What Is A Meta-Class?
---------------------------

[See also section 1.6]

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). [Booch 91, p 119] provides another example in Smalltalk with
timers. In Smalltalk, the situation is more complex. To make this easy, refer
to the following listing, which is based on the number of levels of distinct
instantiations:

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.
There is only 1 kind of object.
2 Level System
All Objects are instances of a Class but Classes are not accessible to
programs (no Meta-Class except for in the compiler and perhaps for type-safe
linkage, as in C++).
There are 2 kinds of distinct objects: objects and classes.
3 Level System
All objects are instances 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.
There are 2 kinds of distinct objects (objects and classes), with a
distinguished class, the metaclass.
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

The "class class"es handle messages to classes, such as constructors and
"new", and also "class variables" (a term from Smalltalk), which are
variables shared between all instances of a class (static member data in
C++). There are 3 distinct kinds of objects (objects, classes, and
metaclasses).


1.5) What Is The Infinite Regress Of Objects And Classes?
----------------------------------------------------------

In the authors opinion, a myth. The story goes an object is an instance of a
class (Meta-Object), a class is an instance of a Meta-Class, which must also
be an instance of a Meta-Meta-Class, which must also be an instance of a Meta-
Meta-Meta-Class, ... Closure can be achieved with an instance-of loop, as with
a Meta-Class being an instance of itself or with a "Meta-Class - Meta-Class
class" instance-of loop (as in Smalltalk).


1.6) What Are MOPs And Reflection?
-----------------------------------

MOP is an acronym for Meta-Object Protocol. This is a system with
Meta-Classes accessible to users [Kiczales 92, Paepcke 93]. In CLOS
terminology, 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. This is a good example
of object-oriented reuse, since the compiler itself is reused thru
specialization to provide new frameworks.

"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). Reflective systems are inevitably reflexive (as are most
quality compilers), providing a direct program interface to the system.


1.7) What Is Inheritance?
--------------------------

Inheritance provides a natural classification for kinds of objects and allows
for the commonality of objects to be explicitly taken advantage of in modeling
and constructing object systems. Natural means we use concepts,
classification, and generalization to understand and deal with the complexities
of the real world. See the example below using computers.

Inheritance is a relationship between classes where one class is the parent
(base/superclass/ancestor/etc.) class of another. Inheritance provides
programming by extension (as opposed to programming by reinvention
[LaLonde 90]) and can be used as an is-a-kind-of (or is-a) relationship or
for differential programming. Inheritance can also double for assignment
compatibility (see section 2.7).

In delegation languages, such as Self, inheritance is delegation where objects
refer to other objects to respond to messages (environment) and do not
respecify state by default.

Inherited parents can specify various flavors of state. Delegation languages
don't specify new state by default (to do so requires cloning), C-based (C++,
Objective-C, etc.), lisp-based (CLOS, Flavors, Scheme, etc.), and Pascal-based
(Ada95, Modula-3, Object Pascal, etc.) OO languages do, but with multiple-
inheritance can also share parents within a class lattice (CLOS and Eiffel
provide this as a default at the level of slots and features, respectively).

Inheritance also provides for member lookup, or internal environment. Various
schemes exist, for example C++ finds the closest match within a scope but
causes an ambiguity error iff more than one parent has match, CLOS creates
a linear precedence list, Self provides parent priorities, and Eiffel forces
renaming for any parent member conflicts.

Defining inheritance (with a thorough description or denotational semantic
definition, or both) can avoid confusion about which inheritance scheme is
being used (especially in OOD), because inheritance has many variations and
combinations of state and environment (sometimes with complex rules).
Inheritance can also be used for typing, where a type or class can be used to
specify required attributes of a matching object (see sections 2.1, 2.7 and
[Cardelli 85]). It would be more judicious to have discussions on how
inheritance should be defined instead of over what it is, since it has many
existing uses and semantics.

An example of the is-a-kind-of relationship is shown below. Is-a is often
used synonymously, but can be used to show the "object is-a class"
instantiation relationship. In classical OO, inheritance is a relationship
between classes only. In one-level systems, is-a (object instantiation) and
is-a-kind-of (inheritance) are merged into one [Ungar 87, Madsen 93, Sciore
89].

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

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

Differential programming is the use of inheritance to reuse existing classes
by making 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.


1.8) What Is Multiple Inheritance?
-----------------------------------

Multiple Inheritance occurs when a class inherits from more than one parent.
For example, a person is a mammal and an intellectual_entity, and a document
may be an editable_item and a kind of literature.

Mixin's is a style of MI (from flavors) where a class is created to provide
additional attributes or properties to other classes. They are intended to be
inherited by any class requiring them. Method combination, or calling
sequences of before, after, and around methods or even several primary methods
[Kim 89, ch 4], make good use of mixins by invoking their methods without
explicitly calling them, allowing client class code to remain unchanged [Booch
91, p 113].


1.9) 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 by accessing the first signature match (or ambiguity) encountered for
methods (at least one way, C++ hides some member functions). Since several
distinct parents can declare a member within a multiple inheritance hierarchy,
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, as did
the earlier flavors. C++ declares an error iff a conflict arises, but a
class qualifier can be used to explicitly disambiguate. Smalltalk renders
same names for instance variables of subclasses illegal.

On the other hand, multiple-inheritance can be seen as required for basic
object-oriented programming, because many objects in the real world belong to
several classes. In classical systems without MI, a class which should inherit
from more than one class must textually include all but one of those classes in
its interface, causing code duplication (and a messy interface).


1.10) What Is Dynamic Inheritance?
-----------------------------------

Dynamic inheritance allows objects to change and evolve over time. Since base
classes provide properties and attributes for objects, changing base classes
changes the properties and attributes of a class. A previous example was a
window changing into an icon and then back again, which involves changing a
base class between a window and icon class.

More specifically, dynamic inheritance refers to the ability to add, delete,
or change parents from objects (or classes) at run-time. Actors, CLOS, and
Smalltalk provide dynamic inheritance in some form or other. Single hierarchy
systems, such as Self, provide dynamic inheritance in the form of delegation
[Ungar 87].

See also [Kim 89, chs 1, 3] for a discussion and [Coplien 92] for some
implementation discussion in C++.


1.11) 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 and consistent name
resolution but requires more work for parents with many features.


1.12) Why Use Inheritance?
---------------------------

Inheritance is a natural way to model the world or a domain of discourse,
and so provides a natural model for OOA and OOD (and even OOP). This is
common in the AI domain, where semantic nets use inheritance to understand
the world by using classes and concepts for generalization and categorization,
by reducing the real-world's inherent complexity.

Inheritance also 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. Class libraries
also allow reuse between applications, potentially allowing order-of-magnitude
increases in productivity and reductions in defect rates (program errors),
as library classes have already been tested and further use provides further
testing providing even greater reliability.

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. See [Raj 89] for an alternative approach as found in Jade.

Polymorphism is often explicitly available in many OO languages (such as C++,
CLOS, Eiffel, etc.) based on inheritance when type and class are bound together
(typing based on subclassing, or subclass polymorphism), since only an object
which is a member of (inherits from) a class is polymorphically assignment
compatible with (can be used in place of) instances or references of that
class. Such assignment can result in the loss of an object's dynamic type in
favor of a static type (or even loss of an object's representation to that of
the static class, as in C++ slicing). Maintaining the dynamic type of objects
can be provided (and preferred); however, C++ provides both sliced and non-
sliced replacement in a statically typed environment (see section 2.1).


1.13) 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).
The former is a kind of language dependent feature commonly found in object-
oriented languages which are then associated with the term "inheritance"
(although they don't need to be. For example, delegation languages allow graph
inheritance stuctures). 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 or renaming, and most consider MI to be highly desirable. See the
latter part of section 1.9 for an example of why MI is important.

Some prefer association to MI, claiming "roles" (as defined in [Rumbaugh 91])
should be associations and inheritance should be reserved for a single
hierarchy "creation" mechanism, however this loses polymorphism and loses the
use of inheritance for typical classification. Representation "roles" can be
supported by dynamic multiple inheritance (DMI) in many situations.


1.14) 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 are overridable and non-
"frozen" features in Eiffel can 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 multiple-polymorphism because parameters do
not have to be declared. Eiffel and BETA are examples of languages allowing
any member to be redefined and not just methods, as is typical.


1.15) 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.
These languages support abstract data types (Adts) and not classes, which
provide inheritance and polymorphism. Ada95 and Modula-3; however, support
both inheritance and polymorphism and are object-oriented. [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.
- Types may inherit attributes from supertypes.

object-oriented = data abstractions + object types + type inheritance

These definitions are also found in [Booch 91, Ch2 and Wegner 87].

[Coad 91] provides another model:

Object-Oriented = Classes and Objects
+ Inheritance
+ Communication with messages

Stroustrup's first edition of [Stroustrup 91, '86 p. 37] defines object based
as: "... storing type identification in each object, brings us to a style of
programming often referred to as "object based"", which is quite different
from C+W's.

A more modern definition of "object-oriented" includes single-hierarchy
languages and perhaps object id's for unique objects. Object id's support the
modern notion of relocatable, persistent and distributed objects that can
even migrate across machines. Distributed Smalltalk's proxy objects [Kim 89,
ch 19 and Yaoqing 93] provide another example of a distributable and migratable
object facility. Separate type system support is another extension.

[Booch 94, 2.2] proposes 7 "Elements of the Object Model"; 4 major and 3 minor:
Major:
Abstraction
Encapsulation
Modularity
Hierarchy (Inheritance)
Minor:
Typing
Concurrency
Persistence


1.16) 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 are instances of
meta-classes. But classes play a dual role, because objects can only be
declared to be instances of a class (and class objects instances of a
meta-class). In 1 Level (single-hierarchy) systems, all classes are objects.


1.17) 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 (excluding
hybrid systems). However, all objects may be classes in single hierarchy
systems, since any object may act as a class (provide object instantiation or
act as a shared parent).


1.18) What Is A Method? (And Receiver And Message)
---------------------------------------------------

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.

A method is a function or procedure which is defined in a class and typically
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. An exception exists with C++'s static member functions
which do not have a receiver, or "this" pointer. The following are some common
notations for invoking a method, and this invocation can be called a message
(or message passing, see below):

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 keywords (or formal parameter names, like named parameters) are
considered part of the selector in Smalltalk (and hence Objective-C).

If done statically, this can be referred to as invocation, and message passing
if done dynamically (true dynamic binding). Statically typed dynamic binding
(e.g. C++ and Eiffel) is really in between (checked function pointers).

See also section 1.19 below for a discussion on the functional (prefix) verses
message based (receiver based) notation.


1.19) What Are Multi-Methods And Multiple-Polymorphism?
--------------------------------------------------------

Multi-methods involve two primary concepts, multiple-polymorphism and lack of
encapsulation. These issues are orthogonal. Multiple-polymorphism implies
more than one parameter can be used in the selection of a method. Lack of
encapsulation implies all arguments can be accessed by a multi-method (although
packages can be used to restrict access, as in CLOS). Multi-methods can also
imply a functional prefix notation, although the CLOS designers (who coined the
term "multi-method") consider the functional and receiver based forms
(messages) equivalent. Functional syntax was chosen "in order to minimize the
number of new mechanisms added to COMMON LISP" [Kim ch 4, p70 (D. Moon)].
[Chambers 93] discusses multi-methods in his new OO language, Cecil.

Multiple-polymorphism allows specialized functions or methods to be defined to
handle various cases:

+(int, int)
+(int, float)
+(int, complex)
+(int, real)
+(float, complex)
+(float, real)
+(float, float)

The above functions are specialized to each of the cases required allowing
single, highly cohesive and loosely coupled functions to be defined. This is
also the true essence of object-oriented polymorphism, which allows objects to
define methods for each specific case desired. In addition to better coupling
and cohesion, multiple-polymorphism reduces program complexity by avoiding
coding logic (switch statements) and because small methods further reduce
complexity, as code complexity doesn't grow linearly with lines of code per
method, but perhaps exponentially. This should be distinguished from double
dispatch, a fancy name for single dispatch after a call, which only provides
switching on a single argument per call (but for 2 levels), consistently
ignoring the inherent type of parameters in messaging. Double dispatch is
used in languages with static typing for simplicity and efficiency
considerations.

If all of the above types are Numbers, code can be written without concern for
the actual classes of objects present:

fn(one, two: Number): Number
return one + two;

The addition expression above will invoke the correct "+" function based on the
inherent (true, actual, or dynamic) types of one and two. Only the inherent
type of "one" would be used with double dispatch! In the author's opinion,
this is a serious shortcoming. Further, double dispatch would only allow
switching to the "fn" function based on the type of "one" also. This could
lead to the use of switch statements based on type or complex coding in many
real-world programming situations, unnecessarily. In the author's opinion,
this should only be used as necessary, e.g. if the implementation language
doesn't support multiple-polymorphism and either efficiency considerations
dominate and double dispatch can be suffered, or an embedded dynamic typing
scheme is used.

Why do multi-methods allow open access to parameters? It allows efficient
handling, like C++ friends, usually by allowing representation details of more
than one object to be exposed. See [Kim ch 4, pp70-71 (D. Moon)] for an
alternative explanation. While open access can be useful in some cases, it
typically isn't recommended as a general OO practice (see section 1.15, C+W's
requirement 1 for OO languages and Section 1.2 on Encapsulation) and also
violates subtype polymorphism, because only subclass polymorphism is based on
representation and not type.

Polymorphic languages can be statically typed to provide strong type checking,
efficiency, and to support a static programming idiom, but require restrictions
in many cases, such as requiring overriding methods to have identical
signatures with the methods they substitute (as in C++) or allowing covariant
parameters but limiting base class usage (as in Eiffel). If these restrictions
are dropped, multiple-polymorphism results. Thus 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. This therefore
requires both static and dynamic typing, because no formal argument
differentiation is possible without static types, as in Smalltalk, and no
actual argument differentiation is possible without dynamic types (as in C++
and Eiffel). See section 2.3 for another example of multiple-polymorphism.

There is some concern about the efficiency of run-time method selection as
can occur with multiple-polymorphism (or even dynamic message passing).
However, static analysis optimizations are commonly available in the
literature, potentially providing a single static selection in many cases
[See Agrawal 91, Chambers 92, Mugridge 91, and etc.].

But coupling the two cases of selector variables (as found in CLOS,
Objective-C, and etc.) and several possible known selectors together with the
general undecidability of dynamic types at compile-time renders dynamic typing
and run-time selection (or checking) as unavoidable in the general case [a
point often mistaken in comp.object. E.g. simple statically/strongly typed
multi-methods still require dynamic types!]

See [Booch 91], multiple-polymorphism, for a good CLOS example.


1.20) What Is OOP?
-------------------

OOP stands for Object-Oriented Programming, the usual programming/hacking and
etc. most programmers think of. Modern software engineering methodologies;
however, consider OOP as the implementation/evolution of an OOD.


1.21) What Is OOA/OOD (And Where Can I Get What I Need On It)?
---------------------------------------------------------------

See also section 3.7, the Annotated Bibliography, and APPENDIX D. The
classified bibliography in [Booch 94] also contains entries on OOA(B), OOD(F)
and OOP(G).

[Booch 91]
"In OOA, we seek to model the world by identifying the classes and objects
that form the vocabulary of the problem domain, and in OOD, we invent the
abstractions and mechanisms that provide the behavior that this model
requires."

[Coad 91]
"OOA is the challenge of understanding the problem domain, and then the
system's responsibilities in that light".
"To us, analysis is the study of a problem domain, leading to a specification
of externally observable behavior; a complete, consistent, and feasible
statement of what is needed; a coverage of both functional and quantified
operational characteristics (e.g. reliability, availability, performance)".
"Design. The practise of taking a specification of externally available
behavior and adding details needed for actual computer system implementation,
including human interaction, task management, and data management details."

And on Domain Analysis:

"Whereas OOA typically focuses upon one specific problem at a time, domain
analysis seeks to identify the classes and objects that are common to all
applications within a given domain, [...]". - [Booch 91]

[The following quotes on domain analysis are from [Berard 93]]

"An investigation of a specific application area that seeks to identify the
operations, objects, and structures that commonly occur in software systems
within this area. - Dan McNicholl

"Systems analysis states what is done for a specific problem in a domain
while domain analysis states what can be done in a range of problems in a
domain. ...A domain analysis is only useful in many similar systems are to
be built so that the cost of the domain analysis can be amortized over the
cost of all the systems.

The key to reusable software is captured in domain analysis in that it
stresses the reusability of analysis and design, not code. - Jim Neighbors

"The process of identifying, collecting, organizing, and representing the
relevant information in a domain based on the study of existing systems and
their development histories, knowledge captured from domain experts,
underlying theory, and emerging technology within the domain." - Kang et al.

Object-oriented domain analysis (OODA) seeks to identify reusable items
localized around objects, e.g., classes, instances, systems of interacting
objects, and kits [frameworks]. OORA analysts and OOD designers will
interact on a fairly frequent basis with the domain analysis effort.

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part6
Last-Modified: 04/02/96
Version: 1.0.9

The VODAK Model Language VML homogeneously integrates the concept of
metaclasses and the separation of types and classes with other
object-oriented concepts such as properties, methods, inheritance, and
object identity. Complex nested data structures can be defined using
the set, array, tuple, and dictionary type constructors. VML supports
its own programming language for implementing methods, specifying
transactions and an ad hoc query language.

In VML classes are used to organize a set of objects corresponding to
real world entities and relationships between them. Object types define
the structure of objects and the operations defined on these
structures. They are associated with classes in order to determine the
structure and behavior of the class' instances. Metaclasses are first
class objects whose instances are classes. Metaclasses are associated
with three object types: an (optional) own-type extending their own
behavior, an instance-type specifying the behavior of their instances
(which are classes), and an instance-instance-type specifying the
behavior of the instances of their instances. Metaclasses can be
organized in an instantiation hierarchy of arbitrary depth.

This approach leads to an open, adaptable data model which provides for
the specification of additional modeling primitives at a meta layer of
the database schema. The concept of metaclasses and the separation of
classes and types allow to determine the structure and behavior of
objects and the individual inheritance behavior via semantic
relationships between arbitrary objects already at the meta layer
independently from the specifications given at the application layer
for the application specific classes.


The VODAK Transaction Model

In VODAK, we focus on two specific problems of transaction management.

1. Operations to read and edit (hyper)documents are typically complex,
interactive and of long duration. A high degree of concurrency is
required to reduce the number and length of times a transaction is
blocked.

2. A publication environment has to handle existing database systems
for using and modifying remote information and documents. Transaction
managers of existing systems, i.e. concurrency control and recovery,
have to be integrated in a transparent way utilizing the functionality
of existing managers.

Our transaction model is based on open nested transactions. Compared to
conventional flat transactions, nested transactions allow more
concurrency and are more flexible for recovery. A nested transaction
is a tree-like structure, dynamically built up by the call of
subtransactions until a bottom implementation level is encountered.

We extended the open nested model from a fixed calling hierarchy of
operations in a layered system (multi-level transactions) to an
arbitrary calling hierarchy of operations in an object-oriented system.
Commutativity of operations is applied to system defined VODAK methods,
and to methods of user defined object types. For the second type of
operations, we developed a framework to specify commutativity and
inverse operations in VML.

Query Processing

Although nearly all object-oriented data models proposed so far include
behavioral aspects, most object-oriented query languages, algebras and
query optimization strategies simply adapt relational concepts since
they focus on the complex structures of objects and neglect the
behavior. We claim that this approach is not sufficient since it does
not reflect the much richer semantics methods can carry which have to
be taken into account for really efficient query processing. The quite
straightforward approach we consider is to integrate methods in an
algebraic framework for query processing and to make there partial
knowledge about methods available in the form of equivalences. We
integrate algebraic set operators with methods defined in database
schemas within an object-oriented data model. We investigate the impact
on the architecture of the query processor when the algebra becomes an
extendible component in query processing.

Multimedia Support

The V3 Video Server was built as a demonstration showing a multimedia
application developed on top of the VODAK database management system.
The V3 Video Server allows a user to interactively store, retrieve,
manipulate, and present analog and short digital video clips. A video
clip consists of a sequence of pictures and corresponding sound.
Several attributes like author, title, and a set of keywords are
annotated.

In the future, the VODAK DBMS will be enhanced with new built-in
functionality for multimedia datatypes. Therefore, existing components
of VODAK must be changed and new ones must be added to support time
dependencies, high data volumes, and user interaction.

Query Processing

Although nearly all object-oriented data models proposed so far include
behavioral aspects, most object-oriented query languages, algebras and
query optimization strategies simply adapt relational concepts since
they focus on the complex structures of objects and neglect the
behavior. We claim that this approach is not sufficient since it does
not reflect the much richer semantics methods can carry which have to
be taken into account for really efficient query processing. The quite
straightforward approach we consider is to integrate methods in an
algebraic framework for query processing and to make there partial
knowledge about methods available in the form of equivalences. We
integrate algebraic set operators with methods defined in database
schemas within an object-oriented data model. We investigate the impact
on the architecture of the query processor when the algebra becomes an
extendible component in query processing.

The VODAK Prototype

The system architecture consists of a central database environment and
several external database environments to which the user wants to have
integrated access. Each of these environments consists of an object
manager, a message handler, a transaction manager, and a communication
manager. In addition to these components an external database
environment includes a database interface module which realizes the
access to an external database system.

The DBMS components are currently built on top of DAMOKLES and will be
in the near future on top of ObjectStore.

A first version of a C++ based prototype of VODAK is available for Sun
Sparc Stations under certain conditions. It implements all the
features specified in including e.g. metaclasses, transactions, and
remote message execution.

References

P. Muth, T. Rakow, W. Klas, E. Neuhold: A Transaction Model for an
Open Publication Environment. A. K. Elmagarmid (Ed.): Database
Transaction Models for Advanced Applications. Morgan Kaufmann
Publishers, San Mateo, Calif., 1992.

Wolfgang Klas, Karl Aberer, Erich Neuhold Object-Oriented Modeling for
Hypermedia Systems using the VODAK Modeling Language (VML) to appear
in: Object-Oriented Database Management Systems, NATO ASI Series,
Springer Verlag Berlin Heidelberg, August 1993.

Karl Aberer, Gisela Fischer Object-Oriented Query Processing: The
Impact of Methods on Language, Architecture and Optimization
Arbeitspapiere der GMD No. 763, Sankt Augustin, July 1993.

T.C. Rakow, P. Muth The V3 Video Server: Managing Analog and Digital
Video Clips, Sigmod 93, Washington, DC.

For further information contact

{aberer,muth,rakow,klas}@darmstadt.gmd.de

GMD-IPSI
Dolivostr. 15
D-64293 Darmstadt
GERMANY

FAX: +49-6151-869 966


Commercial Systems
__________________

> ArtBASE (Object-Oriented Data Model)

by: ArtInAppleS Ltd.
Kremelska 13
845 03 Bratislava
SLOVAKIA
Phone: x42-7-362-889
fax: x42-7-777 779
EMail: artbase...@artinapples.cs

Distributor for Germany:
ARS NOVA Software GmbH
Stettener Strasse 32/3
73732 Esslingen a.N.
Germany
Phone: x49-711 3704001
Fax: x49-711 3704001
EMail: in...@arsnova.stgt.sub.org

Languages: Objectworks\Smalltalk by ParcPlace Systems, Inc.

Platforms: Unix, PC Windows, Macintosh

Features:
- Fully implemented in Objectworks\Smalltalk
(ArtBASE is delivered with source code)

- ArtBASE extents Smalltalk of persistency. Persistent objects are handled the
same way as transient objects.

- Optimistic and pessimistic concurrency control.

- Transactions, including long lived transactions

- User concept with access restrictions

- storing of classes and methods in the database - entire applications
may be stored in an ArtBASE database, including the data AND the
application classes

- Currently, a single user version is available. The Distributed Multi User Server Version
will be presented at the OOPSLA'93 at Washington D.C. in September 1993 for Unix
environments and PCs.

- Existing applications can be turned to database applications very easily using ArtBASE


> EasyDB (Basesoft Open Systems, Sweden)

Produce EasyDB, a single or multi user distributed Object Database
Management System. Well integrated with C, C++ and Ada. Appears well
architected.

Main features include: fully distributed, multi-client, multi-server
architecture; distributed storage and access transparent to the user;
well integrated language bindings to C, C++ and Ada; multiple language
access and data independence between different programming languages;
conceptual modeling approach - intuitive and natural Data Definition
Languages, based on the well known ERA-technique combined with object
orientation where the user can choose between a graphical or a textual
notation; dynamic schema evolution; interactive ad-hoc query language;
powerful type system with possibilities to define ranges of permitted
values; in addition to conventional data types there are BYTESTREAM and
DATABASE REFERENCE (link); support for bidirectional relationships;
support for short and long transactions; support for versioning; dynamic
and static name resolution; high reliability and powerful
error/conflict/exception handling.

Customers include SAAB Aircraft, Swedish Defence Research, Ericsson
Radar, Swedish Telecom, Swedish Defence.

Popular applications areas include communications (EDI), simulation,
GIS, CASE/CAD, library and retrieval systems (reuse libraries).

Basesoft Open Systems AB
P.O. Box 1097
S-164 21 Kista
Sweden

Voice: +46 8 752 07 70
Telefax: +46 8 751 22 77
Email: req...@basesoft.se

Jaan Haabma, President


> GemStone (Formerly Servio Corporation)

The GemStone Object-Oriented Database, from GemStone Systems, Inc.

First introduced in 1987, GemStone is the oldest commercial ODBMS available
today. GemStone is particularly well suited for use in complex multi-user,
multi-platform client/server applications. It supports concurrent access
from multiple external languages, including Smalltalk (VisualWorks, Visual
Age, and Visual Smalltalk), C++ and C. GemStone also provides Smalltalk as
an internal DML, which can execute methods or entire applications in the
database.


CAPABILITIES

GemStone is a highly scalable client-multiserver database for commercial
applications. GemStone's features include:

o Server Smalltalk -- GemStone allows database application developers to
create classes and write methods which are stored and executed directly
in the database. These methods can be accessed either internally, or
from external client applications. This can significantly reduce network
traffic and allow applications to take advantage of the compute power or
network connectivity of the server. This also eliminates the need to
rebuild and re-deploy applications whenever application or business
processing rules change. This in turn allows for centralized code
development and management, architecture-independent code that ports

o Concurrent Support for Multiple Languages -- GemStone provides
concurrent support for applications developed in Smalltalk, C++, or C.
All applications, regardless of language, can have simultaneous access
to the same database objects.

o Flexible multi-user transaction control -- Multiple users can
operate in the database simultaneously, with a variety of transaction
control modes available. GemStone also provides a number of
reduced-conflict classes which can increase system throughput
substantially.

o Object-level security -- Authorization control can be applied to any
object in the database, allowing for fine tuning of object security.

o Dynamic schema and object evolution -- GemStone supports schema
modification through class versioning and allows full migration of
objects between versions of their classes with a simple message send.
Migration is fully customizable and is undoable.

o Production Services -- GemStone delivers the full suite of features
required in any production-ready networked database including online
backup, rapid recovery, referential integrity, event signals, notifiers,
and sophisticated concurrency control including optimistic, pessimistic
and behavior based (type specific) control.

o Scalability -- In a recent independent benchmark, GemStone scaled to
support more than 1,000 simultaneous log-ins and 100 concurrent active
users on a mid-sized SMP server.

o Legacy Gateways -- GemStone incorporates gateways or data bridges
that allow object applications to integrate legacy data, whether in SQL,
IMS, VSAM or other formats. The level of integration between GemStone
and legacy data and applications can range from simple query access to
extensive read-write interoperability.

o Developer Tools -- GemStone includes tools for debugging, browsing and
inspecting database classes and methods. Included in this set of tools
are browsers, inspectors, a debugger, and a code profiler for
performance analysis.

o Database Administration Tools -- GemStone includes a number of tools for
general database administration, including creating new user accounts,
assigning user and object security, managing database extents, and more.


PLATFORMS

GemStone release 4.0 and all language interfaces are available for UNIX
workstations and servers from Sun, HP, IBM, NCR, Siemens, and Sequent.
Client-only support is available in a number of languages for Windows 3.1,
Windows NT, OS/2 and Macintosh. GemStone is an active member of the Object
Management Group and the ANSI Smalltalk standardization committee. GemStone
supports ODMG, ANSI C++ and intends to comply fully with the emerging
standards.


REFERENCES

[Maier, et al. 84] D. Maier, J. Stein, A. Otis, A. Purdy, ``Development
of an object-oriented DBMS'' Report CS/E-86-005, Oregon Graduate Center,
April 86 - ACM 0-89791-204-7/86/0900-0472

R.G.G. Cattell: Object Data Management - Object-Oriented and Extended
Relational Database Systems; Addison-Wesley. ISBN 0-201-53092-9

Robert Bretl, David Maier, Allan Otis, Jason Penney, Bruce Schuchardt,
Jacob Stein, E. Harold Williams, Monty Williams. "The GemStone Data
Management System." Chapter 12 of "Object-Oriented Concepts, Databases
and Applications", by Kim and Lockovsky.


CONTACTS

==== Headquarters - Beaverton ====

GemStone Systems, Inc.
15400 NW Greenbrier Parkway
Suite 280
Beaverton, OR 97006

Tel: 800-243-9369
Tel: 503-629-8383
Fax: 503-629-8556

==== San Mateo ====

GemStone Systems, Inc.
2100 Winward Way
Suite 100
San Mateo, CA 94404

Tel: 415-345-3144
Fax: 415-345-9950

==== Chicago ====

GemStone Systems, Inc.
8410 Bryn Mawr
Suite 400
Chicago IL 60631

Tel: 312-380-1310
Fax: 312-380-1308

==== New York ====

GemStone Systems, Inc.
1120 Avenue of the Americas
4th Floor
New York NY 10036

Tel: 212-626-6680
Fax: 212-626-6684

==== Dallas ====

GemStone Systems, Inc.
5001 LBJ Freeway
Suite 700
Dallas TX 75244

Tel: 214-715-2602
Fax: 214-715-2623

==== Europe/UK ====

GemStone Systems, Inc.
Maple House
High Street
Potters Bar
Herts EN6 5BS England

Tel: +44 1707 827925
Fax: +44 181 343-8537


======================
==== Distributors ====
======================

==== Germany, Austria, Switzerland ====

Georg Heeg
Objektorientierte Systemtechnologien
Baroperstrasse 337
44227 Dortmund
Germany

Tel: +49 231 975 9900
Fax: +49 231 975 9920

==== Scandinavia ====

WM-Data
Sandhamnsgatan 65
Box 27030
102 51 Stockholm
Sweden

Tel: +46 8 6702000
Fax: +46 8 6702060

==== Japan ====

Japan Information Processing Co., Ltd.
2-4-24 Toyo Koto-ku
Tokyo 135 Japan

Phone: 81 3 5690 3268
Fax: 81 3 5690 3229


ABC Co., LTD Shonan System Development Div
Attn: Shoji Maekawa
271-2 Kamimachiya Kamakura-city, Kanagawa Prefecture
241 Japan.
TEL: 0467-47-8872
FAX: 0467-44-8845

==== Taiwan ====

Anco Technologies
11-1F, 76 Tun Hwa S. Road, Sec. 2
Taipei
Taiwan, R.O.C.

Tel: +886-2-7053779
Fax: +886-2-7053896

==== Mexico ====

Computadoras
Objectos y Communicaciones S.A. de C.V.
3A CDA. Porto Alegre 51
Col. San Andres Tetepilco
Mexico, D.F. 09940

Phone +52 5 672-6549 or +52 5 672-6403
Fax +52 5 672-7049


> ITASCA

Introduction

Itasca Systems develops, markets, and supports ITASCA, a distributed
active object database management system and related tools. The initial
research work for ITASCA occurred in the Object-Oriented and Distributed
Systems Lab at the Microelectronics and Computer Technology
Corporation (MCC) in Austin, Texas. The research was known as the
ORION prototypes.

The ITASCA Distributed ODBMS is a language neutral, full-featured, active
object database that supports data access from various object
languages. ITASCA allows clients to transparently access data that is
distributed among multiple servers. ITASCA supports full dynamic schema
modification that can be performed during any phase of the software
lifecycle. Applications written in dissimilar and incompatible languages,
such as C++ and CLOS, share objects through ITASCA. ITASCA stores methods
inside the database, promoting reusability and maintainability. The only
commercial ODBMS based upon the MCC Orion technology, ITASCA is considered
by many to be the most feature-rich ODBMS on the market today.

This overview describes release 2.2 of the ITASCA Distributed Object
Database Management System. It describes how ITASCA functions,
outlines its implementation features, and explains some of the system
benefits.


History of ITASCA

ITASCA is based on a series of object database research prototypes. Work
on these prototypes began in 1985 at the Microelectronics and Computer
Technology Corporation (MCC) Object-Oriented and Distributed Systems
Laboratory. MCC released the first prototype, ORION-1, in May, 1987, as
a single-user system. MCC extended ORION-1 to the ORION-1SX
prototype system and released it to the shareholder companies in April,
1988. ORION-1SX was a multi-user system with a multi-client, single
server architecture. The third prototype, ORION-2, introduced a distributed,
object-oriented architecture for a multi-user environment. MCC released
the third prototype to shareholder companies in July, 1989. ORION-2 has a
multi-client, multi-server architecture. Having met its objectives, MCC
stopped all work on ORION at that time. Over five million dollars was spent
for the three generations of prototypes.

The ITASCA product is an extension and commercialization of the ORION-2
prototype from MCC. Itasca Systems has added major enhancements and
features, improved the performance, and strengthened the code. It now runs
on UNIX systems from multiple vendors. ITASCA is an industrial-strength,
documented product, fully supported by Itasca Systems, Inc. Itasca Systems
continues to develop tools and other products to work with ITASCA.


Overview

ITASCA employs a distributed architecture with private and shared objects
spread across UNIX-based computers on a local-area network. The
ITASCA model follows the object-oriented view that uniformly models any
real-world entity as an object. Each object has a unique identifier along with
a state and behavior. Attributes represent the state of an object. Methods
(code) define the behavior of an object. A class object collects objects that
share the same set of attributes and methods. Subclasses derive from
existing classes. The resulting schema, or database definition, is a class
hierarchy. Each subclass inherits all the attributes and methods of its
superclasses. ITASCA supports multiple inheritance. A subclass may derive
from more than one superclass.

One of the breakthroughs of object-oriented technology is the reusability of
code. ITASCA allows for the active management of both reusable code and
data in an integrated system. Developers may write applications in C++,
CLOS, C or Common Lisp. This means ITASCA is language neutral. Objects
stored using one programming language can be accessed by other
programming languages. It also means an application program need not be
written in an object-oriented language.

The ITASCA database management system has features belonging to most any
database system. This includes persistent storage for data and schema,
concurrency control and locking, transaction management, multiple
security levels, and logging and recovery for both CPU and disk media
failure. Additional features of ITASCA include dynamic schema
modification, long-duration transactions, shared and private databases,
distributed version control, distributed transaction management, distributed
query management, distributed change notification, object migration, and
an extensible architecture.

Shared and private databases exist in a distributed environment in ITASCA.
The shared database is distributed across workstations (sites) in a network.
An ITASCA server controls the partition of the shared database at each site.
ITASCA clients provide transparent access to the various partitions of the
shared database. The architecture allows any number of private databases at
each distributed database site. Data can move between private and shared
databases. Private databases allow private data that is not shared with other
users of the database.

ITASCA stores the schema redundantly at each site to improve
performance. The schema storage also includes code in the form of
methods. Management of schema updates is automatic for all sites. This
includes sites that were off-line during any changes. Automatic distribution
of schema changes, including method code changes, simplifies database
administration.

ITASCA stores each instance of data in one site. The system or a user may
move the data from one site to another to improve data locality. Access to
moved data remains transparent. There is no need for a user or application
to know the specificlocation of data in the ITASCA distributed database.
ITASCA will automatically find the location of the data. This simplifies
distributed application development. The developer can rely on ITASCA
finding data in the distributed database.

No single site acts as a master site, thus ITASCA's architecture has no
single point of failure. ITASCA has neither a central data server nor a
central name server. This is important for maintaining a database system
with high availability in a networked workstation environment.

ITASCA supports dynamic schema modification to create a flexible
environment for changing or customizing a database system. Authorized
users can add and remove attributes or change the subclass/superclass
relationship at any time. Authorized users can also add or remove partitions
of the shared database at any time. All this can be done interactively without
affecting other parts of the ITASCA database at the time changes occur to
the schema. There is no need to "bring the system down" or off-load/reload
data to restructure the database. Dynamic schema modification can
significantly reduce maintenance costs. It also is useful in environments
where change to data definitions are normal or relatively frequent.

ITASCA has a sophisticated security authorization technique tied to the
class hierarchy. It supports both positive and negative authorizations at any
level in the class hierarchy. For example, granting access to all objects but
one requires only two authorizations: a global grant followed by a specific
denial. Authorization extends to classes, instances of classes, attributes,
and methods. Also, inheritance of authorization reduces the work of database
administration.

Long-duration transactions allow users to check objects out of the shared,
distributed database into their private databases. Users can then change the
objects in the private databases without affecting the shared database or
other users. These changes can be committed to the private database. Then,
at any later time, the user can check the updated object or objects back into
the shared database.

ITASCA supports version control of objects. A new version of an object
promotes the original or parent object to restrict further changes to the
parent. ITASCA also supports alternate versions such that multiple versions
can have the same parent. Promoting an object version to a released status
restricts any deletion of the object. ITASCA uses generic versions to
dynamically reference the most recent or default version of an object
without any intervention by a user or application.

Change notification in ITASCA is either flag-based or message-based.
Flag-based notification will identify an updated object upon querying the
object for such information. It is a passive notification scheme. Message-
based notification, on the other hand, is an active notification scheme. It
will execute a method (or code) upon an update or other change to an object.
Such methods can send mail messages or invoke other methods or
programs.

Memory management in ITASCA uses both page and object buffers.
ITASCA has a traditional database page buffer scheme that contains pages
with multiple objects. Desired objects move from the page buffer to an
object buffer. The object buffer then provides ITASCA with enhanced in-
memory performance because it contains only frequently-referenced
objects.


IBEX Corporation

ITASCA is a distributed active object database management system and
related tools. The ITASCA Distributed ODBMS is a language neutral,
full-featured, active object database that supports data access from
various object languages. ITASCA allows clients to transparently access
data that is distributed among multiple servers. ITASCA supports full
dynamic schema modification that can be performed during any phase of the
software

A point release of ITASCA (2.3.5) was delivered to customers with current
service contracts in September 1995. Development continues with the
expectation of ODMG compliance in the next full release, scheduled for
1996.

IBEX has built its DAWN Distributed Archiving and Workflow Network class
library of methods and development tools as an application framework to
speed the development of customized solutions to enterprise-level
integration problems. ITASCA's installed based has been largely in
manufacturing and engineering until now, but with DAWN, banking and other
services are beginning to take advantage of the products extended
functionality. DAWN is also used to link production and front office
environments for active decision support. The DAWN Manager Series comprises
focused applications (developed on ITASCA with DAWN), such as DAWN 9000 and
DAWN Account Manager which have an embedded Optical Character Recognition
functionality linked to the database with a customer-defined workflow.

IBEX has re-activated the ITASCA ObjectShare Library and encourages clients
to contribute reusable objects for use by registered ITASCA customers.
Several HTML and Web Browsers for the server itself are underway.

ITASCA was very well rated in a 1994 BUtlerBloor comparison of Object
Databases (the only one to receive more than one uncontested first rating
-- it got four!

Three framework papers describing IDE and CALS in more detail may be found
at Web site http://www.acq.osd.mil/cals/


IBEX Computing
International Business Park
4e Bd., Bat. Hera
74160 Archamps
France

Email: ib...@iprolink.ch
Voice: +33 50 31-5700
Fax: +33 50 31-5701

Web: http://www.iprolink.ch/ibexcom/

IBEX Object Systems, Inc. (North American office)
Minneapolis, MN 55401
U.S.A.

Voice: (612) 341-0748
Fax: (612) 338-5436


> MATISSE

OODBMS FEATURES LIST:

An Industrial Strength Open Semantic Object Database

Performance
- Symmetric, Fine Grain, Multi-Threaded Architecture
- Parallel and Asynchronous Disk I/O
- Automatic Disk Optimization through Dynamic Clustering
B
- High Speed OLTP Environment
Reliability
- 24 Hour - Mission Critical Operation
- Media Fault Tolerant (Object Replication)
- Transparent On-line Recovery
Database Administration
- Full On-line Administration (No Down Time)
- On-line Incremental or Full Back-Up
- Dynamically Increase Database Size - On-line
- Full On-line Monitoring
Data Management and Consistency
- Dynamic Schema Evolution
- Consistent Database Reads without Locking
- Historical Versioning, both Schema and Data Objects
- Built-in Enforced Referential Integrity
- Object Level Implicit or Explicit Locking
Scalability
- Hundreds of Concurrent On-line Users
- Hundreds of Gigabytes Per Database
- From Few Bytes to Four Gigabytes for Each Object
- Up to Four Giga-objects Per Database
Object Model
- Full Object Oriented Model
- User Extensible Object Meta-Schema
- Support for Complex, Highly Dynamic, Variable Sized Objects
- Multiple Inheritance
Intelligent Objects
- Triggers at Object, Attribute, or at Relationship Level
- Consistency Rules at Object, Attribute, or at Relationship Level
- Customizable Intelligent Object Indexing
- Automatic Inverse Relationships
Open Systems
- Open C, C++ API
- Supports Any Commercial Development Tool and Language
- No Proprietary Tool Required
- Heterogeneous Cross Platform Client/Server Architecture


For additional information on MATISSE, contact
----------------------------------------------

In the UNITED STATES:
ADB Inc. (MATISSE)
1 Twin Dolphin Drive
Redwood Shores, CA 94065
U.S.A.

Voice: 1 (415) 610-0367
Fax: 1 (415) 610-0368
Email: in...@adb.com
Web: http://www.adb.com


In EUROPE:
ADB S.A. Inc.
12-14, rue du Fort de St Cyr
Montigny Le Bretonneux
78182 St Quentin en Yvelines
Cedex, France

Voice: 33 (1) 48 64 72 73
Email: in...@adb.fr
Web: http://www.adb.fr


In ASIA:
ADB Asia / SGN
Urban Toranomon Building
1-16-4 Toranomon
Minato-ku Tokyo 105
Japan

Tel: 81 (3) 3593 3431
Fax: 81 (3) 3593 3432


MATISSE TECHNOLOGY BRIEF

MATISSE was designed to have an OPEN API, and not be
tightly bound to a single language (such as C++ or Smalltalk).
MATISSE can be used effectively with C++, C, and any other language.
This allows for MATISSE to be easily integrated into almost any
user application.

MATISSE is based upon the following principles and ideals:

MATISSE is first and foremost a database, whose purpose is to
always provide information in a consistent and correct format,
insuring referential integrity amidst the most complex database
modifications. And, to provide a set of DBA tools which meet
the challenge of managing large, complex database applications.

Production quality applications require production quality databases.
This means high reliability, high scalability, no database down
time for archival/backup/restore and 24hr/7days per week operation.
MATISSE supports these requirements.

A flexible, intelligent meta-model architecture based upon the
principles of semantic links and object technology allows for the
most effective bases for representing and managing complex, highly
interrelated data. The MATISSE meta-model provides built in
constraint checking, user definable constraints for triggers and
daemons, and full dynamic schema and meta-schema evolution.

Providing an architecture which is open allows for the integration
of MATISSE with any language or environment. MATISSE is not bound
to any language. Its 'C' API allows for its use with many
languages and environments.

The following list describes the features of MATISSE which we
believe provide the competitive advantage:
- Mission-critical operation - 24 hour operation and fault tolerance
- Independence from any programming language
- Dynamic schema management and evolution
- Flexibility of the MATISSE meta-model
- Historical versioning
- Consistent reads without locking - concurrency and locking
- Support for high level consistency and referential integrity
- Multi-threading architecture provides for a high degree of scalability

Each of these items are described in more detail below:

Mission Critical Operation.
MATISSE is designed to support 24 hour a day / 7 day a week operation,
on multi-client / multi-server architectures. Administration tools
offer high end features which are mandatory for legacy DB administrators.


Independence from any Programming Language.
The MATISSE client is implemented as a library of C procedures. As a
result, any standard language can be used to develop applications on
top of MATISSE, provided that the corresponding compiler is capable
of calling external C-functions. To date, production applications have
been built on top of MATISSE using C, ADA and C++.


Dynamic Schema Management.
Schema objects can be accessed using the same API available for data
objects. The Data Definition Language is identical to the Data
Manipulation language. Versioning is implemented for both schema
and data objects. Thus, any running application can modify the database
schema, provided that existing instances do not become inconsistent with
that schema. Consistency rules are checked by MATISSE.


Flexibility of the Model.
MATISSE is compliant with the IRDS standard. Its architecture is
highly extendible at both the Schema and the Meta-Schema level. The
MATISSE Semantic Meta-Model is not hard-coded. It can be updated to
conform with any OMG, ANSI, ISO, ... standard that might be issued
in the future. MATISSE can easily adapt to changing and evolving
standards, without significant effort or re engineering.


Versioning.
Using the on-line versioning mechanism, MATISSE allows any connected
client application to dynamically access any past database version which
was marked as a version to be saved. Access can be performed without
any particular administrative operation, and concurrently with other
on-line accesses to current or other historical versions.

Since a database version includes both data and schema objects, a
past version is always consistent, even after schema modification. As
a past version is accessed, so to is it's schema, and even the
appropriate meta-schema associated with the accessed version.


Consistent Reads without Locking.
Using its versioning mechanism, MATISSE offers three kinds of
database access:

Typical transaction-based access: : as the
database migrates forwards, and updates are made, database access
occurs against the latest consistent database version. A successful
transaction commit results in a new consistent version. If explicitly
named, this version becomes a historical database version, which can
be accessed by its logical name in the future .

Historical version access: the application specifies the logical
name of the historical version to be accessed. Access is read-only,
and does not require any locking mechanism.

Current Time access: : this is a very powerful and unique feature
of MATISSE. Any application can request the latest available consistent
database version, using a reference to current time, with no
locking overhead. The "current time" database version is based
upon the last transaction commit, and is automatically maintained by
the database. A "current time" database version acquires no database
locks when accessed in read-only mode, thereby significantly
reducing overhead.

Through these three access modes, MATISSE supports on-line
transaction processing and decision support requirements concurrently
within a single application, through the use of current and historical
versions.

Support for High Level Consistency.
With MATISSE, referential integrity cannot be corrupted. MATISSE's
Semantic Links are specialized - i.e. they are specifically
established between classes, they are directional, and, inverse links
are automatically and dynamically set by MATISSE. As a result, a
MATISSE database understands its relationships, and fully manages
all internal consistency features, insuring that no corruption occurs.

Developers can describe very complex consistency methods and rules
using daemons and triggers. These methods can be attached to
particular events such as, before or after creation, as well as class,
instance, attribute modification. Daemons and triggers provide for
message propagation within your database. This results in a very
intelligent database, which can be event driven.


MATISSE Server runs on
- Sun Sparcstation - SunOS 4.1.3
- Sun Sparcstation - Solaris
- VAX - VMS
- HP9000 - HP-UX

MATISSE Client runs on
- Sun Sparcstation - SunOS 4.1.3
- Sun Sparcstation - Solaris
- HP9000 - HP-UX
- Windows NT
- Macintosh


> NeoAccess

NeoLogic Systems

NeoLogic Systems produces NeoAccess, a cross-platform object database
engine, and NeoShare, a client/server collaborative computing engine.
NeoAccess consists of a set of C++ database and collection classes.
NeoShare extends NeoAccess to provide shared multi-user access to objects
in a database. Both products come with full source code for all supported
development environments (Windows, Macintosh and Unix). NeoAccess is
priced at $749 per developer for full surce code for all supported
environments, and there are no licensing fees. Support options are
available.

NeoAccess Introductory Toolkit is available without charge. The
Toolkit consists of a 200+ page technical overview on the product plus
several sample applications with source code. This is everything you
need to determine what NeoAccess is and how you might use it in your
development. The Macintosh, Windows and Unix versions of the
documentation can be downloaded from the NeoLogic home pages or FTP
site, or a diskette can be supplied upon request.

NeoAccess Version 4.0, released in October 1995, features full support
for Microsoft Visual C++ 4.0 IDE and the MFC 4.0 application framework.
The client/server database engine, NeoShare 1.1, was released in December
1995, and includes support for additional application frameworks.

NeoLogic Systems
1450 Fourth Street, Suite 12
Berkeley, CA 94710
U.S.A.

Voice: (510) 524-5897
Fax: (510) 524-4501

Email: neol...@neologic.com
Compuserve: 71762,214
AOL: NeoLogic
Apple Link: NeoLogic
Web: http://www.neologic.com/~neologic/
Ftp: ftp.neologic.com /users/neologic

NeoLogic News:
To subscribe, send email to: list...@fairbanks.pvt.k12.ca.us
with the following line: SUB NeoAccess-Forum <Your Name>

NeoLogic Systems has representatives in Germany, Switzerland, UK,
Belgium, France, and Japan.


> OBST+

Xcc Software Technology Transfer offer OBST+, a full-featured, language
independant OODBMS with a C++-Interface and a Tcl/Tk binding. It's multiuser,
supports schema evolution, check-in/check-out, full access to the Meta-DB and
is available on several Unix-Platforms, and a Win NT port is underway.
A GNU-version is available. (archie search: OBST3-4.3.tar.gz)

Xcc Software Technology Transfer
Durlacher Allee 53
D-76131 Karlsruhe
Germany

Voice: 49-721-96179-0
Fax: 49-721-96179-79

email: ob...@xcc-ka.de

Web: http://www.xcc-ka.de/OBST/OBST.html
http://www.fzi.de/divisions/dbs/projects/OBST.html

Ftp: ftp://ftp.fzi.de/pub/OBST/current
ftp://ftp.xcc-ka.de/pub/OBST


> O2 (O2 Technology)

O2 Technology, Inc.

The O2 System is a fully modular object database, well adapted for
developing large-scale client/server applications. The O2 system conforms
to the ODMG 93 standard. O2 is an open system, which ensures its
compatibility with a corporate computing environment.

O2 integrates a powerful engine with a graphic programming environment, a
complete set of development tools and programming languages. The modules
can be integrated with existing relational database engines, GUI tools,
the World Wide Web, programming languages and CASE and methodology tools.

With O2, you can develop and run applications in areas where traditional
tools and systems cannot handle information efficiently (e.g. management
of technical information, geographical information systems, CAD/CAM and
network management).

For more information on O2, consult the following REFERENCES:

Francois Bancilhon, Claude Delobel, Paris
Kanellakis. "Building an Object-Oriented Database
System: The Story of O2". Morgan Kaufmann Series
in Data Management Systems, San Mateo, Calif., 1992.

F. Bancilhon, G. Barbette, V. Benzaken, C. Delobel,
S. Gamerman, C. Lecluse, P. Pfeffer, P. Richard,
and F. Velez. "The Design and Implementation of
O2, and Object-Oriented Database System".
Advances in Object-Oriented Database Systems,
Springer Verlag. (Lecture Notes in Computer Science
series, Number 334.)

C. Lecluse, P. Richard, and F. Velez. "O2, an
Object-Oriented Data Model". Proceedings of
SIGMOD88. Also appears in Zdonik and Maier,
"Readings in Object-Oriented Database Systems",
Morgan Kaufmann, 1990.

2 Technology, Inc.
3600 West Bayshore Road, Suite 106
Palo Alto, Ca 94303
U.S.A.

Voice: (415) 842-7000
Fax: (415) 842-7001
Email: o2i...@o2tech.com
Web: http://www.o2tech.com


O2 Technology, Inc.
7 rue du Parc de Clagny
78035 Versailles Cedex
France

Voice: 33-1-30-84-77-77
Fax: 33-1-30-84-77-90
Email: o2i...@o2tech.fr


O2 Technology
North Heath Lane
Horsham
West Sussex RH12 5UX
United Kingdom

Contact: Dr. Sharon Cooper

Voice: (44) 403 211 020
Fax: (44) 403 273 123
02t...@tenet.co.uk

Web: http://www.o2tech.fr/ Note: this Web server is built on top
of O2Web, the O2 WWW gateway, and
uses the O2 ODBMS for a backend.


> Objectivity/DB (Objectivity)

Introduction:

Objectivity/DB has a fully distributed client/server architecture that
transparently manages objects distributed across heterogeneous environments and
multiple databases. It provides an application interface that uses transparent
indirection to ensure integrity and provides a single logical view of all
information, with all operations working transparently on any database on the
network, with scalable performance as users and objects increase. A
higher-level Object Definition Language (ODL) is available as well as a C
functional interface, integrated C++ interface, and SQL++.


Objectivity/DB

Objectivity/DB [Reference: Technical Overview, Objectivity, 1993], a product
of Objectivity, Inc. of Menlo Park, CA, provides an integrated C++ programming
interface with an emphasis on the DBMS engine for robustness and scalability
from workgroups to enterprise-wide production applications. In production use
today with more than 50,000 end users licensed, it supports a fully
distributed, rather than central-server, architecture, with all operations
working transparently over a mixture of multiple databases, schemas, users, and
computers, and over heterogeneous hardware, operating systems, and networks.
The language interface includes a C++ class library interface, soon to be ODMG;
a C function library; and SQL++, supporting query predicates with either SQL or
C++ syntax, interactively or programmatically. Over forty administrative and
GUI tools provide both an interactive and programmatic interface, and a
messaging backplane allows third party tools integration at four different
levels, with a list of partners at all levels.

One of the key architectural concepts of Objectivity/DB is an object reference
mechanism that ensures data integrity. Unlike traditional ODBMSs that use
direct pointers, which become invalid after commit and hence lead to crashes
and corrupt databases, Objectivity/DB uses an indirection to guarantee safe
reference. Transparent to the user, this indirection requires an extra test
and pointer dereference, or a couple of cycles, which is not measurable in most
applications. However, it ensures integrity of all references, even across
transaction boundaries, resulting in production quality robustness. Also, it
provides object level granularity for the object manager, allowing it to move,
cluster, and swap objects as necessary, one of the keys required for
scalability in objects and users. Finally, it allows object-level granularity
for current features, such as heterogeneity and versioning, and future
extensions, such as object-level security.

A higher-level Object Definition Language (ODL) is provided that allows
declaration of modeling concepts such as bi-directional associations, behavior
of associations between objects as they version (move, copy drop), and
propagation of methods across associations. These then result in automatically
generated methods and declarations for both C++ and C. The standard C++ API
allows application programmers to work with any standard compilers and
debuggers, with no extra pre-processors, providing ODBMS capabilities via
overloading C++ operators (new, ->, etc.), and declarations via provided
classes (for references, etc.).

Workgroup through enterprise-wide and cross-enterprise computing is supported
via a distributed client/server architecture that provides a single logical
view over multiple databases on heterogeneous machines. The user sees a
logical view of objects connected to objects and need not worry that one object
is in a database on a Sun workstation, while another may be in a database under
Windows or VMS. All operations work transparently across this environment,
including atomic transactions with two-phase commit, propagating methods, and
versioning. Objects may be moved between databases and platforms without
affecting working applications or requiring changes to the applications.
Multiple schemas may be created, without affecting other users or databases,
and may be used simultaneously with shared schemas, allowing local groups to
define their own models but still connect to other groups. Databases may be
detached from this shared environment (federated database) and used on portable
devices, reconnected or moved to different (compatible) environment, or
distributed as parts or image libraries. Gateways to RDBMSs are provided via
third-party integration with Persistence Software, and more generally to any
foreign data store, as long as the user installs the appropriate access
methods, extending the single-logical-view to include read/write access to
arbitrary foreign data stores. Together, these allow delegation of
responsibilities to the appropriate users, integration with existing systems,
and gradual migration toward full enterprise-wide sharing.

The on-demand object manager directly and automatically manages object access
and buffering, rather than relying on system facilities such as virtual memory
or user manual get/put calls. Mechanisms used include multiple buffer pools
locally and remotely, b-trees, hashing, scoped names, keys, and iterators, with
distributed catalogues for schemas and databases. A direct connection is
established between the user and the objects used, so that users do not
conflict unless and until they are competing for the same objects, thus
avoiding the traditional central-server bottleneck. Short transactions are
based on traditional (transient) locks, owned by the process, and group
together an arbitrary set of operations. Long transactions are based on
persistent locks, owned by the user, and provide the same arbitrary grouping.
Default concurrency is two-phase locking and serialization, but extensions
available include MROW, or multiple-readers concurrent with one-writer, and
allow users to lock with or without wait or with timed waits, to implement more
sophisticated mechanisms.

Objects may be modeled using C++ structures augmented by classes provided such
as strings, dictionaries, and relationship management, as well as some
particular domain libraries. A simple object is a C++ class (or C structure)
with associated access methods. A complex object may include multiple varrays,
each being a dynamically varying sized array of arbitrary structure. A
composite object is any network of related objects that acts as a single
object, both structurally and behaviorally, via propagation of behaviors to
component objects. Any number of composite objects may be contained in
composite objects, and a single object may participate in any number of
composites. The relationship mechanism supports uni- and bi-directional
relationships, one-to-one, one-to-many, and many-to-many. Versioning is
supported at object granularity, may be turned on or off at any time for each
object, may be restricted to linear or allow branching with multiple writers.
References to versioned objects may be to a specific version or to the default
version, which may be separately specified by a method and may allow multiple
defaults. Schema and object evolution are supported via versioning of the
type-defining objects. Each time a type definition is changed, its defining
object is versioned, allowing arbitrary changes. Objects may then be instances
of the old or new type version. Object evolution or upgrading to the new type
version is supported by the user writing conversion methods which are
installed and invoked by the system.

ANSI SQL query is supported in the SQL++ product. Predicate syntax may be
either C++ or SQL. The ODBC and SQL Access Group (SAG) protocols are
supported. Queries may be invoked programatically or interactively, with ad
hoc support. Access to object features is available via methods and traversal
of relationships.

Over forty administrative and developer tools are provided, each with both an
interactive and programmatic interface. These include GUI object and type
browsers, query browsers, report generator, tools to examine and force short
and long locks, to move objects and databases, etc. On-line incremental backup
provides a consistent network-wide snapshot, including referential integrity
across all databases, and runs incremental and full database backups with no
need to acquiesce the databases and no interference with active applications.
All tools are built around a messaging backplane, which supports four levels of
integration with user and third-party tools. Integrated products include HP
SoftBench (full operational level), CenterLine's ObjectCenter (tool level),
Persistence RDBMS gateway, PTech and ProtoSoft Design and Analysis (language
level), and XVT and UIM/X (compatibility level).

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part7
Last-Modified: 04/02/96
Version: 1.0.9

Objectivity/DB is resold by Digital Equipment Corporation as DEC Object/DB,
providing a multi-billion-dollar second source vendor. Over 50,000 end users
are licensed in production use, with applications including real-time
telecommunications, aerospace, defense, case, CAD/CAM, CIM, manufacturing, oil
& gas, process control, transportation, multi-media, case, document management,
financial analysis, and corporate information management. Platform support
includes all Sun, all DEC (including VMS, alpha, OSF-1), HP/9000 series (both
68xxx and PA-RISC), IBM RS/6000, NCR 3300, SGI, Windows 3.1, and Windows NT.

On Schema Evolution (from original survey):

In the just-released Version 2.0 (shipping Oct 92), schema evolution
is supported via dynamic versioning of type-defining objects [ie.
class versions -- SMC], and via a step-by-step approach that allows
conversion of instance data via user-provided conversion methods.
Also, a full dynamic type manager interface is available for doing
fancier things.

Objectivity, Inc.
301B East Evelyn Avenue
Mountain View, CA 94041-1530
U.S.A.

Voice: (415) 254-7100
Fax: (415) 254-7171
Toll Free: 1-800-676-6259 1-800-SOS-OBJY

Email: in...@objy.com
Ftp: ftp.objy.com
Web: http://www.objectivity.com

Objectivity maintains regional offices in Los Angeles, CA; Burlington,
MA; Iselin, New Jersey.

Objectivity-Europe
Beijerscheweg 28a
2821 NG Stolwijk
The Netherlands

Voice: +31 1820 50506
Fax: +31 1820 12362
Rick ter Horst - ho...@objy.com

Objectivity - Europe
Socratesstraat 22
6836 GG ARNHEM
The Netherlands

Voice: +31 85 235 907
Fax: +31 85 235 541
Henk Nijenhuis - he...@objy.com

Additional representatives in Ireland, France, Germany Sweden, United
Kingdom, Israel, Italy, Portugal, Switzerland, Taiwan, Japna, Hong Kong


> ObjectStore

Product Description

ObjectStore[TM] is a high performance ODBMS designed for ease of use in
development of sophisticated applications using object-oriented
development techniques. It offers a tightly-integrated language
interface to a complete set of traditional DBMS features including
persistence, transaction management (concurrency control and
recovery), distributed access, associative queries over large amounts
of data, and database administration utilities. ObjectStore's data
management facilities combined with popular development tools create a
high productivity development environment for implementing
object-oriented applications.

Key Features:

- Transparent interface designed for popular C and C++ programming
environments.

- Concurrent access to large amounts of persistent data.

- Distribution of objects over networks using a variety of popular
network protocols.

- Access to persistent data at the same speed as transient data.

- Extensible data modeling capabilities for applications requiring
complex data structures.

- Easy migration path for existing C and C++ applications.

- Class libraries for version and configuration management.

- Class libraries for managing collections of objects.

- A fully distributed (multi-server/multi-database) ad hoc query
capability.

- An interactive Browser to inspect objects and object
descriptions.

- Interoperable with ObjectStore servers running on other operating
systems and hardware environments.

- Complete schema evolution for an application's metadata and
existing object instances.

- Full online backup for continuous processing environments.

- Meta object protocol with programmatic access to schema
information.

- Dynamic Type creation for extending existing class definitions
during program execution.


System View

ObjectStore supports cooperative access through its flexible
client/server software architecture, which allows users to make the
take advantage of the computational power that exists on the desktop.
ObjectStore's client/server implementation allows one server to
support many client workstations, each workstation to simultaneously
access multiple databases on many servers, and a server to be resident
on the same machine as a client. ObjectStore's distributed
architecture supports several network environments for
interoperability among popular workstations and PC's and includes
support for TCP/IP, Novell IPX/SPX, other popular network protocols.


Application Interface

Access to ObjectStore is provided through a library based application
interface compatible with popular C and C++ compilers and programming
environments. The ObjectStore application interface provides support
for C++ compilers -- such as those from workstation suppliers -- and
development environments from independent software vendors such as
Visual C++ from Microsoft, ObjectCenter from CenterLine Software, Inc.
and Energize from Lucid, Inc. The application interface provides
powerful high-level function calls which enable the programmer to
create multi-user application which share large amounts of data.
These functions include:

- Relationship Management
- Version Management
- Collection Management
- Storage Management
- Associative Queries
- Object Iteration
- Transaction Management
- Index Management
- Clustering

Applications developed using ObjectStore library calls are
source-level compatible with ObjectStore applications developed for
other operating systems on other hardware platforms.

Platforms

ObjectStore is available on the following major platforms:

Unix Workstation Platforms

- DEC MIPS Ultrix
- HP 700 Series HP-UX
- HP 800 Series HP-UX
- IBM RS/6000 AIX
- NCR 3000
- Olivetti LSX-50xx SVR4
- Silicon Graphics IRIX 5.x
- SunSoft Intel Solaris 2
- SunSoft SPARC Solaris 1 SunOS 4
- SunSoft SPARC Solaris 2 SunOS 5
- Univel UnixWare

PC Platforms

- Windows 3.1 (Win32s)
- Windows NT (Intel)
- OS/2 Release 2.0 and 2.1
- Novell Netware Release 3.1 and 4.0 (server only)

The Company


Object Design, Inc.
25 Mall Road
Burlington, MA 01803
U.S.A.

Voice: 1-800-962-9620
(617) 674-5179
(617) 674-5000
Fax: (617) 674-5010

Email: in...@odi.com
Web: http://www.odi.com
Ftp: ftp.odi.com


Offices in Asia Pacific, Europe and throughout the U.S.. Full contact
information available through their web page.

The German user group (OS_UG) has a web site:
http://www.informatik.th-darmstadt.de/OS_UG


> ONTOS [formerly VBase] (Now ONTOS, Inc. formerly Ontologic)

Entry on schema evolution only:

*Ontos provides schema evolution. It allows any class to be modified.
*The major drawback is that data does not migrate ie., instances are
*not modified to adopt to the new class definition. So schema changes
*can be done only on classes that do not contain instances and do not
*have sub classes that contain instances.
*[h.subr...@trl.OZ.AU]

*As a system for experiments, we are currently using ONTOS from
*Ontologic Inc. Unfortunately, there is no transparent concept of
*schema evolution for populated database. Thus, we still investigate
*how it works.


ONTOS, Inc. provides object-oriented products and services that enable
users to integrate, distribute, and manage information across the
enterprise.

Product Overview: The ONTOS Virtual Information Architecture (ONTOS VIA)
is a strategy for integrating an organization's disparate information
resources. It includes a set of products for developing and deploying
distributed, network-based applications and for accessing information
stored in a variety of formats. ONTOS VIA allows organizations to take
advantage of new technologies while preserving existing technology
investments.

The products that make up ONTOS VIA include ONTOS DB, a fully distributed
Component Object Database and ONTOS Object Integration Server (ONTOS
OIS), which provides object access to relational and mainframe databases.
ONTOS products are available on UNIX and Microsoft operating environments.

ONTOS, Inc.
900 Chelmsford St.
Lowell, MA 01851
U.S.A.

Voice: (508) 323-8000
Fax: (503) 323-8101
Email: in...@ontos.com
sup...@ontos.com
Web: http://www.ontos.com


> Odapter/OpenODB (Hewlett-Packard)

Odapter is HP's new object/relational adapter which
enables object-oriented developers to share a common
object model stored in the ORACLE7 relational database
management system (RDBMS). Odapter is also available with
HP's ALLBASE/SQL RDBMS. The combination of Odapter
and ALLBASE/SQL is called OpenODB.

Odapter
Technical Data
Object/Relational Adapter

A Productivity Tool for Scalable Object-Oriented
Applications

Odapter is a tool for developers writing scalable
object-oriented applications requiring the
integration of new objects and legacy information.
Odapter is valuable because it:
* accelerates application development
* reduces the cost of keeping applications current
* enables applications to scale

Odapter delivers the productivity of object
technology while adhering to your data management
standards.

Consider Odapter if you need to be able to do one
or more of the following:
* develop object-oriented applications and
store objects in a relational database
* easily access legacy data and existing
applications from your new system
* support a large number of end-users who will
be simultaneously accessing information
* store large amounts of complex information

The following are examples of applications well-
suited for Odapter:
* a customer billing application written in
Smalltalk combining data stored in DB2 with new
objects. (Telecommunications)
* a network management application written in C
using Odapter as the object manager, able to scale
to millions of objects (Manufacturing)
* a complex Oil and Gas industry standard model
automatically generated from an Express analysis
and design tool.
(Oil & Gas)
* a medical application using Odapter to
combine heterogeneous components of patient
records. (Healthcare)

Odapter provides authorized access to sharable
objects, including existing data and business
processes. By bringing object-oriented capabilities
to heterogeneous systems environments, Odapter
delivers increased functionality while leveraging
the stability of existing RDBMSs and legacy
information.

Odapter Object Model

The Odapter object model is based on three key
concepts - objects, types and functions.
* Objects are a combination of data and
behavior (functions). Figure 2 is an example of an
object.
* Types are dynamic templates allowing you to
group together similar components or objects.
* Functions define the attributes,
relationships and behavior of objects. Odapter
supports four types of user-defined functions:

Stored functions define attributes and
relationships that are stored in the database. In
Figure 2, flightno is a stored function. The
functions aircraft and crew are also stored
functions with user-defined results.

SQL-based functions allow you to access existing
relational tables with Odapter's object-oriented
model. In Figure 2, citypair is an SQL-based
function accessing values from an existing
relational table.

OSQL-based functions define attributes and
relationships that are derived or calculated with
OSQL statements. In Figure 2, delay and depart are
OSQL-based functions. Delay calculates changes in
arrival and departure times based upon events that
disrupt the schedule; depart handles the update of
functions related to departure and transitions the
flight from OnGround to InAir.

External functions are a reference to code or data
stored outside of Odapter. In Figure 2, cancel is
an external function that executes code outside of
Odapter to free up resources no longer assigned to
the flight.

Odapter Language

The Odapter language can be combined with functions
implemented in C++, Smalltalk or C. You create and
manipulate objects, types and functions using
Odapter's object-oriented structured query language
(OSQL). OSQL is a functional language that is a
semantic superset of SQL, the structured query
language for relational databases. OSQL is a
computationally complete language with statements
allowing you to define and manipulate information
in your Odapter enhanced relational database,
specify authorization for individuals or groups,
define transactions, embed program logic within
functions, and administer the database.

OSQL includes programming flow statements, such as
IF/THEN/ELSE, FOR and WHILE. This procedural
language allows Odapter functions to model complex
behavior, simplifying your application code. By
decoupling behavior from the applications, multiple
applications can share information with benefits
such as consistency, security and integrity. See
Table 5 for a list of all OSQL statements.

Odapter Object Storage

Odapter objects are stored in the developer's
choice of relational databases. Odapter interfaces
to the underlying RDBMS through an SQL command
interface. Currently, developers can choose to
store their objects in ORACLE7 or HP ALLBASE/SQL.

The choice of RDBMS is made when a particular
database is created. The users are only limited by
the number of Odapter concurrent user licenses
purchased. This flexibility allows database
administrators to continue using their existing
administration procedures and keeps the group from
having to choose yet another database management
system.

During the initial development of an application,
developers can make rapid progress without
knowledge of the underlying relational database.
Optimization of the objects and how they are stored
in the underlying relational database is best
done during the deployment phase.

Odapter Development Environments

Odapter developers have a choice of development
environments. Whether Smalltalk, C++ or more
traditional C and C-linkable languages are used,
Odapter enables object storage in a scalable and
robust relational database. In fact, objects can be
shared between different applications, allowing
different projects to employ the best tools for the
job!

Odapter and Smalltalk

Odapter provides Smalltalk developers with
transparent access to information stored in the
underlying relational database.

Odapter's Smalltalk Class Builder utility
automatically generates ParcPlace Smalltalk
compatible classes and methods based upon an
Odapter object model. The developer can select
specific Odapter types and functions, resulting in
a corresponding set of Smalltalk classes and
methods. Once the Smalltalk schema is generated,
the Smalltalk developer can transparently access
the underlying relational database, as shown in
Figure 3.

printFlight
|allFlightObjects|
allFlightObject:=Flight allObjects.
AllFlightObjects do: [:aFlight|
Transcript show :aFlight flightno value; cr].
Figure 3


Figure 3 shows how to access the flight objects
shown in Figure 2 through Smalltalk. This example
retrieves all flight object identifiers and prints
the flight# for each one of the flight objects.

All Smalltalk classes and methods which result in
the access of Odapter structures are italicized.
Flight is a Smalltalk class that corresponds to the
Odapter type Flight. The Smalltalk methods
allObjects and flightno map to Odapter calls that
access data from the relational database storage
manager.

Odapter and C++

For C++ developers, once the corresponding C++
model is created, Odapter provides the abilility to
manage C++ objects stored in the underlying
relational database, as shown in Figure 4.

void printFlight()
{
int i;
ODBType Flight ("Flight");
ODBBag allFlights=Flight.allObjects();
ODBFunc flightno("flighno");

for(i=0;i<allFlights.size();i++){
cout<<flightno(allFlights[i]);
}
}
Figure 4

Figure 4 shows a C++ version of the Smalltalk
example in Figure 3. That is, Figure 4 shows how to
access all the flight objects shown in Figure 2 and
prints the flight number associated with each
flight object.

The Odapter C++ library includes a set of classes
(e.g. ODBType, ODBClass, ODBFunc, ODBBag) and
corresponding member functions (e.g. allObjects).
User-defined classes (Flight) and member functions
(flightno) are also shown. In Figure 4, all Odapter
calls are in italics.

Odapter and C-linkable Languages

For traditional developers using C, or any
languages linkable with C, the object-oriented
features are provided by Odapter. Odapter objects
are manipulated by embedding OSQL statements in the
C program, similar to the db.execosql call shown in
Figure 4. In addition, the C interface requires the
conversion of data types from Odapter to C.

By embedding Odapter calls in a C program, the C
language becomes object-oriented.

Features and Benefits

Accelerates Application Development

Odapter accelerates application development by
integrating with familiar development environments
and by providing a robust object-oriented model.

Odapter's choice of development environments
includes those which support the Smalltalk, C++ and
C languages.

Odapter's robust object model enables the
integration of legacy data and business processes
in the context of one sharable business object
model, shielding the developer from the data
storage complexity.

The following Odapter features accelerate
application development:

Automatic mapping of objects to relational
databases
The application developer is shielded from the task
of converting complex object models to two
dimensional relational tables.

Smalltalk Class Builder
Once an OSQL schema is created, whether using
available analysis and design tools or manually,
Odapter's Smalltalk Class Builder can generate
corresponding Smalltalk classes and methods. The
developer can select the relevent part of the
Odapter schema to generate. As the Odapter object
model changes, developers can also incrementally
update the Smalltalk classes.

Object Identity
Each object manipulated by Odapter has a unique,
system-provided handle called an object identifier
(OID). OIDs eliminate the need for creating unique
keys to identify stored information. Additionally,
OIDs reduce duplication of information when several
attributes would be needed to uniquely identify
information in the database. OIDs are also a
powerful way to tune data access and performance.

Inheritance
Odapter objects can use functions defined on parent
types in the type hierarchy. For example, as shown
in Figure 5, a subtype of Employee called Pilot
could inherit functions from Employee like hire and
name, while defining unique functions like
hoursflown and status.


Multiple Inheritance
Functions defined on a type can be inherited by one
or more subtypes. In Figure 5, functions accessible
by the type ManagingPilot are inherited from its
parents, namely all functions defined on Employee,
Pilot and Manager. By inheriting rather than
redefining functions, you can easily add
functionality to your application.

OSQL
If you already know SQL, you can quickly be
productive using Odapter's OSQL. Both query
languages are set-based, that is they retrieve sets
of information based upon queries. Thus, OSQL does
not require users to navigate through the database
chasing pointers or object references.

Encapsulation
Odapter protects end-user applications from changes
to the internal definition of objects. Since
Odapter only allows access to data through
functions with well defined arguments and results,
your applications are protected from changes to the
function body and you have control over how
information is used.

Aggregate Types
Aggregates are used to represent collections, such
as crew members (maybe several pilots, flight
attendants and a mechanic) for a particular flight,
or the employees reporting to a particular manager.
Aggregates are not required to have a predetermined
size. Odapter manages the memory associated with
aggregates, relieving your application of this
work.

User-defined Data Types
You can construct user-defined data types in
Odapter, such as a type called Flight, Employee or
Aircraft, as shown in Figure 6. Functions defined
on these types can manipulate data stored within
the current object, within other related objects or
outside of Odapter. User-defined types maximize
flexibility and lead to more manageable, clearer
code.

Complex Objects
With Odapter you can construct complex objects from
simpler objects. For example, Figure 6 shows the
relationships between the types Flight, Aircraft
and Employee. Complex objects relieve applications
from managing such relationships.


Reduces the Cost of Keeping Applications Current

Odapter supports a server-centric business model
which means the business logic and associated data
is sharable by multiple applications. By separating
out business objects (data and processes), from the
application development environment, your company's
business can be modified without impacting the
applications. These changes can be immediately
leveraged by the calling applications without
recompilation

The following features make applications easier to
keep current:

External Functions
Using external functions, you can access
distributed data and code stored outside of the
relational database used by Odapter for storage,
regardless of location or data format. Examples of
external data sources include IMS, DB2 as well as
custom databases and flat files. Odapter acts as an
integrator so your application can manipulate
information as recognizable business objects. This
not only allows transparent migration of data over
time, it accelerates developer productivity by
hiding the complexity of a diverse data storage
environment.

Overloaded Functions
Multiple functions can have the same name with
different implementations. An application calls a
function (e.g. salary) and Odapter determines at
run-time which code (salary for Manager or salary
for Pilot) to execute, based upon the type of the
object against which the function is invoked. The
application is simplified since the conditional
logic for determining which function to execute is
now in Odapter.

Dynamic Schema Modification
Odapter object models can be modified while the
database is running. Developers can add new
functions and types, as well as change the
implementation of functions. This capability is
particularly valuable to applications with high
availability requirements.

Dynamic Typing
You can change the type of an object without
destroying and recreating the object. An object can
also belong to more than one type. As shown in
Figure 7, once a Flight leaves the ground, it would
change state from being an OnGround to an InAir
Flight. OnGround functions such as maintenancecrew
and availableseats would no longer be needed. An
InAir object would need certain functions like
bestroute and delay to calculate the most time
efficient route and to calculate a projected delay
based current weather conditions. Dynamic Typing
allows you to represent an object in Odapter which
transforms itself over time and, therefore, changes
capabilities and attributes.

Late Binding
Odapter supports functions that are resolved at
runtime. Late binding allows you more flexibility
in application development and gives you the full
power of overloaded functions as described earlier.
On the other hand, Odapter will precompile or do
early binding to improve performance. However, when
types and functions changes at runtime, impacting a
particular function, late binding occurs and the
application automatically takes advantage of the
new implementation of the function when it is
called.

Referential Integrity
Since Odapter manages the relationships between
objects, it can manage referential integrity on
your behalf. That is, if an object referenced by
other objects is deleted, the system removes all
dependencies. Your application code is simplified
since Odapter is able to keep the logical business
model intact automatically.

Multimedia
Odapter allows you to manage large, unformatted
data in binary format and treat that data as an
attribute of an object. For example, you may want
to create a function called diagram to show the
sections and seating for an Aircraft object.
Multimedia information can include graphics, images
and voice. You can also define functions in Odapter
to manipulate this multimedia information. For
example, you can create a function called showexits
that adds information to the diagram. Thus, various
applications can share these complex functions.

Import Facility
The Odapter Import facility allows developers to
update existing Odapter functions with data from
external files such as spreadsheets or other
databases. This is an object-oriented version of
the relational "bulk load" functionality.

Enables Applications to Scale

Odapter makes applications more scalable by storing
objects in a choice of RDBMSs, like ORACLE7. As a
result, applications can access large volumes of
data, be used by a large numbers of users, and
perform on-line backup. In addition, Odapter
protects against unauthorized access from users in
a distributed environment.

Odapter, with the help of the underlying relational
storage manager, ensures the integrity and security
of your data while maximizing the availability of
that data for end users.

The following features enable applications to
scale:

Indexing
Indexes are automatically generated when you create
types and functions in Odapter. You can also define
your own indexes using B-tree and hashing
algorithms. Indexes make end user access to
information faster.

Clustering
Related functions and objects which have the same
value for a function can be stored close to each
other. This ability to influence how objects are
stored allows you to tune the performance of the
database based on how the information will be
accessed by applications.

Transaction Management
Odapter ensures the logical and physical integrity
of your database by giving you complete control
over the unit of work to be performed within a
single transaction. With this control, you can save
or rollback a transaction (throw away temporary
work) at your discretion. Savepoints are also
supported so that you can rollback parts of a
transaction.

Multi-user Concurrency Control
Odapter is designed to support hundreds of users
accessing the same information while guaranteeing
the integrity of that information.

Authorization
You can control access to an Odapter enhanced
database at the database and function levels based
on individuals or groups of users. For example,
authorization statements can provide read access to
a large group of users while limiting write or
delete access.

High Availability
Because Odapter actually stores objects in an
RDBMS, Odapter can leverage RDBMS features to
maximize the availability of your information by
providing:
* on-line backup of the database, to backup the
database while it is being accessed
* dual logging, to ensure the integrity of your
log file
* switch log, to automatically switch to a
second log file if the original log file becomes
full
* dynamic file expansion, to expand the size of
your database as it becomes full

Odapter will also take advantage of other available
features of the underlying relational database
management system such as replication or "warm
standby".

Recovery
Odapter uses the robust logging and recovery
facilities of the RDBMS. In case of a failure, you
can rollback work or perform rollforward recovery
to a particular time, using the log file to
recreate saved work.

Odapter Software Components

Odapter uses a client/server architecture, enabling
you to efficiently utilize your computing power.
Clients use the object application call interface
(OACI) to communicate with the server over the
network. The clients and server components can also
reside on the same machine.

Odapter is bundled with the following client and
server components, as shown in Figure 8:

Client Components

* Interactive Object-Oriented SQL (IOSQL)
This interface allows you to interactively enter
all Object-oriented SQL (OSQL) statements,
facilitating rapid prototyping and testing. IOSQL
provides query, administration and editing
capabilities.

* Graphical Browser (GOSQL)
The Graphical Browser is a tool that allows you to
graphically explore your database schema and
contents, and execute any OSQL statement. This tool
is designed to assist application developers by
making it easier to view and manipulate your object
model stored in Odapter.

* Windows OSQL (WINOSQL)
This PC-based interactive interface to OSQL allows
you to interactively enter all OSQL statements.

* Object Application Call Interfaces (OACI)
Odapter provides client interface libraries for the
Smalltalk and C++ object-oriented programming
languages, allowing these languages to be tightly
coupled with Odapter.

You can also write Odapter applications using any
programming language that can be linked with C
(such as Ada, COBOL, FORTRAN and Pascal). The
programmatic interface is similar to a "Dynamic
SQL" interface, and passes strings representing
OSQL statements to the Odapter server. No
preprocessors are required.

Server Components

* Odapter Object Manager
The Object Manager executes OSQL calls made by the
Odapter clients. The Object Manager processes
requests, and accesses data and code stored in the
Odapter enhanced relational data storage manager or
passes the request to a subsystem outside of
Odapter using Odapter External Functions.

* External Functions
External functions allow you to access data and
code stored outside of Odapter, regardless of data
format or location. External functions can
automatically link to specific data sources using
the Odapter EDA-Objects class library and the
EDA/SQL product from Information Builder's, Inc.
(IBI). External functions can also be implemented
by you as subroutines written in general-purpose
programming languages and compiled outside of
Odapter. External functions can be called by any
OSQL statement, allowing you to manipulate this
remote data and application code like any other
Odapter object. For example, Figure 9 shows how
Odapter integrates diverse heterogeneous
information in an Oil and Gas environment.

* EDA-Objects
HP and IBI have jointly developed an external
function library called EDA-Objects. Coupled with
IBI's EDA/SQL product, EDA-Objects provides
connections to over 50 commonly used databases on
35 different platforms. The external function
library to connect to EDA/SQL is shipped with
Odapter; however, you must purchase other EDA/SQL
components from IBI directly to use the product.
EDA-Objects is one way to integrate external data
from multiple servers into a single business model
managed by Odapter. This is done without physically
moving the data or changing the applications which
are dependent on the data in its current form.

Additional Products

* Development Environments and Tools
Odapter allows you to use your favorite development
environments for application development. Some
tools are more tightly coupled with Odapter than
others. HP has recruited tools partners to address
all aspects of application development including
application design and analysis, data model
manipulation, fourth generation language
application development, report writing and legacy
data access.

* Relational Database
Odapter uses a relational database as its storage
manager for the storage of Odapter objects. The
relational database performs physical file
management and database functions such as multi-
user concurrency, transaction management, and
recovery. The relational database allows you to
perform on-line backup and recovery, manage
physical distribution of files, maximize
availability and change database parameters.

* COMPASS
COMPASS is a consulting product which includes the
Hewlett-Packard implementation of the
Petrotechnical Open Software Corporation (POSC)
Software Integration Platform (SIP) specification.
The SIP specification defines a data model and an
interface which allow users and applications to
access exploration and production data, independent
of the database engine technology.

The COMPASS package is an add-on to Odapter and
includes:
* COMPASS specific consulting/training (1 day)
* POSC-based DAE interface library and documentation
* Interactive user interface called ixpres
* Archived copy of a pre-loaded Odapter
enhanced database with sample reference data
* Scripts for building a POSC-based Odapter
enhanced database
* Contributed software library (data loaders,
demonstration programs)

COMPASS gives developers a 'jump start' on building
applications focused on petroleum exploration and
production. Other industries will find COMPASS an
inexpensive and useful approach for building
geographic information systems (GIS) and other
applications which can re-use of the cartography
(mapmaking) and geometric objects defined in the
model.

POSC is a not-for profit organization created to
lower the costs associated with accessing and
integrating exploration and production data for the
oil and gas industry.

System Environment

Hardware Operating Memory Disk Space
platform System (minimum) (minimum)*

HP 9000 S700 HP-UX 8.07 32MB 10MB +
S800 or later necessary
swap space

Sun Solaris 1.0 32MB 10MB +
(SunOS 4.3); necessary
Solaris 2.0 swap space
(SunOS 5.2)

IBM RS/6000 AIX 3.2.5 32MB 10MB +
necessary
swap space

X Terminal 6MB none

IBM PC DOS 5.0, 4MB 1MB
compatible MS-Windows
3.1 or later
Table 1: Odapter Client Environments

* Swap space needed will depend on the complexity
of the application and the number of concurrent
users. Swap space will significantly increase the
necessary disc space.

Hardware Operating Memory Disk Space
platform System (minimum) (minimum)*

HP 9000 S700 HP-UX 9.0 64MB 15MB +
S800 or later necessary
swap space
Table 2: Odapter Server Environment

* Additional memory may be required. Swap space
will significantly increase the necessary disc
space. The amount of memory and swap space depends
on the complexity of the application and the number
of concurrent users.

Odapter Software Requirements

To use Odapter, you will need one of the RDBMSs
listed below, TCP/IP transport and ARPA Berkeley
Services (for Unix systems), HP LAN Manager or
Microsoft LAN Manager (for the PC client) software.
To use the Odapter Graphical Browser, you will need
X11 X-Window support.

Table 3: Relational Databases

Version Memory Disk Space
(minimum) (minimum)

ORACLE7 7.0.13 or later refer to refer to
with "procedural Oracle Oracle
option" (PL/ manuals manuals
SQL), Pro*C,
SQL*Plus & Oracle
common libraries and
utilities

ALLBASE/SQL shipped with 64MB A/SQL 10MB
OpenODB and Odapter

* ALLBASE/SQL is included with the Odapter
software. The combination of Odapter and
ALLBASE/SQL is known as OpenODB.


Ordering Information

Software, training, consulting and support can be
purchased separately, as well as in bundles.
Pricing for the stand-alone software is based on
the number of user processes accessing a single
database server at the same time. Any number of
user licenses can be ordered. You must also order
the Odapter Media & Manuals product when ordering
the Developer's Bundle or the Concurrent User
License. HP standard support options are available
for all Odapter license and media products.
The OpenODB and Odapter products are sold together.
OpenODB is the combination of Odapter and
ALLBASE/SQL. You are only limited by the number of
concurrent licenses purchased for Odapter.

Product Number and Product Description

B3767BB Odapter/OpenODB Concurrent User License
Software license only. Must order B3768BA to
receive software and manuals. Must specify number
of users.

B3768BA Odapter/OpenODB Media and Manuals Must
choose media option. Includes software and one set
of manuals. Requires prior or concurrent purchase
of software license.

B2470BA Odapter/OpenODB Developer's Bundle
Includes 8 user software license, 5 days of on-
your-site consulting, one year of on-line support
and 2 passes to the Odapter/OpenODB Training Class.
Must order B3768BA to receive software and manuals.

B3179A Odapter/OpenODB Evaluator's Bundle
Includes a 40 user software license for 3 months,
media, documentation, 3 months of on-line support,
and 1 pass to the Odapter/OpenODB Training Class.

B3184S Odapter/OpenODB Training Class (5 days)

B3185A Odapter/OpenODB Reference Manuals Includes
the Odapter/OpenODB Reference Manual and the
Odapter/OpenODB System Functions Manual.

B3186A Odapter/OpenODB Consulting Customized
consulting in any of the following areas: COMPASS,
object-oriented analysis and design, schema design
and review, authorization/security design and
review, performance tuning, advanced usage,
Odapter/OpenODB application development planning
and review and implementation of access to legacy
data sources.

To order these products, please contact your local
HP sales representative or one of the offices on
the back page of this document.

Table 5. Odapter Features

OBJECT-ORIENTED FEATURES
Aggregates (BAG, LIST, SET, TUPLE)
Complex Objects
Dynamic Schema Modification
Dynamic Typing
Encapsulation
External Functions
Functions (Stored Code or Methods)
Late Binding
Multiple Inheritance
Object Identity (OID)
Overloaded Functions
Type (Class) Hierarchy
User-defined Data Types
Versioning Primitives

CLASS LIBRARIES
C++
EDA-Objects
Smalltalk
Softbench

CLIENT INTERFACES
Graphical Browser (GOSQL)
Import
Interactive OSQL
Object Application Call Interfaces (OACI):
C++
SmallTalk
C-linkable languages (Ada, COBOL, FORTRAN,
Pascal)
Smalltalk Class Builder
Windows OSQL

OSQL STATEMENTS
Add/Remove Type To/From Object
Add/Remove User
Begin/Commit/Rollback Work
Call Function
Change Owner
Change Password
Connect/Disconnect
Create/Delete Function
Create/Delete Index
Create/Delete Object
Create/Delete Type
Create/Delete User/Group
Declare/Delete variables
Grant/Revoke
If/Then/Else, While, For
Implement/Modify Function
Open/Fetch/Close Cursor
Raise Error
Security On/Off
Savepoint
Select
Store
Update

PRIMITIVE DATA TYPES
Binary
Boolean
Character
Date
Datetime
Decimal
Floating Point
Integer
Interval
Small Integer
Time

Sales Offices
For more information, call you local sales office
listed in your telephone directory or an HP
regional office listed below for the location of
your nearest sales office.

United States:
1-800-637-7740, extension 8521

Canada:
Hewlett-Packard Ltd.
6877 Goreway Drive
Mississauga, Ontario L4V 1M8
(416) 678-9430

Japan:
Yokogawa-Hewlett-Packard Ltd.
15-7, Nishi Shinjuku 4 Chome
Shinjuku-ku
Tokyo 160, Japan
(03) 5371-1351

Latin America:
Hewlett-Packard
Latin American Region
Headquarters
5200 Blue Lagoon
Suite 950
Miami, FL 33126
(305) 267-4220

Australia New Zealand:
Hewlett-Packard Australia Ltd.
31-41 Joseph Street
Blackburn, Victoria 3130
Australia (A.C.N. 004 394 763)
(03) 895 2805

Asia Pacific:
Hewlett-Packard Asia Ltd.
22/F Bond Centre, West Tower
89 Queensway
Central, Hong Kong
(852) 848-7777

Europe/Africa/Middle East:
Hewlett-Packard S.A.
150, Route du Nant-d'Avril
CH-1217 Meyrin 2
Geneva, Switzerland
(22) 780 81 11

Technical information in this document is subject
to change without notice.
All brand and product names appearing herewith are
registered trademarks or trademarks of their
respective holders.

` Copyright Hewlett-Packard Company 1994. All
rights reserved. Reproduction , adaptation, or
translation without prior written permission is
prohibited except as allowed under the copyright
law.
Printed in USA 7/94
5963-2045E


For more information, please send a message to
oda...@cup.hp.com with the subject of "index" or
"help". If you would like to speak with someone
in person, please leave a voice mail message at
the Odapter Support, Training and Consulting number,
(408) 447-5051 and someone will get back to you
as soon as possible.


> OOFILE (A.D. Software)

WHAT IS OOFILE?
OOFILE is a c++ framework. It can be used as a "traditional" ODBMS or can be
used to access a more traditional RDBMS or record-oriented database. The
current release is implemented with a Faircom c-tree Plus ISAM backend
on Mac and MS Windows. There would be very little difficulty in porting
this to any platform supported by Faircom, and we already have over 8
OS/compiler combinations in use (including 3 in-house).

Design Goals
- everything is native C++ with no (database) preprocessor required

- external interfaces to enable calling from Hypercard, Smalltalk etc.

- keep syntax very simple, familiar to 4GL users and not needing c++ gurus

- safe syntax that makes it hard to do the wrong thing by mistake, making
maximum use of c++ compiler type-checking

- implement with a choice of database engines for the backend

- integrate with a range of common application frameworks

- provide additional classes for managing gui interfaces to help construct
typical database applications, where features are not commonly part of
application frameworks

- use a widely available level of c++ (no RTTI, templates or exception handling)

WHO IS OUR MARKET
1) c++ developers (or wannabees) wanting an embedded database for writing
applications, probably working in combination with an application framework
such as zApp, OWL or PowerPlant.

2) World Wide Web developers seeking a database and report-writer
combination to create web pages in response to queries, searching hundreds
of thousands of records (at least).


BASIC PHILOSOPHY
Object-oriented design is mainly about classes, not individual objects.

OOFILE is similar. Most of the time you model your data in terms of
classes. You do NOT declare individual objects (unlike the ODMG model).

Consider a database from the user's view. They generally see collections of
data and edit or interact with individual records from the collection. The
user doesn't care about individual object identity, they don't create
symbolic names for particular objects. These things may be important inside
the database, but do not need to be exposed.


SOME SIMPLE EXAMPLES
Note: for more examples, including online queries, look on
http://www.highway1.com.au/adsoftware/oofile.html

Before venturing into database definitions, let's consider some
operations on a database containing People, Job Histories and Companies.

// print my address
cout << People["Andy Dent"].Address;

// get a separate list (iterator) of people who worked for software companies
dbPeople softP( People.PrevJobs->Company->MainBusiness()=="Software" );

// for the current softP record (ie person), print the number of large companies
// where they've worked, and the current company size
cout << softP.Name() << "\t"
<< (softP.PrevJobs->Company->NumEmployees() > 100).count()
<< "\t"
<< softP.CurrentJob->Company->NumEmployees() << endl;

NOTE:
The () at the end of fields, as shown above, are optional for all cases except
fields in relational expressions, eg: People.CurrentJob->StartDate().


DECLARING SIMPLE TABLES
To define a table with a few fields, the simplest declaration would be:
CLASS_TABLE(dbPeople)
dbChar Name, Address;
dbInt Salary;
};


This defaults the size of the dbChar fields to 80 chars. To specify the
size of the fields, and/or control indexing options, you need to add a
constructor:
CLASS_TABLE(dbPeople)
dbChar Name, Address;
dbInt Salary;

dbPeople : Name(40, "Name", kIndexNoDups),
Address(255, "Address"),
Salary("Salary", kIndexed)
{};
};

Note that the constructors also specify the field name strings. These
are optional, but are of great benefit when writing query and
report-writer logic or when constructing a database schema that should
be readable by others.

SOME OTHER FEATURES
- Derived fields, either specified as a combination of existing fields or
user-calculated

- User-defined relations

- keyword indexing

- phonetic indexing

- inbuilt report-writer


RELATIONS
One of the big features of an ODBMS is modelling the relationships between
objects. OOFILE allows you to model relations in a pure ODBMS sense, using
object identifiers, or explicitly perform runtime joins over database fields.
This would be mainly used by people porting existing database structures. There
are a number of syntaxes available to establish relationships, eg:

dbConnect_ctree theDB; // the physical database
dbAcademics Academics; // a couple of tables
dbStudents Students;

dbRelation Supervision("Supervision"); // a concrete relation

Supervision.Names("Supervises", "is Supervised by")
.Tables(Academics, Students)
.Links(Academics.Supervises, Students.Boss)
.JoinField(Academics.StaffNo, Students.SupervisorNo);


APPLICATION FRAMEWORKS AND OOFILE
GUI Integration classes are under development for zApp & PowerPlant with more
frameworks to follow. A "non-intrusive" approach has been taken of providing
helper classes and instructions that let you incorporate OOFILE use into an
existing program.

These helper classes include subclasses of the native edit fields, that
store data directly into the database. Depending on your framework,
other classes are added for displaying lists of records, managing
multiple page input forms and similar business application functions.

For Macintosh users, the popular AppMaker code generator is being enhanced
to generate OOFILE applications. You will be able to go from drawing your
interface to a complete working database application, without writing code.
The next AppMaker and CodeWarrior CD's will contain more information and
samples.


STATUS
The current c-tree implementation is solid and the inbuilt test data generator
has been used to create databases of up to 200Mb in various configurations. The
largest beta tester is operating a 270Mb+ database on a Sparc Classic.
(500,000+ IP-flow objects as of mid July).

Product release, including (at least) zApp and PowerPlant integrations is
anticipated for September


TEST PLATFORMS in-house
c-tree+ v6.4B

Mac
- Symantec c++ v7.0.4
- CodeWarrior 6.1

MS Windows
- Borland c++ v4.5p3

SunOS 4.3
- g++ v2.6.3


CONTACT
Andy Dent
A.D. Software
94 Bermuda Drive
Ballajura, Western Australia 6066
Phone/Fax +61-9-249-2719
eWorld: DentA
CompuServe: 100033,3241
Internet: de...@highway1.com.au
ftp://ftp.highway1.com.au/pub/adsoftware/
http://www.highway1.com.au/adsoftware/


MAINTENANCE
Priority fixes/consulting rate (drop-everything mode) $60/hour

Patches to each version - free.

Major upgrades - 30% per seat.
or
Annual Maintenance, regardless of number of upgrades - 40% per seat


UPGRADES
Upgrading between database and report-writer options is at the cost difference.

Changing from one GUI to another is 50%. If you decide to later reactive the
original, it's also at 50% (ie: net result same as buying the 2nd GUI outright).

Note: if later GUI kits are at different prices, exchange rules will vary
to suit.


SITE LICENSING
(Excluding bundled c-tree)
by negotiation for large sites.
or
40% off 2nd and subsequent copies


Andy Dent, Product Architect, A.D. Software, Western Australia
OOFILE - "the cross-platform OODBMS that speaks c++"
ftp://ftp.highway1.com.au/pub/adsoftware/
http://www.highway1.com.au/adsoftware/


> Phyla

Mainstay produce Phyla, an end-user, OODB for PCs. Includes a drag-and-drop
interface and diagrams to represent objects and their relationships. Runs
under Macintosh System. Listed at $500.

Mainstay
591 A Constitution Avenue
Camarillo, CA 93012
U.S.A.

Voice: (805)484-9400
1-800-484-9817 Code 6276
Email: main...@aol.com


> POET <Persistent Objects and Extended Database Technology> (Poet Software)

POET is a full-featured C++ ODBMS with support for, schema versioning,
check-in/check-out, online backup and object queries with OQL.
Workbenches are included for developers and administrators. POET is
available for nearly all platforms. OLE is supported and an ODBC
driver is available. A single user version is sold for around $499,
and a multi-user user for mixed networks is also available.

C++ Language Support

o tight semantic integration with C++
o any C++ object or structure can be made persistent by adding the
persistent keyword
o storing and reading a C++ object does not change its state or behavior
o full support for C++ encapsulation, object identity, inheritance, and
polymorphy
o C++ pointers and references are automatically converted to database
references when storing objects
o database references are automatically converted to C++ pointers and
references when reading objects
o all database definition is done through a small extension to C++
declaration syntax

NOTE: Visual Basic support with Sourcecraft.

Database Functionality
navigation, queries, sorting, indexes, single-user operation, multi-user
operation using client/server architecture, flexible locking for objects
and sets, nested transactions, watch & notify for objects and sets,
event handling, database size limited only by hard disk size

C++ Language Extensions
persistence, indexes, transient data elements in persistent classes, sets,
dependent objects, templates

PTXX schema compiler
automatically converts extended C++ class declarations into ANSI 2.0 code,
registers classes in the class dictionary, provides class versioning

Predefined C++ Classes
date, time, strings, and BLOBS (binary large objects)

Portability
all platforms are source-code compatible, any POET database may be read by
any computer full support for heterogeneous networks

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part8
Last-Modified: 04/02/96
Version: 1.0.9

Platforms
Available for MS-DOS / MS-Windows (Borland C++, Microsoft), OS/2
(Borland C++), Novell, Macintosh MPW, and various Unix systems, including
NeXT (NeXTStep) and Sun OS (Sun C++). See web site for details.


POET Software Corporation
999 Baker Way


Suite 100
San Mateo, CA 94404

U.S.A.

Toll Free: 1-800-950-8845
Direct: (415) 286-4640
Fax: (415) 286-4630
Email: in...@poet.com

Web: http://www.poet.com
Compuserve: GO POETSW


POET Software, GmbH
Fossredder 12
D 22359 Hamburg
Germany

Voice: +49 (0)40 / 60990 0
Fax: +49 (0)40 / 60398 51
Email: in...@poet.de


> Statice (Symbolics)

>From: fisc...@darmstadt.gmd.de (Markus Fischer)
Newsgroups: comp.databases.object,comp.lang.lisp
Subject: Statice now runs on Unix
Date: 15 Jun 93 14:55:48 GMT

Hi there,

since I've never seen 'Symbolics' or 'Statice' in
comp.database.object, this might be interesting:

A few days ago, Symbolics announced the availability of a beta-
release of their ODBMS 'Statice' on Unix platforms. It is quite
powerful and tightly integrated within Common Lisp.
Currently, Symbolics and LUCID are supported.
People (like me) used to Symbolics' Genera development environment
can continue to use Statice there (where it has been already
successfully employed in 'real world' applications)
and now also use it on Unix Workstations. (Those are the cheaper
boxes, I guess). Both kinds of platforms can be freely intermixed
in a network.

Statice is based on standards of Lisp: CLOS and CLIM
(Common Lisp Object System, resp. Common Lisp Interface Manager)

Here's the address of Symbolics in Germany; they're mostly
responsible for Statice on Unix:

Symbolics Systemhaus GmbH
Mergenthalerallee 77
6236 Eschborn (til June 31)
65760 Eschborn (from July 1)
Tel. (49) 6196-47220, Fax (49) 6196-481116

Contact person is Dr. Thomas Neumann (T...@symbolics.de).

Also:

"Update Database Schema" brings an existing database into conformance
with a modified schema. Changes are classified as either compatible
(lossless, i.e., completely information-preserving) or incompatible
(i.e., potentially information-losing in the current implementation).
Basically, any change is compatible except for the following:

-- If an attribute's type changes, all such attributes extant
are re-initialized (nulled out). Note that Statice permits
an attribute to be of type T, the universal type. Such an
attribute can then take on any value without schema
modification or information loss.

-- If a type's inheritance (list of parents) changes, the
type must be deleted and re-created, losing all extant
instances of that type. This is Statice's most serious
current limitation. The simplest workaround is to employ a
database dumper/loader (either the one supplied by Symbolics
or a customized one) to save the information elements and
then reload them into the modified schema.

[Lawrence G Mayka <l...@IExist.ATT.COM>]


> UniSQL

UniSQL, Inc. produce a unified object-relational database systems that let
users move to an object-oriented paradigm while perserving existing investments in SQL-based applications. Supports a while range of languages, databases
and platforms. Prices start at $3,995.

UniSQL offers a state-of-the-art suite of integrated object-oriented database
systems and application development products which can be used separately or
together to support complex development projects which use object-oriented
development techniques, integrate sophisticated multimedia data, and require
true multidatabase access to relational and object-oriented databases. The
UniSQL product suite includes:

UniSQL/X Database Management System;
UniSQL/M Multidatabase System; and
UniSQL/4GE Application Development Environment
User interfaces include: C++, C, Object SQL, SmallTalk, and ODBC
Database interfaces include: Ingres, Oracle, Sybase, UniSQL/X, and EDA/SQL

UniSQL offers:

- A wide selection of user interfaces including C++, SmallTalk, C, Microsoft's
ODBC, both embedded (static and dynamic) and interactive Object SQL, and UniSQL
and 3rd-party development tools.

- Mission-critical database features such as a high-level query language
(SQL/X), cost-based query optimization, automatic transaction management,
automatic concurrency control, dynamic schema evolution, dynamic authorization,
physical disk structuring options, and installation tuning parameters.

- The UniSQL Multimedia Framework which provides natural and uniform database
system support for all types of large unstructured data objects. The Multimedia
Framework also provides for seamless integration of multimedia devices such as
fax machines, CD jukeboxes, satellite feeds, image compression boards, etc.

- The UniSQL/M Multidatabase System enables developers to manage a collection
of multi-vendor databases -- Ingres, Oracle, Sybase, DB2, UniSQL/X, and others
-- as a single federated database system with full object-oriented
capabilities.

The majority of UniSQL customers use UniSQL database products for
mission-critical applications which require object-oriented, multimedia,
post-relational, and heterogeneous database capabilities.

A typical UniSQL customer is a Fortune 500 company, a commercial software
developer, or government organization that is using UniSQL database products
to:

- support mission-critical application development projects which are being
developed using object-oriented programming languages and development
techniques,

- support applications which must integrate many different types of corporate
data -- text and documents, tabular data, images and audio, engineering
drawings, GIS data, procedural data (programs), etc. -- into a single
application context.

- support the full object-oriented development paradigm using existing
relational database systems such as Ingres, Oracle, Sybase, and DB2.

- logically integrate one or more relational and object-oriented databases to
form a single, homogenized database server which supports both relational and
object-oriented facilities.

UniSQL was founded in May 1990 by Dr. Won Kim, President and CEO, delivering
the UniSQL/X DBMS in March of 1992. With its world-class database research and
architectural team, UniSQL has perfected what the database industry has sought
since the mid-1980s: a fully object-oriented data model that is a natural
conceptual outgrowth of the popular relational model. Both the UniSQL/X DBMS
and the UniSQL/M Multidatabase System represent the first of a powerful new
generation of client-server database systems that support the full
object-oriented paradigm yet retain all of the strengths and capabilities of
relational database systems including support for ANSI-standard SQL.

For more information, contact:

UniSQL, Inc.
8911 N. Capital of Texas Hwy
Suite 2300
Austin, Texas 78759-7200
U.S.A.

Voice: 1-800-451-3267
(512) 343 7297
Fax: (512) 343 7383
Email: in...@unisql.com


> Unisys Universal Repository

Unisys Corporation makes available the Unisys Universal Repository, a fully
object-oriented repository for access, concurrent sharing and immediate
updating of all business information for workgroup software development.
Using an open, extensible architecture, the Universal Repository enables
encapsulation of legacy applications and data in addition to use of new
object-oriented information, and allows integration of leading development
tools and objects.

Information reuse is achieved through built-in hooks which encourages
data and business rule interchange among popular application development
tools. This enables developers to continue using their preferred tools
and to reuse existing models and data.

The Universal Repository uses the object database from Versant Object
Technology Corporation, EXCHANGE bridging technology from leading U.K.
integration and metadata specialist Software One Limited. EXCHANGE allows
use of repository data with a wide range of the most popular front-end
design, analysis and modeling tools including Texas Instruments IEF,
Knowledgeware IEW and ADW, Intersolv Excelerator and Unisys LINC Design
Assistant III. When integrated with the Universal Repository, information
created by tools can also be stored for reuse. A CASE Data Interchange
Format (CDIF) bridge supports the loading and unloading of business
information to and from the repository. Users can also access the
Software One Core Model (SOCM), a neutral interoperability model comprised
of the objects required to describe tool models.

The Unisys Universal Repository is available now for Sun Solaris
platforms, with support for UNIX and Windows clients. A version for
Windows NT Client and Windows NT Server is also under development.

The Unisys Universal Repository is available immediately for independent
software vendors (ISVs) under OEM licensing agreements. Sales to end-users
will be through select resellers. The introductory stand alone price
ranges from $1,900 ($U.S.) to $9,000 ($U.S.) depending on selected
options.

Call for more information and the location of the nearest Unisys
authorized reseller.

Contraste Europe S.A.
OSMOS Relational Object Database

Voice: (714) 380-6460
Email: Buch...@SJ.Unisys.Com
Web: http://osmos.unisys.com

Contact: Gordon DeGrandis
Gordon.D...@ping.be


> Versant (Versant Object Technology)

See also: http://www.versant.com

Versant is a client/server object database management system (ODBMS) targeted
at distributed, multi-user applications. Versant runs on UNIX and PC platforms.
Versant provides transparent language interfaces from object-oriented
programming languages such as C++ and Smalltalk. Versant also supports a C API.

Versant is built with an object-level architecture, which means that operations
are generally performed on the object (or group thereof) level. Key Versant
features include:

Performance
-----------

* Object-level locking for fine granularity concurrency control
* Server-based query processing to reduce network I/O
* Dual caching to speed warm traversals
* Dynamic space reclamation and reuse

Distribution
------------

* Immutable, logical object identifiers for data integrity
* Object migration (transparent relocation across nodes)
* Transparent cross-node references (distributed db)
* Automatic two-phase commit

Other
-----

* Schema evolution (online via lazy updates)
* Standard workgroup features (e.g., versioning, checkin/out)
* Detachable, personal databases
* DBA utilities

Provide object database management system and development tools for
multi-user, distributed environments. Supports C++ and Smalltalk
access.

Argos is their application development environment product. It's built
on ParcPlace VisualWorks.

Versant Object Technology Corporation
1380 Willow Road
Menlo Park, CA 94025
U.S.A.

Voice: (415) 329-7500
Fax: (415) 325-2380

3872 Larkspur
CourtLoveland, CO 80538
U.S.A.

Voice: (303) 593-9871
Fax: (303) 593-9874

Email: in...@versant.com
Web: http://www.versant.com


> VisualWorks

ParcPlace Systems, Inc. produce Smalltalk based development tools including
VisualWorks, a client/server tool that includes a database application
creator for rapid application development.

ParcPlace Systems, Inc.
999 East Arques Avenue
Sunnyvale, CA 94086-4593
U.S.A.

Voice: (408) 481-9090

Other Models
------------

Research Systems
________________

> GRAS

--------------------------------------------------------------
GRAS - A Graph-Oriented Database System for SE Applications
Copyright (C) 1987-1993 Lehrstuhl Informatik III, RWTH Aachen
--------------------------------------------------------------

See the GNU Library General Public License for copyright details.

Contact Adresses:

Dr. Andy Schuerr
Lehrstuhl fuer Informatik III,
University of Technology Aachen (RWTH Aachen),
Ahornstr. 55,
D-5100 Aachen

Email to

an...@i3.informatik.rwth-aachen.de

GRAS is a database system which has been designed according
to the requirements resulting from software engineering
applications. Software development environments are composed
of tools which operate on complex, highly structured data.
In order to model such data in a natural way, we have selected
attributed graphs as GRAS' underlying data model.

A first prototype of the GRAS (GRAph Storage) system - described
in /BL 85/ - was already realized in 1985. Since this time
gradually improving versions of the system have been used at
different sites within the software engineering projects
IPSEN /Na 90/, Rigi /MK 88/, MERLIN /DG 90/, and CADDY /EHH 89/.
Based on these experiences, almost all parts of the original
prototype have been redesigned and reimplemented.

Thus, nowadays a stable and efficiently working single-process
version of the system GRAS with interfaces for the programming
languages Modula-2 and C is available as free software for Sun
workstations (the GRAS system itself is implemented in Modula-2
and consists of many layers which might be reusable for the
implementation of other systems):

Via anonymous ftp from ftp.informatik.rwth-aachen.de
in directory /pub/unix/GRAS in file gras.<version-no>.tar.Z.

There are several files containing documentation, sources, binaries,
application examples, and libraries. All binaries are for Sun/4
machines. Sun/3 binaries are shipped only if explicitly requested.

You have to use the following sequence of operations for installing
the GRAS system at your site:

1) 'ftp ftp.informatik.rwth-aachen.de' (with login name "anonymous"
and password equal to your mail address).
2) 'cd pub/unix/GRAS' (for changing the current directory).
3) 'binary' (command for changing ftp mode).
4) 'get gras.<version-no.>' (use 'ls' for finding the currently used
GRAS version nr.).
5) 'bye' (for exiting ftp).
6) 'uncompress gras.<version-no>.tar'.
7) 'tar xvf gras.<version-no>.tar' (creates a subdirectory GRAS_2 for
the Modula-2 implementation of GRAS including its C-interface).
8) Follow the instructions in file GRAS_2/README.


The current version has programming interfaces for Modula-2 and C
and supports:

- the manipulation of persistent attributed, directed node- and
edge-labeled graphs (including the creation of very long
attributes and of attribute indexes).

- the manipulation of temporary/volatile generic sets/relations/lists,

- the coordination of graph accesses by different GRAS applications
(multiple-read/single-write access with graphs as lock units),

- error recovery based on shadow pages and forward logs,

- nested transactions and linear undo/redo of arbitrarily long
sequences of already committed graph modifying operations based
on forward and backward logs,

- event-handling (with certain kinds of graph-modifications
as events and graph-modifying transactions as event-handlers),

- primitives for version control comprising the capability
for efficiently storing graphs as forward/backward deltas to
other graphs,

- and primitives for declaring graph schemes and for incremental
evaluation of derived attributes.

Furthermore, tools for (un-)compressing graphs and a X11R5-based
graph browser are part of this release.

A multi-process version of the system GRAS supporting the inter-
action of multiple client and multiple server processes within
one local area network is nearby completion (version 6.0/0).

Thus, the GRAS system may be considered to be the core of a graph
oriented DBMS environment. The development of such an environment
based on a very high-level specifications language named PROGRES
is under way (the underlying calculus of this specification language
are so-called PROgrammed GRaph REwriting Systems).

This environment will comprise the following tools (a prerelease
of this environment might be made available upon request):

- a syntax-directed editor for graph schemes, graph rewrite rules,
and sequences of graph rewrite rules,

- an incrementally working consistency checker,

- an incrementally working compiler&interpreter translating
PROGRES specifications into sequences of GRAS procedure
calls (for C as well as for Modula-2),

- and an "enhanced" graph (scheme) browser.


References
----------

Refer to the following publications for further info about GRAS, PROGRES,
and related topics:

/BL85/ Brandes, Lewerentz: A Non-Standard Data Base System within
a Software Development Environment. In Proc. of the Workshop
on Software Engineering Environments for Programming-in-the-
Large, pp 113-121, Cape Cod, June 1985

/DHKPRS90/ Dewal, Hormann, Kelter, Platz, Roschewski, Schoepe: Evaluation
of Object Management Systems. Memorandum 44, University
Dortmund, March 1990

/Feye92/ Feye A.: Compilation of Path Expressions (in German), Diploma
Thesis, RWTH Aachen (1992)

/Hoefer92/ Hoefer F.: Incremental Attribute Evaluation for Graphs (in
German), Diploma Thesis, RWTH Aachen (1992)

/HPRS90/ Hormann, Platz, Roschweski, Schoepe: The Hypermodel Benchmark,
Description, Execution and Results. Memorandum 53, University
Dortmund, September 1990

/KSW92/ * Kiesel, Schuerr, Westfechtel: GRAS, A Graph-Oriented Database
System for (Software) Engineering Applications. Proc. CASE 93,
Lee, Reid, Jarzabek (eds.): Proc. CASE '93, 6th Int. Conf. on
Computer-Aided Software Engineering, IEEE Computer Society
Press (1993), pp 272-286
Also: Technical Report AIB 92-44,

/Klein92/ Klein P.: The PROGRES Graph Code Machine (in German), Diploma
Thesis, RWTH Aachen (1992)

/Kossing92/ Kossing P.: Modelling of Abstract Syntax Graphs for normalized
EBNFs (in German), Diploma Thesis, RWTH Aachen (1992)

/LS88/ Lewerentz, Schuerr: GRAS, a Management System for Graph-
Like Documents. In Proceedings of the Third International
Conference on Data and Knowledge Bases, Morgan Kaufmann
Publ. Inc. (1988), pp 19-31

/Nagl89/ Nagl (ed.): Proc. WG'89 Workshop on Graphtheoretic Concepts
in Computer Science, LNCS 411, Springer-Verlag (1989)

/NS91/ Nagl, Schuerr: A Specification Environment for Graph Grammars,
in Proc. 4th Int. Workshop on Graph-Grammars and Their
Application to Computer Science, LNCS 532, Springer-
Verlag 1991, pp 599-609

/Schuerr89/ Schuerr: Introduction to PROGRES, an Attribute Graph Grammar
Based Specification Language, in: /Nagl89/, pp 151-165

/Schuerr91a/ * Schuerr: PROGRES: A VHL-Language Based on Graph Grammars,
in Proc. 4th Int. Workshop on Graph-Grammars and Their
Application to Computer Science, LNCS 532, Springer-
Verlag 1991, pp 641-659
Also: Technical Report AIB 90-16

/Schuerr91b/ Schuerr: Operational Specifications with Programmed Graph
Rewriting Systems: Theory, Tools, and Applications,
Dissertation, Deutscher Universitaetsverlag (1991) (in German)

/SZ91/ * Schuerr, Zuendorf: Nondeterministic Control Structures for
Graph Rewriting Systems, in Proc. WG'91 Workshop in Graph-
theoretic Concepts in Computer Science, LNCS 570, Springer-
Verlag 1992, pp 48-62
Also: Technical Report AIB 91-17

/Westfe89/ Westfechtel: Extension of a Graph Storage for Software
Documents with Primitives for Undo/Redo and Revision Control.
Technical Report AIB Nr. 89-8, Aachen University of Technology,
1989

/Westfe91/ Westfechtel: Revisionskontrolle in einer integrierten Soft-
wareentwicklungsumgebung, Dissertation, RWTH Aachen, 1991

/Zuendorf89/ Zuendorf: Kontrollstrukturen fuer die Spezifikationssprache
PROGRES, Diplomarbeit, RWTH Aachen, 1989

/Zuendorf92/ * Zuendorf A.: Implementation of the Imperative/Rule Based
Language PROGRES, Technical Report AIB 92-38, RWTH Aachen,
Germany (1992)

/Zuendorf93/ * Zuendorf A.: A Heuristic Solution for the (Sub-) Graph
Isomorphism Problem in Executing PROGRES, Technical
Report AIB 93-5, RWTH Aachen, Germany (1993)

* : All reports marked with an asterisk are available via anonymous ftp from
ftp.informatik.rwth-aachen.de in directory /pub/reports/... .

See also PROGRES documentation.

[See also APPENDIX E]


> IRIS (HP Labs)

[Iris is a system out of HP Labs that began as a prototype and eventually
became a commercial product. I believe it was eventually incorporated into
the new HP product, OpenODB. - clamen]

Long and short system summaries can be found in:

[FISH89] D.H. Fishman et. al. Overview of the Iris DBMS. In Won.


Kim and Frederick H. Lochovsky, editors,
Object-Oriented Concepts, Databases and Applications,

chapter 10, pages 219--250. Addison-Wesley, Reading,
MA, 1989.

[FBC+87] D.H. Fishman, D. Beech, H.P. Cate, E.C. Chow,
T. Connors, J.W. Davis, N. Derrett, C.G. Hock, W. Kent,
P. Lyngbaek, B. Mahbod, M.A. Neimat, T.A. Tyan, and
M.C. Shan. Iris: An object-oriented database
management system. ACM Transactions on Office
Information Systems, 5(1):48--69, January 1987.

The abstract of the latter (written early in the project) follows:

The Iris database management system is a research prototype of
a next-generation database management system intended to meet
the needs of new and emerging database applications, including
office automation and knowledge-based systems, engineering
test and measurement, and hardware and software design. Iris
is exploring a rich set of new database capabilities required
by these applications, including rich data-modeling
constructs, direct database support for inference, novel and
extensible data types, for example to support graphic images,
voice, text, vectors, and matrices, support for long
transactions spanning minutes to many days, and multiple
versions of data. These capabilities are, in addition to the
usual support for permanence of data, controlled sharing,
backup and recovery.

The Iris DBMS consists of (1) a query processor that
implements the Iris object-oriented data model, (2) a
Relational Storage Subsystem (RSS) -like storage manager that
provides access paths and concurrency control, backup and
recovery, and (3) a collection of programmatic and interactive
interfaces. The data model supports high-level structural
abstractions, such as classification, generalization, and
aggregation, as well as behavioral abstractions. The
interfaces to Iris include an object-oriented extension to
SQL.


On Schema Evolution (from original survey):

Objects in the Iris system may acquire or lose types dynamically.
Thus, if an object no longer matches a changed definition, the user
can choose to remove the type from the object instead of modifying the
object to match the type. In general, Iris tends to restrict class
modifications so that object modifications are not necessary. For
example, a class cannot be removed unless it has no instances and new
supertype-subtype relationships cannot be established.


Commercial Systems
__________________


> IDL (Persistent Data Systems)

IDL is a schema definition language. Schema modifications are defined
in IDL, requiring ad-hoc offline transformations of the database, in
general. A simple class of transformations can be handled by
IDL->ASCII and ASCII->IDL translators (i.e., integer format changes,
list->array, attribute addition).

[conversation with Ellen Borison of Persistent Data Systems]


ADDITIONAL REFERENCES:
John R. Nestor. "IDL: The Language and Its
Implementation". Prentice Hall. Englewood Cliffs,
NJ., 1989.

> Kala
Kala Technical Brief

Summary

Kala(tm) is a Persistent Data Server managing distributed, shared,
arbitrarily complex and evolving persistent data. Kala is highly
efficient and secure. Kala manages the visibility of persistent data
elements to its clients, thus supporting any types of transactions,
versions, access control, security, configurations. Kala does not
restrict you to any particular model. Kala provides the mechanism, but
imposes no policy. Usable as either a link library communicating to a
server or as a standalone, Kala is compact and simple.

Kala is used for applications such as: kernel of DBMS products,
substrate for extended file systems, implementation of language
persistence, data manager for groupware applications as well as
applications which deal with large, complex, and changing volumes of
data (text databases, financial distributed transaction systems). Our
current customers use Kala in applications ranging from CASE
repositories to CAD systems, from document management for financial
institutions to OODBMS platforms, from real-time applications to
database research. Kala is a component of broad reuse.


Motivation

The simplest persistent data storage available to you is the file
system on your disk drive. File systems have some attractive
characteristics; their performance is good, they can hold any data,
they're easy to use, and, of course, the price is right. Conversely,
files are unreliable. They provide no mechanism for in maintaining
data consistency and only primitive data sharing facilities. Few file
systems offer version control and all require that you transform data
between "internal" and "external" forms all the time.

Unlike a file system, a true database management system provides
mechanisms for sharing data and for ensuring the integrity of the
data. It supports transactions and version control, although the
specifics of these functions may not be exactly what your application
needs. Finally, a database system is scalable, and much more robust
than a file when your hardware or software fails.

The downside to a database system is that, compared to a file system,
it is slower by an order of magnitude or more. Also, a database system
generally confines you to dealing only with the kind of data that it
can handle. In addition, a database is usually very complicated,
difficult to learn and use, and expensive, both in terms of your cost
of operation and in the amount of system resources they consume.

Whether you choose a file system or a database manager, then, you
have to sacrifice either economy or performance. Is there a happy
medium? Something with the speed and flexibility of files, the
reliability, shareability and robustness of databases, and at a cost
that won't break your wallet or the available hardware? Sure there is!
Kala is a first in a new breed of products, persistent data servers,
aimed squarely at the yawning gap between DBMSs and file systems.


Overview

Kala is *not* a DBMS. Instead, you use Kala whenever the few canned
combinations of DBMS features do not meet the needs of your
application. A DBMS product constrains you to accept *its* choice of
an end-user graphical interface, a query language binding, a specific
high level data or object model, a particular transaction model, a
single versioning scheme, etc. This either compromises your
application's functionality, or forces your to spend substantial
development effort and money to bridge the impedance mismatch to the
application. Instead, Kala allows *you* to develop no more and no
less than the functionality you need. You build your domain specific
functionality our of a small set of primitives with very little code.
Your gains in productivity, efficiency, and flexibility are
substantial.

To sustain this level of flexibility and reuse, Kala manages any data
that you can represent in machine memory out of bits and references.
Examples include records, dynamically linked graphs and lists,
executable code, and object encapsulations.

Kala can handle data as small as one bit, and as large as the virtual
memory and more, while being totally unaware of the data's semantics.
Its stores and retrieves data efficiently, and compactly over a
distributed and dynamically reconfigurable set of Stores. Upon
retrieval, Kala dynamically relocates embedded references to retain
the original topological structure of the data, thus preserving
referential integrity. Kala also supports active data, physical store
management, and automatic archiving.

Kala repackages the fundamentals and universals of data management in
one reusable data server, separating them from the application domain
specific models and policies. Kala defines a low level interoperabi-
lity point for the data storage domain, just as X does for the display
domain and Postscript does for the printing domain.

Kala has matured through four successive versions to its present
industrial strength implementation and stable API. Kala is lean,
compact, and portable. Kala is a high performance, low overhead
system. We call it a Reduced Instruction Set Engine (RISE). Unlike
large, complex, and typically bulky DBMS products, Kala is small,
simple, and suitable for managing anywhere from a single diskette to
terabytes of distributed data.


Benefits

* For those who need functionality traditionally associated with
databases, but cannot tolerate the overhead and complications DBMS
products introduce, Kala offers a flexible, compact, performant,
elegant, and simple alternative.

* For those whose application domain requires data models where the
mapping to those offered by today's DBMS products is cumbersome,
introduces development and execution overhead, and is not portable
across multiple linguistic and environmental platforms, Kala offers
a data model independent interface against any data model
expressible in terms of bits and pointers can be easily built.

* For those who need DBMS functionality or qualities that no single
DBMS product now has, Kala offers the opportunity to build that
functionality now with little effort out of a simple set of
primitives, and not wait for one vendor or another to deliver
it later.

* For those who have determined that the only viable option for their
application's persistent data needs is the file system, and have
resined to the idea that they will have to build everything else
they need from scratch, Kala offers an off-the-shelf implementation
without loss of any of files' advantages.

* For those who need performance, size, portability, storage
compactness, and industrial strength that no single DBMS product can
now satisfy, Kala offers all of the above now.

* For those who realize that while object-level interoperability is a
strong desideratum, the likelihood of a single, universal such model
in the foreseeable future is quite low, Kala offers a solid, long
term alternative. Data store interoperability that brings us beyond
file systems is the best practical bet. Kala is the basis for data
store interoperability now.

* Finally, for all of you who are concerned about the economics of
software, and take the view that there are many elements that
could contribute negatively to the soundness of your business, such
as operational costs, software maintenance costs, software licensing
costs, software development and learning costs, etc., you will find
Kala an economically sound, sensible, and practical product.


Features

- The execution architecture is that of multiple (communicating)
servers and multiple clients. Kala can also be configured in a
standalone (single process) mode. Kala's IPC is built for maximum
performance, portable to any given datagram protocol.

- The managed data elements are made out of uninterpreted bits and
references. Data elements (named `monads') are universally uniquely
identified. Bits are stored with no overhead. References,
represented in memory as native machine pointers, are stored
very compactly, introducing an average of 2.5 bytes overhead.

- Kala is a fully recoverable system, short of media damage. Recovery
from hardware failures can be supported by the layer beneath Kala.

- The Kala primitives support arbitrary transaction models, including
classic short transactions, long (persistent) transactions, nested
transactions, shared transactions, pessimistic and optimistic
policies, etc. Concurrency control is achieved through two locking
mechanisms (short-term and long-term (persistent, shared) locking),
with full support for atomicity of operations and two-phase commit.

- The Kala primitives support arbitrary versioning models, allowing
versions to co-exist in split/rejoined networks, various version
organization strategies (single-thread, tree, DAG, etc.). Kala
primitives provide mechanisms for arbitrary access and update
triggers, such as notifications, security checks upon access/update,
etc. __ with no limitations on what the trigger code does. Kala
provides protection measures against virus and other intruding
executions.

- The Kala primitives support a wide range of access control, security
and protection models, including revocable access rights, access
control without the overhead of ACL management, arbitrary access
validation routines, etc. Kala does not introduce any more security
holes than the operating environment already has.

- Kala has primitives for physical store allocation and de-allocation
management, for a wide spectrum of store administrative tasks, as
well as licensing administration. The latter includes application-
sensitive time-limited client-connect-based licensing, as well as
metered (connect/load/store) usage. Kala can be set up to do
automatic archiving and backup of its physical store.

- Kala provides a wide spectrum of licensing schemes, usable by
platforms and applications built upon Kala to their customer base.
Kala provides renewable licenses, perpetual licenses, full
protection against duplication without hardware (hostid) support,
metered (pay-by-use) usage, etc.

- And more ... not fitting on this page-long Technical Brief.


Availability

o Kala is available now on Sun platforms (SunOS / 68K & SPARC), as
well as on 80x86/MS-DOS (both Microsoft and Borland compilers &
runtimes supported) platforms. If you are interested in a port to
your favorite platform, call us to discuss our Development and
Porting Partnership Programme.

o Kala's interface is ANSI C, also callable from C++. If you are
interested in an interface or a binding to your favorite programming
language, please call us to discuss out Development Partnership
Programme.

o For pricing and other information, please contact us by phone, fax
or via e-mail at In...@Kala.com


On Schema Evolution (from original survey):

Kala manages an untyped persistent store, implementing the semantics
of robust, distributed, secure, changing, and shareable persistent
data. Layers built upon the Kala platform can implement the semantics
of objects with the same properties.

As it operates below the schema layer, Kala does not address schema
evolution directly. However, It supports the building of schema'ed
layers above it and below the application, and those layers can
provide for schema evolution conveniently using Kala primitives.
This parts-box approach requires extra work on the part of the developer
compared to out-of-the-box solutions, but provides power and
flexibility sufficient for relatively low cost solutions in
difficult environments (e.g. graph-structured data, dynamic classing)
where no out-of-the-box solution is available.


REFERENCES:
Segui S. Simmel and Ivan Godard. "The Kala Basket: A
Semantic Primitive Unifying Object Transactions,
Access Control, Versions, annd Configurations


Penobscot Development Corporation

Penobscot Development produces and markets Kala, a persistent data server
managing distributed, shared, arbitrarily complex and evolving persistent
data. Kala manages the visibility of persistent data elements to its
clients, thus supports all types of transactions, versions, access
control, security, configurations. Kala does not restrict you to any
particular model. Kala provides the mechanism, but imposes no policy.
Usable as either a link library communicating to a server or as standalone,
Kala is compact and simple.

Kala is not an OODBMS. Instead, you use Kala whenever the few canned
combinations of DBMS features do not meet the needs of your application.
This parts-box approach requires extra work on the part of the developer
compared to out-of-the-box solutions, but provides power and flexibility
sufficient for relatively low cost solutions in difficult environmentsi
(e.g. graph-structured data, dynamic classing) where no out-of-the-box
solution is available.

Penobscot Development Corporation
One Kendall Square Building
Suite 2200
Cambridge, MA 02139-1564
U.S.A.

Voice: (617) 267-5252
Fax: (617) 859-9597
Email: in...@kala.com


> Pick

With Pick and its variants you only have problems if you want to
redefine an existing field. Because of the way the data are stored
and the separation of the data and the dictionary you can define
additional fields in the dictionary without having to do anything to
the data - a facility which we have found very useful in a number of
systems.

There is no general facility to redefine an existing field - you just
make whatever changes are required in the dictionary then write an
Info Basic program to change the data. We have seldom needed to do
this, but it has not been complicated to do.

If a field in the database is no longer used, it is often easiest
simply to delete the reference to that field in the dictionary, and
accept the storage overhead of the unused data. In such cases, while
the data cannot be accessed through the query language, (Pick)Basic
programs can still access them.

[Geoff Miller <g...@ccadfa.cc.adfa.oz.au>]

Interfaces
----------


Research Systems
________________


> Penguin (Stanford)

Penguin is an object-oriented interface to relational databases.
Penguin has its own simple language-independent object model with
inheritance for composite objects defined as views (called
view-objects) of a relational database. These view-objects represent
data according to application requirements in such a way that multiple
applications can share overlapping, but different, sets of data.
Multiple applications may share data by having overlapping schemata
with differing composite objects and differing inheritance mappings.
We have a C++ binding, which supports multiple inheritance. The
result is a framework for collaboration among multiple users, each
with differing perspectives about the system and its data.

For additional information, please contact a...@db.stanford.edu

References:

``A C++ Binding for Penguin: a System for Data Sharing among
Heterogeneous Object Models,'' Arthur M. Keller, Catherine Hamon,
Foundations on Data Organization (FODO) 93, October 1993, Chicago.

``Querying Heterogeneous Object Views of a Relational Database,''
Tetsuya Takahashi and Arthur M. Keller, Int. Symp. on Next Generation
Database Systems and their applications, Fukuoka, Japan, September
1993, to appear.

``Updating Relational Databases through Object-Based Views,'' by
Thierry Barsalou, Niki Siambela, Arthur M. Keller, and Gio Wiederhold,
ACM SIGMOD, Denver, CO, May 1991.

``Unifying Database and Programming Language Concepts Using the Object
Model'' (extended abstract), Arthur M. Keller, Int. Workshop on
Object-Oriented Database Systems, IEEE Computer Society, Pacific
Grove, CA, September 1986.


Commercial Systems
__________________

>AllegroStore

See Databases & Development Sept. 5, 1994, p1.

"Lisp, Smalltalk Languages Given Database Systems"

Quote:
Franz, based in Berkeley, Calif., is now shipping AllegroStore, which the
company calls the first object database system designed for object-oriented
Lisp.

[...] The database is based on the ObjectStore engine from Object Design, also
in Burlington. It supports multiple clients and servers, [...]

Franz is at 800-333-7260 or 510-548-3600.


> DBTools.h++

Rogue Wave Software

A leading producer of C++ class libraries including Tools.h++, Heap.h++,
C++ Booch Components, and DBTools.h++ for accessing relational databases,
such as SYBASE, from C++ programs. Rogue Wave recently merged with
Inmark Development (zApp), so their products now includes visual builders,
visual interfaces, and code generators for C++ developers.

Rogue Wave Software, Inc.
260 S.W. Madison Avenue
P.O. Box 2328
Corvallis, OR 97339
U.S.A.

Toll Free: 1-800-487-3217
Direct: (503) 754-3010
Fax: (503) 757-6650
Email: sa...@roguewave.com
Web: http://www.roguewave.com


>OBJECT GATEWAY

Object Gateway is a modeling, mapping and code generation tool that lets
you look at existing relational data in Oracle, Sybase and other servers
as if they are object oriented. It is a 100% client-resident and runs on
Microsoft Windows platforms.

Schema Genie, the design time component of Object Gateway, lets you design an
ODMG-style object model for your SQL database. Once the model is designed,
you can generate a variety of language interfaces for it (C++, C, OLE
Automation and Visual Basic are currently supported).

Object Engine is the run-time component of the system and it implements the
object data model by supporting features such as activation and deactivation of
objects, complex object assembly, inheritance, relationships and cache
management. Object Browser is a component of the system that lets you browse
through and manipulate data based on the object model that you defined.

The central tenet of Object Gateway is that inside every complex relational
database, there is an object model waiting to get out. Such a model reduces
the abstraction level mismatch between modern, object oriented client tools
and SQL servers. Automatic generation of an object oriented data access layer
eliminates the need for programmers to hand-craft code to do the same.

For more information, please contact Sierra Atlantic at the address
below:

Sierra Atlantic Inc
830 Hillview Court, Suite 270,
Milpitas, CA 95035
Phone: (408) 956 3006
Fax: (408) 956 3001
Email: obj...@shell.portal.com

> Persistence

PERSISTENCE(TM): BRIDGING THE GAP BETWEEN OBJECT
ORIENTED DEVELOPMENT AND RELATIONAL DATA

Persistence is an application development tool which provides object
oriented access to existing relational data. Persistence uses an
automatic code generator to convert object models into C++ classes
which know how to read and write themselves to a relational database.

Leverage existing data

Persistence enables object oriented access to existing relational
databases. Applications built with Persistence can work side by side
with legacy systems.

Automate database access

By generating the methods to convert relational data into objects,
Persistence saves the developer from having to write literally hundreds
of lines of code per class.

Speed application development

With Persistence, major changes to the application object model can be
completed in minutes, not weeks.

Quality

Persistence generates tested, bug-free code. Using Persistence helps
ensure the reliability and reusability of your applications.

Performance

At Runtime, Persistence manages an object cache to enhance performance
while ensuring data integrity. The Persistence object cache can provide
a factor of ten performance improvement for data intensive
applications.

Portability

Code generated by Persistence is database independent. You can choose
which database to work with at link step, increasing application
portability.

TECHNICAL SPECIFICATIONS

The Persistence Database Interface Generator converts object schemas
into C++ classes.

Custom
Code
|
v

Object schema ---> Persistence ----> Generated
Generator Classes
^
|
v
Persistence
Object Cache
^
|
v
Legacy Data


Encapsulation

Each class generated by Persistence maps to a table or view in the database.
- Query using ANSI SQL or attribute values
- Add custom code to generated classes
- Preserve custom code when model changes

Inheritance

Persistence supports inheritance of attributes, methods and relationships.
- Propagate superclass queries to subclasses
- Use virtual methods for polymorphism

Associations

Persistence maps associations to foreign keys in the database. Each class has methods to access related classes.
- Ensure referential integrity between classes
- Specify delete constraints for associations

Object Caching

The Persistence Runtime Object Management System caches objects during
transactions and ensures data integrity. In the object cache,
Persistence "swizzles" foreign key attributes into in-memory pointers,
speeding object traversal.

Transactions

When a transaction is committed, Persistence walks through the object
cache and writes out changes to the database.

Environment

Platforms/Operating systems
Persistence will support all major Unix and Intel platforms
- Sun/SunOS 4.x, Solaris 2.x
- HP/HP-UX 8.0, 9.0
- IBM/AIX (planned 11/93)
- Intel/NT (planned 3/94)

Development Tools

Persistence supports all major C++ compilers and integrates with GE's
OMTool, allowing developers to go straight from an object model to a
running C++ application.
- Cfront 2.1: ObjectCenter 1.0, SPARCompiler, ObjectWorks
- Cfront 3.0: ObjectCenter 2.0, SPARCompiler, Softbench C++
- GE's OMTool

Databases

Persistence provides database independence. With our Objectivity
integration, we also provide a clear migration path to object
databases.
- Oracle V6, V7
- Sybase 4.x
- Ingres 6.x
- Objectivity ODBMS
- Informix (planned 9/93)
- ODBC (planned 3/94)

CUSTOMER QUOTES

"We wanted to use object technology while continuing to support our
legacy systems. Persistence made this feasible by automating over 30
percent of our development cycle." Steve Hunter, Sterling Software

"Persistence cut our development time by approximately 40%, because we
would have had to do all the mapping functions ourselves." Jim
Adamczyk, Partner, Andersen Consulting

"I'm convinced we'll save weeks or months of time because of
Persistence." Mike Kubicar, SunSoft Defect Tracking Team

"The good thing is that you can change your object model and just
re-generate the database interface classes at the press of a button."
Richard Browett, Product manager, K2 Software Developments, Ltd.

"The Persistence package saved at least 25 to 50 percent of the
development time, and seemed extremely robust. Support has been nothing
short of phenomenal." Stew Schiffman, DuPont Research and Development

FOR MORE INFORMATION


Persistence Software, Inc.
1700 S. Amphlett Blvd.
Suite 250
San Mateo, CA 94402
U.S.A.

Voice: 1-800-803-8491
(415) 341-7733
Fax: (415) 341-8432
Email: in...@persistence.com
Web: http://www.persistence.com


> Subtleware

Connecting C++ with Relational Databases


Subtleware for C++ (Subtleware) is a software development toolset which
openly automates C++ connectivity to relational databases by providing:

* A C++ pre-processor that automatically generates the code necessary
to read and write C++ objects to a relational database.

* A schema mapper that defines C++ classes from relational database
schema, and

* A class library that simplifies C++ application access to existing
relational data,


SUBTLEWARE INCREASES PROGRAMMER PRODUCTIVITY

Subtleware vastly simplifies the coding necessary for C++ to work with
relational databases:

* It jump starts application development by generating C++ class
definitions from relational database schema.

* It speeds application development by eliminating the need to
write hundreds of lines of database mapping code per class.

* It dramatically reduces application maintenance time by eliminating
the need to modify the database mapping code with each C++ class
definition change.

As a result, C++ application developers can focus on what brings value to
their organization, application development; and, C++ application
development projects can reduce their development costs as well as speed
their time-to-market.


SUBTLEWARE IS DESIGNED TO BE OPEN

* Subtleware adds value to your C++ development environment!
Subtleware fits into your existing C++ development environment by
working with your preferred C++ design tools, compilers, and class
libraries. No Subtleware-specific design tools are necessary.

* Subtleware works directly with your existing C++ class definitions!

* Subtleware adds value to your relational database systems!
Your C++ applications can work concurrently and share data with
your other relational database applications. Subtleware makes your
existing relational database into a powerful OODBMS.

* Subtleware library source code and generated code is freely
available! No run-time fees are imposed.


SUBTLEWARE IS WIDELY AVAILABLE

Subtleware runs on a wide range of computing platforms:
* PC's running Windows 3.x, Windows NT, OS/2, and DOS.
* Unix workstations, including Sun and HP.

Subtleware supports a variety of database interfaces:
* ANSI SQL * ODBC
* Oracle * Sybase
* Watcom * Informix (planned 8/95)
* Ingres (planned 10/95)
* ODMG (planned 12/95)

Subtleware supports virtually all C++ 2.x and 3.x compilers, including:
* Borland C++
* Microsoft Visual C++
* HP C++
* SunPro C++


SUBTLEWARE IMPROVES SOFTWARE QUALITY

Subtleware generates well-documented, bug-free code. Furthermore,
Subtleware code generation can be customized for your application
requirements. Using Subtleware greatly increases the reliability and
reusability of your applications.


SUBTLEWARE OPTIMIZES APPLICATION PERFORMANCE

Subtleware generates static SQL code that can be linked directly into your
application or packaged as a DLL or shared library. Subtleware does not
require the use of high-overhead, run-time modules for managing your
persistent objects.

Bob Hathaway

unread,
Apr 3, 1996, 3:00:00 AM4/3/96
to
Archive-name: object-faq/part11
Last-Modified: 04/02/96
Version: 1.0.9

Indicate in your accompanying letter whether you want the system on a 9-track
tape at 1600 BPI, at 6250 BPI, on a cartridge tape for SUN shoeboxes (QIC 24
format), or on a TK50 DEC cartridge tape.


>22 Sniff (C++ devel environ)

[See also APPENDIX C, SNiFF+, for the commercial version]

What: SNIFF (Sniff 1.1b (C++ Development Environment))
From: sh...@sinkhole.unf.edu (Stephen Hite)
Date: 23 Aug 92 18:14:00 GMT

Sniff 1.1b is available from iamsun.unibe.ch in the C++ hierarchy. It's a
development environment for C++ (minus the C++ compiler or interpreter).
It's freely available and you're gonna need OpenWindows 3.0 if you want
to play with it immediately. I just downloaded it and haven't had a
chance to look into whether the XView 3.0 package will be able to handle
everything Sniff requires of the OpenLook part.

And:

From: sn...@takeFive.co.at (Mr. Sniff)
Newsgroups: comp.lang.c++,comp.unix,comp.unix.osf.osf1,comp.unix.solaris,comp.object
Subject: SNiFF+ takeFive Starts Free University Distribution of Commercial C/C++ Programming Environment
Date: 22 Sep 1993 15:51:26 GMT
Organization: EUnet EDV-Dienstleistungsgesellschaft m.b.H
Keywords: programming environments, browsing, C++

SNiFF+: takeFive Starts Free University Distribution of Commercial C/C++
Programming Environment

1. Introduction
===============
Since the beginning of 1993 takeFive has taken over development and support
for SNiFF+, a leading edge C/C++ programming environment. With SNiFF+
rapidly gaining commercial acceptance takeFive has decided to offer the
product free to educational establishments. There are several reasons for
this step.

...

6. How to Obtain SNiFF+
=======================
6.1 FTP
-------
Sniff can be downloaded from anonymous FTP sites in USA and Europe.
You can get all details from in...@takeFive.co.at.

And:

From: hu...@iam.unibe.ch (Hermann Hueni)
Subject: Re: Browsers
Date: Fri, 11 Jun 1993 12:37:28 GMT

Sniff is a commercial product.
Send mail to in...@takeFive.co.at
AN early version is available as a SUN SPARC binary only from
siam.unibe.ch:C++/Sniff1.6/ (THIS site is in EUROPE)


>23 C++ tags

What: ctags/etags for C and C++
From: ken...@centerline.com (Sam Kendall)
Date: 10 Jun 92 09:31:27 GMT

A lot of people have requested this software! You can now get Tags for
C/C++ version 1.0 via anonymous ftp at:

ftp.centerline.com:/pub/tags-1.0.tar.Z

ftp.centerline.com is 140.239.2.29. Anonymous ftp means login as "ftp" and
give your email address as the password.

If you don't have ftp access to the internet, you may want to wait for this
stuff to come out in comp.sources.unix. Or, if you plan to use it right away,
send me a letter that says "I can't use ftp; please send by email" and I will
do so.


>24 short tool

From: ne...@aldur.demon.co.uk (Neil Wilson)
Subject: New version of 'short' available
Date: Sat, 7 Aug 1993 09:38:25 +0000

A new beta release (1.2) of 'short' is available from the Stuttgart
Eiffel archive (ftp.informatik.uni-stuttgart.de) in directory
/pub/eiffel/eiffel-3/sig

Command line processing is now included in the short system. Short can
now cope with multiple input files, the standard input and deal with
most file errors.

Short now depends on the argument cluster which is available from
the same archive and directory.

Short supports the following options:

-V, +version, -h, +help
Displays the 'short' version information and gives the
usage help message for the command.

-e, +abstract, +eiffel
Produces a fully deferred version of the input class(es)
which will compile just like any other class (hopefully :-)

-l <class_name>, +view <class_name>
Produces the output from the point of view of the class
<class_name> - the "short form for <class_name>".
Special handling for ANY and NONE of course. By default
short outputs the "short form for ANY".

-f, +full
Produces the short form including all the feature
blocks. (Implemented as the "short form for NONE".)

-p, +parents
Retains the inheritance clause in the output. The default is
to drop it.

-b <number>, +blank <number>
Indent levels by <number> characters.

-c <number>, +column <number>
Width of the output is <number> characters. Should be
greater than 20.

Obsolete features are not retained. Obsolete classes retain no features.

The output of the tool now conforms to the layout rules in Appendix A of
ETL and should look like the 'short' examples in the book. As much as is
possible the output and command line options conform to ISE's 2.3
version of 'short'.

This release of short has been tested on all the v1.21 Eiffel/S
libraries, itself and the argument clusters, plus any other class
fragments I had lying around at the time.

My biggest debt is of course to David Morgan. This version is only
really a tiny modification of his work. His ELEXER Eiffel 3 parser
remains the core of the tool. I though am responsible for any remaining
deficiencies or problems with this release.

Problems, suggestions, comments, criticisms to me please. All gratefully
received - I can't improve my Eiffel if somebody doesn't tell me where I
blew it.


>25 COOL(C++, Cfront 2.1, from GE)

COOL is a C++ class library developed at Texas Instruments.

Features are:
1. Rich set of containers like Vector, List, Hash_Table, Matrix, etc...
2. Hierarchy is shallow with no common base class, rather than deep like NIHCL.
3. Functionality close to Common Lisp data structures, like GNU libg++.
4. Template syntax very close to Cfront3.x, g++2.x.
5. Free, with good documentation, and extensive test cases.

Light version of COOL from General Electric:
1. Hairy macros, run-time type, exceptions removed for mainstream C++
compatibility
2. Free of memory leaks and bound violations. Leaks and bounds are checked
with Purify.
3. Has memory management and efficient copy in expressions like:
Set c = a+b+c;
Pointers are shared with Handle and Reference count. Deep copy in
expressions are replaced by shallow copy.
4. Compatible with Cfront2.1, and is being converted to Cfront3.0. You can
build both static and shared library on SunOS 4.1.x

1. original version from Texas Instruments:
at csc.ti.com, get pub/COOL.tar.Z
2. Cfront2.1 version modified by General Electric:
at cs.utexas.edu, get pub/COOL/GE_COOL2.1.tar.Z

I am working on Cfront3.0 version of COOL, using the Beta 3.0 from Sun. I am
experiencing problems with instantiation and specialization of templates. So
Cfront3.0 version of COOL won't be available until Sun's Cfront 3.0 is
released with bugs fixed.

Van-Duc Nguyen
General Electric
Research & Development Ctr
1 River Road, Room K1-5C39.
Schenectady, NY 12301.
Phone: (518) 387-5659
Fax: (518) 387-6845
ngu...@crd.ge.com


>26 idl.SunOS4.x, idl.Solaris2.x

Subject: Binaries for OMG IDL CFE placed on omg.org
Date: 11 Jun 93 00:13:11 GMT
Reply-To: j...@toss.eng.sun.com


SunSoft has made available statically linked binaries for the OMG IDL CFE,
for both Solaris 1.x and Solaris 2.x. Because they are statically linked,
these binaries can be used on systems which do not have the SparcWorks (TM)
compilers installed.

It is expected that people who only want an IDL parser will prefer to
obtain these binaries instead of compiling the program on their host.
People who want to build a complete compiler, by programming their own
back-end, will continue to obtain the sources which are also provided at
the same location.

The binaries can be obtained by anonymous FTP to omg.org. They are
installed in the directory pub/OMG_IDL_CFE_1.2/bin, in idl.SunOS4.x and
idl.Solaris2.x. Uuencoded versions are also available, in the same
directory.

Please send email to idl...@sun.com if you obtain these files.

The attached copyright applies to the provided binaries and to the source
files provided on the omg.org file server.


Copyright:
Copyright 1992 Sun Microsystems, Inc. Printed in the United States of
America. All Rights Reserved.

This product is protected by copyright and distributed under the following
license restricting its use.

The Interface Definition Language Compiler Front End (CFE) is made
available for your use provided that you include this license and copyright
notice on all media and documentation and the software program in which
this product is incorporated in whole or part. You may copy and extend
functionality (but may not remove functionality) of the Interface
Definition Language CFE without charge, but you are not authorized to
license or distribute it to anyone else except as part of a product or
program developed by you or with the express written consent of Sun
Microsystems, Inc. ("Sun").

The names of Sun Microsystems, Inc. and any of its subsidiaries or
affiliates may not be used in advertising or publicity pertaining to
distribution of Interface Definition Language CFE as permitted herein.

This license is effective until terminated by Sun for failure to comply
with this license. Upon termination, you shall destroy or return all code
and documentation for the Interface Definition Language CFE.

[...] etc. on copyright stuff [...]

SunSoft, Inc.
2550 Garcia Avenue
Mountain View, California 94043

>27 Browser for OO info

A search engine for Object-Oriented Information Sources on the World
Wide Web is being maintained by the Software Composition Group at the
University of Berne, Switzerland. The URL to access is:

http://iamwww.unibe.ch/~scg/OOinfo/index.html

A mirror of the catalog is available from the University of Geneva:

http://cuiwww.unige.ch/OSG/OOinfo/

Please e-mail suggestions for new entries to: s...@iam.unibe.ch

A searchable bibliography of object-oriented references is also available:

http://iamwww.unibe.ch/cgi-bin/oobib

as is a (searchable) version of the OO FAQ:

http://iamwww.unibe.ch/~scg/OOinfo/FAQ/index.html

Oscar Nierstrasz

---
Prof. Dr. Oscar Nierstrasz; os...@iam.unibe.ch; http://iamwww.unibe.ch/~oscar
Software Composition Group; CS Inst., U. Berne; Tel/Fax: +41 31 631.4618/3965

>28 Apertos(Meta-Obj Distr OS, research)

The Apertos (formerly MUSE) project at Sony Research
is a meta-object based distributed OS for turning portable wireless
hand-held computers into fully-connected Dynabook-like
terminals. It's very very wizzy. The papers are on:
scslwide.sony.co.jp:pub/CSL-Papers

The source is available for research; I think you have to
sign something first.


>29 Actors Paper (UIUC)

From: ag...@cs.uiuc.edu (Gul Agha)
Subject: Actor Theory Paper available
Organization: University of Illinois, Dept. of Comp. Sci., Urbana, IL
Date: Wed, 4 Aug 1993 15:41:02 GMT

A new paper providing a definitive and detailed development of the
semantics of actor systems is available via anonymous ftp. Comments
are especially welcome.


Title: A Foundation for Actor Computation

Authors: Gul Agha, Univerity of Illinois at Urbana-Champaign
Ian Mason, Stanford University
Scott Smith, John Hopkins University
Carolyn Talcott, Stanford University

Abstract:

We present an actor language which is
an extension of a simple functional language, and provide a precise
operational semantics for this extension. Actor configurations are
open distributed systems, meaning we explicitly take into account the
interface with external components in the specification of an actor
system. We define and study various notions of equivalence on actor
expressions and configurations.

to ftp the compressed postscript file:
ftp sail.stanford.edu (or 36.28.0.130)
login: anonymous
send ident as password.
cd pub/MT
the file is called:
93actors.ps.Z

Note: the paper is 76pp long. It subsumes work reported in our paper
in CONCUR '92.

(A number of other recent papers on actor languages and their
implementation may be obtained by anonymous ftp from
biobio.cs.uiuc.edu in the directory pub/papers).


>30 Chambers' Thesis

What: SELF optimizing compiler and Thesis
From: cham...@cs.washington.edu (Craig Chambers)
Date: 9 May 92 22:00:53 GMT

My Ph.D. thesis, entitled "The Design and Implementation of the Self Compiler,
an Optimizing Compiler for Object-Oriented Programming Languages," is now
available as Stanford technical report number STAN-CS-92-1420. Copies may be
ordered from Stanford. Stanford requires $20 (plus tax for orders from within
California), in advance, for each copy.

The dissertation also is available in compressed postscript form. The
electronic version may be copied via anonymous ftp from self.stanford.edu in
the directory pub/papers/chambers-thesis. This version is free. Note however
that the thesis is about 250 pages long.


>31 graph drawing

From: r...@cs.brown.edu (Roberto Tamassia)
Subject: annotated bibliography on graph drawing algorithms
Organization: Brown University Department of Computer Science
Date: Wed, 30 Jun 1993 06:45:48 GMT

A new revised version of the annotated bibliography on graph drawing
algorithms by Giuseppe Di Battista, Peter Eades, Roberto Tamassia, and
Ioannis Tollis is now available via anonymous ftp from
wilma.cs.brown.edu (128.148.33.66). The files are /pub/gdbiblio.tex.Z
and /pub/gdbiblio.ps.Z.


>32 Law of Demeter

From: lie...@ccs.neu.edu (Karl Lieberherr)
Subject: Law of Demeter/Adaptive Software
Organization: College of CS, Northeastern University
Date: Fri, 4 Jun 1993 20:41:49 GMT

>...
Yes, the Law of Demeter paper is available in electronic form on the
net. Indeed, many of the Demeter project papers are available from
the ftp server at Northeastern University (see instructions below).

The Law of Demeter idea has been automated in the Demeter Tools/C++
as an adaptive software tool which automatically makes much of your C++ code
compliant with the Law of Demeter. The tool is an add-on tool to
your favorite C++ development environment and is commercially available
from Demeter International. The Demeter Tools/C++ lift
object-oriented programming to a higher level of abstraction
by allowing the user to focus on the essential and
stable classes. A paper on ADAPTIVE SOFTWARE will appear in
the Communications of the ACM and is also available from the
ftp server.

For more information, use the ftp instructions below or call

Demeter International
56 Bennett Road
Marblehead, MA 01945

phone: (617) 639 1544
fax: (617) 373 5121

or send e-mail to dem...@ccs.neu.edu

-- Karl Lieberherr

FTP instructions:

Some of our papers are available in one package by anonymous ftp from

ftp.ccs.neu.edu (129.10.10.51)

in directory pub/demeter/documents

Use the following command sequence to copy the Demeter papers:

% ftp ftp.ccs.neu.edu or 129.10.10.51)
Name ( ... ): ftp
Password: your-email-address
ftp> cd pub/demeter/documents
ftp> ls
ftp> binary
ftp> get papers.tar.Z
ftp> quit
% uncompress papers.tar.Z
% tar xf papers.tar

If you want to copy individual papers and not all at once, go to
directory pub/demeter/documents/papers and retrieve them
individually.

Law of Demeter paper:
LH89-law-of-demeter.ps
Adaptive Software papers:
LSLX93-adaptive-programming.ps
L92a-component-enhancement.ps
LHSLX92-pp-experience.ps


>33 OO Dyn Grping, memory

From: ma...@cs.man.ac.uk (Mario Wolczko)
Subject: Re: OOPLs and Locality of Reference
Keywords: locality of reference
Date: 5 Jul 93 14:39:13 GMT
Organization: Dept Computer Science, University of Manchester, U.K.

[...]
The measurements done as part of the work here on the Mushroom project
show that temporal locality within Smalltalk objects is great (and
hence even conventional caches work reasonably well [unless the GC
scheme trashes the cache]), whereas spatial locality on a scale much
larger than the average object (which is 40 bytes) is much harder to
come by.

More details can be found in these papers (all available by ftp from
mushroom.cs.man.ac.uk in /pub/mushroom/papers):

dgvm1.ps.Z
"Dynamic Grouping in an Object Oriented Virtual Memory Hierarchy"
Ifor Williams, Mario Wolczko, Trevor Hopkins, Proc. ECOOP 87,
Springer-Verlag LNCS 276, pp.79-88.

dgvm2.ps.Z
"Realization of a Dynamically Grouped Object-Oriented Virtual
Memory Hierarchy", Proceedings of the Workshop on Persistent Object
Systems: Their Design, Implementation and Use, available as
Persistent Programming Research Report PPRR-44-87, Universities
of Glasgow and St. Andrews, Aug. 1987, pp.298--308.

obma.ps.Z
"An Object-Based Memory Architecture"
Ifor Williams and Mario Wolczko, in Implementing Persistent Object
Bases: Proc. Fourth International Workshop on Persistent Object Systems,
Morgan Kaufmann, 1991, pp.114-130.
The first three figures are in obma-fig[123].ps.Z.

Mario Wolczko

______ Dept. of Computer Science Internet: ma...@cs.man.ac.uk
/~ ~\ The University uucp: mcsun!uknet!man.cs!mario
( __ ) Manchester M13 9PL JANET: ma...@uk.ac.man.cs
`-': :`-' U.K. Tel: +44-61-275 6146 (FAX: 6236)
____; ;_____________the mushroom project___________________________________


>34 Pred Classes (Cecil)

What: "Predicate Classes" paper
From: cham...@klamath.cs.washington.edu (Craig Chambers)
Date: Fri, 30 Apr 93 01:25:02 GMT

"Predicate classes are a new linguistic construct designed to
complement normal classes in object-oriented languages. Like a normal
class, a predicate class has a set of superclasses, methods, and
instance variables. However, unlike a normal class, an object is


automatically an instance of a predicate class whenever it satisfies a
predicate expression associated with the predicate class. The
predicate expression can test the value or state of the object, thus
supporting a form of implicit property-based classification that
augments the explicit type-based classification provided by normal
classes. By associating methods with predicate classes, method lookup
can depend not only on the dynamic class of an argument but also on

its dynamic value or state. If an object is modified, the
property-based classification of an object can change over time,
implementing shifts in major behavior modes of the object. A version


of predicate classes has been designed and implemented in the context
of the Cecil language."