In object-oriented languages, an abstraction often involves a group
of objects acting as a single entity. The programmer often has a
mental vocabulary by which to label the objects: for example, in a
particular LR(0) automaton, one object might represent the state
``P ::= R . S''. In a particular instance of a binary-tree, one
object might represent the data item ``15''. In general, each
object in an abstraction can be mentally labeled, by the
programmer, according to some statement of its purpose. The
programmer's vocabulary to taxonomize and label the objects
constituting an abstraction may be quite sophisticated and
detailed. However, that vocabulary is only in the programmer's
mind, it does not exist at the language level. The runtime system
has no means to tell two instances of class binary-tree-node apart
--- it can't even distinguish the nodes of one tree from the nodes
of another without sophisticated analysis. Though object-oriented
languages make it possible to construct data structures with many
different parts, they do not create a language-level vocabulary by
which to refer to the different parts of the data structure.
There are several problems in the field of object-oriented
parallel processing that have hampered programmers for years, and
for which solutions have been elusive. We argue that the lack of
solutions to these problems stems from the absence of a
vocabulary with which to express those solutions. In
particular, the inability to refer to objects by name, and the lack
of a vocabulary to distinguish objects from each other, makes it
difficult to even describe what is desired from a complex
algorithm. When the runtime system can't identify which object is
which, it becomes becomes impossible to express such ideas as
locality, or interconnectivity, or grouping. Clearly, this is a
serious problem for parallel programmers. We have designed a new
encapsulation mechanism for parallel processing, the agent
declaration. This mechanism makes it possible to create an
abstraction whose subcomponents are labeled and taxonomized. Having
done so, we straightforwardly address some of the difficulties that
have been facing object-oriented parallel programmers for years.
The purpose of this research is to explore the consequences of
having a vocabulary by which to distinguish objects, and to
experiment with powerful language-level constructs that were
previously inexpressible.
Joshua M. Yelon, "Agents: an Abstraction Mechanism that Labels and Taxonomizes
the Objects it Encapsulates", Parallel Programming Laboratory, Department of
Computer Science, University of Illinois at Urbana-Champaign, 1997.
