Thanks for the reminder Stef.
If my prodded memory still serves, I think Ralph Johnson did document the
implementation trick in TypeObject.
What I really wanted to focus on was the alternate metaclass universe
ideas.  Our particular Metaclass substrate forces us into certain
categories of design and implementation approaches.  Other substrates would
enforce other approaches.  Just wondering if there is something there worth
investigating.  For instance, would our beloved design patterns still apply
in these alternate universes?  Some clearly do, others may not.  The same
may be said of new patterns to be discovered in these alt spaces, they may
be useful in ours as well.

Regards,
Sam



Sam S. Adams, IBM Distinguished Engineer, IBM Research
tie line 444-0736, outside 919-254-0736, email: ssadams at us.ibm.com
<<Hebrews 11:6, Proverbs 3:5-6, Romans 1:16-17, I Corinthians 1:10>>



|---------+--------------------------------------------->
|         |           ducasse <ducasse at iam.unibe.ch>    |
|         |           Sent by:                          |
|         |           squeak-dev-bounces at lists.squeakfou|
|         |           ndation.org                       |
|         |                                             |
|         |                                             |
|         |           11/05/2003 03:42 PM               |
|         |           Please respond to The             |
|         |           general-purpose Squeak developers |
|         |           list                              |
|         |                                             |
|---------+--------------------------------------------->
  >---------------------------------------------------------------------------------------------|
  |                                                                                             |
  |       To:       The general-purpose Squeak developers list                                  |
  |        <squeak-dev at lists.squeakfoundation.org>                                              |
  |       cc:                                                                                   |
  |       Subject:  Re: About reflection and it engineering                                     |
  |                                                                                             |
  >---------------------------------------------------------------------------------------------|




hi adam

did you read the TypeObject pattern because it is interesting too and
somehow related?
You have one class that represents the type VideoTape then a class
representing the actual physical
instance that has a reference to its type VideoTape.

For plant collector like me, you can see that when you want to model
plant, the physical plant
in described by a class that coers its actual state and specificity
while the TypeClass covers the generic aspect such as the
classifications and other business that fanatic collector really enjoy.
Stef


On Mercredi, nov 5, 2003, at 21:21 Europe/Zurich, Sam Adams wrote:

> To be more direct, you create a class (say AccountType) in Squeak whose
> instances are different types of accounts, and then create a class (say
> Account) in Squeak whose instances are the individual accounts
> themselves,
> but act as if they were instances of the instances of AccountType.  The
> AccountType instances would define the structure(data) and
> behavior(policies, notifications, etc) for the Account instances.  Each
> Account instance would upon creation refer to its AccountType "class"
> for
> details of what kind of private data structure (variables) to
> construct.
> During later execution, the Account instance would refer to its
> AccountType
> "class" for its behavior, which would be shared across all Acount
> instances
> referencing the same AccountType "class".