[EVALUATION] - E03e - The Ruby Object Model (Summary)

[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42

···

-

The above thread has led to this code:

class Class
    def Meta()
      @Meta ||= (class<<self;self;end)
    end
end

which is modified here to:

class Object
    def sso()
      @sso ||= (class<<self;self;end) # see code below
    end
end

simplified:
    def sso()
      unless @sso
        @sso = (class<<self; self; end) #
      end
      @sso
    end

-

sso = Specializing Singleton Object

-

The sso contains definitions (methods, attributes, constants) which specialize the behaviour of its carrying object.

The "sso" of a "class object" is used to specialize the behaviour of the class (against Class).

-

The sso's are essentially internal implementation details, although they are accessible (see code above).

The sso's are _not_ part of the Ruby Object Model (e.g. inheritance hierarchy).

-

As stated before, the following documentation is false:

cmd:> ri Class

"Classes, modules, and objects are interrelated. In the diagram that
follows, the arrows represent inheritance, and the parentheses
meta-classes. All metaclasses are instances of the class `Class'."

                            +------------------+
                            > >
              Object---->(Object) |
               ^ ^ ^ ^ |
               > > > > >
               > > +-----+ +---------+ |
               > > > > >
               > +-----------+ | |
               > > > > >
        +------+ | Module--->(Module) |
        > > ^ ^ |
   OtherClass-->(OtherClass) | | |
                              > > >
                            Class---->(Class) |
                              ^ |
                              > >
                              +----------------+

-

a) The term "meta-classes" is false.
      Correction: "specializing-singleton-objects"

b) vertical arrows do not represent inheritance
      e.g.: Object---->(Object)
      Correction: Object-----(Object)

c) the classes in "()" do not belong to the object model
      Correction: remove (showcase sso in seperate topic)

-

My final questions are basicly:

  * Ruby is OO. Why is the sso not directly accessible?

  * Who has written the "ri Class" documentation?

  * Can I expect an apology for this false documentation?

-

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

..

--
http://lazaridis.com

[Fair warning to those who plan on emailing me regarding this
response. I'll be ignoring you. I am posting this to make sure that
there is a public refutation to Ilias's incorrect statements below.
-a]

As stated before, the following documentation is false:

Stated incorrectly. The documentation is, in fact, correct. It
doesn't mesh with UML, perhaps, and it doesn't mesh with your
limited capacity for understanding, but that doesn't make it
incorrect.

Metaclass -- singleton class, virtual class, or whatever you wish to
call it -- is something that doesn't mesh well with standard object
notations. You are the first person that I've seen in three and a
half years to suggest that they don't understand this documentation
once they've started playing with the capabilities of Ruby and
understanding the practical means by which the object model is
supported in the language. As others have pointed out -- with lots
of supporting code -- it is not the documentation which is wrong
here.

[...]

a) The term "meta-classes" is false.
Correction: "specializing-singleton-objects"

It is not false. It is, perhaps, over used in a variety of terms. It
is "meta" in terms of Ruby objects. Your term may be more useful in
the future, but I have my doubts. As Class is an Object, a MetaClass
is a MetaObject :wink:

b) vertical arrows do not represent inheritance
e.g.: Object----> (Object)
Correction: Object-----(Object)

Those are horizontal, not vertical. It is also one of those things
that, as others have pointed out, is not *quite* as *you* understand
it. Metaobjects don't show up in the public inheritance hierarchy,
but that makes them no less real.

c) the classes in "()" do not belong to the object model
Correction: remove (showcase sso in seperate topic)

This is incorrect. The metaobjects/metaclasses shown in the diagrams
are essential, if not normally visible, parts of the Ruby Object
Model. I do not believe that this is just an implementation detail,
as it is exposed to the language for use.

My final questions are basicly:
* Ruby is OO. Why is the sso not directly accessible?

The metaobjects/metaclasses are not directly accessible because Matz
has chosen not to make them directly accessible. There is an RCR
which recommends the creation of a method to make this easily and
directly accessible because Ruby developers have discovered the
value and utility that these metaobjects have. There is significant
disagreement on the name of what this method should be. However, as
Why the Lucky Stiff has demonstrated, it's a no-brainer for users to
develop this single method themselves -- and he's even written it
for them to copy or use as they please.

* Who has written the "ri Class" documentation?

Matz wrote the essentials. I don't think that anyone knows the Ruby
object model better than he.

* Can I expect an apology for this false documentation?

Given that the docuemntation isn't false, no. Of course, even if you
*were* correct and the documentation was false, I suspect that you'd
get an apology only if hell is endothermic. And, as we all know,
it's exothermic. (Either that, or you'll get your apology after all
atomic motion has stopped because.)

-austin

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:
--
Austin Ziegler * halostatue@gmail.com
               * Alternate: austin@halostatue.ca

b) vertical arrows do not represent inheritance
     e.g.: Object---->(Object)
     Correction: Object-----(Object)

Pretty sure you mean "horizontal arrows" not "vertical arrows".

My final questions are basicly:

* Ruby is OO. Why is the sso not directly accessible?

You've posted code in this message showing how to access an "sso".

James Edward Gray II

···

On Apr 21, 2005, at 7:39 AM, Ilias Lazaridis wrote:

So it's "sso" now, ey? A small step to "sos", and then on to "sob" :wink:

Ilias Lazaridis wrote:

[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42

-

The above thread has led to this code:

class Class
   def Meta()
     @Meta ||= (class<<self;self;end)
   end
end

which is modified here to:

class Object
   def sso()
     @sso ||= (class<<self;self;end) # see code below
   end
end

simplified:
   def sso()
     unless @sso
       @sso = (class<<self; self; end) #
     end
     @sso
   end

-

sso = Specializing Singleton Object

ISBO = Instance Specific Behaviour Object

dvto = Dedicated Virtual Table Object

dvco = Dedicated Virtual Class Object

dvc = Dedicated Virtual Class

....

..

···

--
http://lazaridis.com

My final questions are basicly:
* Can I expect an apology for this false documentation?

Apology? Read the ruby license again. Hint: you did not buy "ruby".

My suggestion: if you don't like certain parts of the documentation, discuss the "mistakes", on this group in a friendly way and at the end rewrite the documentation parts you did not like based on the discussion's conclusions - after that offer the author of the documentation to exchange the parts you found mistakes in with your corrected version.

newbish greetings
  Jonas

The heck, no. Can we expect an apologoy from you for being such an asshole?

Has anybody ever suggested you writing your own language, its Object
Model and the so much desired correct documentation?

Regards,
Ed

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42

My final questions are basicly:

  * Can I expect an apology for this false documentation?

--
Encontrá a "Tu psicópata favorito" http://tuxmaniac.blogspot.com
"Tener una amiga en Ginebra es como tener quinotos en almibar o uvas en ron."

Ilias Lazaridis wrote:

[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42

-

The above thread has led to this code:

class Class
   def Meta()
     @Meta ||= (class<<self;self;end)
   end
end

which is modified here to:

class Object
   def sso()
     @sso ||= (class<<self;self;end) # see code below
   end
end

simplified:
   def sso()
     unless @sso
       @sso = (class<<self; self; end) #
     end
     @sso
   end

-

sso = Specializing Singleton Object

-

The sso contains definitions (methods, attributes, constants) which specialize the behaviour of its carrying object.

The "sso" of a "class object" is used to specialize the behaviour of the class (against Class).

-

The sso's are essentially internal implementation details, although they are accessible (see code above).

The sso's are _not_ part of the Ruby Object Model (e.g. inheritance hierarchy).

-

As stated before, the following documentation is false:

cmd:> ri Class

"Classes, modules, and objects are interrelated. In the diagram that
follows, the arrows represent inheritance, and the parentheses
meta-classes. All metaclasses are instances of the class `Class'."

                           +------------------+
                           > >
             Object---->(Object) |
              ^ ^ ^ ^ |
              > > > > >
              > > +-----+ +---------+ |
              > > > > >
              > +-----------+ | |
              > > > > >
       +------+ | Module--->(Module) |
       > > ^ ^ |
  OtherClass-->(OtherClass) | | |
                             > > >
                           Class---->(Class) |
                             ^ |
                             > >
                             +----------------+

-

a) The term "meta-classes" is false.

confirmed by: Mr. Matsumoto:

"In Ruby, the Class class is the class of all classes, no metaclass."

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/40537

···

-

confirmed by: the general-validity term "metaclass".

[Mr. Matsumoto was unwilling to answer directly to the root-message]

     Correction: "specializing-singleton-objects"

or possibly: xclass = eXclusive-class

or singleton class.

but _not_ metaclass.

this is _false_ and completely _missleading_.

b) vertical arrows do not represent inheritance
     e.g.: Object---->(Object)
     Correction: Object-----(Object)

confirmed by Mr. Matsumoto within this thread:

"And I will add a word "vertical" before "arrow" for
the next check in, anyway."

[Mr. Matsumoto was unwilling to answer directly to the root-message]

c) the classes in "()" do not belong to the object model
     Correction: remove (showcase sso in seperate topic)

No confirmation.

Seeing the egoism-loaded community, it should take around 1 to 3 further years to clarify this issue.

My final questions are basicly:

* Ruby is OO. Why is the sso not directly accessible?

"considered abuse" by the language designer Mr. Matsumoto

http://www.ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-talk/40548

Of course this is irrational, as there is a "singleton-class-notation" available, which makes the object accessible anyway.

class << <object>

No need to refuse a convenience method.

Except: Rubyist are sheeps, which must be protected from doing damage.

* Who has written the "ri Class" documentation?

from within this thread:

Mr. Matsumoto has drawn the diagramm.

Mr. Matsumoto has provided the confusion with the term "metaclass", most possibly as he was/is confused/unclear about the theory/implementation:

ruby source-code, file "object.c"

"
void
Init_Object()
{
     VALUE metaclass;

     rb_cObject = boot_defclass("Object", 0);
     rb_cModule = boot_defclass("Module", rb_cObject);
     rb_cClass = boot_defclass("Class", rb_cModule);

     metaclass = rb_make_metaclass(rb_cObject, rb_cClass);
     metaclass = rb_make_metaclass(rb_cModule, metaclass);
     metaclass = rb_make_metaclass(rb_cClass, metaclass);
"

vs.

"In Ruby, the Class class is the class of all classes, no metaclass."

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/40537

..

* Can I expect an apology for this false documentation?

It looks like this community lacks any strong personalities.

I can neither expect an apology from the responsile person, Mr. Matsumoto, nor an open, egoism-free analysis of the problem domain from the community.

-
Many people from the community are not ashamed to used the discussion i've initialized to understand (partly within other threads), without saying: "hey, thank you for raising this issue. this is positive for ruby's evolution"

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

time to close this thread.

_such_ a waste of time.

..

--
http://lazaridis.com

James Edward Gray II wrote:

b) vertical arrows do not represent inheritance
     e.g.: Object---->(Object)
     Correction: Object-----(Object)

Pretty sure you mean "horizontal arrows" not "vertical arrows".

yes, of course.

my apologies.

My final questions are basicly:

* Ruby is OO. Why is the sso not directly accessible?

You've posted code in this message showing how to access an "sso".

which is an indirection.

My question contains "directly".

[please no more harisplitting]

James Edward Gray II

..

···

On Apr 21, 2005, at 7:39 AM, Ilias Lazaridis wrote:

--
http://lazaridis.com

Austin Ziegler wrote:

[Fair warning to those who plan on emailing me regarding this
response. I'll be ignoring you. I am posting this to make sure that
there is a public refutation to Ilias's incorrect statements below.
-a]

As stated before, the following documentation is false:

Stated incorrectly. The documentation is, in fact, correct. It

[...] - (babbling, justifying, talkaround)

the documentation is false.

see below.

a) The term "meta-classes" is false.
Correction: "specializing-singleton-objects"

It is not false.

[...] - (babbling, justifying, talkaround)

"meta-classes" is completely false.

possibly you believe this one more:

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/40537

b) vertical arrows do not represent inheritance
e.g.: Object----> (Object)
Correction: Object-----(Object)

Those are horizontal, not vertical.

ok, my mistake.

I apologize.

It is also one of those things

[...] - (babbling)

please focus.

ri Class states: "the arrows represent inheritance"

but: the _horizontal_ arrows do _not_ represent inheritance.

this is a simple, clear and undoubtable error.

c) the classes in "()" do not belong to the object model
Correction: remove (showcase sso in seperate topic)

This is incorrect. The metaobjects/metaclasses shown in the diagrams
are essential, if not normally visible, parts of the Ruby Object
Model.

This is false, see below

I do not believe that this is just an implementation detail,
as it is exposed to the language for use.

what you believe is irrelevant.

reality counts.

and (especially for you) possibly this here:

http://www.ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-talk/40548

My final questions are basicly:
* Ruby is OO. Why is the sso not directly accessible?

The metaobjects/metaclasses are not directly accessible because Matz
has chosen not to make them directly accessible.

[...]

I see.

* Who has written the "ri Class" documentation?

Matz wrote the essentials.

what do you mean by "essentials"?

Is Mr. Matsumoto the author of the "ri Class" content or not?

I don't think that anyone knows the Ruby
object model better than he.

"knowing" means not in the same time "ability to communicate".

* Can I expect an apology for this false documentation?

Given that the docuemntation isn't false, no.

[...] - (babbling)

This question target's the responsible person.

..

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

--
http://lazaridis.com

Ilias Lazaridis wrote:
> [EVALUATION] - E03d - The Ruby Object Model (End Game)
> http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42
>
> -
>
> The above thread has led to this code:
>
> class Class
> def Meta()
> @Meta ||= (class<<self;self;end)
> end
> end
>
> which is modified here to:
>
> class Object
> def sso()
> @sso ||= (class<<self;self;end) # see code below
> end
> end
>
> simplified:
> def sso()
> unless @sso
> @sso = (class<<self; self; end) #
> end
> @sso
> end
>
> -
>
> sso = Specializing Singleton Object

ISBO = Instance Specific Behaviour Object

dvto = Dedicated Virtual Table Object

dvco = Dedicated Virtual Class Object

dvc = Dedicated Virtual Class

....

introduction of more confusing non-standard acronyms for your
understanding will do nothing but confuse the issue at hand.

please remain on-topic and discontinue this line of off-topic communication.

have you also decided not to reply to my above comments?
this is considered rude, and should be stopped. again, i must insist
this thread is closed and you should refrain from further off-topic
discussions in it.

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

..

--
http://lazaridis.com

--
===Tanner Burson===
tanner.burson@gmail.com
http://tannerburson.com <---Might even work one day...

Jonas Hartmann wrote:

My final questions are basicly:
* Can I expect an apology for this false documentation?

Apology? Read the ruby license again. Hint: you did not buy "ruby".

It's a matter of degnity.

Mr. Matsumoto knows what I am talking about.

My suggestion:

[...] (process)

..

···

--
http://lazaridis.com

* Edgardo Hames <ehames@gmail.com> [0401 21:01]:

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:
> [EVALUATION] - E03d - The Ruby Object Model (End Game)
> http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42
>
> My final questions are basicly:
>
> * Can I expect an apology for this false documentation?
>

The heck, no. Can we expect an apologoy from you for being such an asshole?

No, because he's a troll. ffs guys, three or four times now he's said 'my
evaluation is over' and people have chipped in with 'one more thing'.

Let it die.

--
'Oh, wait you're serious. Let me laugh even harder.'
    -- Bender
Rasputin :: Jack of All Trades - Master of Nuns

Ilias Lazaridis, April 22:

time to close this thread.

_such_ a waste of time.

So very, very true,
        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);}

Champagne !!! :slight_smile:

···

Ilias Lazaridis <ilias@lazaridis.com> wrote:

time to close this thread.

--
Luc Heinrich - lucsky@mac.com

My final questions are basicly:

* Ruby is OO. Why is the sso not directly accessible?

You've posted code in this message showing how to access an "sso".

which is an indirection.

My question contains "directly".

[please no more harisplitting]

Strange, first you complain about somebody else not following your question word-by-word, and next sentence you complain about hairsplitting. Pot. Kettle. Black. And just in case you don't know that phrase, the german equivalent'd be "Wer im Glashaus sitzt, sollte keine Steine werfen." (Your website is registered in Germany and your snail-mail address is german).

So, to come back to topic, maybe you should define "directly" first?

You can access your so called "sso"s from within Ruby, without resorting to third party libraries or low level C code. That is "direct", in my book at least.Just because you don't like the syntax _how_ you can access them doens't mean they're not readily accessible, as numerous posters before have answered already. And you even got a "direct" answer to your question, from Austin Ziegler

---8<-----
The metaobjects/metaclasses are not directly accessible because Matz
has chosen not to make them directly accessible. There is an RCR
which recommends the creation of a method to make this easily and
directly accessible because Ruby developers have discovered the
value and utility that these metaobjects have. There is significant
disagreement on the name of what this method should be. However, as
Why the Lucky Stiff has demonstrated, it's a no-brainer for users to
develop this single method themselves -- and he's even written it
for them to copy or use as they please.
---8<-----

So. There. Respect somebody investing time to answer by at least reading the answers.

Austin Ziegler wrote:
> [Fair warning to those who plan on emailing me regarding this
> response. I'll be ignoring you. I am posting this to make sure that
> there is a public refutation to Ilias's incorrect statements below.
> -a]
>
>
>>As stated before, the following documentation is false:
>
> Stated incorrectly. The documentation is, in fact, correct. It
[...] - (babbling, justifying, talkaround)

the documentation is false.

see below.

[...] - (repeating questions already answered)

>>b) vertical arrows do not represent inheritance
>>e.g.: Object----> (Object)
>>Correction: Object-----(Object)
>
> Those are horizontal, not vertical.

ok, my mistake.

I apologize.

[...] - (repeating questions already answered)

> I do not believe that this is just an implementation detail,
> as it is exposed to the language for use.

what you believe is irrelevant.

reality counts.

what you believe to be reality is irrelevant.
the opinions of those actually using the language on a daily basis for
real applications, counts.
the opinions of those glancing across the language without attempting
to use it, is rrelevant.

>>* Who has written the "ri Class" documentation?
>
> Matz wrote the essentials.

what do you mean by "essentials"?

Possibly this will help?

Is Mr. Matsumoto the author of the "ri Class" content or not?

> I don't think that anyone knows the Ruby
> object model better than he.

"knowing" means not in the same time "ability to communicate".

have you attempted communication with him? if so please provide
transcripts or links of this.

>>* Can I expect an apology for this false documentation?
>
> Given that the docuemntation isn't false, no.
[...] - (babbling)

This question target's the responsible person.

responsible for what? providing documentation you are incapable of
understanding?

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

> On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

..

--
http://lazaridis.com

--
===Tanner Burson===
tanner.burson@gmail.com
http://tannerburson.com <---Might even work one day...

Tanner Burson wrote:

Ilias Lazaridis wrote:

[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42

-

The above thread has led to this code:

class Class
  def Meta()
    @Meta ||= (class<<self;self;end)
  end
end

which is modified here to:

class Object
  def sso()
    @sso ||= (class<<self;self;end) # see code below
  end
end

simplified:
  def sso()
    unless @sso
      @sso = (class<<self; self; end) #
    end
    @sso
  end

-

sso = Specializing Singleton Object

ISBO = Instance Specific Behaviour Object

dvto = Dedicated Virtual Table Object

dvco = Dedicated Virtual Class Object

dvc = Dedicated Virtual Class

dsc = dedicated singleton class

sco = singleton class object

asco = attached singleton class object

"singleton instance" = the one and only instance
"singleton method" = a method, exclusively for one instance
"singleton class" = a class, exclusively for one instance

=>

sco = Singleton class object

sc = Singleton class

s = singleton

=> <object>.singleton

=> <object>.singletonClass

obj.class
obj.class_singleton
obj.singleton_class

introduction of more confusing non-standard acronyms for your
understanding will do nothing but confuse the issue at hand.

???

please remain on-topic and discontinue this line of off-topic communication.

what ???

have you also decided not to reply to my above comments? this is considered rude, and should be stopped. again, i must insist
this thread is closed and you should refrain from further off-topic
discussions in it.

please.

get serious.

..

···

On 4/21/05, Ilias Lazaridis <ilias@lazaridis.com> wrote:

--
http://lazaridis.com

Ilias Lazaridis wrote:

Austin Ziegler wrote:
"meta-classes" is completely false.

possibly you believe this one more:

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/40537

[snip]

> I do not believe that this is just an implementation detail,
> as it is exposed to the language for use.

what you believe is irrelevant.

reality counts.

and (especially for you) possibly this here:

http://www.ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-talk/40548

Guys, Ilias does have a point.

If we insist on that metaclasses as we have now are just an accidental
implementation of the singleton feature -- and the authoritive one,
Matz seems to do so -- then we can conclude that they cannot be part of
the Ruby object model, where Ruby is an abstract entity, Ruby, as such,
the language.

So then I accept that he doesn't accept the "ri Class" diagram. Even if
that's correct if we understood Ruby as its realized by the canonical
implementation today.

However, if we decide to mean Ruby as the abstract language, then maybe
it just doesn't make sense to plea for a *class* diagram -- if we ditch
metaclasses, Ruby's OO ceases to be purely class based. It still makes
sense to ask for some kind of figure representing inheritance.

I don't know UML, is it capable of representing classless (or not fully
class based) OO?

If not, then the answer to Ilias' question: "either mean Ruby as the
current implementation defines it, or don't ask for an UML diagram
'cause can't be made one."

Csaba

Ilias Lazaridis wrote:

Jonas Hartmann wrote:

My final questions are basicly:
* Can I expect an apology for this false documentation?

Apology? Read the ruby license again. Hint: you did not buy "ruby".

It's a matter of degnity.

dignity.

Mr. Matsumoto knows what I am talking about.

My suggestion:

[...] (process)

.

..

···

--
http://lazaridis.com