FOCUS TOPIC 4

5 August 2002 <<Cancelled>>

The Object Identity Pattern Language

Organizers:

Pascal Costanza, University of Bonn, Germany (costanza@web.de)
Peter Grogono, Concordia University, Montreal, Canada

Motivation:

Object identity is one of the cornerstones of object-oriented programming.
In [Booch91] it is stated that an "object has state, behavior, and identity". [Khoshafian86] says that "object identity is that property of an object which distinguishes each object from all others".

Without object identity there would be no means to relate a set of fields (instance variables) and (instance) methods to an instance of a generalized concept as described in a class definition. So one could even state that object identity is the single distinguishing concept of object orientation - there can be objects without behavior, there can be objects without state, but there can never be objects without identity!

However, there are also some pitfalls involved in this concept. In practice, object identity is used for just two different purposes. One is object reference which permits object correlation and access to objects' internal states. The other is object comparison which permits the decision as to whether two variables actually refer to the same object. The fact that object identity encompasses these two different notions results in some restrictions on how objects may evolve in programs over time. These restrictions have been formally described in [Wieringa95]: each object is referred by exactly one reference (Singular Naming); each reference refers to exactly one object (Singular Reference); and finally, if a reference points to a particular object at a given time, this reference is bound to that object at any point in time thereafter (Monotic Designation). All of these requirements result from the fact that in almost all programming languages references are not only used for expressing relationships between objects but also as a basis for defining default comparison operations that determine object identity.

Sometimes, however, these requirements are too restrictive and, consequently, there have always been other approaches that allow work-arounds. Programming language designers have worked hard to offer means for influencing the result of comparison operations (for example, by means of overriding operator== in C++ or method "equals()" in Java) or even for manipulating references (for example, by application of method
"become:" in Smalltalk). Several authors have discussed in detail how to implement several variations of object identity [Kent91, Khoshafian86] and comparison [Baker93, Grogono2000] correctly.

Last but not least, there already exist many design patterns that can be read as ways to overcome the limitations of object identity. Here are a few examples: the Proxy, Decorator and Strategy patterns [Gamma95] introduce delegation in order to allow for manipulation of references; the Extrinsic Property pattern [Fowler97] allows for introduction of new references to an object "after the fact"; the Basic Relationship Patterns [Noble2000] discuss different ways to set up references between objects; and the
Comparand pattern [Costanza2001] allows for flexible and sound definition of logical equality.

The Singleton pattern [Gamma95], designed to ensure uniqueness, and the Cache Proxy pattern [Rohnert96] are closely related to object identity.

Goal of the Workshop:

The goal of this refactoring workshop is to start from the notions of object identity and use them as guiding principles to classify the existing patterns and other work in this realm. We are very confident that this will result in interesting relationships and links between these patterns and generate ideas for new patterns. In the long run, we ultimately hope for a coherent pattern language that covers a wide range of recurring problems in
contexts in which ideas related to object identity offer appropriate solutions.

Participation Guidelines:

Prospective participants should submit a short statement (about one page) with the following information.

* Something about themselves that they think is relevant or important for this workshop.
* A short outline of how they would approach the workshop and/or what material to include.

>>>
We are not only interested in material that is closely related to object identity but also in topics that depart somewhat but are still related. So, for example, we are also interested in object-relational mappings, object caching, Singleton objects and extrinsic properties, to name a few.
<<<

We do not want to set up strict deadlines. However, if there is a lot of response we will probably limit the number of participants to about 20 in order to guarantee a fruitful working atmosphere.

Information about Organizers:

Pascal Costanza has an MS degree from the University of Bonn, Germany, and has been a research assistant at the University of Bonn for the last 4 years, focusing mostly on programming language constructs for unanticipated software evolution. Currently, he is finishing his doctoral thesis on the programming language Gilgul that strictly separates the notions of reference and comparison that are traditionally subsumed in the concept of
object identity.

Peter Grogono is Professor of Computer Science and Director of the undergraduate Software engineering program at Concordia University in Montreal, Quebec. His technical interests include programming languages, software development, and evolutionary programming.

References:

[Baker93] Henry Baker, "Equal Rights for Functional Objects or, The More
Things Change, The More They Are The Same", ACM OOPS Messenger, 4, 4,
October 1993.

[Booch91] Grady Booch, "Object-Oriented Design with Applications",
Addison-Wesley, 1991.

>>>
[Brown95] Kyle Brown, Bruce G. Whitenack, "Crossing Chasms: A Pattern
Language for Object-RDBMS Integration", PLoPD 2, Addison-Wesley, 1996.
<<<

[Costanza2002] Pascal Costanza, "Dynamic Replacement of Active Objects in
the Gilgul Programming Language", CD 2002, proceedings, Springer LNCS.

[Costanza2001] Pascal Costanza, Arno Haase, "The Comparand Pattern",
EuroPLoP 2001, proceedings.

[Gamma95] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, "Design
Patterns", Addison-Wesley, 1995.

[Grogono2000] Peter Grogono, Markku Sakkinen, "Copying and Comparing:
Problems and Solutions", ECOOP 2000, proceedings, Springer LNCS.

[Kent91] William Kent, "A Rigorous Model of Object References, Identity and
Existence", Journal of Object-Oriented Programming, 4(3):28-36, 1991.

[Khoshafian86] Setrag N. Khoshafian, George P. Copeland, "Object Identity",
OOPSLA '86, proceedings, ACM Press.

>>>
[Kordale96] R. Kordale, M. Ahamad, M. Devarakonda, "Object Caching in a
CORBA Compliant System", Proceedings of the USENIX 1996 Conference on
Object-Oriented Technologies (COOTS),
http://www.usenix.org/publications/library/proceedings/coots96/full_papers/korda
le/paper.html

<<<

[Noble2000] James Noble, "Basic Relationshop Patterns", PLoPD 4,
proceedings, Addison-Wesley.

[Powell93] Michael L. Powell, "Objects, References, Identity and Equality -
White Paper", OMG TC Document Number 93.7.5, Sun Microsystems Inc., 1993.

[Rohnert96] Hans Rohnert, "The Proxy Design Pattern Revisited", PLoPD 2,
Addison-Wesley.

[Wieringa95] Roel Wieringa, Wiebren de Jonge, "Object Identifiers, Keys,
and Surrogates - Object Identifiers Revisited", Theory and Practice of
Object Systems, 1(2):101-114, 1995.