"Alejandro F. Reimondo" aleReimondo@sugarweb.com wrote:
Parts for Smalltalk works connecting objects with links. The objects can be visual (GUI) objects or non-visual. You can save your work in aFile with the component, later you can use the component (loaded from file). You can connect the parts with point & drag; but if you want to, you can
write
a new method for any object. The method will be bound to the object (not
to
its class) to expand the part or to implement a more convenient message in the context where the part is been used.
What we're getting into here is the advantage of instance-methods, or more radically, prototype object models, for dynamic GUI building environments. A couple interesting examples of such systems include:
* Amulet, done by Brad Myers' group at CMU, in which they implemented a prototype object model on top of C++(!):
http://www.cs.cmu.edu:80/afs/cs/project/amulet/www/amulet-overview.html
*SK8, done at Apple (a project with which I was associated for awhile), with a prototype object model implemented on top of Lisp: http://sk8.research.apple.com/ <--- Sigh... this link appears to be dead.
*NewtonScript, a relative of Self, with a really funky inheritance/containment model.
*Hmm... I bet we can consider Cocoa (now Stagecast) to be built with prototypes, too :-) http://www.stagecast.com/
Mike Wirth
Perhaps the prototype is not so radical anymore. It has snuck up on us via one of the most popular languages in use today - JavaScript! The following links should provide a good start for exploring JavaScript's prototype-based, object-oriented power:
http://siasphere.thepattern.com/cgi-bin/blackboard?14@%5E8261@.ee8b481 http://builder.cnet.com/Programming/FreeDOM/ http://builder.cnet.com/Programming/Shafer/100697/
-Laurence
wirth@almaden.ibm.com wrote:
"Alejandro F. Reimondo" aleReimondo@sugarweb.com wrote:
Parts for Smalltalk works connecting objects with links. The objects can be visual (GUI) objects or non-visual. You can save your work in aFile with the component, later you can use the component (loaded from file). You can connect the parts with point & drag; but if you want to, you can
write
a new method for any object. The method will be bound to the object (not
to
its class) to expand the part or to implement a more convenient message in the context where the part is been used.
What we're getting into here is the advantage of instance-methods, or more radically, prototype object models, for dynamic GUI building environments. A couple interesting examples of such systems include:
- Amulet, done by Brad Myers' group at CMU, in which they implemented a
prototype object model on top of C++(!):
http://www.cs.cmu.edu:80/afs/cs/project/amulet/www/amulet-overview.html
*SK8, done at Apple (a project with which I was associated for awhile), with a prototype object model implemented on top of Lisp: http://sk8.research.apple.com/ <--- Sigh... this link appears to be dead.
*NewtonScript, a relative of Self, with a really funky inheritance/containment model.
*Hmm... I bet we can consider Cocoa (now Stagecast) to be built with prototypes, too :-) http://www.stagecast.com/
Mike Wirth
Some here already know that the Prototype is one of the GOF's Creational patterns. It's potentcy goes far beyond GUI development. As the object paradigm becomes more and more pervasive, object-oriented software systems have become more dependent upon object compostition than class inheritance. The impulse for this shift stems from important knowledge representation and cognitive issues regarding how we categorize information about the world around us. The Prototype pattern provides flexibility in the creation of objects. Java and C++ use another Creational pattern - the Factory to provide flexiblity, but nothing beats a Prototype for flexiblity.
-Laurence
wirth@almaden.ibm.com wrote:
"Alejandro F. Reimondo" aleReimondo@sugarweb.com wrote:
Parts for Smalltalk works connecting objects with links. The objects can be visual (GUI) objects or non-visual. You can save your work in aFile with the component, later you can use the component (loaded from file). You can connect the parts with point & drag; but if you want to, you can
write
a new method for any object. The method will be bound to the object (not
to
its class) to expand the part or to implement a more convenient message in the context where the part is been used.
What we're getting into here is the advantage of instance-methods, or more radically, prototype object models, for dynamic GUI building environments. A couple interesting examples of such systems include:
- Amulet, done by Brad Myers' group at CMU, in which they implemented a
prototype object model on top of C++(!):
http://www.cs.cmu.edu:80/afs/cs/project/amulet/www/amulet-overview.html
*SK8, done at Apple (a project with which I was associated for awhile), with a prototype object model implemented on top of Lisp: http://sk8.research.apple.com/ <--- Sigh... this link appears to be dead.
*NewtonScript, a relative of Self, with a really funky inheritance/containment model.
*Hmm... I bet we can consider Cocoa (now Stagecast) to be built with prototypes, too :-) http://www.stagecast.com/
Mike Wirth
squeak-dev@lists.squeakfoundation.org
-
Laurence Rozier -
wirth＠almaden.ibm.com