Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the ACM Conference on ObjectOriented Programming Systems, Languages, and Applications, pages 214--223, Portland, Oregon, October 1986. Special Issue of SIGPLAN Notices, Volume 21, Number 11, November, 1986. 25  Home/Search   Document Not in Database   Summary   Related Articles   Check

.... methods, to call the corresponding assertion methods of its supertypes (see Chapter 6) The method calls are delegations in that, if the supertypes assertions refer to methods declared by the supertypes but overridden by the subtype, what are actually invoked are the subtype s methods [98] [142] The delegation approach correctly implements the semantics of JML regarding specification inheritance, as the inherited specifications of supertypes are resolved in the supertypes environment; e.g. field names are statically resolved and instance method calls are dispatched dynamically. ....

Henry Lieberman. Using prototypical objects to implement shared behavior in object oriented systems. ACM SIGPLAN Notices, 21(11):214--223, November 1986.

....instance variables) and implements the various operations of the type with procedures. A class operation is typically used to create instances of a type and is not one of the operations Some object oriented programming languages do not have classes, but are based on a notion of delegation [Lie86] [SLU89] In such systems one can still speak of an object s instance operations (the set of messages to which it responds) even though there are no classes and class operations. Specified class operations might be implemented by functions that clone prototypes, or by instance operations of ....

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. ACM SIGPLAN Notices, Conference Proceedings, Norman Meyrowitz (editor), September 1986, Portland, Oregon.

....complete replacement for general delegation, however. A general delegation system allows the child object to override methods in the parent. If there are multiple children, the parent must select the method definition from the child on which the invocation originated the so called self problem [13]. Ions explicitly outlaw this form of behavioural modification the child s methods cannot override the parent s so ion based delegation is only applicable when extending the parent s functionality. Delegation is particularly important in distributed systems, where an object may wish to ....

Henry Lieberman. Using prototypical objects to implement shared behaviour in objectoriented systems. In Proceedings of OOPSLA'86, 1986.

....software exhibiting three key properties: evolution, incompleteness, and safety. In the context of the object oriented paradigm the first two properties amount to have objects with method and delegate overriding, addition, removing and which can delegate executions of methods to other objects [Lie86] ABC 92] AD02] A traditional approach for ensuring safety is typing. There is a large literature about calculi of objects with types (see [AC96a] Bru02] Pie02] and their references) where safety is interpreted mainly as the property that well typed programs cannot go wrong, i.e. ....

Henry Lieberman. Using prototypical objects to implement shared behavior in object-oriented systems. In OOPSLA'86, ACM SIGPLAN Notices, volume 21(11), pages 214--223, ACM Press, New York, NY, 1986.

....known identity and binds it to the given name. The declaration also names the objects from which the new object inherits (its parents) The descends relation among objects is the reflexive, transitive closure of the declared inheritance relation. As in other classless languages [LaLonde et al. 86, Lieberman 86, Ungar Smith 87, Chambers 92, Abadi Cardelli 96] objects play the roles of both classes and instances, and isa accordingly plays the roles of both inheritance and instantiation. For example, in the modules of figure 2, the colorPoint object represents a subclass of point that has a color, ....

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems. OOPSLA '86 Conference Proceedings, pp. 214-223, Portland, OR, September, 1986. Published as SIGPLAN Notices 21(11), November, 1986.

....or if the composed behaviour is not needed. The complete composed basecomponent can be used as default for the imports, but this has one major drawback. It is no longer possible to use this reference as a reference to a composed base component. This problem is also known as the self problem [18]. For example the role Renter of the feature Renting creates a new Contract with a reference to the correct Video and Customer.TheCustomer is the instance of the class itself, so we want to use the this reference. In the composition the Contract has to accept actor A1 4 2 as a valid Customer.It ....

Henry Lieberman. Using prototypical objects to implement shared behavior in object-oriented systems. In Conference proceedings on Object-oriented programming systems, languages and applications, pages 214--223. ACM Press, 1986. http://doi.acm.org/10.1145/28697.28718

....relies in that it enables a run time decoration of objects, while both mixin and Beta approaches allow to decorate code (classes) Concerning delegation, we remark that the delegation mechanism shown in Section 2.2 is used by prototype based languages to share code. Prototypebased languages [14] drop the notions of class and inheritance to achieve a higher dynamic exibility at the cost of the detriment of safety. The lack of a static type system easily leads to run time errors such as message not understood . Because of these problems, prototype based languages had not the same success ....

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Norman Meyrowitz, editor, Proc. of OOPSLA, volume 22, pages 214-223. ACM Press, 1987.

....the facts proposed for updating during the proof of Iqsg in context 0bj are not actualized until the call successfully terminates, so to avoid any interference with the deductive process. In any case, complete update undoing is performed on backtracking. The notion of prototype a la Liehermann [3] can be reproduced too, by allowing evolving contexts to share not only their class context, but also the clauses of their self unit. The implementation of the CSM model is based on an extension to the SICStus Prolog system, where both units and contexts are represented similarly to SICStus ....

H. Liebermann. Using Prototypical Objects to Implement Shared Be- havior in Object-Oriented Systems. in OOPSLA 86 Conference Proceedings, pages 214-223, 1986.

....Technically, the most important di#erence between our delegation layer approach and mixin layers is that the mixin layer notion of multi class mixininheritance is replaced by multi object delegation . For those readers who have never heard of mixin inheritance [5] or delegation [20] (we will elaborate on that in the paper) this can be tentatively summarized as: With mixin layers, everything happens on classes at compile time, whereas with delegation layers, everything happens on objects at runtime. This has a deep impact on the semantics and expressiveness of the model. In ....

....For example, a graph that is both colored and weighted can be used where a colored graph is expected. Please note that in contrast to the frequent use of the term delegation as a synonym for forwarding semantics, in this paper it stands for dynamic, object based inheritance as defined in [20]. Thus the advantages of standard OO subtyping (reusability, decoupling etc. are transferred to collaboration inheritance. In general, this property does not apply for mixin layers. Composition consistency: Our approach guarantees that all operations inside a compound collaboration are ....

[Article contains additional citation context not shown here]

H. Liebermann. Using prototypical objects to implement shared behavior in objectoriented systems. In Proceedings OOPSLA '86, ACM SIGPLAN Notices, 1986.

....of reference among related objects by grouping them together. Bishop uses areas to develop an efficient garbage collector for objects in a single, very large, paged, linear address space. His ideas influenced several other designs, including those of Baker [Baker, Jr. 78] Lieberman and Hewitt [Lieberman 80], Luniewski [Luniewski 79] Almes [Almes 80] and Vestal [Vestal 87] 2.2.5 Distributed Object Oriented Systems Distributed systems are composed of several machines communicating via some network. A distributed system is inherently more complex than a single node system. Recognizing that an ....

....is performed only by the system and only when objects are no longer accessible. Garbage collection may employ a mark and sweep algorithm [Knuth 73] that traverses and marks all referenced objects from some known root set, it may periodically copy referenced objects into a new object space [Lieberman 80], or it may continuously keep track of the number of references for each object (reference counting) Garbage collectors, except those employing reference counting, usually suspend all other system activity during the collection process. If the collector is able to proceed in parallel with normal ....

[Article contains additional citation context not shown here]

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the ACM Conference on Object-Oriented Programming Systems, Languages, and Applications, pages 214--223, Portland, Oregon, October

....the difference with a client calling method m of the wrappee on a reference to the wrapper. Forwarding is a form of automatic message resending; delegation is a form of inheritance with binding of the parent (superclass) at run time, rather than at compile link time as with normal inheritance [16]. Generic Wrappers 213 wrapper w forwarding wrappee f this.n( a) Forwarding wrapper w delegation wrappee f this.n( b) Delegation wrapper: void n( print( n1 ) wrappee: void m( print( m2, n( void n( print( n2 ) Output: m2, n2 Output: m2, n1 Fig. 6. ....

Henry Lieberman. Using prototypical objects to implement shared behavior in object-oriented systems. In Proceedings of OOPSLA '86, pages 214--223. ACM Press, 1986.

....for these collaborations. This makes it possible to use existing client code (code that uses a composed collaboration, e.g. the aforementioned graph collaboration) with di#erent collaborations at runtime. In general, this is not possible with mixin layers as presented in [18] Delegation [11] can be seen as a generalization of mixinbased inheritance that allows to determine the inheritance hierarchy at runtime. For this reason, we think that delegation layers are a natural generalization of mixin layers, and they will be used to enable runtime composition. The second point is more ....

....unsafe dynamic type casts. In addition, this does not work for constructor calls in subclasses as explained in the previous paragraph, because superclasses cannot be dynamically assigned in a language with static inheritance. We think that this problem can be seen as a variant of the self problem [11], a.k.a. broken delegation [7] In a composite component, all actions should be applied to the composite component, rather than to an individual part of it. In class A void foo( print( A ) class B extends A void foo( print( B) super.foo( class C extends A void foo( ....

H. Liebermann. Using prototypical objects to implement shared behavior in object-oriented systems. In Proceedings OOPSLA '86, ACM SIGPLAN Notices, 1986.

....changes and cannot easily be adapted without invalidating existing clients. Actually, the need to combine properties of inheritance and object composition has already been the driving force for two families of non standard approaches to object oriented composition. On one side, delegation [20] enriches object composition with inheritance properties. Please note that in contrast to the frequent use of the term delegation as a synonym for forwarding semantics, in this paper it stands for dynamic, object based inheritance. In pure delegation based models, objects are created by cloning ....

....methods in the decorators but to the local implementations. A further consequence is that if a base object passes this to other objects, it passes itself instead of the decorator. In some situations, however, the opposite e#ect would be desirable. This anomaly is known as the self problem [20] or as broken delegation [16] The manual simulation of transparent redirection is rather complex and leads to a design that is very di#erent from the original decorator pattern because the base object needs some way of knowing about the decorators. One alternative is to store a back reference to ....

[Article contains additional citation context not shown here]

H. Liebermann. Using prototypical objects to implement shared behavior in object-oriented systems. In Proceedings OOPSLA '86, ACM SIGPLAN Notices, 1986.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the ACM Conference on ObjectOriented Programming Systems, Languages, and Applications, pages 214--223, Portland, Oregon, October 1986. Special Issue of SIGPLAN Notices, Volume 21, Number 11, November, 1986. 25

No context found.

Henry Lieberman. "Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems". Sigplan Notices 21, 11 (Nov. 1986), 214-223. ACM Conference on Object-Oriented Programming; Systems Languages and Applications; OOPSLA'86.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems. In N. K. Meyrowitz, editor, OOPSLA'86, ACM SIGPLAN Notices, volume 21(11), pages 214--223, ACM Press, New York, NY, 1986.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Norman Meyrowitz, editor, Proc. of OOPSLA, volume 22, pages 214--223. ACM Press, 1987.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 214{ 223, Portland, September/October 1986. Published as ACM SIGPLAN Notices 21(11), November 1986.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the Conference on Object-Oriented Systems, Languages and Applications (OOPSLA), Portland, Oregon, USA, pages 214--223, September/October 1986.

No context found.

H. Liebermann. Using prototypical objects to implement shared behavior in object-oriented systems. In Proceedings OOPSLA '86, ACM SIGPLAN Notices, 1986.

No context found.

Henry Lieberman. Using prototypical objects to implement shared behavior in object-oriented systems. In Norman Meyrowitz, editor, Proceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), volume 21(11), pages 214--223, New York, NY, 1986. ACM Press.

No context found.

Henry Liebermann. Using prototypical objects to implement shared behavior in object-oriented systems. In Proc. of OOPSLA 86, pages 214--223. ACM Sigplan Notices, 1986. 252

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In Proceedings of the 1986 Conf. on Object-Oriented Programming, Systems, Languages and Architectures, pages 214--223, 1986.

No context found.

Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems. In N. K. Meyrowitz, editor, OOPSLA'86, ACM SIGPLAN Notices, volume 21(11), pages 214--223, ACM Press, New York, NY, 1986.

No context found.

Henry Lieberman, `Using prototypical objects to implement shared behavior in object-oriented systems', Proc. OOPSLA'86, Object-Oriented Programming Systems, Languages and Applications. Sigplan Notices 21(11), 214--223 (1986).

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC