[EVALUATION] - E03c - The Ruby Object Model (Revised Documentation)
Ilias Lazaridis
http://groups-beta.google.com/group/comp.lang.ruby/msg/e9d841fedb35903f
-
The above thread has shown, that the existen documentation is false.
Within this page, you'll find a link to an UML diagramm
http://lazaridis.com/case/lang/ruby/
-
Please review the diagramm.
If it's correct, please ensure that the existent documentation is corrected.
.
lostbo...@yahoo.com
your latest demand for filling in your template (1000s of page views, 1
bump, 0 responses):
Ilias Lazaridis
> Ilias Lazaridis wrote:
>
>> [EVALUATION] - E03b - The Ruby Object Model
>> http://groups-beta.google.com/group/comp.lang.ruby/msg/e9d841fedb35903f
>
>> -
>>
>> The above thread has shown, that the existen documentation is
>> false.
>>
>> Within this page, you'll find a link to an UML diagramm
>>
>> http://lazaridis.com/case/lang/ruby/
>>
>> -
>>
>> Please review the diagramm.
>>
>> If it's correct, please ensure that the existent documentation is
>> corrected.
>
> your latest demand for filling in your template
what has this to do with "false ruby language core documentation"?
additionally: possibly the python community is scared about a
transparent direct comparison with ruby and other languages.
> (1000s of page views, 1 bump, 0 responses):
where do you get the information "1000s of page views"?
what do you mean by "bumbp"?
Anyone of the ruby community knows python?
please fill the python template, to showcase the differences.
-
and please don't forget to ensure the quality of the ruby documentation.
.
Martin Ankerl
Why do you say that?
> what do you mean by "bumbp"?
Maybe your plans have something to do with this.
> Anyone of the ruby community knows python?
Are you sure that anyone of the ruby community knows python?
> please fill the python template, to showcase the differences.
Is it because of your life that you are going through all this?
> and please don't forget to ensure the quality of the ruby documentation.
I don't understand.
--
M-x doctor
Ilias Lazaridis
an example for wrong ruby documentation:
-
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) |
^ |
| |
+----------------+
.
Ilias Lazaridis
[...] - (several babbling)
> I don't understand.
no, you don't _want_ to understand.
cause you don't want to admit that the ruby documentation is false.
but anyhow - it's irrelevant.
One should call Mr. Matz to review this.
Most possibly he's the only one who knows.
.
Nikolai Weibull
> One should call Mr. Matz to review this.
> Most possibly he's the only one who knows.
It seems that you don't anyway,
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);}
Ilias Lazaridis
> Ilias Lazaridis, April 18:
>
>>One should call Mr. Matz to review this.
>
>>Most possibly he's the only one who knows.
>
> It seems that you don't anyway,
I've invested some time (whilst ignoring finally the current
documentation) to create this UML diagramm:
http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
I'm asking now for confirmation/feedback.
This is nothing special within serious software-development.
-
But as it looks, this community is incapable to do so (giving productive
feedback).
.
gene...@gmail.com
I've noted that there's been unflattering stuff being said both by you
and others. Whatever happens, I hope that nobody feels inhibited from
asking good ruby questions. That's the whole point of the list. I
think there's still no ruby-tutor, and ruby-forum.org is still down, so
ask away.
That being said, I doubt that anybody's going to spend hours filling
inyour ruby and python templates. That's your job. And maybe it's
time to read the Pickax carefully and start digging for yourself.
Ilias Lazaridis
> Ilias:
>
> I've noted that there's been unflattering stuff being said both by you
> and others. Whatever happens, I hope that nobody feels inhibited from
> asking good ruby questions. That's the whole point of the list. I
> think there's still no ruby-tutor, and ruby-forum.org is still down, so
> ask away.
>
> That being said, I doubt that anybody's going to spend hours filling
> inyour ruby and python templates. That's your job.
Please let the people decide.
Many simply provide this information.
and btw: this thread here has nothing to do with the templates.
> And maybe it's
> time to read the Pickax carefully and start digging for yourself.
Maybe it's time that you realize, that the ruby documentation is false:
http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
I will not continue to read _any_ ruby documentation, until this issue
here is clarified.
.
Lionel Thiry
I can.
-
But there are other ways of asking, you know... :(
-
I'll give it a try: the documentation "ri Class" gives is not wrong at all.
Maybe not complete, but not wrong.
-
In "ri Class" text, if you replace references to "metaclasses" (which are said
to be between parentheses) by "singleton method placeholders", perhaps it
becomes clearer?
-
I remember that what was disturbing you was the stuff about metaclasses. I told
you ruby invite you to think more in terms of singleton method than in terms of
metaclasses. But it seems that you ignore what are singleton methods.
-
Have you ever evaluated some classless OO langages? I know some: IO (
http://www.iolanguage.com/ ), Self ( http://c2.com/cgi/wiki?SelfLanguage ) and
REBOL (rebol is not basically OO, but its OO part is classless.
http://www.rebol.com/ ). If you would, the concept of singleton method would be
far easier to understand for you. (this is actually how I understood that concept)
-
http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
Your UML diagram of ruby object model is hard to read, and probably wrong. The
separation between classes in memory and in source code is totally confusing. In
ruby, classes *are* objects. Learn more about classless languages, and it should
be far easier to understand these concepts.
There is another evident mistake in your UML diagram. Object doesn't inherit
from nil, nil is a literal and an instance of NilClass which inherit from Object.
-
I tried my best, I can't say anymore. Please, don't ask me for lengthy
exhausting explanations. Try the languages I told you about, they are really
worth it.
-
Have a nice day.
--
Lionel Thiry
PS: Please, anybody, do not blame me for anwsering this post. Do not blame me
for imitating Lazaridis posting. Do not blame me for trying to be nice.
Henrik Horneber
> Ilias Lazaridis a écrit :
>
>> Nikolai Weibull wrote:
>>
>>> Ilias Lazaridis, April 18:
>>>
>>
>> productive feedback).
I can't help it, this sounds too much like http://bash.org/?152037 to
not make me laugh.
>
> PS: Please, anybody, do not blame me for anwsering this post. Do not
> blame me for imitating Lazaridis posting. Do not blame me for trying to
> be nice.
>
>
I, for one, appreciate your effort very much, (even though I fear it's
wasted).
Henrik
tsuraan
On Apr 17, 2005, at 10:18 PM, Henrik Horneber wrote:
> Lionel Thiry schrieb:
>> Ilias Lazaridis a écrit :
>>> Nikolai Weibull wrote:
>>>
>>>> Ilias Lazaridis, April 18:
>>>>
>>>
>>> But as it looks, this community is incapable to do so (giving
>>> productive feedback).
>
>
> I can't help it, this sounds too much like http://bash.org/?152037 to
> not make me laugh.
Scary... Before I even clicked the link, I was sure of which one you
were referring to.
Carlos
> an example for wrong ruby documentation:
>
> -
>
> 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'."
Well, yes. If I'm not mistaken, horizontal arrows represent "instance
of". Only vertical ones represent inheritance.
Florian Groß
> and btw: this thread here has nothing to do with the templates.
Maybe it's time that you realize, that starting a thread doesn't mean
owning it.
Martin Ankerl
>
> no, you don't _want_ to understand.
Uh, I thought it was obvious that my response was automatically
generated by a bot (emacs' psycodoctor).
martinus
Christian Neukirchen
> Ilias Lazaridis wrote:
>
> an example for wrong ruby documentation:
>
> -
>
> 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) |
> ^ |
> | |
> +----------------+
I do not see what's wrong here, can you explain?
> http://lazaridis.com
--
Christian Neukirchen <chneuk...@gmail.com> http://chneukirchen.org
Ilias Lazaridis
please let's not go into discussion essential usenet rules (or
mailinglist/forum rules).
It's a matter of gentleness against readers to stay in-topic, especially
within analytical threads.
.
Ilias Lazaridis
Ilias Lazaridis
not exactly, it's more a "becomes" relation:
"class definition" ----"becomes"----> "(class) instance"
-
"instance of" would be false, because:
* the direction fo the arrow would be wrong
* all 'metaclasses' are instances of the class "Class"
> Only vertical ones represent inheritance.
yes.
so, the minimum correction would be:
additional text:
"the vertical arrows represent XXXX"
.
Ilias Lazaridis
> Ilias Lazaridis <il...@lazaridis.com> writes:
>>Ilias Lazaridis wrote:
>>
>>an example for wrong ruby documentation:
>>
>>-
>>
>>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) |
>> ^ |
>> | |
>> +----------------+
>
> I do not see what's wrong here, can you explain?
definitive errors:
a) not all arrows represent inheritance, just the verticals.
b) the relation "(Object)"---[inherits from]--->"Class" is false.
correct: "(Object)"---[inherits-from]------->nil
or
correct: "(Object)"---[is-an-instance-of]--->Class
-
and finally:
the diagramm gives the impression, that "Object" and "(Object)" (etc.)
are both classes, which is of course false. There is a "definition" and
an "(instance)".
-
I will shortly update the UML diagramm to version 1.1, to simplify it a
little bit more:
http://lazaridis.com/case/lang/ruby
.
Ilias Lazaridis
> Ilias Lazaridis a écrit :
>> Nikolai Weibull wrote:
>>> Ilias Lazaridis, April 18:
>>>> One should call Mr. Matz to review this.
>>>
>>>> Most possibly he's the only one who knows.
>>>
>>> It seems that you don't anyway,
>>
>> I've invested some time (whilst ignoring finally the current
>> documentation) to create this UML diagramm:
>>
>> http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
>>
>> I'm asking now for confirmation/feedback.
>>
>> This is nothing special within serious software-development.
>>
>> -
>>
>> But as it looks, this community is incapable to do so (giving
>> productive feedback).
>
> I can.
>
> -
>
> But there are other ways of asking, you know... :(
there are other ways of answering, too.
> -
>
> I'll give it a try: the documentation "ri Class" gives is not wrong at
> all. Maybe not complete, but not wrong.
it's incomplete, wrong and missleading.
> -
>
> In "ri Class" text, if you replace references to "metaclasses" (which
> are said to be between parentheses) by "singleton method placeholders",
> perhaps it becomes clearer?
no, then it becomes completely confusing.
>
> -
>
> I remember that what was disturbing you was the stuff about metaclasses.
> I told you ruby invite you to think more in terms of singleton method
> than in terms of metaclasses. But it seems that you ignore what are
> singleton methods.
of course i ignore them.
they are not relevant when reviewing ruby's oject-model.
>
> -
>
> Have you ever evaluated some classless OO langages? I know some: IO (
> http://www.iolanguage.com/ ), Self ( http://c2.com/cgi/wiki?SelfLanguage
> ) and REBOL (rebol is not basically OO, but its OO part is classless.
> http://www.rebol.com/ ). If you would, the concept of singleton method
> would be far easier to understand for you. (this is actually how I
> understood that concept)
[will possibly take a look at them shortly]
>
> -
>
> http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
>
> Your UML diagram of ruby object model is hard to read, and probably
> wrong. The separation between classes in memory and in source code is
> totally confusing.
the seperation exist in reality (and in the "ri class" documentation).
additionally: It was neccessary for my understanding process.
the next version (1.1), the diagramm will be simplified (possibly in a
few hours, if the stuff has passed).
> In ruby, classes *are* objects.
yes, but there is still a class definition.
> Learn more about
> classless languages, and it should be far easier to understand these
> concepts.
this is not relevant to understand ruby's Object Model.
I just need a (correct) UML diagram to understand Ruby's Object Model.
>
> There is another evident mistake in your UML diagram. Object doesn't
> inherit from nil, nil is a literal and an instance of NilClass which
> inherit from Object.
you are wrong:
irb(main):001:0> Object.superclass
=> nil
irb(main):002:0> nil.class
=> NilClass
[btw: to simplify the analysis, I've stopped exporing "nil" at that point]
>
> -
>
> I tried my best, I can't say anymore. Please, don't ask me for lengthy
> exhausting explanations. Try the languages I told you about, they are
> really worth it.
will possibly do this shortly.
>
> -
>
> Have a nice day.
>
> --
> Lionel Thiry
>
> PS: Please, anybody, do not blame me for anwsering this post. Do not
> blame me for imitating Lazaridis posting. Do not blame me for trying to
> be nice.
.
Ilias Lazaridis
This technique leads to uncontrolled threads, full of off-topic ranting.
that's why I don't use it [at least not here within comp.lang.ruby]
.
Jim Weirich
> > There is another evident mistake in your UML diagram. Object doesn't
> > inherit from nil, nil is a literal and an instance of NilClass which
> > inherit from Object.
>
> you are wrong:
>
> irb(main):001:0> Object.superclass
> => nil
The documentation for superclass clearly states that it returns the superclass
of its target, or nil.
In this case it returns nil because Object does not have a superclass, i.e. it
does not inherit from anything.
--
-- Jim Weirich j...@weirichhouse.org http://onestepback.org
-----------------------------------------------------------------
"Beware of bugs in the above code; I have only proved it correct,
not tried it." -- Donald Knuth (in a memo to Peter van Emde Boas)
Ilias Lazaridis
> On Monday 18 April 2005 11:34 pm, Ilias Lazaridis wrote:
>
>>>There is another evident mistake in your UML diagram. Object doesn't
>>>inherit from nil, nil is a literal and an instance of NilClass which
>>>inherit from Object.
>>
>>you are wrong:
>>
>>irb(main):001:0> Object.superclass
>>=> nil
>
> The documentation for superclass clearly states that it returns the superclass
> of its target, or nil.
>
> In this case it returns nil because Object does not have a superclass, i.e. it
> does not inherit from anything.
In context of an Language Object Model:
Object inherits from "nil".
"nil" is represented by an _instance_ of class "NilClass".
I've drawn this instance "nil" into the diagram.
[possibly it will be removed with the next revision]
-
Nil is a terribly confusing topic, thus I would prefere to keep is out
of the currect topic.
You can review an old thread about smalltalk's Nil:
comp.lang.smalltalk > ST - The Loneliness of Nil
http://groups-beta.google.com/group/comp.lang.smalltalk/msg/f7f017a49e6268e1
.
Saynatkari
Le 19/4/2005, "Ilias Lazaridis" <il...@lazaridis.com> a écrit:
>Jim Weirich wrote:
>> On Monday 18 April 2005 11:34 pm, Ilias Lazaridis wrote:
>>
>>>>There is another evident mistake in your UML diagram. Object doesn't
>>>>inherit from nil, nil is a literal and an instance of NilClass which
>>>>inherit from Object.
>>>
>>>you are wrong:
>>>
>>>irb(main):001:0> Object.superclass
>>>=> nil
>>
>> The documentation for superclass clearly states that it returns the superclass
>> of its target, or nil.
>>
>> In this case it returns nil because Object does not have a superclass, i.e. it
>> does not inherit from anything.
>
>In context of an Language Object Model:
>
>Object inherits from "nil".
Er, no. Object does not inherit. As was pointed out to
you, #superclass just happens to return nil to signify
there is no superclass.
>"nil" is represented by an _instance_ of class "NilClass".
>
>I've drawn this instance "nil" into the diagram.
>
>[possibly it will be removed with the next revision]
>
>-
>
>Nil is a terribly confusing topic, thus I would prefere to keep is out
>of the currect topic.
Why is it confusing? nil is 'nothing'.
>You can review an old thread about smalltalk's Nil:
>
>comp.lang.smalltalk > ST - The Loneliness of Nil
>http://groups-beta.google.com/group/comp.lang.smalltalk/msg/f7f017a49e6268
E
--
template<typename duck>
void quack(duck& d) { d.quack(); }
Martin DeMello
>
> In context of an Language Object Model:
>
> Object inherits from "nil".
Object does *not* inherit from nil. Object.superclass returns 'nil'
because Object has no superclass.
martin
Jim Weirich
> > In this case it returns nil because Object does not have a superclass,
> > i.e. it does not inherit from anything.
>
> In context of an Language Object Model:
> Object inherits from "nil".
Nothing can inherit from nil, for nil is not an instance of Class... as
demonstrated below.
>> class NilSubClass < nil; end
TypeError: superclass must be a Class (NilClass given)
from (irb):10
In the context of the Ruby Object Model, Object has not superclass and does
not inherit from anything.
Please remove the inaccuracies in your Language Object Model.
mark sparshatt
As other people have pointed out this is wrong since nothing can inherit
from nil, since it isn't a class.
The mistake you're making is that (Object) doesn't represent an instance
of Object. It represents Object's metaclass.
Using _why's metaid library
Object.metaclass.superclass #=> Class
So the ruby documentation is correct, (Object) does inherit from Class
> or
>
> correct: "(Object)"---[is-an-instance-of]--->Class
>
This is correct. (Object) both inherits from and is an instance of Class.
> -
>
> and finally:
>
> the diagramm gives the impression, that "Object" and "(Object)" (etc.)
> are both classes,
Object and (Object) are both classes.
> which is of course false. There is a "definition" and
> an "(instance)".
no there is a "class" and a (metaclass)
--
Mark Sparshatt
Ilias Lazaridis
> On Tuesday 19 April 2005 12:59 am, Ilias Lazaridis wrote:
>
>>>In this case it returns nil because Object does not have a superclass,
>>>i.e. it does not inherit from anything.
>>
>>In context of an Language Object Model:
>>Object inherits from "nil".
>
> Nothing can inherit from nil, for nil is not an instance of Class... as
> demonstrated below.
you reverse things.
>>>class NilSubClass < nil; end
>
> TypeError: superclass must be a Class (NilClass given)
> from (irb):10
this is irrelevant.
> In the context of the Ruby Object Model, Object has not superclass and does
> not inherit from anything.
it inherits from nothing, which is represented by "nil", which is a
'living' object, which is an instance of class NilClass, which inherits
from Object.
> Please remove the inaccuracies in your Language Object Model.
I will add the above describewd circularity to the new diagram.
then please review it again.
.
Ilias Lazaridis
> Le 19/4/2005, "Ilias Lazaridis" <il...@lazaridis.com> a écrit:
>>Jim Weirich wrote:
>>>On Monday 18 April 2005 11:34 pm, Ilias Lazaridis wrote:
>>>
>>>>>There is another evident mistake in your UML diagram. Object doesn't
>>>>>inherit from nil, nil is a literal and an instance of NilClass which
>>>>>inherit from Object.
>>>>
>>>>you are wrong:
>>>>
>>>>irb(main):001:0> Object.superclass
>>>>=> nil
>>>
>>>The documentation for superclass clearly states that it returns the superclass
>>>of its target, or nil.
>>>
>>>In this case it returns nil because Object does not have a superclass, i.e. it
>>>does not inherit from anything.
>>
>>In context of an Language Object Model:
>>
>>Object inherits from "nil".
>
> Er, no. Object does not inherit. As was pointed out to
> you, #superclass just happens to return nil to signify
> there is no superclass.
you can express this as "Object inherits from nil".
which is similar to "Object inherits from nothing".
but the second is not true, as .superclass returns an object, which is
"nil".
>>"nil" is represented by an _instance_ of class "NilClass".
>>
>>I've drawn this instance "nil" into the diagram.
>>
>>[possibly it will be removed with the next revision]
>>
>>-
>>
>>Nil is a terribly confusing topic, thus I would prefere to keep is out
>>of the currect topic.
>
> Why is it confusing? nil is 'nothing'.
in context of Language Object models.
see the thread below:
>>You can review an old thread about smalltalk's Nil:
>>
>>comp.lang.smalltalk > ST - The Loneliness of Nil
>>http://groups-beta.google.com/group/comp.lang.smalltalk/msg/f7f017a49e6268
.
Ilias Lazaridis
I've not said that "Object inherits from Class nil".
I've said: Object inherits from nil
which is true.
the new diagramm (V1.1) will be out in a few hours.
Yukihiro Matsumoto
In message "Re: - E03c - The Ruby Object Model (Revised Documentation)"
on Tue, 19 Apr 2005 17:04:33 +0900, Ilias Lazaridis <il...@lazaridis.com> writes:
|>>Object inherits from "nil".
|>
|> Er, no. Object does not inherit. As was pointed out to
|> you, #superclass just happens to return nil to signify
|> there is no superclass.
|
|you can express this as "Object inherits from nil".
Don't, please. It is confusing.
matz.
Martin DeMello
[...]
> > In the context of the Ruby Object Model, Object has not superclass
> > and does not inherit from anything.
>
> it inherits from nothing, which is represented by "nil", which is a
> 'living' object, which is an instance of class NilClass, which inherits
> from Object.
With apologies to Martin Gardner,
1. Nothing is better than eternal happiness
2. A ham sandwich is better than nothing
3. Therefore, a ham sandwich is better than eternal happiness
martin
Ilias Lazaridis
I am myself confused, but will shortly be in clarity.
for now I can only rephrase to:
"class Object inherits from nothing (represented by object nil)"
.
Ilias Lazaridis
thank's for the reminder.
time to eat.
after this (~ 2 to 3 hours), I'll publish the 1.1 version here:
http://lazaridis.com/case/lang/ruby/
.
Peter Reilly
Very zen like!
Peter
>
> ..
>
mark sparshatt
> Martin DeMello wrote:
>
>> Ilias Lazaridis <il...@lazaridis.com> wrote:
>>
>>> In context of an Language Object Model:
>>>
>>> Object inherits from "nil".
>>
>>
>> Object does *not* inherit from nil. Object.superclass returns 'nil'
>> because Object has no superclass.
>
>
> I've not said that "Object inherits from Class nil".
>
> I've said: Object inherits from nil
>
> which is true.
>
nil's methods
nil.methods - Object.methods #=> ["&", "|", "^", "to_i", "to_s"]
Object.to_s #=> NoMethodError: undefined method 'to_s' for Object:Class
Since Object doesn't inherit all of nil's methods I don't see how it can
make sense to say that Object inherits from nil.
--
Mark Sparshatt
Ralf Müller
And that's what the whole things is about.
Many thanks to you martin. I can't guess a better summary.
ts
I> Possibly the same bot has generated the the "ri class" documentation.
the schema in "ri class" was created by matz.
Guy Decoux
Ilias Lazaridis
Ilias Lazaridis
see my reply to Mr. Matsumoto:
"class Object inherits from nothing (represented by object nil)"
new diagramm:
http://lazaridis.com/case/lang/ruby/
> --
> Mark Sparshatt
.
Ilias Lazaridis
> [EVALUATION] - E03b - The Ruby Object Model
> http://groups-beta.google.com/group/comp.lang.ruby/msg/e9d841fedb35903f
>
> -
>
> The above thread has shown, that the existen documentation is false.
>
> Within this page, you'll find a link to an UML diagramm
>
> http://lazaridis.com/case/lang/ruby/
>
> -
>
> Please review the diagramm.
>
> If it's correct, please ensure that the existent documentation is
> corrected.
the new diagramm (needs possibly a refresh within your browser):
http://lazaridis.com/case/lang/ruby/
-
please do _not_ focus on the nil issue, but on the existing documentation.
this is covered for now with this statement:
"class Object inherits from nothing (represented by object nil)"
.
Ilias Lazaridis
simply rephrase to:
"Object inherits from nothing" or
"Object does not inherit".
> The mistake you're making is that (Object) doesn't represent an instance
> of Object.
I understand.
Thus horizontal arrows represent inheritance, too.
Let's see.
> It represents Object's metaclass.
again my initial question:
how do I access this metaclass?
> Using _why's metaid library
this library is irrelevant.
I'm evaluating standard ruby and its Object Model.
The [Meta] Object Model must be accessible without additional libraries.
> Object.metaclass.superclass #=> Class
output of pure ruby:
irb(main):014:0> Object.metaclass.superclass
NoMethodError: undefined method `metaclass' for Object:Class
from (irb):14
> So the ruby documentation is correct, (Object) does inherit from Class
not in my installation:
I have no "(Object)"
>> or
>>
>> correct: "(Object)"---[is-an-instance-of]--->Class
>
> This is correct. (Object) both inherits from and is an instance of Class.
it's easier:
(Object) is not existent.
>
>> -
>>
>> and finally:
>>
>> the diagramm gives the impression, that "Object" and "(Object)" (etc.)
>> are both classes,
>
> Object and (Object) are both classes.
"Object" and "(Object)" are essentially the same thing.
>> which is of course false. There is a "definition" and an "(instance)".
>
> no there is a "class" and a (metaclass)
there are no metaclasses in ruby.
If i'm wrong:
please show me the pure-ruby [no additional libraries] access-code.
-
The version 1.1 UML diagramm backups all my statements.
You can verify it with a standard ruby installation:
Jim Weirich
> > Using _why's metaid library
>
> this library is irrelevant.
> I'm evaluating standard ruby and its Object Model.
> The [Meta] Object Model must be accessible without additional libraries.
Accessing Object's metaclass:
>> meta_class_of_Object = class << Object; self; end
=> #<Class:Object>
>> meta_class_of_Object.class
=> Class
So, the metaclass of Object /does/ inherit from class.
Now we demonstrate that the object in meta_class_of_Object is really the
metaclass by defining a method on Object and finding the method added to its
metaclass:
>> meta_class_of_Object.instance_methods(false)
=> ["new", "allocate"]
>> def Object.method_only_in_Object(); puts "HI"; end
=> nil
>> meta_class_of_Object.instance_methods(false)
=> ["method_only_in_Object", "new", "allocate"]
>> Object.method_only_in_Object
HI
=> nil
David A. Black
On Tue, 19 Apr 2005, Jim Weirich wrote:
> On Tuesday 19 April 2005 06:39 am, Ilias Lazaridis wrote:
>>> Using _why's metaid library
>>
>> this library is irrelevant.
>> I'm evaluating standard ruby and its Object Model.
>> The [Meta] Object Model must be accessible without additional libraries.
>
> Accessing Object's metaclass:
>
>>> meta_class_of_Object = class << Object; self; end
> => #<Class:Object>
>>> meta_class_of_Object.class
> => Class
>
> So, the metaclass of Object /does/ inherit from class.
Doesn't that tell you that it is an instance of Class, rather than
that it inherits from Class? As opposed to:
irb(main):001:0> c = (class << Object; self; end)
=> #<Class:Object>
irb(main):002:0> c.superclass
=> Class
?
David
--
David A. Black
dbl...@wobblini.net
Austin Ziegler
> "class Object inherits from nothing (represented by object nil)"
This is not true.
Object is the root object. It has no parents. It needs no parents. To
paraphrase:
In the beginning was the Object, and the Object was Object.
-austin
--
Austin Ziegler * halos...@gmail.com
* Alternate: aus...@halostatue.ca
Austin Ziegler
> please do _not_ focus on the nil issue, but on the existing documentation.
>
> this is covered for now with this statement:
>
> "class Object inherits from nothing (represented by object nil)"
But, as stated, this is wrong.
Object doesn't inherit from nil or NilClass.
The existing diagram is far better than your attempt.
Ilias Lazaridis
[...] - (creating new context)
please, the context of the discussion is already given:
I've stated, that the _specific_ and _given_ (described within "ri
Class") "(Object)" metaclass is not existent.
launch irb.
"Object" is accessible.
please name me the "(Object)" class.
you cannot:
it's not existent.
.
Martin DeMello
>
> please, the context of the discussion is already given:
>
> I've stated, that the _specific_ and _given_ (described within "ri
> Class") "(Object)" metaclass is not existent.
>
> launch irb.
>
> "Object" is accessible.
>
> please name me the "(Object)" class.
>
> you cannot:
>
> it's not existent.
Ruby supports the concept of anonymous but reachable objects.
a = ["Hello", "world"]
The two strings in the array have no name other than a[0] and a[1], but
they certainly exist.
a.each {|i| puts i}
The block passed to a.each has no name at all, but it too exists.
Also, the ruby community recognises the value of documentation-level
abstractions and conventions.
String#reverse is not ruby syntax, but shorthand for "the instance
method 'reverse' of objects of class String", and it's a valuable and
widely understood convention in the documentation. Likewise, (Object) is
not ruby syntax, but shorthand for "the singleton class of the class
object Object", and is likewise valuable (try redrawing the diagram
using the expanded form) and understood.
martin
Carlos
> >>"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'."
> >
> >of".
>
> not exactly, it's more a "becomes" relation:
>
> "class definition" ----"becomes"----> "(class) instance"
(?) Please see (attempt to) explanation below. I got a bit enthused with the
ascii art, sorry, but it helped to my understanding of the issue, too.
> "instance of" would be false, because:
>
> * the direction fo the arrow would be wrong
Normally, the standard arrow goes from instance to class
person ----is an instance of the class---> Person
> * all 'metaclasses' are instances of the class "Class"
Yes, the text says that to avoid drawing too many arrows.
Here is the explanation. Please bear with me and correct possible errors:
Objects have only data (instance variables). Their classes have methods.
When you write "person.say_hello", Ruby looks up the method "say_hello" in
the Person class, sets "self" to the object "person" and executes the
method. If you call a method not in the class Person, the method is looked
up in Person's superclass, and so on. We agree until here, yes?
[Object ]
^
|
[person ] ---- instance of ----> [Person ]
@name say_hello()
But now, you have a special person, who says hello differently. If you
change the method "say_hello()" in Person, *all* instances will use it. So
you insert a singleton class, only for the object "person":
[Object ]
^
|
[person ] ----- instance of ----> [Person ]
@name say_hello()
^
|
[mute ] ---- instance of ----> [(mute) ]
@name say_hello() (redefined only for
"mute")
Now, classes are objects, too, with the difference that they have methods
for their instances to use. So, when you call "Person.new", Ruby looks up
the method "new" in Person's class, which is "Class". Then it sets "self" to
the object "Person" and executes the method.
[Object ] [Module ]
^ ^
| |
[Person ] ---- instance of ----> [Class ]
new()
Now say that you want the class Person to have a new method, for example
"new_with_name()". You must define the method in its class, but if you
define it in "Class", *all* objects that are instances of class (that is,
all classes) will have that method. So you create a singleton class for
Person:
[Module ]
^
|
[Class ]
[Object ] new()
^ ^
| |
person -----> [Person ] ---- instance of ----> [(Person) ]
new_with_name()
We agree until now? "person.id()" will try to find "Person#id", then
"Object#id". "Person.attr_accessor" will try to find
"(Person)#attr_accessor", then "Class#attr_accessor", then
"Module#attr_accessor". First go to the right, then up until you find it.
Now let's say you create a new class "Man", inheriting from "Person". You
expect to be able to say "Man.new_with_name()", so the class of "Man"
shouldn't be "Class", but "(Person)". Well, let's assume that the singleton
class for "Man" is already created:
[Class ]
[Object ] new()
^ ^
| |
person -----> [Person ] ---- instance of ----> [(Person) ]
^ ^ new_with_name()
mute -> [(mute)] | ^
| |
man --------> [Man ] ---- instance of ----> [(Man) ]
Of course, the same logic applies to "Person". If "Object" has a singleton
class, we expect that "(Person)" inherits from it ("(Object)"). And also,
all these singleton classes (metaclasses) are instances of "Class". So let's
complete the diagram:
[Class ]
new()
^
|
[Object ] ---- instance of ----> [(Object) ] ---> [Class]
^ ^
| |
person -----> [Person ] ---- instance of ----> [(Person) ] ---> [Class]
^ ^ new_with_name()
mute -> [(mute)] | ^
| |
man --------> [Man ] ---- instance of ----> [(Man) ] ---> [Class]
Well, that's all. I can't squeeze out any more understanding of metaclasses
from my brain. In the upper stages things get a little mixed up, because
metaclasses are instances of Class, but also ultimately inherit from it, so
you need a diagram as the one in "ri Class" to sort these relationships out.
But I don't think that diagram is wrong at all.
Hope this helped. It helped me, at least.
class Person
class << self # now we are in class (Person)
def new_with_name name
o = new
o.name = name
o
end
end
def say_hello
puts "Hello"
end
attr_accessor :name
end
class Other
end
person = Person.new_with_name "Someone"
puts person.name
person.say_hello
mute = Person.new
class << mute # now we are in class (mute)
def say_hello
puts "..."
end
end
mute.say_hello
class Man < Person
end
fred = Man.new_with_name "Fred"
puts fred.name
other = Other.new_with_name "x"
James Edward Gray II
> the new diagramm (needs possibly a refresh within your browser):
>
> http://lazaridis.com/case/lang/ruby/
>
> -
>
> please do _not_ focus on the nil issue, but on the existing
> documentation.
I wish I didn't have to but you have a clearly incorrect arrow and
label. This has been adequately proven by plenty of experts on this
list. The language designer himself has asked you to remove it. You
have become the problem you were complaining about: You are now
publishing false documentation.
You claim your "evaluation" is a service to the Ruby community.
However, making incorrect documentation easily accessible is just the
opposite. If someone learning Ruby stumbles upon your site and
believes what they read there, you have done both the individual and
the community a great disservice.
You are constantly proving a complete lack of all essential social
skills and I feel we're going above and beyond the call to ignore this
and find any possible value for your discussions. Worse, you display
the same void of essential programming skills, causing you to obsess
over minute language details and totally bypass helpful insights into
the language itself. This too we have gone to great lengths to
tolerate. Unfortunately, you've crossed the line from annoying to
dangerous.
I must now strongly encourage all people still learning Ruby to avoid
your information, as the results are likely outright incorrect and you
are proving yourself incapable of admitting that.
That's my evaluation of your evaluation.
James Edward Gray II
Christian Neukirchen
> Jim Weirich wrote:
>> On Tuesday 19 April 2005 12:59 am, Ilias Lazaridis wrote:
>>
>>>>In this case it returns nil because Object does not have a superclass,
>>>>i.e. it does not inherit from anything.
>>>
>>>In context of an Language Object Model:
>>>Object inherits from "nil".
>> Nothing can inherit from nil, for nil is not an instance of
>> Class... as demonstrated below.
>
> you reverse things.
>
>>>>class NilSubClass < nil; end
>> TypeError: superclass must be a Class (NilClass given)
>> from (irb):10
>
> this is irrelevant.
>
>> In the context of the Ruby Object Model, Object has not superclass
>> and does not inherit from anything.
>
> it inherits from nothing, which is represented by "nil", which is a
> living' object, which is an instance of class NilClass, which inherits
> from Object.
Dude, you drive me crazy.
~ruby/object.c:
rb_cObject = boot_defclass("Object", 0);
rb_cModule = boot_defclass("Module", rb_cObject);
rb_cClass = boot_defclass("Class", rb_cModule);
as you can see Object inherits from a NULL pointer, that is:
It doesn't inherit from anything. Nada.
A NULL pointer is not nil, as you can see in ~ruby/ruby.h:
#define Qnil 4
Believe it or not, but STFU,
--
Christian Neukirchen <chneuk...@gmail.com> http://chneukirchen.org
Jim Weirich
David A. Black said:
>> Accessing Object's metaclass:
>>
>>>> meta_class_of_Object = class << Object; self; end
>> => #<Class:Object>
>>>> meta_class_of_Object.class
>> => Class
>>
>> So, the metaclass of Object /does/ inherit from class.
>
> Doesn't that tell you that it is an instance of Class, rather than
> that it inherits from Class? As opposed to:
>
> irb(main):001:0> c = (class << Object; self; end)
> => #<Class:Object>
> irb(main):002:0> c.superclass
> => Class
I stand corrected. David's code demonstrates that the metaclass does
inherit from Class. Mine demonstrated that it was an instance of Class.
vruz
please re-tag as [ILIAS]
Florian Groß
> "class Object inherits from nothing (represented by object nil)"
Not all nothings you can possibly think of are represented by 'nil'. One
example: If there is nothing in an Array that is not the same as [nil].
So there really is not much of a meaningful connection between Object
and NilClass. (That way -- NilClass inherits from Object, however)
Jim Weirich
Ilias Lazaridis said:
> I've stated, that the _specific_ and _given_ (described within "ri
> Class") "(Object)" metaclass is not existent.
>
> launch irb.
>
> "Object" is accessible.
> please name me the "(Object)" class.
> you cannot:
> it's not existent.
The class has no "name". That means it is anonymous. It does not mean it
doesn't exist.
In the context of the diagram, the notation "(Object)" is used to denote
the metaclass of Object. This is not the name of the class (which has no
name). The class so designated does exist as demonstrated in the irb
session in the previous message.
Florian Groß
> see my reply to Mr. Matsumoto:
>
> "class Object inherits from nothing (represented by object nil)"
>
> new diagramm:
>
> http://lazaridis.com/case/lang/ruby/
Why is it so hard to say "doesn't inherit" instead of "inherits from
non-existent"? Expertise isn't making things looking more complex than
they are -- it is making them as simple as possible, but not any
simpler. Just remove clutter that doesn't matter and you will end up
with a diagram that is more clear and easier to understand.
I'm not sure what you mean by the term 'singleton instance' -- classes
are instances of Class. Whenever you see something like 'foobars' you
can transform that to 'instances of Foobar' mentally.
What Ruby's singleton classes do is providing a way of treating a single
Object as if it had a class by itself that nobody else uses. Here is an
example:
obj = "hello world"
def obj.reverse() "fake reverse" end
obj.reverse # => "fake reverse"
"foobar".reverse # => "raboof"
Which is equivalent to this:
obj = "hello world"
class << obj # enter singleton class
def reverse() "fake reverse" end
end # exit singleton class
obj.reverse # => "fake reverse"
"foobar".reverse # => "raboof"
And as you can see from this example singleton classes are indeed
handled as regular classes:
obj = "hello world"
class << obj
# outputs #<Class:#<String:0x2b83cc8>> (or similar)
p self
# outputs Class
p self.class
# outputs [String, Enumerable, Comparable, Object, Kernel]
p self.ancestors
attr_accessor :foo
end
obj.methods(false) # => ["foo", "foo="]
That is basically all you need to know about singleton classes. The rest
is implementation details.
If you really want to give Ruby a look and aren't just doing these
evaluations to waste your time / boost your curriculum vitae then that
information will help you. If not then you are probably happy about me
wasting my time by responding to you. I'm still not sure what your
intentions are, but I'd certainly like to believe that you are a honest
person, even though you had a bit of trouble with approaching various
communities before.
It is okay to ask questions about this relatively exotic parts of Ruby,
but please do research before asking -- that can mean reading a book
that is available online for free, buying a book and reading it in
commute time or just trying things out in IRB / a personal set of unit
tests.
Florian Groß
> We agree until now? "person.id()" will try to find "Person#id", then
> "Object#id". "Person.attr_accessor" will try to find
> "(Person)#attr_accessor", then "Class#attr_accessor", then
> "Module#attr_accessor". First go to the right, then up until you find it.
And Ruby describes (Person)#attr_accessor as Person.attr_accessor:
class Person; end
def Person.attr_accessor() end
Person.method(:attr_accessor) # => #<Method: Person.attr_accessor>
Person.method(:new) # => #<Method: Class#new>
[].method(:inject) # => #<Method: Array(Enumerable)#inject>
I think this notational difference helps in figuring out where a method
truly comes from.
I think your explanation was a good one, even though in practice you can
ignore the fact that meta classes are implemented by inserting the meta
class before the physical class in the inheritance chain and that an
object is thus an instance of its meta class.
Lionel Thiry
> Lionel Thiry wrote:
>
>> Ilias Lazaridis a écrit :
>>> But as it looks, this community is incapable to do so (giving
>>> productive feedback).
>>
>>
>> I can.
>>
>> -
>>
>> But there are other ways of asking, you know... :(
>
>
> there are other ways of answering, too.
You're right! :)
Then change your way of asking, and I bet people will change their ways of
anwsering! :)
>> I'll give it a try: the documentation "ri Class" gives is not wrong at
>> all. Maybe not complete, but not wrong.
> it's incomplete, wrong and missleading.
I may seem to ask a bit too much of you, but, would you mind explain where it is
wrong?
>> I remember that what was disturbing you was the stuff about
>> metaclasses. I told you ruby invite you to think more in terms of
>> singleton method than in terms of metaclasses. But it seems that you
>> ignore what are singleton methods.
>
> of course i ignore them.
>
> they are not relevant when reviewing ruby's oject-model.
>
If you knew about singleton methods, the said metaclasses would not have been
such a source of confusion for you.
>> http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
>>
>> Your UML diagram of ruby object model is hard to read, and probably
>> wrong. The separation between classes in memory and in source code is
>> totally confusing.
>
>
> the seperation exist in reality (and in the "ri class" documentation).
>
> additionally: It was neccessary for my understanding process.
>
> the next version (1.1), the diagramm will be simplified (possibly in a
> few hours, if the stuff has passed).
>
>> In ruby, classes *are* objects.
>
>
> yes, but there is still a class definition.
In fact, not even. In java or C++, they are processed during compilation, not
during execution. In ruby, those "declarations" are really processed during
execution. So, they look like declarations, but they are not: they are
instructions. Hence I told you that separation in your UML diagram is a source
of confusion.
>
>> Learn more about classless languages, and it should be far easier to
>> understand these concepts.
>
>
> this is not relevant to understand ruby's Object Model.
But this would help you so much!
>
> I just need a (correct) UML diagram to understand Ruby's Object Model.
>
>>
>> There is another evident mistake in your UML diagram. Object doesn't
>> inherit from nil, nil is a literal and an instance of NilClass which
>> inherit from Object.
>
>
> you are wrong:
By the way, you should never say to someone "you are wrong". Prefer to say "If
you are right, then, I don't understand this". Doing things that way, you'd
avoid a lot of flaming.
>
> irb(main):001:0> Object.superclass
> => nil
> irb(main):002:0> nil.class
> => NilClass
>
irb(main):001:0> Object < nil.class
=> false
irb(main):002:0> Object > nil.class
=> true
--
Lionel Thiry
Personal website: http://users.skynet.be/lthiry/
Lionel Thiry
> mark sparshatt wrote:
>
>> Ilias Lazaridis wrote:
>>
>>> Christian Neukirchen wrote:
>>>
>>>> Ilias Lazaridis <il...@lazaridis.com> writes:
>>>>
>>>>> Ilias Lazaridis wrote:
>> Using _why's metaid library
>
>
> this library is irrelevant.
>
> I'm evaluating standard ruby and its Object Model.
>
> The [Meta] Object Model must be accessible without additional libraries.
Just check this page then:
<http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html>
A little advice by the way. You should not say:
> this library is irrelevant.
>
> I'm evaluating standard ruby and its Object Model.
>
> The [Meta] Object Model must be accessible without additional libraries.
which shows a great lack of tact,
but instead:
> I'm evaluating standard ruby and its Object Model.
>
> The [Meta] Object Model must be accessible without additional libraries.
>
> Why would this metaid.rb be relevant for me?
which would be a bit better.
Ilias Lazaridis
> [Ilias Lazaridis <il...@lazaridis.com>, 2005-04-19 04.04 CEST]
>
>>>>"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'."
>>>
>>>Well, yes. If I'm not mistaken, horizontal arrows represent "instance
>>>of".
>>
>>not exactly, it's more a "becomes" relation:
>>
>>"class definition" ----"becomes"----> "(class) instance"
>
>
> (?) Please see (attempt to) explanation below. I got a bit enthused with the
> ascii art, sorry, but it helped to my understanding of the issue, too.
I'm sorry, I cannot review this at this point.
[protection of own understanding process]
I have marked your message for a later review.
My apologies.
.
Ilias Lazaridis
> On Apr 19, 2005, at 5:14 AM, Ilias Lazaridis wrote:
>
>> the new diagramm (needs possibly a refresh within your browser):
>>
>> http://lazaridis.com/case/lang/ruby/
>>
>> -
>>
>> please do _not_ focus on the nil issue, but on the existing
>> documentation.
>
> I wish I didn't have to but you have a clearly incorrect arrow and
> label. This has been adequately proven by plenty of experts on this
> list.
which experts?
those who are unable to communicate their knowledge?
e.g. due to commonly recognised terminology and notations?
> The language designer himself has asked you to remove it. You
no, he has stated that it's _confusing_ (not wrong).
[but I have a surprise in the next version]
> have become the problem you were complaining about: You are now
> publishing false documentation.
>
> You claim your "evaluation" is a service to the Ruby community.
> However, making incorrect documentation easily accessible is just the
> opposite.
the incorrect (and thus completely missleading) documentation is within
"ri class"
> If someone learning Ruby stumbles upon your site and believes
> what they read there, you have done both the individual and the
> community a great disservice.
everything is evaluatable by a ruby standard installation and an small
irb session.
> You are constantly proving a complete lack of all essential social
> skills and I feel we're going above and beyond the call to ignore this
[...] - (aborted processing)
I'm tired of this "bad-boy-stuff"
> James Edward Gray II
.
Ilias Lazaridis
[...]
> which shows a great lack of tact,
your interpretation is irrelevant.
as takt is.
mastering the Ruby Object Model is relevant.
.
Ilias Lazaridis
aah, low-level code.
nice!
> as you can see Object inherits from a NULL pointer, that is:
> It doesn't inherit from anything. Nada.
>
> A NULL pointer is not nil, as you can see in ~ruby/ruby.h:
>
> #define Qnil 4
>
> Believe it or not, but STFU,
just becoming warm.
.
Ilias Lazaridis
> Ilias Lazaridis wrote:
>
>> see my reply to Mr. Matsumoto:
>>
>> "class Object inherits from nothing (represented by object nil)"
>>
>> new diagramm:
>>
>> http://lazaridis.com/case/lang/ruby/
>
>
> Why is it so hard to say "doesn't inherit" instead of "inherits from
> non-existent"? Expertise isn't making things looking more complex than
sorry, I cannot read your document (nex context)
everything is in the diagramm (original context).
the corrected version of "ri class".
.
Ilias Lazaridis
[...]- (thorough comments)
I apologize for not answering in detail, but many things are not anymore
actual.
The version 1.2 will be out in a few hours:
http://lazaridis.com/case/lang/ruby
.
Ilias Lazaridis
> Ilias Lazaridis <il...@lazaridis.com> wrote:
>
>>please, the context of the discussion is already given:
>>
>>I've stated, that the _specific_ and _given_ (described within "ri
>>Class") "(Object)" metaclass is not existent.
>>
>>launch irb.
>>
>>"Object" is accessible.
>>
>>please name me the "(Object)" class.
>>
>>you cannot:
>>
>>it's not existent.
>
> Ruby supports the concept of anonymous but reachable objects.
> Likewise, (Object) is
> not ruby syntax, but shorthand for "the singleton class of the class
> object Object", and is likewise valuable (try redrawing the diagram
> using the expanded form) and understood.
>
> martin
Ruby's nonstandard notation has not very much relevance to me.
But let's see your definitions:
(Object) = "the singleton class of the class object Object"
Object = ?
.
Ilias Lazaridis
> Ilias Lazaridis said:
>
>>I've stated, that the _specific_ and _given_ (described within "ri
>>Class") "(Object)" metaclass is not existent.
>>
>>launch irb.
>>
>>"Object" is accessible.
>> please name me the "(Object)" class.
>>you cannot:
>>it's not existent.
>
> The class has no "name". That means it is anonymous. It does not mean it
> doesn't exist.
In context of Language Object Model, the class does not exist.
until someone showcases, how to _directly_ access this mystic [meta]class.
.
Lionel Thiry
> Lionel Thiry wrote:
> [...]
>
>> which shows a great lack of tact,
>
> [...]
>
> your interpretation is irrelevant.
>
> as takt is.
?!
Do you seriously claim that you don't care about tact (or anything related to it
as courtesy, social skill, and so on)?
David Mitchell
> this library is irrelevant.
and later wrote:
> your interpretation is irrelevant.
>
> mastering the Ruby Object Model is relevant.
One word: Borg
--
David Mitchell
Software Engineer
Telogis
NOTICE:
This message (including any attachments) contains CONFIDENTIAL
INFORMATION intended for a specific individual and purpose, and
is protected by law. If you are not the intended recipient,
you should delete this message and are hereby notified that any
disclosure, copying, or distribution of this message, or the
taking of any action based on it, is strictly prohibited.
Mark Smith
> Martin DeMello wrote:
>
>>Likewise, (Object) is
>>not ruby syntax, but shorthand for "the singleton class of the class
>>object Object", and is likewise valuable (try redrawing the diagram
>>using the expanded form) and understood.
>>
>>martin
>
>
> Ruby's nonstandard notation has not very much relevance to me.
>
> But let's see your definitions:
>
> (Object) = "the singleton class of the class object Object"
>
> Object = ?
Ilias,
Do you not know what "Object" is in Ruby? And you are trying to create
a model to correct what was designed by Matz--the creator of Ruby?
Please, stop trying to compare Ruby to your "fictive language" until you
first read the Ruby documentation.
ri Object states . . .
---------------------------------------------------------- Class: Object
+Object+ is the parent class of all classes in Ruby. Its methods
are therefore available to all objects unless explicitly
overridden.
+Object+ mixes in the +Kernel+ module, making the built-in kernel
functions globally accessible. Although the instance methods of
+Object+ are defined by the +Kernel+ module, we have chosen to
document them here for clarity.
In the descriptions of Object's methods, the parameter _symbol_
refers to a symbol, which is either a quoted string or a +Symbol+
(such as +:name+).
------------------------------------------------------------------------
I'm curious.
Does your [EVALUATION] have a purpose?
Is there an audience for it? Or are you just doing this as an exercise?
Many others have suggested material you could read to understand Ruby
better. They've suggested that you write some code to see how Ruby
really works. Instead, you expend abundant amounts of time and energy
trying to get others to review your material, and then dismiss honest
attempts to help you learn what you do not know.
Read the Ruby documentation, and evaluate your own "evaluation"--or else
just give up and try to create a "fictive" model of assembly language.
[now back to my lurking]
Regards,
Mark Smith mailto:mas.lists[at]cox.net
================================================================
A: Yes.
>Q: Are you sure?
>>A: Because it reverses the logical flow of conversation.
>>>Q: Why is top posting frowned upon?
================================================================
Mark Smith
> Lionel Thiry wrote:
> [...]
>
> your interpretation is irrelevant.
>
> as takt is.
>
> mastering the Ruby Object Model is relevant.
Your Ruby Object Model is irrelevant (to me).
Writing programs in Ruby that can manipulate data to solve real life
information problems . . . Now THAT is relevant.
Have you written a single program in Ruby? Why not?
--
David Mitchell
is a parody. I'm just taking the piss. (OT: Please don't pull me up for
the apostrophe I have put in Ilias's name, some camps consider it
correct, others don't, it's not hugely important).
<PissTake>
Mark Smith wrote:
> Do you not know what "Object" is in Ruby?
of course
> And you are trying to create
> a model to correct what was designed by Matz--the creator of Ruby?
clarify
and to correct existing documentation
> Please, stop trying to compare Ruby to your "fictive language" until you
> first read the Ruby documentation.
irrelevant
> ri Object states . . .
[snip]
obvious
> Does your [EVALUATION] have a purpose?
yes
> Is there an audience for it? Or are you just doing this as an exercise?
yes
> Many others have suggested material you could read to understand Ruby
> better. They've suggested that you write some code to see how Ruby
> really works. Instead, you expend abundant amounts of time and energy
> trying to get others to review your material, and then dismiss honest
> attempts to help you learn what you do not know.
if that is what you call the type of confrontational behaviour I have
come to expect from this list
> Read the Ruby documentation, and evaluate your own "evaluation"--or else
> just give up and try to create a "fictive" model of assembly language.
case in point
</PissTake>
Ilias Lazaridis
> Ilias Lazaridis a écrit :
>
>> Lionel Thiry wrote:
>> [...]
>>
>>> which shows a great lack of tact,
>>
>>
>> [...]
>>
>> your interpretation is irrelevant.
>>
>> as takt is.
>
>
> ?!
>
> Do you seriously claim that you don't care about tact (or anything
> related to it as courtesy, social skill, and so on)?
No.
I don't care about your [faulty] interpretations about 'takt'.
.
Ilias Lazaridis
> Ilias Lazaridis said the following on 4/19/2005 9:37 PM:
>> Ruby's nonstandard notation has not very much relevance to me.
>>
>> But let's see your definitions:
>>
>> (Object) = "the singleton class of the class object Object"
>>
>> Object = ?
>
> Ilias,
>
> Do you not know what "Object" is in Ruby? And you are trying to create
> a model to correct what was designed by Matz--the creator of Ruby?
>
> Please, stop trying to compare Ruby to your "fictive language" until you
> first read the Ruby documentation.
[...]
please wake up.
I'm discussing the documentation.
specificly: ri Class
.
Ilias Lazaridis
> Ilias Lazaridis wrote:
>
>> this library is irrelevant.
>
> and later wrote:
>
>> your interpretation is irrelevant.
>>
>> mastering the Ruby Object Model is relevant.
>
> One word: Borg
One more: Efficiency
-
http://lazaridis.com/efficiency
.
Ilias Lazaridis
> Ilias Lazaridis said the following on 4/19/2005 9:35 PM:
>
>> Lionel Thiry wrote:
>> [...]
>>
>> your interpretation is irrelevant.
>>
>> as takt is.
>>
>> mastering the Ruby Object Model is relevant.
>
> Your Ruby Object Model is irrelevant (to me).
>
> Writing programs in Ruby that can manipulate data to solve real life
> information problems . . . Now THAT is relevant.
>
> Have you written a single program in Ruby? Why not?
I've written "Talker":
http://lazaridis.com/case/lang/ruby/base.html
which hits on several limitations.
I've tried to overcome those.
Hitting on missleading documentation.
Thus I create the doc's myself.
http://lazaridis.com/case/lang/ruby/TheRubyObjectModel.png
To be able to continue.
.
Luke Graham
> Mark Smith wrote:
> > Ilias Lazaridis said the following on 4/19/2005 9:35 PM:
> >
> >> Lionel Thiry wrote:
> >> [...]
> >>
> >> your interpretation is irrelevant.
> >>
> >> as takt is.
> >>
> >> mastering the Ruby Object Model is relevant.
> >
> > Your Ruby Object Model is irrelevant (to me).
> >
> > Writing programs in Ruby that can manipulate data to solve real life
> > information problems . . . Now THAT is relevant.
> >
> > Have you written a single program in Ruby? Why not?
>
> I've written "Talker":
>
> http://lazaridis.com/case/lang/ruby/base.html
>
> which hits on several limitations.
If anyones wondering, his app prints a couple of strings, most of
which complain about lack of meta-stuff in ruby. I wonder if its a
sample of the AI that drives him?
--
spooq
vruz
> If anyones wondering, his app prints a couple of strings, most of
> which complain about lack of meta-stuff in ruby. I wonder if its a
> sample of the AI that drives him?
what does AI stand for ?
(I understand "Artificial" but the rest of the traditional acception
doesn't seem to apply here)
vruz
> > label. This has been adequately proven by plenty of experts on this
> > list.
>
> which experts?
>
> those who are unable to communicate their knowledge?
Among others, people who are authors the of code you're profiting from.
Among others the highly respected creator of the Ruby language, who
many here believe to be a genius and a person of excellent human
qualities.
Will you show us some minimal display of decency ?
Luke Graham
hehe
Ilias, before you close this thread, let me just say that Ive just
read your resume. If half of the stuff on there is true, you do have
experience with hardware. Why are you here asking strange questions
and making strange assertions about programming languages? Maybe you
should write a fictive language.
If your resume is real, your mind works differently to most - and
seeing as Ive dealt with people like that before and know their likely
reaction, let me assure you its not necessarily a good thing. If its
invented, then youre an incredibly dedicated troll. I am tempted to
call the number listed just to see what happens. Assuming its real,
you must have made money from that start-up company in order to fund
so many years of unpaid internet research.
I have to say though, the Ilias Lazaridis I saw on the university
website is not old enough to have that resume. Care to confirm or deny
that its you?
--
spooq
Ilias Lazaridis
>>> I wish I didn't have to but you have a clearly incorrect arrow
>>> and label. This has been adequately proven by plenty of experts
>>> on this list.
>>
>> which experts?
>>
>> those who are unable to communicate their knowledge?
[REQUOTE]
>> e.g. due to commonly recognised terminology and notations?
[/REQUOTE]
> Among others, people who are authors the of code you're profiting
> from.
I'm not profiting from this code.
currently, it's documentation cost me just huge amounts of time.
> Among others the highly respected creator of the Ruby language, who
> many here believe to be a genius and a person of excellent human
> qualities.
System designers should not document their own systems.
And if they see that their documentation causes problems:
then they should clarify things:
[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42?hl=en
> Will you show us some minimal display of decency ?
this is not my task.
.
Ilias Lazaridis
herein anymore]
I'll give it a final try within this thread:
[EVALUATION] - E03d - The Ruby Object Model (End Game)
http://groups-beta.google.com/group/comp.lang.ruby/msg/ea9da543dc256b42?hl=en
.
vruz
>
> this is not my task.
yeah, we noticed
Luc Heinrich
> (I understand "Artificial" but the rest of the traditional acception
> doesn't seem to apply here)
"Insanity" ? :)
--
Luc Heinrich - luc...@mac.com
Gary Lowder
Hash: SHA1
David Mitchell wrote:
| Let me see how closely I can predict Ilias's answer. Please note, this
| is a parody. I'm just taking the piss. (OT: Please don't pull me up for
| the apostrophe I have put in Ilias's name, some camps consider it
| correct, others don't, it's not hugely important).
|
| <PissTake>
|
| Mark Smith wrote:
|
|> Do you not know what "Object" is in Ruby?
|
|
| of course
|
..
..
..
| case in point
|
| </PissTake>
|
LOL, thanks David, I really liked that. I'm only following the thread
out of morbid curiosity as to where this is going.
Florian and a few others who painstakingly take the time to provide
really well thought out answers get as a reply from Illias:
| sorry, I cannot read your document (nex context)
Now I know, people have wasted a cumulatively large/inordinate number of
hours explaining what won't be read.
I'm extreemly new to Ruby, and I got something out of Florian's
explainations, but Illias didn't give it the courtesy of a read.
I've decided Illias has a research project, possibly a thesis on the
line here. Illias' job is to fill in these templates he's devised, with
differing languages to show some interrelation or correlation based on
<insert blah here>.
Illias has devised the great Huckleberry Finn ploy to paint his fence.
Illias, read the book, I won't explain what that statement means. I'm
willing to bet the intended audience of this post knows.
Next, my two cents:
I'm really new to Ruby, and am working my way through Pickaxe II, a
great read Illias. It really boils down to this, who gives a shit. The
diagram in question has not, nor in my opinion will not, have any
bearing on how 99.99% of actual programmers will use or understand Ruby.
People, there is nothing left to see here in this thread, move along.
If someone won't read a book/passage you hand to him, why hand him the
book? Secondly, do not help paint the fence.
Now, it's one thing to ignore a sender's address, trivial with procmail.
~ How do you completely ignore all of a person's threads? As any replys
to the thread will have different sender's addresses. I don't think
procmail does that as elegantly.
~ /me goes to ponder
Gary.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.3 (GNU/Linux)
Comment: Using GnuPG with Thunderbird - http://enigmail.mozdev.org
iD8DBQFCZfn9uXzcPSKHG/URAhGHAJ0Wzg087bpHLzHSMuiwGd5PuKMsyACfZxMv
fFN4/8cL9hIYrkMfjpa3DVc=
=ecki
-----END PGP SIGNATURE-----
Bill Kelly
>
> > Will you show us some minimal display of decency ?
>
> this is not my task.
You categorical homosapien!
:)
Have you not expressed dismay when some community
doesn't respond to YOU with decency?
You've asked the community to treat you well; it asks
the same of you. Task schmask.
Regards,
Bill
P.S. No. 4. The Larch.
vruz
> ~ How do you completely ignore all of a person's threads? As any replys
> to the thread will have different sender's addresses. I don't think
> procmail does that as elegantly.
> ~ /me goes to ponder
As I suggested, (and Ryan Davis at least agreed) the original poster
should tag his threads in an identifiable manner, as a minimal display
of decency for those who prefer not to be "benefited" by his "useful"
"information".
Suggested tag is [ILIAS].
Nikolai Weibull
> Let me see how closely I can predict Ilias's answer.
⋮
You forgot to misspell your replies,
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);}
Nikolai Weibull
> Lionel Thiry wrote:
> > Ilias Lazaridis a écrit :
> > > Lionel Thiry wrote:
> > > > which shows a great lack of tact,
> > > your interpretation is irrelevant.
> > > as takt is.
> > Do you seriously claim that you don't care about tact (or anything
> > related to it as courtesy, social skill, and so on)?
> I don't care about your [faulty] interpretations about 'takt'.
Why do you continue to misspell the word “tact”?,
Nikolai Weibull
> > If anyones wondering, his app prints a couple of strings, most of
> > which complain about lack of meta-stuff in ruby. I wonder if its a
> > sample of the AI that drives him?
> what does AI stand for ?
Artificial Ilias,
tsuraan
> out of morbid curiosity as to where this is going.
>
> Now I know, people have wasted a cumulatively large/inordinate number
> of
> hours explaining what won't be read.
>
> I'm extreemly new to Ruby, and I got something out of Florian's
> explainations, but Illias didn't give it the courtesy of a read.
>
reason trolls always amuse me), I actually have learned quite a bit
from the honest attempts that people have made to correct Ilias. He
might be an idiot or a troll, but the responses to his assertions were
not wasted. I, at least, have learned from them. I just thought I'd
give some support so the people trying to correct Ilias don't feel too
discouraged from responding with informative replies in the future.
--jay
Florian Groß
> sorry, I cannot read your document (nex context)
I guess that is a direct answer to this part of my message then:
> If you really want to give Ruby a look and aren't just doing these
> evaluations to waste your time / boost your curriculum vitae then
> that information will help you. If not then you are probably happy
> about me wasting my time by responding to you. I'm still not sure
> what your intentions are, but I'd certainly like to believe that you
> are a honest person, even though you had a bit of trouble with
> approaching various communities before.
Florian Groß
> I'm extreemly new to Ruby, and I got something out of Florian's
> explainations, but Illias didn't give it the courtesy of a read.
While it didn't take me too much time to write that up It is still a
good thing that the effort was not totally wasted. Thank you.
Florian Groß
> One more: Efficiency
Kicking people into the nuts doesn't seem efficient when you want to get
help.