C. Chambers, D. Ungar, B.-W. Chang, and U. Holzle. Parents are shared parts of objects: Inheritance and encapsulation in Self. Lisp and Symbolic Computation, 4(3), June 1991.  Home/Search   Document Details and Download   Summary   Related Articles   Check

.... The compiler solves name con icts by applying a rule, such as the pre order traversal of the inheritance tree, as in Phyton [15] or by linearizing the inheritance graph (i.e. reducing the inheritance graph to a at list) as in CLOS [21] or by prioritizing an object s parents as in Self [10]. Otherwise the language may simply make the same names for instance variables of subclasses illegal as in SmallTalk [12] Explicit resolution. Ei el forces the programmer to explicitly remove all the ambiguities by renaming methods that con ict [16] C [23] complains when a con ict arises, ....

C. Chambers, D. Ungar, B.-W. Chang, and U. Holzle. Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self. Lisp and Symbolic Computation, 4(3):207-222, 1991.

....voluminous to be included. The Scheme language is described in [30] the ML language in [67] and the Miranda language in [107] Simple polymorphic type systems are introduced in [47, 66] Slide 12,18 Simula and Beta are described in [36, 37, 56, 62] Smalltalk in [42, 43] CLOS in [53] Self in [108, 29, 26]; C in [98, 97, 100] and Eiffel in [64, 65, 39] Slide 21 26 The formalization of coercion functions is found in [89, 90] Slide 27 The use of coercion theory for phrase types is developed in [91, 75, 92] and for implicit scalings in [103] Slide 28 38 The basic encoding is presented in ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Holzle. Parents are shared parts of objects: Inheritance and encapsulation in Self. Lisp and Symbolic Computation, 4(3):207--222, June 1991.

....dynamically. This feature is often regarded as dynamic inheritance. In the Self approach [UnSm86] which is a kind of symbiosis between copying and delegation, objects are normally composed of two parts. Operations and shared variables of objects are gathered into special objects called traits [CUCH91], whereas variables representing the local states of objects are stored in objects referred to as prototypes. Object definition is started by first defining a traits object, which defines the local behavior part of the object. Concrete prototypes are then composed by creating another object which ....

Chambers, C., Ungar, D., Chang, B.-W., Hlzle, U., Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self. Lisp and Symbolic Computation, (4) 1991, pp.207-222.

....restricted, dynamic inheritance mechanisms ####. Method update is one of these better behaved mechanisms, especially in the absence of delegation, as in our calculus. Method update is statically typable, and can be used to emulate the mode switching applications of dynamic inheritance [13]. With method update we avoid some dangerous aspects of dynamic inheritance ########, while maintaining its dynamic specialization aspects originally advocated by the Treaty of Orlando ####. In this paper, we study an untyped calculus (section 2) and then we present a type structure for it ....

Chambers, C., D. Ungar, B.-W. Chang, and U. Hlzle, Parents are shared parts of objects: inheritance and encapsulation in Self. Lisp and Symbolic Computation 4(3). 1991.

....starting aim of the work developed in this paper was the definition of a semantic framework suitable for modeling inheritance as a module composition operator. In the spirit of separation of concerns, in this paper we focus on one aspect of inheritance, i.e. following the slogan in the title of [16], the possibility it offers of combining modules sharing part of their states. Indeed, let us consider a class H = extends P by M which inherits a set of attributes from its parent class P. Since methods in M may refer to some of these attributes, H can be obtained as the merge of M and P where ....

Chambers, C., D. Ungar, B. Chang, and U. Holzle: 1991, `Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self'. Journ. of Lisp and Symbolic Computation 4(3).

....references I, J, NUMROWS, NUMCOLS, LASTROW, and LASTCOL that are used in matrix subscripts. Including these in the grammar is straightforward but tedious, and we have omitted them for brevity. subclass and instance since any object can be used as the basis for defining a new object. Self [Ungar et al. 1991] is perhaps the best known prototype based language. ObjectWorld [Penz 1991; Penz and Wollinger 1993] is a prototype based language that, like ours, uses visual mechanisms to emphasize concreteness and does not use delegation. However, unlike our approach, ObjectWorld does not use any inheritance ....

Ungar, D., C. Chambers, B. Chang, and U. Hlze, "Parents Are Shared Parts of Objects: Inheritance And Encapsulation In Self," Journal of Lisp and Symbolic Computation 4(3), 1991.

....restricted, dynamic inheritance mechanisms [23] Method update is one of these better behaved mechanisms, especially in the absence of delegation, as in our calculus. Method update is statically typable, and can be used to emulate the mode switching applications of dynamic inheritance [13]. With method update we avoid some dangerous aspects of dynamic inheritance [14, 23] while maintaining its dynamic specialization aspects originally advocated by the Treaty of Orlando [22] In this paper, we study an untyped calculus (section 2) and then we present a type structure for it ....

Chambers, C., D. Ungar, B.-W. Chang, and U. Hlzle, Parents are shared parts of objects: inheritance and encapsulation in Self. Lisp and Symbolic Computation 4(3). 1991.

....updating of shared state. These concerns have led to the search for better behaved, restricted, dynamic inheritance mechanisms [29] Method update is one of these betterbehaved mechanisms; it is statically typeable, and can be used to emulate the modeswitching applications of dynamic inheritance [15]. With method update we avoid some dangerous aspects of dynamic inheritance [17, 29] while maintaining its dynamic specialization aspects [28] 2.3 Procedures Our object calculus is so minimal that it does not include procedures, but these can be expressed too. To illustrate this point, we ....

Chambers, C., D. Ungar, B.-W. Chang, and U. Hlzle, Parents are shared parts of objects: inheritance and encapsulation in Self. Lisp and Symbolic Computation 4(3). 1991.

....in CLOS. In this language ambiguities are solved by linearizing the ancestor graph of a class to produce an inheritance list (see [Sny87] for a criticism of this process) In Self linearization is furtherly weakened yielding partial orders of ancestors and solving ambiguities with error messages [CUCH91] To introduce multiple inheritance in our framework we extend definitions with s : j e d meaning that s inherits all the attributes in every class in e c. Ambiguities may be solved by suitable rewriting rules for definitions. For instance a rule solving multiple inheritance as in CLOS ....

C. Chambers, D. Ungar, B. Chang, and U. Holzle. Parents are shared parts of objects: Inheritance and encapsulation in SELF. Lisp and Symbolic Computation, 4(3):207--222, July 1991.

....client can be related to one or more parents, thus characterizing a many to many relationship. Multiple parent delegation implies the choice of the parent to which the message must be delegated. Our approach consists of delegating the message to all parent objects. Other approaches can be found in [Cha91,Wol92]. The delegation mechanism can be combined with inheritance [Bal95] However, inheritance relationships must be given priority over delegation. Thus, when a message is sent to an object, the corresponding method is first searched in the object class hierarchy. If the method is not found, the ....

CHAMBERS, C. et al. Parents are Shared Parts of Objects: Inheritance and Encapsulation in SELF. Lisp and Symbolic Computation: An International Journal, v.4, n.3, 1991.

....of Self that we have described in this paper is the version that was publicly released in the Fall of 1992 (release 2.0.1) It is both a simple and a complex language. Simple, e.g. because it does not have classes and metaclasses, but complex, e.g. because it has complicated inheritance rules [5]. The type inference work has focused attention on many of the complexities, providing input to an ongoing attempt to further simplify Self. The version of the type inference implementation that is described is from the Spring of 1993. Later implementations have made significant improvements in ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Holzle. Parents are shared parts of objects: Inheritance and encapsulation in self. Lisp and Symbolic Computation, 4(3):207--222, June 1991.

....as 54 a full blown MOP can. However, it is not clear that completely opening up the implementation will not result in much complexity and inadvertent abuse by users. Finally, inheritance of first class modules must be compared with class less programming with prototypes and delegation as in SELF [19]. Class less programming languages allow individual objects to inherit from (or delegate to) other objects. Thus, there is no notion of classes instantiable into objects. The crucial characteristic of delegation is that inherited objects are shared parts of inheriting objects, whereas in ordinary ....

Chambers, C., Ungar, D., Chang, B.-W., and Holzle, U. Parents are shared parts of objects: Inheritance and encapsulation in SELF. LISP and Symbolic Computation: An International Journal 4, 3 (1991).

....added to the encapsulator. A custom encapsulator s wrapper methods could be built incrementally, but this has not yet been implemented, so for the purposes of our experiments we have written the wrapper methods manually. 4 The Split Object Problem Objects in Self can inherit from other objects [2]. Objects inherited from are known as trait or parent objects, and the objects which inherit from them as child objects. Inheritance splits an object s definition across the many objects from which it inherits, and this is known as the split object problem [3] Some prototype based models, such ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Holzle. Parents are shared parts of objects: inheritance and encapsulation in Self. Lisp And Symbolic Computation, 4(3), 1991.

....upper bound on the methods that must be compiled; thus, the compiler itself can be omitted from stand alone applications. Self is both a simple and a complex language. Simple, e.g. because it does not have classes and meta classes, but complex, e.g. because it has complicated inheritance rules [4]. The type inference work has focused attention on many of the complexities, energizing the e#orts to simplify the langllage. The Self language is less amenable to type inference than many other object oriented languages, yet we have obtained promising results. We believe that our algorithm is ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Holzle. Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self. In Lisp and Symbolic Computation 4(3), pages 207-222, Kluwer Acadamic Publishers, June 1991.

....the policy followed by Eiffel [51] Owl 25 Gamma Gamma Gamma Gamma Gamma Gamma Gamma I I Gamma Gamma Gamma Gamma Gamma Gamma Gamma Ellipse FillEllipse Circle FillCircle Figure 2.4. The diamond problem [62] CLOS [35] and SELF [68, 69]. The reader may wish to ponder the obvious common sense of this approach before continuing. The only modular solution is to treat the name collisions as errors, just as if the conflicting names had been defined in different classes. Similarly, each path in the graph must contribute a subobject. ....

Ungar, D., Chambers, C., Chang, B.-W., and Holzle, U. Parents are shared parts of objects: Inheritance and encapsulation in SELF, 1990. In The SELF papers, compiled by Urs Holzle.

....of Self that we have described in this paper is the version that was publicly released in the Fall of 1992 (release 2.0.1) It is both a simple and a complex language. Simple, e.g. because it does not have classes and metaclasses, but complex, e.g. because it has complicated inheritance rules [4]. The type inference work has focused attention on many of the complexities, providing input to an ongoing attempt to further simplify Self. One example is the recent elimination of parent priorities. The Self language is less amenable to type inference than many other objectoriented languages, ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Holzle. Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self. In Lisp and Symbolic Computation 4(3), pages 207--222, Kluwer Acadamic Publishers, June 1991.

....have learned the hard way that smaller is better and that examples can be deceptive. Early in the evolution of Self we made three mistakes: prioritized multiple inheritance, the sender path tie breaker rule, and method holder based privacy semantics. 2 Each was motivated by a compelling example [CUCH91]. We prioritized multiple parent slots in order to support a mix in style of programming. The sender path tie breaker rule allows two disjoint objects to be used as parents, for example a rectangle parent and a tree node parent for a VLSI cell object. The method holder based privacy semantics ....

....to be used as parents, for example a rectangle parent and a tree node parent for a VLSI cell object. The method holder based privacy semantics allowed objects with the same parents to be part of the same encapsulation domain, thereby supporting binary operations in a way that Smalltalk cannot [CUCH91]. 1 Simula TM is a trademark of a.s. Simula 2 In all fairness, the first author was across the Atlantic at the time and had nothing to do with it. On the other hand, if he had not wandered off maybe these mistakes could have been avoided. But each feature also caused us no end of confusion. ....

Craig Chambers, David Ungar, Bay-Wei Chang, and Urs Hölzle, Parents are Shared Parts of Objects: Inheritance and Encapsulation in Self. Journal of Lisp and Symbolic Computation, 4(3), Kluwer Academic Publishers, June, 1991.

....Since classless languages have no explicit classes or types, it would appear that type based encapsulation would be impossible to support, severely weakening any encapsulation provided by the language. Perhaps surprisingly, SELF s visibility rules do support a form of type based encapsulation [5]. A method may access the private slots of any of its descendants or ancestors, so that a method defined in a traits object may access the private slots of all instances of the trait (i.e. clones of prototypes inheriting from the traits object) just as methods defined in a C class may access ....

Chambers, C., Ungar, D., Chang, B., and Hölzle, U. Parents are Shared Parts of Objects: Inheritance and Encapsulation in SELF. To be published in Lisp and Symbolic Computation, 4, 3 (1991).

No context found.

C. Chambers, D. Ungar, B.-W. Chang, and U. Holzle. Parents are shared parts of objects: Inheritance and encapsulation in Self. Lisp and Symbolic Computation, 4(3), June 1991.

No context found.

Craig Chambers, David Ungar, Bay-Wei Chang and Urs H olzle, `Parents are shared parts of objects: Inheritance and encapsulation in self', Lisp and Symbolic Computation, 4(3), 207--222 (1991).

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