[ETYMOLOGY] - Sterile Classes / Sterile Meta Classes

[Ilias_Lazaridis1 (Ilias Lazaridis)]

Another suggestion for the "Ruby Singleton Classes" or "Exclusive Classes":

Sterile Classes

Class: keeps structure and behaviour
Sterile: cannot create ( instances / objects )

The Term is currently unassigned:

http://www.google.com/search?q=sterile+classes

···

-

Concept of a "Sterile Class":

A Sterile Class is a Class, with all the abilities of the languages
Classes, exept:

  * It cannot be instantiated.
  * It is not part of the observable object-model

In Ruby, Sterile Classes are used to change the behaviour of _one_ object.

The Sterile Class
  * becomes _not_ part of the observable inheritance-chain.
    * e.g.: cannot be reached via
      obj.class,
      obj.superclass,
      obj.instance_of [...]
  * _becomes_ part of the non-observable inheritance-chain.
    * e.g.: method-resolution looks _first_ at the "Sterile Class"
      * internal implementation

[Thus, "Pseudo Class" would be possibly a right term, too - but already
used within CSS domain]

-

please look at the 1.3 version of the Diagramm:

http://lazaridis.com/case/lang/ruby/

"john" has an "Exclusive Sterile Class"
"john" is an instance of "Talker"
"john" has _no_ observable relation to its "Exclusive Sterile Class"

[observable via OOAD]

=> "[Exclusive] Sterile Class"
=> "Sterile Class"

-

"Talker" has an "Sterile Class" (Class:Talker)
"Class:Talker" keeps the structure and behaviour of class Talker.
thus "Class:Talker" is the "MetaClass" of class Talker.
=> MetaClass

but Talker is an instance of class "Class".
the MetaClass "Class:Talker" has no instances.

=> "Sterile Meta Class"

-

The terminology depends finally on the further development direction of
Ruby.

If it is planned to make the object model more OO like, and to implement
_real_ metaclasses, then it would be enouth to say:

"Attention: In the current implementation, a Ruby MetaClass is based on
"Sterile Classes". Although they describe structure and behaviour of a
Class, they do not instantiate those classes. They are _not_ part of the inheritance-tree and thus _not_ part of the object-model. That's why the documentation referes them as "Sterile Meta Classes" "

..

--
http://lazaridis.com

[Anonymous_Coward]

Le 7/5/2005, "Ilias Lazaridis" <ilias@lazaridis.com> blathered:
[snipped]

I wholeheartedly encourage you to find out more about sterilization.

E

···

--
template<typename duck>
void quack(duck& d) { d.quack(); }

[Logan_Capaldo]

[...]

  * It cannot be instantiated.

[..]

but Talker is an instance of class "Class".
the MetaClass "Class:Talker" has no instances.

Regarding SCs (heh, one acronym fits your terminology and the current
terminology) not having instances, while not present in Ruby their is
the idea of the <a
href="http://c2.com/cgi/wiki?AbstractClass&quot;&gt;abstract class</a>, (seen
only in C++ AFAIK, although Java's interfaces are similiar in some
respects) which has no instances. This doesn't (debately) make it less
of a class however. Plus one can consider an instance to be some state
(represented by instance variables) and a pointer to the instatiated
classes method lookup table (not sure of the right terminology here).
Then one would would have to consider the instance to be the object
that the SC is an SC of.

···

On 5/7/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

[Nikolai_Weibull]

Ilias Lazaridis, May 8:

[blah]

What does this have to do with etymology? I don't think you know what
the word "etymology" means. Please refrain from using terms
incorrectly in the future. Thanks,
        nikolai

···

--
Nikolai Weibull: now available free of charge at http://bitwi.se/!
Born in Chicago, IL USA; currently residing in Gothenburg, Sweden.
main(){printf(&linux["\021%six\012\0"],(linux)["have"]+"fun"-97);}

[Yukihiro_Matsumoto2 (Yukihiro Matsumoto)]

Sterile means "Not producing or incapable of producing offspring",
right? The word suggest the (class-like) object cannot create its
instances. But this is not the only class-like object in Ruby that
can not (or should not) create its instances, for example, modules in
Ruby are class-like objects which are not capable to instantiate.
Abstract classes as well are classes not supposed to create their
direct instances.

Being hidden from observable object model is not important neither.
In the new model, it would not be hidden any more, and perhaps, there
will be a method to retrieve "singleton class" from an object. I hope
the method name would not be Object#singleton_class.

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

In this standard, "singleton" is the best I can think of, unless name
conflict. Sad coincidence.

              matz.

···

In message "Re: [ETYMOLOGY] - Sterile Classes / Sterile Meta Classes" on Sun, 8 May 2005 06:14:28 +0900, Ilias Lazaridis <ilias@lazaridis.com> writes:

Another suggestion for the "Ruby Singleton Classes" or "Exclusive Classes":

Sterile Classes

[Ilias_Lazaridis1 (Ilias Lazaridis)]

Mr. Matsumoto wrote within this thread:

In the new model, it would not be hidden any more, and perhaps, there
will be a method to retrieve "singleton class" from an object. I hope
the method name would not be Object#singleton_class.

>

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

this results in the following template, where you can insert the suggested word:

···

-

instructions:

  * <x> emphasize on the "per-object" characteristic of the object
  * <x> describes that the class is per-object
  * <x> is an adjective, or a noun that can be used like an adjective.
  * "<x> methods" replaces todays term "singleton methods"

Test Code:

  obj.<x>_class
  obj.<x>_methods
  obj.<x>_attributes

-

Usage of the template simplifies the evaluation of the new <x> term.

..

--
http://lazaridis.com

[Ilias_Lazaridis1 (Ilias Lazaridis)]

must write this down, could be a key:

this method is privat - to the object
this method is inherited - from the superclass
this method is exclusive - to the object

this method is singleton - [...]

···

-

time to sleep.

-

Thank you very much for the productive feedback.

..

--
http://lazaridis.com

[Ilias_Lazaridis1 (Ilias Lazaridis)]

http://lazaridis.com/case/lang/ruby/xclass.html

suggested terms:

exclusive
extension
proto
prototype
x [unknown, can be internally spoken as <anything>]

···

-

http://rubygarden.org/ruby?RenamingSingletonClass

suggested terms:

# adapted
# adjunct
# adjusted
# adjutant
# annex
# changed
# class object
# crafted
# custom
# customized
# decorated
# distinct
# ego
# eigenclass
# essential
# expanded
# idioclass
# individual
# instance
# localised
# lone
# modified
# objectcustomiser
# own
# particular
# pouch
# reflexive
# satori
# self
# shadow
# shallow
# sibling
# singular
# singularity
# solitary
# solo
# specific
# tailored
# template
# transformed
# uncle
# uniclass
# unique
# mu

-

I 'close' this thread at this point.

I need some further day's to get more clarity.

..

--
http://lazaridis.com

[Bill_Atkins]

You are my hero.

···

On 5/7/05, Saynatkari <ruby-ml@magical-cat.org> wrote:

Le 7/5/2005, "Ilias Lazaridis" <ilias@lazaridis.com> blathered:
[snipped]

I wholeheartedly encourage you to find out more about sterilization.

E

--
template<typename duck>
void quack(duck& d) { d.quack(); }

--
Bill Atkins

[Jon_A_Lambert2 (Jon A. Lambert)]

Saynatkari wrote:

Le 7/5/2005, "Ilias Lazaridis" <ilias@lazaridis.com> blathered:
[snipped]

I wholeheartedly encourage you to find out more about sterilization.

It depends on whether this has a double meaning. Has science discovered a troll gene? Nature or nurture?
As you might guess I lean towards the nurture side.

On the other meaning...
In the ColdC language, well ColdCore library to be more specific, objects that are "spawnable" have a "fertile" attribute attached to them. There's no such thing as a "class" though, just pure objects. Spawned objects inherit from their parents, while "cloned" objects are siblings in the inheritance tree. The absence of the "fertile" symbol is similar to Java's 'final'.

···

--
J Lambert

[Jon_A_Lambert2 (Jon A. Lambert)]

Nikolai Weibull wrote:

Ilias Lazaridis, May 8:

[blah]

What does this have to do with etymology? I don't think you know what
the word "etymology" means. Please refrain from using terms
incorrectly in the future. Thanks,
       nikolai

Mmm... chewy etyms

singleton - an unmarried unattached person - circa 1930's
singleton also refers to a single card of a suit in one's dealt hand in whist - 1876
single - Old French - sengle "one, separate" - 1300's
Latin singulus "one individual, separate"
Latin diminutive of sim- (stem of simplus) - "simple"
related to simpleton - which brings us full circle and back to Ilias Lazardis - 2005

···

--
J Lambert

[Ilias_Lazaridis1 (Ilias Lazaridis)]

Logan Capaldo wrote:

[...]

* It cannot be instantiated.

[..]

but Talker is an instance of class "Class".
the MetaClass "Class:Talker" has no instances.

Regarding SCs (heh, one acronym fits your terminology and the current
terminology) not having instances, while not present in Ruby their is
the idea of the <a
href="http://c2.com/cgi/wiki?AbstractClass&quot;&gt;abstract class</a>, (seen
only in C++ AFAIK, although Java's interfaces are similiar in some
respects) which has no instances.

yes, you are right.

there's a collision.

But possibly the term "Abstract Class" is the foundation for a solution.

Dynamic Abstract Class.

This doesn't (debately) make it less
of a class however. Plus one can consider an instance to be some state
(represented by instance variables) and a pointer to the instatiated
classes method lookup table (not sure of the right terminology here).
Then one would would have to consider the instance to be the object
that the SC is an SC of.

I do not understand exactly.

but the essence is in the above about "abstract".

..

···

On 5/7/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

--
http://lazaridis.com

[Bill_Guindon1 (Bill Guindon)]

>Another suggestion for the "Ruby Singleton Classes" or "Exclusive Classes":
>
>Sterile Classes

Sterile means "Not producing or incapable of producing offspring",
right? The word suggest the (class-like) object cannot create its
instances. But this is not the only class-like object in Ruby that
can not (or should not) create its instances, for example, modules in
Ruby are class-like objects which are not capable to instantiate.
Abstract classes as well are classes not supposed to create their
direct instances.

Being hidden from observable object model is not important neither.
In the new model, it would not be hidden any more, and perhaps, there
will be a method to retrieve "singleton class" from an object. I hope
the method name would not be Object#singleton_class.

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

unique, lone, solo, distinct, specific, custom, customized, changed,
expanded, crafted, decorated, tailored, adapted, adjusted,
transformed, modified.

any of these come close?

···

On 5/8/05, Yukihiro Matsumoto <matz@ruby-lang.org> wrote:

In message "Re: [ETYMOLOGY] - Sterile Classes / Sterile Meta Classes" > on Sun, 8 May 2005 06:14:28 +0900, Ilias Lazaridis <ilias@lazaridis.com> writes:

In this standard, "singleton" is the best I can think of, unless name
conflict. Sad coincidence.

                                                        matz.

--
Bill Guindon (aka aGorilla)

[Ilias_Lazaridis1 (Ilias Lazaridis)]

Yukihiro Matsumoto wrote:

>Another suggestion for the "Ruby Singleton Classes" or "Exclusive Classes":
>
>Sterile Classes

Sterile means "Not producing or incapable of producing offspring",
right? The word suggest the (class-like) object cannot create its
instances. But this is not the only class-like object in Ruby that
can not (or should not) create its instances, for example, modules in
Ruby are class-like objects which are not capable to instantiate.
Abstract classes as well are classes not supposed to create their
direct instances.

yes, the term "Sterile" was finally bad.

Being hidden from observable object model is not important neither.

Clarification:

by hidden i mean
  * not reachable via standard OO-observations (obj.instance-of, class, superclass, ...)

In the new model, it would not be hidden any more, and perhaps, there
will be a method to retrieve "singleton class" from an object. I hope
the method name would not be Object#singleton_class.

Can I have some more informatin about the new model?

  a) method to retrieve "singleton class", Object#singleton_class

further planned changes?

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

"xxxx" => "x"
=> "x class"
=> "xclass"

possibly we can agree temporarily "xclass", wher "x" stands for:

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

the above is a nice template.

In this standard, "singleton" is the best I can think of, unless name
conflict. Sad coincidence.

I understand your 'pain' - honestly!

..

···

In message "Re: [ETYMOLOGY] - Sterile Classes / Sterile Meta Classes" > on Sun, 8 May 2005 06:14:28 +0900, Ilias Lazaridis <ilias@lazaridis.com> writes:

--
http://lazaridis.com

[Ilias_Lazaridis1 (Ilias Lazaridis)]

Nikolai Weibull wrote:

Ilias Lazaridis, May 8:

[blah]

What does this have to do with etymology? I don't think you know what
the word "etymology" means. Please refrain from using terms
incorrectly in the future. Thanks,
        nikolai

You cannot find concise terms without etymology.

[but I agree that a usenet forum is possibly not the best place]

..

···

--
http://lazaridis.com

[craig_duncan]

Yukihiro Matsumoto wrote:

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

In this standard, "singleton" is the best I can think of, unless name
conflict. Sad coincidence.

              matz.

I would assume that this has already been considered and (long ago) discarded. But from my understanding (which may not be adequate) "instance_class" most clearly describes it to me.

craig

[Glenn_Parker1 (Glenn Parker)]

Yukihiro Matsumoto wrote:

Sterile means "Not producing or incapable of producing offspring",
right? The word suggest the (class-like) object cannot create its
instances.

Mind you, when Ilias is active in a thread, I generally delete it without a second look. So, I honestly don't expect many people to see this, but since Matz is still looking for meaningful terminology...

I humbly suggest "uniclass". Sounds sort of like "eunuch-class", implying sterility, and also like "unique-class", which follows because there is at most one of these per object. It also reminds me of "Unibrow" from the Austin Powers series, but that is neither here nor there.

···

--
Glenn Parker | glenn.parker-AT-comcast.net | <http://www.tetrafoil.com/&gt;

[Chris_Pine3 (Chris Pine)]

How about "self"?

  "self class"
  "self methods"
  obj.self_class

or "solo"?

  "solo class"
  "solo methods"
  obj.solo_class

Chris

···

On 5/8/05, Yukihiro Matsumoto <matz@ruby-lang.org> wrote:

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

[Carlos]

[Yukihiro Matsumoto <matz@ruby-lang.org>, 2005-05-08 17.13 CEST]
[...]

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

"Particular"?

(In Spanish it fits perfectly, but maybe is a false friend...)

[Balwinder_S_bsd_Dhee (Balwinder S "bsd" Dheeman)]

From The Collaborative International Dictionary of English v.0.48 [gcide]:

   Abstract \Ab"stract`\, n. [See {Abstract}, a.]
      1. That which comprises or concentrates in itself the
         essential qualities of a larger thing or of several
         things. Specifically: A summary or an epitome, as of a
         treatise or book, or of a statement; a brief.
         [1913 Webster]

               An abstract of every treatise he had read. --Watts.
         [1913 Webster]

               Man, the abstract
               Of all perfection, which the workmanship
               Of Heaven hath modeled. --Ford.
         [1913 Webster]

      2. A state of separation from other things; as, to consider a
         subject in the abstract, or apart from other associated
         things.
         [1913 Webster]

      3. An abstract term.
         [1913 Webster]

               The concretes "father" and "son" have, or might
               have, the abstracts "paternity" and "filiety." --J.
                                                     S. Mill.
         [1913 Webster]

So as per 2nd definition above, how is about...

'abstract class'
'abstract objects'
'abstract methods'

Hope that helps.

···

On 05/08/2005 08:43 PM, Yukihiro Matsumoto wrote:

I'd like to emphasize the "per-object" attribute of the object.
Ideally, the term should be "xxxx class" where

  * xxxx describe the class is per-object.
  * xxxx is an adjective, or a noun that can be used like adjective.
  * we can call methods now we call "singleton methods" as xxxx
    methods for consistency.

In this standard, "singleton" is the best I can think of, unless name
conflict. Sad coincidence.

--
Dr Balwinder Singh Dheeman Registered Linux User: #229709
CLLO (Chief Linux Learning Officer) Machines: #168573, 170593, 259192
Anu's Linux@HOME Distros: Ubuntu, Fedora, Knoppix
More: http://anu.homelinux.net/~bsd/ Visit: http://counter.li.org/