Object-Oriented Programming


Henry Lieberman, Marcottage: A Navigational Approach to Object-Oriented Programming

Unpublished Draft: Comments and suggestions for publication welcome

In many situations involving highly connected networks of objects, such as semantic networks in AI, hypermedia networks, or scene representations in computer graphics, the notion of "current viewpoint" or "current focus of attention" is important. In traditional systems, the network structures are considered relatively fixed, while the user's viewpoint is considered to move through the structure. But it is also possible to take the alternative approach, where the viewpoint is considered fixed and the surrounding structure is constantly changing to maintain the consistency of the user's viewpoint. As the theory of relativity asserts the equivalence of all frames of reference, this unconventional approach is just as good as the traditional one. But keeping a fixed viewpoint has significant advantages for algorithms in which the current viewpoint plays an important role.

I present a system that uses a process of "re-rooting" called marcottage, to implement this approach. Whenever a link is followed in this system, the system conceptually reverses the link. This leads to a kind of navigational programming style which has some distinct advantages [as well as disadvantages] compared to the traditional one. The entire network remains accessible from any particular viewpoint, and it is easy to implement reversible algorithms or "undo" operations. An incremental change operation is provided which appears to the user as if the entire network has been modified, but in fact all state is preserved, and information is copied only as needed to maintain this illusion. This incremental change operation is useful, for example, in making private annotations to hypermedia networks, counterfactuals in knowledge bases, or incremental redisplay algorithms in computer graphics.

Marcotte: A part of a plant capable of regenerating missing parts, thus propagating a new plant capable of independent growth.

  • Web Format [HTML]

  • RTF Format [Microsoft Word, Mac and PC] [300 KB]
  • PostScript Format [2 MB]

  • Henry Lieberman, David Ungar and Lynn Andrea Stein, The Treaty of Orlando: A Shared View of Sharing, in Object-Oriented Concepts, Applications and Databases, Won Kim and Fred Lochovsky, eds., Addison-Wesley, 1988
    Henry Lieberman, Parallelism in Interpreters for Knowledge Representation Languages , in Concepts and Characteristics of Knowledge-Based Systems, M. Tokoro, Y. Anzai, A. Yonezawa, eds., North-Holland, 1989
    Machine Tongues: Object-Oriented Programming, in The Well-Tempered Object: Musical Applications of Object-Oriented Software Technology, Stephen Pope, ed., MIT Press, 1991
    Henry Lieberman, Reversible Object-Oriented Interpreters, First European Conference on Object-Oriented Programming, Paris, France, Springer-Verlag, 1987.

    Henry Lieberman, Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems

    A traditional philosophical controversy between representing general concepts as abstract sets or classes and representing concepts as concrete prototypes is reflected in a controversy between two mechanisms for sharing behavior between objects in object oriented programming languages. Inheritance splits the object world into classes, which encode behavior shared among a group of instances, which represent individual members of these sets. The class/instance distinction is not needed if the alternative of using prototypes is adopted. A prototype represents the default behavior for a concept, and new objects can re-use part of the knowledge stored in the prototype by saying how the new object differs from the prototype. The prototype approach seems to hold some advantages for representing default knowledge, and incrementally and dynamically modifying concepts. Delegation is the mechanism for implementing this in object oriented languages. Because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the more flexible and general of the two techniques.

    First Conference on Object-Oriented Programming Languages, Systems, and Applications [OOPSLA-86], ACM SigCHI, Portland, Oregon, September 1986. Also in Object-Oriented Computing, Gerald Peterson, ed., IEEE Computer Society Press, 1987.

  • HTML format
  • RTF format [Microsoft Word, Mac and PC], 1 MB
  • Postscript format , 1 MB

  • Henry Lieberman, Concurrent Object Oriented Programming in Act 1, in Object Oriented Concurrent Programming , Aki Yonezawa and Mario Tokoro, eds., MIT Press, 1987

    To move forward to the next generation of artificial intelligence programs, new languages will have to be developed that meet the demanding requirements of these applications. Artificial intelligence software will require unprecedented flexibility, including the ability to support multiple representations of objects, and the ability to incrementally and transparently replace objects with new, upward-compatible versions. As advances in computer architecture and changing economics make feasible machines with large-scale parallelism, artificial intelligence will require new ways of thinking about computation that can exploit parallelism effectively.

    To realize this, we propose a model of computation based on the notion of actors, active objects that communicate by message passing. Actors blur the conventional distinction between data and procedures. For parallel computation, actors called futures create concurrency, by dynamically allocating processing resources. Serializers restrict concurrency by constraining the order in which events take place, and have changeable local state. The actor philosophy is illustrated by a description of our prototype actor interpreter Act 1.

  • HTML format
  • RTF format [Microsoft Word, Mac and PC], 110K
  • Postscript format , 240K

  • Carl Hewitt and Henry Lieberman, Design Issues in Parallel Architectures for Artificial Intelligence IEEE Compcon Conference, March 1984.
    Henry Lieberman, An Object-Oriented Simulator for the Apiary, Conference of the American Association for Artificial Intelligence, Washington, D. C., August 1983.
    Henry Lieberman and Carl Hewitt, A Real Time Garbage Collector Based On The Lifetimes of Objects , Communications of the ACM, June 1983.
    Carl Hewitt, Giuseppe Attardi, and Henry Lieberman, Security and Modularity in Message Passing, First International Conference on Distributed Computing, Huntsville, Ala., October 1979.
    Carl Hewitt, Giuseppe Attardi, and Henry Lieberman, Specifying And Proving Properties Of Guardians For Distributed Systems In Semantics of Concurrent Computation, Springer-Verlag Computer Science Series No. 70.