What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e is an object, right? And then?

bit-naughty@hotmail.com writes:
>What does TWO dots mean in Javascript, exactly? Like,
>e.style.fontSize - e is an object, right? And then?

  It has little to do with object-orientied programming.

  Think of someone who already knows what one �+� means,
  as in �2+4�. So, he knows, it evaluates to �6�.

  Now he tries to wrap his head around �2+4+3�. He is
  nonplussed: He clearly understands one �+� as in �2+4�,
  but two plusses? What could it only mean? 

  How would you explain it to him?

bit-naughty@hotmail.com wrote:

>What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e is 
>an object, right? And then?

"e" is an object. "style" is another object that's part of "e". And
"fontSize" is an attribute of "style".

-- 
Tim Slattery
tim <at> risingdove <dot> com

Tim Slattery wrote:

> bit-naughty@hotmail.com wrote:
>>What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e
>>is an object, right? And then?
> 
> "e" is an object. "style" is another object that's part of "e". And
> "fontSize" is an attribute of "style".

No, that is a common misconception.

“e” is the identifier of a variable or a formal parameter in an enclosing 
execution context, or the name of a property of an object in the scope 
chain.

Whatever it is the identifier/name of, this entity has a value.  Here, that 
value is (has to be) a reference to another object.

That object has a property named “style”.¹  That property has a value.
That value is a reference to yet another object.

That object has a property named “fontSize”.¹  That property has a value.  

That value is a string (sequence) of characters (data type: String).  That 
value is not a reference to an object; it is a primitive value (typeof value 
=== "string"; therefore written “string” here instead):

           ,-----------------.
    e ---> : object[Element] :
           :-----------------:    ,-----------------------------.
           : style : object ----> : object[CSSStyleDeclaration] :
           : ...             :    :-----------------------------:
           `-----------------'    : fontSize : string           :
                                  : ...                         :
                                  `-----------------------------'

But the string value can be converted to an object if necessary.  Then the 
implementation will convert (or handle it as if it converted) internally the 
value to an object (here: a String instance), and return a reference to that 
object; so that property accesses like

  e.style.fontSize.indexOf("px")

are possible.

                            ,------------------------------------.
    Object.prototype -----> : object[Function]                   :
                            :------------------------------------:
                            : ...                                :
                            : +hasOwnProperty(:String) : boolean :
                            : ...                                :
                            : +toString() : string               :
                            : +valueOf()                         :
                            : ...                                :
                            `------------------------------------'
                                          ^
                                          :
                            ,----------------------------.
    String.prototype -----> : object[Function]           :
                            :----------------------------:
                            : ...                        :
                            : +indexOf(:String) : number :
                            : ...                        :
                            : +toString() : string       :
                            : +valueOf() : string        :
                            : ...                        :
                            `----------------------------'
                                          ^
                                          :
                            ,----------------------------.
    (e.style.fontSize) ---> : object[String]             :
                            :----------------------------:
                            : length : number            :
                            `----------------------------'

    Legend: X ---> Y  The value of X is a reference to Y

               Y
               ^
               :     X inherits from Y (direction of prototype chain)
               X

              +X     X is the name of a (public) method  } see also
              X:Y    The (expected) data type of X is Y  } UML(2)

_________
¹  It has that property because it implements an (DOM) interface that
   specifies a corresponding attribute.
-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

On Sun, 11 Dec 2016 09:48:34 -0800 (PST), bit-naughty@hotmail.com wrote:
> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e
> is an object, right? And then?

<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model>

Bookmark MDN for future reference.

On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

  <snip>
>Whatever it is the identifier/name of, this entity has a value.  Here, =
that=20
>value is (has to be) a reference to another object.

What Thomas is trying to say is that some ECMAScript implementations
use Java-style references to do this job, even though the ECMAScript
Standard does not insist that they do it that way.


>That object has a property named =93style=94.=B9  That property has a =
value.
>That value is a reference to yet another object.
  <snip>

Ditto.

  John

JJ wrote:

> On Sun, 11 Dec 2016 09:48:34 -0800 (PST), bit-naughty@hotmail.com wrote:
>> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize -
>> e is an object, right? And then?
> 
> <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model>

Sigh. [psf 10.1]

| The content of this article is under discussion. Please provide
| feedback and help us to make this page better: bug 1201380.
 
> Bookmark MDN for future reference.

While it is undoubtedly the best reference material that is available on the 
topic, a lot of work is still to be done there to get rid of the mistakes 
that the Netscape people made in the original JavaScript Guides/References, 
and of the misconceptions people (re)introduced later.  (Just yesterday I 
had to correct yet another “property reference” misconception in the “Deep 
Clone” part of the Object.assign() article.)

At least someone has rewritten the code of the infamously wrong WorkerBee 
example to present a correct emulation of class-based inheritance using 
ECMAScript Ed. 5+ features [1], but the wrong images of it are still there.

[1] <http://stackoverflow.com/a/12593269/855543>
-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

>Tim Slattery wrote:

Tim Slattery is an identifier. Identifiers do not write Usenet
articles; people do. Therefore
  Tim Slattery wrote:
should be
  A person named Tim Slattery wrote:

At least, that's what Thomas says below.


  <snip>
>> "e" is an object. "style" is another object that's part of "e". And
>> "fontSize" is an attribute of "style".
>
>No, that is a common misconception.
>
>=93e=94 is the identifier of a variable or a formal parameter in an =
enclosing=20
>execution context, or the name of a property of an object in the scope=20
>chain.

>Whatever it is the identifier/name of, this entity has a value.
  <snip>

  John

In article <152u4c5l9g1c3og69evu3nre4ov14c3is6@4ax.com>, John Harris
<niam@jghnorth.org.uk.invalid> wrote:

>On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
><PointedEars@web.de> wrote:
>
>>Tim Slattery wrote:
>
>Tim Slattery is an identifier. Identifiers do not write Usenet
>articles; people do. Therefore
>  Tim Slattery wrote:
>should be
>  A person named Tim Slattery wrote:
>
>At least, that's what Thomas says below.

You are overlooking that PointyHead is Humpty Dumpty. And don't forget
what the White Knight (IIRC) had to say on the matter.

-- 
"The problem with defending the purity of the English language is that English
is about as pure as a cribhouse whore. We don't just borrow words; on occasion,
English has pursued other languages down alleyways to beat them unconscious 
and rifle their pockets for new vocabulary."            -- James Nicoll, rasfw

Stefan Ram wrote:
> Think of someone who already knows what one »+« means, as in »2+4«.
> So, he knows, it evaluates to »6«.
> 
> Now he tries to wrap his head around »2+4+3«. He is nonplussed: [ ... ]

plus 1 for the pun.

  -- Scott

John Harris wrote:

> On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
> <PointedEars@web.de> wrote:
>>Tim Slattery wrote:
> 
> Tim Slattery is an identifier. Identifiers do not write Usenet
> articles; people do. Therefore
>   Tim Slattery wrote:
> should be
>   A person named Tim Slattery wrote:
> 
> At least, that's what Thomas says below.

Just when I thought that your arguments could not get more ridiculous…
 
>   <snip>
>>> "e" is an object. "style" is another object that's part of "e". And
>>> "fontSize" is an attribute of "style".
>>
>>No, that is a common misconception.
>>
>>“e” is the identifier of a variable or a formal parameter in an enclosing
>>execution context, or the name of a property of an object in the scope
>>chain.
> 
>>Whatever it is the identifier/name of, this entity has a value.
>   <snip>

  var e = {};
  var f = e;
  var g = e;

  /* true true true */
  console.log(e == f, f == g, e == g);

  /* undefined undefined undefined */
  console.log(e.foo, f.foo, g.foo);

  e.foo = 42;

  /* 42 42 42 */
  console.log(e.foo, f.foo, g.foo);

What is the "magic" that allowed the three "objects" "e", "f", and "g", that 
by your understanding must exist here, to learn of the change of each 
other’s properties?

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

On Tue, 13 Dec 2016 13:51:28 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

>John Harris wrote:
>
>> On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
>> <PointedEars@web.de> wrote:
>>>Tim Slattery wrote:
>>=20
>> Tim Slattery is an identifier. Identifiers do not write Usenet
>> articles; people do. Therefore
>>   Tim Slattery wrote:
>> should be
>>   A person named Tim Slattery wrote:
>>=20
>> At least, that's what Thomas says below.
>
>Just when I thought that your arguments could not get more ridiculous=85

As you don't say which arguments you are talking about no-one knows
what you are trying to say.

=20
>>   <snip>
>>>> "e" is an object. "style" is another object that's part of "e". And
>>>> "fontSize" is an attribute of "style".
>>>
>>>No, that is a common misconception.
>>>
>>>?e? is the identifier of a variable or a formal parameter in an =
enclosing
>>>execution context, or the name of a property of an object in the scope
>>>chain.
>>=20
>>>Whatever it is the identifier/name of, this entity has a value.
>>   <snip>


It is conventional in Usenet to quote the article you are replying to,
not an article on a different subject.

>  var e =3D {};
>  var f =3D e;
>  var g =3D e;
>
>  /* true true true */
>  console.log(e =3D=3D f, f =3D=3D g, e =3D=3D g);
>
>  /* undefined undefined undefined */
>  console.log(e.foo, f.foo, g.foo);
>
>  e.foo =3D 42;
>
>  /* 42 42 42 */
>  console.log(e.foo, f.foo, g.foo);
>
>What is the "magic" that allowed the three "objects" "e", "f", and "g", =
that=20
>by your understanding must exist here, to learn of the change of each=20
>other=92s properties?

It's not magic, you fool, it's the implementation. I'll say that again
as you didn't seem to understand it the first few times : it's the
*implementation* that causes it to do what the ECMAScript Standard
says it must appear to do.

What must it appear to do? It must appear that exactly the same object
is the value of e, and of f, and of g.

  John

John Harris <niam@jghnorth.org.uk.invalid> wrote:

>On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
><PointedEars@web.de> wrote:
>
>>Tim Slattery wrote:
>
>Tim Slattery is an identifier. Identifiers do not write Usenet
>articles; people do. Therefore
>  Tim Slattery wrote:
>should be
>  A person named Tim Slattery wrote:
>
>At least, that's what Thomas says below.

Well said!

-- 
Tim Slattery
tim <at> risingdove <dot> com

On 2016-12-13, Tim Slattery <tim@risingdove.com> wrote:
> John Harris <niam@jghnorth.org.uk.invalid> wrote:
>>Tim Slattery is an identifier. Identifiers do not write Usenet
>>articles; people do. Therefore
>>  Tim Slattery wrote:
>>should be
>>  A person named Tim Slattery wrote:
>>
>>At least, that's what Thomas says below.
>
> Well said!

"Ceci n'est pas un auteur" (The Treachery of Usenet)?

Jon Ribbens <jon+usenet@unequivocal.eu> wrote on 13 Dec 2016 in 
comp.lang.javascript:

> On 2016-12-13, Tim Slattery <tim@risingdove.com> wrote:
>> John Harris <niam@jghnorth.org.uk.invalid> wrote:
>>>Tim Slattery is an identifier. Identifiers do not write Usenet
>>>articles; people do. Therefore
>>>  Tim Slattery wrote:
>>>should be
>>>  A person named Tim Slattery wrote:
>>>
>>>At least, that's what Thomas says below.
>>
>> Well said!
> 
> "Ceci n'est pas un auteur" (The Treachery of Usenet)?

L'auteur, peut-�tre? (La trahison de la tulle d'utilisation)



-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

John Harris wrote:

> On Tue, 13 Dec 2016 13:51:28 +0100, Thomas 'PointedEars' Lahn
> <PointedEars@web.de> wrote:
>>John Harris wrote:
>>> On Sun, 11 Dec 2016 21:47:01 +0100, Thomas 'PointedEars' Lahn
>>> <PointedEars@web.de> wrote:
>>>>Tim Slattery wrote:
>>> 
>>> Tim Slattery is an identifier. Identifiers do not write Usenet
>>> articles; people do. Therefore
>>>   Tim Slattery wrote:
>>> should be
>>>   A person named Tim Slattery wrote:
>>> 
>>> At least, that's what Thomas says below.
>>
>>Just when I thought that your arguments could not get more ridiculous…
> 
> As you don't say which arguments you are talking about no-one knows
> what you are trying to say.

Do you really want the ugliness of all the ad-hominem nonsense you posted 
here over the years exposed?  I don’t think so.

>>>   <snip>
>>>>> "e" is an object. "style" is another object that's part of "e". And
>>>>> "fontSize" is an attribute of "style".
>>>>
>>>>No, that is a common misconception.
>>>>
>>>>?e? is the identifier of a variable or a formal parameter in an
>>>>enclosing execution context, or the name of a property of an object in
>>>>the scope chain.
>>> 
>>>>Whatever it is the identifier/name of, this entity has a value.
>>>   <snip>
> 
> It is conventional in Usenet to quote the article you are replying to,
> not an article on a different subject.

No, it is conventional in Usenet to quote what one is referring to, which I 
did.
 
>>  var e = {};
>>  var f = e;
>>  var g = e;
>>
>>  /* true true true */
>>  console.log(e == f, f == g, e == g);
>>
>>  /* undefined undefined undefined */
>>  console.log(e.foo, f.foo, g.foo);
>>
>>  e.foo = 42;
>>
>>  /* 42 42 42 */
>>  console.log(e.foo, f.foo, g.foo);
>>
>>What is the "magic" that allowed the three "objects" "e", "f", and "g",
>>that by your understanding must exist here, to learn of the change of each
>>other’s properties?
> 
> It's not magic, you fool, it's the implementation.

Once again *you* are the fool.  I put the text in quotes deliberately.

Because there is no magic, as there are no objects named "e", "f", and "g".  

There is only *one* object here, conceptually and its data stored in heap 
memory.  “e”, “f”, and “g” are merely identifiers of variables, each of 
which *currently* holds as value a reference to *one and the same object*:

  var e = {};

                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                            ,-----------------.
    e --------------------> : [object Object] :
                            :-----------------:
                            `-----------------'

  var f = e;

                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                            ,-----------------.
    e --------------------> : [object Object] : <-------------------- f
                            :-----------------:
                            `-----------------'
  var g = e;


                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                            ,-----------------.
    e --------------------> : [object Object] : <-------------------- f
                            :-----------------: <-------------------- g
                            `-----------------'

  e.foo = 42;

                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                           ,--------------------.
    e -------------------> : [object Object]    : <------------------- f
                           :--------------------: <------------------- g
                           : +foo : Number = 42 :
                           `--------------------'

And after

  e = null

we have only

                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                           ,--------------------.
    e = null               : [object Object]    : <------------ f
                           :--------------------: <------------ g
                           : +foo : Number = 42 :
                           `--------------------'

and _not_

                          ,----------------------.
    Object.prototype ---> : [object Object]      :
                          :----------------------:
                          :----------------------:
                          : …                    :
                          : +toString() : String :
                          : +valueOf() : Object  :
                          : …                    :
                          `----------------------'
                                     ^
                                     :
                           ,--------------------.
    e = null               : [object Object]    :               f = null
                           :--------------------:               g = null
                           : +foo : Number = 42 :
                           `--------------------'

But we will have the latter if we also execute

  f = null;
  g = null;

As there are no more references to the object then, it can be marked for 
garbage collection.

Internally, a pointer value addressing the same location in heap memory may 
have been copied on the first assignment to achieve the former and a null 
pointer to achieve the latter, but that is neither required nor an 
implementation necessity (for example, there is Mozilla Rhino, 
an implementation of ECMAScript in Java, where there are no pointers in 
the implementation language); therefore one does not use the term “pointer” 
for this.

Objects have *identity*, not name.

> I'll say that again as you didn't seem to understand it the first few
> times :

ROTFL.  What do you dream of at night?

> it's the *implementation* that causes it to do what the ECMAScript
> Standar says it must appear to do.

You have still not the slightest clue what "the ECMAScript Standard" says.  
Specifically, it does _not_ say that objects implicitly share their 
properties when they are assigned to one another.  But that would be 
necessary to explain this if one assumed that “e”, “f”, and “g” really 
*were* objects or would have an object has their value, and were not just – 
as it actually is – identifiers of variables with a value which is a 
reference to one and the same object.  A value that *can change*.

> What must it appear to do? It must appear that exactly the same object
> is the value of e, and of f, and of g.

And if Santa Claus does not bring you gifts this year, it is because 
Mrs. Claus fed him too well, and he did not make it through the chimney :->

    [Note to readers¹: John Harris is among the most persistent idiots
     around here.  He has been trolling and repeating such nonsense for many
     years, without any attempt to learn the subject he tries to write
     about.  I reply to him only occasionally, as a service to readers who
     may not recognize his mistakes.  He has proven himself to be unable
     and unwilling to learn anything.]

_______
¹  with thanks to Tom Roberts, a physicist posting in sci.physics.ALL
-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

>John Harris wrote:
>
>> On Tue, 13 Dec 2016 13:51:28 +0100, Thomas 'PointedEars' Lahn
>> <PointedEars@web.de> wrote:

  <snip>
>>>  var e =3D {};
>>>  var f =3D e;
>>>  var g =3D e;
>>>
>>>  /* true true true */
>>>  console.log(e =3D=3D f, f =3D=3D g, e =3D=3D g);

  <snip>
>There is only *one* object here, conceptually and its data stored in =
heap=20
>memory.  =93e=94, =93f=94, and =93g=94 are merely identifiers of =
variables, each of=20
>which *currently* holds as value a reference to *one and the same =
object*:
  <snip>

Why does the term  e =3D=3D f  evaluate to true here? Let us see what the
relevant bits of the current ECMAScript Standard (6th ed) say.


Sec 12.10.3 :

  EqualityExpression : EqualityExpression =3D=3D RelationalExpression

  1. Let lref be the result of evaluating EqualityExpression.
  2. Let lval be GetValue(lref).
  ...
  4. Let rref be the result of evaluating RelationalExpression.
  5. Let rval be GetValue(rref).
  ...
  7. Return the result of performing=20
     Abstract Equality Comparison rval =3D=3D lval.


Sec 7.2.12  Abstract Equality Comparison

  The comparison x =3D=3D y, where x and y are values, produces true or
  false. Such a comparison is performed as follows:
  ...
  3. If Type(x) is the same as Type(y), then
     a. Return the result of performing=20
        Strict Equality Comparison x =3D=3D=3D y.
  ...


Sec 7.2.13  Strict Equality Comparison

  The comparison x =3D=3D=3D y, where x and y are values, produces true =
or
  false. Such a comparison is performed as follows:
  ...
  8. If x and y are the same Object value, return true.
  9. Return false.


If there's any doubt about the meaning of "Object value" it is
ultimately what is returned by the internal function ObjectCreate :


Sec 9.1.13  ObjectCreate(proto, internalSlotsList)

  The abstract operation ObjectCreate with argument proto (an=20
  object or null) is used to specify the runtime creation of new=20
  ordinary objects.=20
  ...
  2. Let obj be a newly created object with an internal slot for=20
     each name in internalSlotsList.
  ...
  6. Return obj.


I therefore assert that the ECMAScript Standard does *not* insist that
the values of e and f are Java-style references.

  John

On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

  <snip>
>    [Note to readers=B9: John Harris is among the most persistent idiots
>     around here.  He has been trolling and repeating such nonsense for =
many
>     years, without any attempt to learn the subject he tries to write
>     about.  I reply to him only occasionally, as a service to readers =
who
>     may not recognize his mistakes.  He has proven himself to be unable
>     and unwilling to learn anything.]

[Note to readers(2): This is Thomas Lahn's way of continuing a
 technical discussion. Hey, Ho.]

(2) with thanks to no-one.

  John

On Sunday, December 11, 2016 at 11:48:40 AM UTC-6, bit-n...@hotmail.com wrote:
> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e is an object, right? And then?

Guys, please stop fighting, I'm just trying to understand.

So - I'm going with the first answer to my reply - is that information correct? i.e "e" is an object, "style" is an object inside it, and "fontSize" is a property of THAT object.....?

On 14.12.2016 at 18:33, bit-naughty@hotmail.com wrote:

> On Sunday, December 11, 2016 at 11:48:40 AM UTC-6, bit-n...@hotmail.com wrote:
>> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize - e is an object, right? And then?
> 
> Guys, please stop fighting, I'm just trying to understand.
> 
> So - I'm going with the first answer to my reply - is that information correct? i.e "e" is an object, "style" is an object inside it, and "fontSize" is a property of THAT object.....?

Why don't you verify that yourself?  In a browser it might be as simple as:

  console.log(e, e.style, e.style.fontSize);

-- 
Christoph M. Becker

John Harris wrote:

> On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
> <PointedEars@web.de> wrote:
>>John Harris wrote:
>>> On Tue, 13 Dec 2016 13:51:28 +0100, Thomas 'PointedEars' Lahn
>>> <PointedEars@web.de> wrote:
>   <snip>
>>>>  var e = {};
>>>>  var f = e;
>>>>  var g = e;
>>>>
>>>>  /* true true true */
>>>>  console.log(e == f, f == g, e == g);
> 
>   <snip>
>>There is only *one* object here, conceptually and its data stored in heap
>>memory.  “e”, “f”, and “g” are merely identifiers of variables, each of
>>which *currently* holds as value a reference to *one and the same object*:
>   <snip>
> 
> Why does the term  e == f  evaluate to true here?

Because (type conversion with “==” notwithstanding; use “===” to avoid this 
condition for anything but +0 vs. -0) “e” and “f” hold the same value.  In 
this case they hold the same reference value, which is therefore referring 
to the same object.  Or, more loosely speaking, they *refer* to the same 
object (but they *are* _not_ objects).  That was easy.

Here is another example:

  var o = {};
  (function (p) { p.answer = 42; }(o));

  /* 42 */
  console.log(o.answer);

If an object (value) would be passed/copied here instead of an object 
reference (value), then “o.answer” would not yield “42”.  Because there is 
no call-by-reference in these languages, only call-by-value, and “p” is a 
local symbol.  (And to assume that the implementation is required to make 
the link from “p” to “o” outside the local execution context, as you did 
before, is outright ridiculous.)

> Let us see what the relevant bits of the current ECMAScript Standard (6th
> ed) say.

Current is the 7th edition, ECMAScript 2016:

<http://ecma-international.org/publications/standards/Ecma-262.htm>

And there have been implementations of editions before that; so, at most, 
what you are quoting applies to previous-to-current versions of 
implementations.
 
> […]
> Sec 7.2.13  Strict Equality Comparison
> 
>   The comparison x === y, where x and y are values, produces true or
                     ^^^
>   false. Such a comparison is performed as follows:
>   ...
>   8. If x and y are the same Object value, return true.
>   9. Return false.

First of all, wrong section for this code.
 
> If there's any doubt about the meaning of "Object value" it is
> ultimately what is returned by the internal function ObjectCreate :
> 
> 
> Sec 9.1.13  ObjectCreate(proto, internalSlotsList)
> 
>   The abstract operation ObjectCreate with argument proto (an
>   object or null) is used to specify the runtime creation of new
>   ordinary objects.
>   ...
>   2. Let obj be a newly created object with an internal slot for
>      each name in internalSlotsList.
>   ...
>   6. Return obj.

Second, there is no definition of “Object value” there.

Third, you could have realized by now that this is deliberately *abstract* 
language and implementations do not follow this to the letter.  Oh wait, 
you did, but only *when it fit your argument*.

“Learn to know what is from what seems to be, and what you wish to be.”
 
> I therefore assert that the ECMAScript Standard does *not* insist that
> the values of e and f are Java-style references.

Nor does it say the opposite.  And Java is by far not the only object-
oriented programming language, nor was it the first of its kind, in which 
objects are handled with references to them.

You just have to start looking above your limited C++ horizon – one 
hopes that this is the reason for your fairytales – where an assignment 
between variables *declared* to be of an object type means something very 
different, and objects are handled very differently (I am just saying 
“object slicing”).

Because it simply does not make sense for an *efficient* implementation to 
create more than one object here inasfar as to allocate memory for the same 
data multiple times *by default* (and you have to go to great lengths to 
really *clone* an object in the languages we are discussing here).  
Especially not when a program is running *within the constraints of 
another*, the Web browser/HTML UA originally.  It makes much more sense to 
pass reference/pointer values around, compare those, and dereference them 
when necessary (property access).  Occam’s Razor.

But go ahead, do memory benchmarks and UTSL, and surprise me with an actual 
finding (instead of your claims based on misconceptions and gut feelings) 
that any implementation of ECMAScript allocates memory for more than one 
*Object* instance here, that it keeps a registry which variable referred to 
which instead of handling references to objects.  Because that would be 
required for your idea to even resemble reality.

I can already tell you one implementation of ECMAScript to which your idea 
does not apply: Mozilla JavaScript.

Hopefully you will *finally* see the light after reading

<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management>

(_not_ written by me.)

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

John Harris wrote:

> On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
> <PointedEars@web.de> wrote:
>   <snip>
>>    [Note to readers¹: John Harris is among the most persistent idiots
>>     around here.  He has been trolling and repeating such nonsense for
>>     many years, without any attempt to learn the subject he tries to
>>     write about.  I reply to him only occasionally, as a service to
>>     readers who may not recognize his mistakes.  He has proven himself
>>     to be unable and unwilling to learn anything.]
> 
> [Note to readers(2): This is Thomas Lahn's way of continuing a
>  technical discussion. Hey, Ho.]
> 
> (2) with thanks to no-one.

There, you are doing it again.  And you really wonder why I cannot take you 
seriously?

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

bit-naughty@hotmail.com wrote:

> On Sunday, December 11, 2016 at 11:48:40 AM UTC-6, bit-n...@hotmail.com
> wrote:
>> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize -
>> e is an object, right? And then?
> 
> Guys, please stop fighting, I'm just trying to understand.
> 
> So - I'm going with the first answer to my reply - is that information
> correct? i.e "e" is an object, "style" is an object inside it,

No.

> and "fontSize" is a property of THAT object.....?

Yes.

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

Christoph M. Becker wrote:

> On 14.12.2016 at 18:33, bit-naughty@hotmail.com wrote:
>> So - I'm going with the first answer to my reply - is that information
>> correct? i.e "e" is an object, "style" is an object inside it, and
>> "fontSize" is a property of THAT object.....?
> 
> Why don't you verify that yourself?  In a browser it might be as simple
> as:
> 
>   console.log(e, e.style, e.style.fontSize);

Partial ACK.  Modern browsers have script consoles that allow one to 
inspect referred objects there even in the output of the console.log() 
method.

However, the simplified way in which this is presented might actually 
enforce the misconception of a beginner that objects would reside inside 
other objects, and that property accessors were merely a way to “reach 
deeper inside” an object.

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

bit-naughty@hotmail.com wrote:
^^^^^^^^^^^^^^^^^^^^^^^
Please post using your real name.  Usenet is the thing with people.

[Attribution novel trimmed, see 
<https://www.netmeister.org/news/learn2quote.html>]

> [?] bit-n...@hotmail.com wrote:
>> What does TWO dots mean in Javascript, exactly? Like, e.style.fontSize -
>> e is an object, right? And then?
> 
> Guys, please stop fighting, I'm just trying to understand.
> 
> So - I'm going with the first answer to my reply - is that information
> correct? i.e "e" is an object, "style" is an object inside it,

Still *NO* (you need to ignore the attacks and read more carefully; 
especially my postings which contain *illustrations* of this, even though 
they are longer because of that).

Objects have identity, _not_ name.

And objects do _not_ reside inside other objects.  (At least not in these 
languages.)  But object?s properties(? values) can refer to (can hold 
references to) other objects which can make it appear this way if you
are not looking closely.

> and "fontSize" is a property of THAT object.....?

Yes.

-- 
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

On Wed, 14 Dec 2016 19:26:12 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

>John Harris wrote:
>
>> On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
>> <PointedEars@web.de> wrote:
>>>John Harris wrote:
>>>> On Tue, 13 Dec 2016 13:51:28 +0100, Thomas 'PointedEars' Lahn
>>>> <PointedEars@web.de> wrote:
>>   <snip>
>>>>>  var e =3D {};
>>>>>  var f =3D e;
>>>>>  var g =3D e;
>>>>>
>>>>>  /* true true true */
>>>>>  console.log(e =3D=3D f, f =3D=3D g, e =3D=3D g);

  <snip>
>> Why does the term  e =3D=3D f  evaluate to true here?
>
>Because (type conversion with =93=3D=3D=94 notwithstanding; use =
=93=3D=3D=3D=94 to avoid this=20
>condition for anything but +0 vs. -0) =93e=94 and =93f=94 hold the same =
value.  In=20
>this case they hold the same reference value,=20
  <snip

Where in any edition of ECMA 262 does it say they hold a "reference
value" ?


  <snip>
>> Let us see what the relevant bits of the current ECMAScript Standard =
(6th
>> ed) say.
>
>Current is the 7th edition, ECMAScript 2016:

Thank you for bringing that to our attention. As it happens, although
several sections have been renumbered and one split in two since the
6th edition, the text that is relevant here has not changed.


>> [=85]
>> Sec 7.2.13  Strict Equality Comparison
>>=20
>>   The comparison x =3D=3D=3D y, where x and y are values, produces =
true or
>                     ^^^
>>   false. Such a comparison is performed as follows:
>>   ...
>>   8. If x and y are the same Object value, return true.
>>   9. Return false.
>
>First of all, wrong section for this code.

7.2.13 Abstract Equality Comparison calls 7.2.14 Strict Equality
Comparison which now calls 7.2.11 SameValueNonNumber, so it is the
right section for this code, as should have been obvious.

=20
>> If there's any doubt about the meaning of "Object value" it is
>> ultimately what is returned by the internal function ObjectCreate :
>>=20
>>=20
>> Sec 9.1.13  ObjectCreate(proto, internalSlotsList)
>>=20
>>   The abstract operation ObjectCreate with argument proto (an
>>   object or null) is used to specify the runtime creation of new
>>   ordinary objects.
>>   ...
>>   2. Let obj be a newly created object with an internal slot for
>>      each name in internalSlotsList.
>>   ...
>>   6. Return obj.
>
>Second, there is no definition of =93Object value=94 there.

I wrote "ultimately". There is a long, long list of specification
functions that copy obj. Eventually it is this that is copied into the
values of e and f and retrieved during evaluation of  e =3D=3D f.

There is no place where obj is described as being replaced by
'reference to obj'.


>Third, you could have realized by now that this is deliberately =
*abstract*=20
>language and implementations do not follow this to the letter. =20

I've been saying that its the Standard's language for months now. I've
also mentioned the obvious : that an implementations job is to
implement it in a way that can't be distinguished from what the
Standard says.


>Oh wait,=20
>you did, but only *when it fit your argument*.

But what you haven't understood yet is that one way to implement it is
not the only way. Therefore it is wrong to discourage people from
using the Standard's language.

Or have you proved beyond all possible doubt that no-one in the
Universe can possibly think up another way to implement it. Even if
you have it's wrong to move people away from the Standard's language.


  <snip>
>Because it simply does not make sense for an *efficient* implementation =
to=20

There you go - implementation.


  <snip>
><https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Manageme=
nt>

That page uses a different meaning of "reference".


HTH
  John

On Tue, 13 Dec 2016 20:23:35 +0100, Thomas 'PointedEars' Lahn
<PointedEars@web.de> wrote:

  <snip>
>Do you really want the ugliness of all the ad-hominem nonsense you =
posted=20
>here over the years exposed?  I don=92t think so.
  <snip>

Wrong. I'd be delighted. Unfortunately it seems that you don't know
what ad hominem is, so here is a little tutorial.

An example of an ad hominem argument would be
  You are a fool, *therefore* you are wrong.

An example that is not would be
  You are a fool *and* you are wrong.
This is not an ad hominem argument, simply because it is not an
argument. It is a plain statement. It is possibly a minority opinion,
possibly malicious, or, indeed, possibly the opinion of nearly
everyone.=20

  John

John Harris <niam@jghnorth.org.uk.invalid> wrote on 15 Dec 2016 in 
comp.lang.javascript:

> <PointedEars@web.de> wrote:
> 
>   <snip>
>> Do you really want the ugliness of all the ad-hominem nonsense 
>> you posted 
>> here over the years exposed?  I don't think so.
>   <snip>
> 
> Wrong. I'd be delighted. Unfortunately it seems that you don't know
> what ad hominem is, so here is a little tutorial.
> 
> An example of an ad hominem argument would be
>   You are a fool, *therefore* you are wrong.
> 
> An example that is not would be
>   You are a fool *and* you are wrong.
> This is not an ad hominem argument, simply because it is not an
> argument. It is a plain statement. It is possibly a minority opinion,
> possibly malicious, or, indeed, possibly the opinion of nearly
> everyone. 

Wrong! 

You cannot define something by examples.

A [good, imho] definition of "ad hominem" is:

Attacking your opponent's character or personal traits in an attempt to 
undermine their argument.



-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Thu, 15 Dec 2016 16:16:20 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>John Harris <niam@jghnorth.org.uk.invalid> wrote on 15 Dec 2016 in 
>comp.lang.javascript:
>
>> <PointedEars@web.de> wrote:
>> 
>>   <snip>
>>> Do you really want the ugliness of all the ad-hominem nonsense 
>>> you posted 
>>> here over the years exposed?  I don't think so.
>>   <snip>
>> 
>> Wrong. I'd be delighted. Unfortunately it seems that you don't know
>> what ad hominem is, so here is a little tutorial.
>> 
>> An example of an ad hominem argument would be
>>   You are a fool, *therefore* you are wrong.
>> 
>> An example that is not would be
>>   You are a fool *and* you are wrong.
>> This is not an ad hominem argument, simply because it is not an
>> argument. It is a plain statement. It is possibly a minority opinion,
>> possibly malicious, or, indeed, possibly the opinion of nearly
>> everyone. 

     Nicely written, sir!

>Wrong! 
>
>You cannot define something by examples.

     Sure you can.  You just have to get all of the examples.  It is
called an extensional definition.  See
          https://en.wikipedia.org/wiki/Extensional_definition

>A [good, imho] definition of "ad hominem" is:
>
>Attacking your opponent's character or personal traits in an attempt to 
>undermine their argument.

     And Mr. Harris's examples make the distinction.

Sincerely,

Gene Wirchenko

Gene Wirchenko <genew@telus.net> wrote on 15 Dec 2016 in 
comp.lang.javascript:

>>You cannot define something by examples.
> 
>      Sure you can.  You just have to get all of the examples.  It is
> called an extensional definition.  See
>           https://en.wikipedia.org/wiki/Extensional_definition

This is essentially nonsense, because then you would have to define the 
concept as limited to the examples, [the limitation of the 'extension'], 
which part of the definition is not an example in itself.

>>>A [good, imho] definition of "ad hominem" is:
>>
>> Attacking your opponent's character or personal traits in an attempt to
>> undermine their argument.

>  And Mr. Harris's examples make the distinction.

What distinction?

Using "ad hominem" is both a vile and a falacious argumentation.

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Thu, 15 Dec 2016 16:16:20 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>John Harris <niam@jghnorth.org.uk.invalid> wrote on 15 Dec 2016 in=20
>comp.lang.javascript:
>
>> <PointedEars@web.de> wrote:
>>=20
>>   <snip>
>>> Do you really want the ugliness of all the ad-hominem nonsense=20
>>> you posted=20
>>> here over the years exposed?  I don't think so.
>>   <snip>
>>=20
>> Wrong. I'd be delighted. Unfortunately it seems that you don't know
>> what ad hominem is, so here is a little tutorial.
>>=20
>> An example of an ad hominem argument would be
>>   You are a fool, *therefore* you are wrong.
>>=20
>> An example that is not would be
>>   You are a fool *and* you are wrong.
>> This is not an ad hominem argument, simply because it is not an
>> argument. It is a plain statement. It is possibly a minority opinion,
>> possibly malicious, or, indeed, possibly the opinion of nearly
>> everyone.=20
>
>Wrong!=20
>
>You cannot define something by examples.

Well, I did say it was a *little* tutorial :-)

  John

John Harris <niam@jghnorth.org.uk.invalid> wrote on 16 Dec 2016 in 
comp.lang.javascript:

> On Thu, 15 Dec 2016 16:16:20 +0100, "Evertjan."
> <exxjxw.hannivoort@inter.nl.net> wrote:
> 
>>John Harris <niam@jghnorth.org.uk.invalid> wrote on 15 Dec 2016 in 
>>comp.lang.javascript:
>>
>>> <PointedEars@web.de> wrote:
>>> 
>>>   <snip>
>>>> Do you really want the ugliness of all the ad-hominem nonsense 
>>>> you posted 
>>>> here over the years exposed?  I don't think so.
>>>   <snip>
>>> 
>>> Wrong. I'd be delighted. Unfortunately it seems that you don't know
>>> what ad hominem is, so here is a little tutorial.
>>> 
>>> An example of an ad hominem argument would be
>>>   You are a fool, *therefore* you are wrong.
>>> 
>>> An example that is not would be
>>>   You are a fool *and* you are wrong.
>>> This is not an ad hominem argument, simply because it is not an
>>> argument. It is a plain statement. It is possibly a minority opinion,
>>> possibly malicious, or, indeed, possibly the opinion of nearly
>>> everyone. 
>>
>>Wrong! 
>>
>>You cannot define something by examples.
> 
> Well, I did say it was a *little* tutorial :-)

ACK.


-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Fri, 16 Dec 2016 09:07:37 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 15 Dec 2016 in 
>comp.lang.javascript:
>
>>>You cannot define something by examples.
>> 
>>      Sure you can.  You just have to get all of the examples.  It is
>> called an extensional definition.  See
>>           https://en.wikipedia.org/wiki/Extensional_definition
>
>This is essentially nonsense, because then you would have to define the 
>concept as limited to the examples, [the limitation of the 'extension'], 
>which part of the definition is not an example in itself.

     Of course, the concept is limited to the examples.  That is the
way the extensional definitions work, being definition by examples. If
there were not enough examples, then the definition is not complete.
Extensional definitions work just fine with limited sets such even
primes and single-digit squares.

>>>>A [good, imho] definition of "ad hominem" is:
>>>
>>> Attacking your opponent's character or personal traits in an attempt to
>>> undermine their argument.
>
>>  And Mr. Harris's examples make the distinction.
>
>What distinction?

     The distinction between argument and arguer.

>Using "ad hominem" is both a vile and a falacious argumentation.

     A good thing that we are not using it then, eh?

Sincerely,

Gene Wirchenko

Gene Wirchenko <genew@telus.net> wrote on 16 Dec 2016 in 
comp.lang.javascript:

>>Using "ad hominem" is both a vile and a falacious argumentation.
> 
>      A good thing that we are not using it then, eh?

Right you are!

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
posted:

>A [good, imho] definition of "ad hominem" is:
>
>Attacking your opponent's character or personal traits in an attempt to
>undermine their argument.

Does that agree with
        <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?

-- 
 (c) John Stockton, Surrey, UK.  �@merlyn.demon.co.uk   Turnpike v6.05   MIME.
 Merlyn Web Site <                       > - FAQish topics, acronyms, & links.

Dr J R Stockton <reply1600@merlyn.demon.co.uk.invalid> wrote on 17 Dec 2016 
in comp.lang.javascript:

> In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
> Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
> posted:
> 
>>A [good, imho] definition of "ad hominem" is:
>>
>>Attacking your opponent's character or personal traits in an attempt to
>>undermine their argument.
> 
> Does that agree with
>         <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?

Does it?

Should it [need to be]?


-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Sat, 17 Dec 2016 20:40:58 +0000, Dr J R Stockton
<reply1600@merlyn.demon.co.uk.invalid> wrote:

>In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
>Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
>posted:
>
>>A [good, imho] definition of "ad hominem" is:
>>
>>Attacking your opponent's character or personal traits in an attempt to
>>undermine their argument.
>
>Does that agree with
>        <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?

     Who knows?  Someone who can read Latin.

     I went for the English version, and I think "it" matches fairly
well.  (It does miss the case of those traits being relevant to the
argument.)

Sincerely,

Gene Wirchenko

Gene Wirchenko <genew@telus.net> wrote on 19 Dec 2016 in 
comp.lang.javascript:

> On Sat, 17 Dec 2016 20:40:58 +0000, Dr J R Stockton
> <reply1600@merlyn.demon.co.uk.invalid> wrote:
> 
>>In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
>>Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
>>posted:
>>
>>>A [good, imho] definition of "ad hominem" is:
>>>
>>>Attacking your opponent's character or personal traits in an attempt to
>>>undermine their argument.
>>
>>Does that agree with
>>        <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?
> 
>      Who knows?  Someone who can read Latin.
> 
>      I went for the English version, and I think "it" matches fairly
> well.  (It does miss the case of those traits being relevant to the
> argument.)

Discussion should be based on evidence and logic, 
and of an agreed understanding of relevant definitions.

Argumenting by authority or dogma is not sound.

So if you want to use a different definition of 'Argumentum ad hominem',
do so in discussion, not by pointing to sources in an attempt
to "proove" the "right definition". That's what religions do/are for.

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

In comp.lang.javascript message <XnsA6E26D806DA37eejj99@194.109.6.166>,
Sun, 18 Dec 2016 10:45:51, Evertjan. <exxjxw.hannivoort@inter.nl.net>
posted:

>Dr J R Stockton <reply1600@merlyn.demon.co.uk.invalid> wrote on 17 Dec 2016
>in comp.lang.javascript:
>
>> In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
>> Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
>> posted:
>>
>>>A [good, imho] definition of "ad hominem" is:
>>>
>>>Attacking your opponent's character or personal traits in an attempt to
>>>undermine their argument.
>>
>> Does that agree with
>>         <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?
>
>Does it?
>
>Should it [need to be]?

Certainly it should agree, and modern usage should agree with the
original.  The expression should not be misused in the way that
"decimated" now is by /hoi polloi/.  But ISTR that your Latin is better
than mine.

-- 
 (c) John Stockton, Surrey, UK.  �@merlyn.demon.co.uk   Turnpike v6.05   MIME.
 Merlyn Web Site <                       > - FAQish topics, acronyms, & links.

On Mon, 19 Dec 2016 19:55:29 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 19 Dec 2016 in 
>comp.lang.javascript:
>
>> On Sat, 17 Dec 2016 20:40:58 +0000, Dr J R Stockton
>> <reply1600@merlyn.demon.co.uk.invalid> wrote:
>> 
>>>In comp.lang.javascript message <XnsA6DFA5882E690eejj99@194.109.6.166>,
>>>Thu, 15 Dec 2016 16:16:20, Evertjan. <exxjxw.hannivoort@inter.nl.net>
>>>posted:
>>>
>>>>A [good, imho] definition of "ad hominem" is:
>>>>
>>>>Attacking your opponent's character or personal traits in an attempt to
>>>>undermine their argument.
>>>
>>>Does that agree with
>>>        <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?
>> 
>>      Who knows?  Someone who can read Latin.
>> 
>>      I went for the English version, and I think "it" matches fairly
>> well.  (It does miss the case of those traits being relevant to the
>> argument.)
>
>Discussion should be based on evidence and logic, 
>and of an agreed understanding of relevant definitions.
>
>Argumenting by authority or dogma is not sound.
>
>So if you want to use a different definition of 'Argumentum ad hominem',
>do so in discussion, not by pointing to sources in an attempt
>to "proove" the "right definition". That's what religions do/are for.

     Sources can include definitions.  That one did.

Sincerely,

Gene Wirchenko

On 20/12/2016 6:15 AM, Dr J R Stockton wrote:

> Certainly it should agree, and modern usage should agree with the
> original.  The expression should not be misused in the way that
> "decimated" now is by /hoi polloi/.

"Hoi polloi" actually means "the majority" but I suspect you're using it 
to mean "the many".

Andrew Poulos

Gene Wirchenko <genew@telus.net> wrote on 20 Dec 2016 in 
comp.lang.javascript:

>>So if you want to use a different definition of 'Argumentum ad hominem',
>>do so in discussion, not by pointing to sources in an attempt
>>to "proove" the "right definition". That's what religions do/are for.
> 
>      Sources can include definitions.  That one did.
> 

Quite.

But rather than accepting such definition because of authority,
and Wikipedia does not even claim to be such an authority,
in a discussion it suffices to agree upon a definition,
than to argue over its "trueness".

Example: If we both agree the sun to be a mouse, that is still better for a 
fruitfull discussion, than that one of us would claim the sun to be just one 
of a type of heavenly bodies among miriads and the other that it is the 
single true god. 

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

Dr J R Stockton <reply1600@merlyn.demon.co.uk.invalid> wrote on 19 Dec
2016 in comp.lang.javascript: 

> In comp.lang.javascript message <XnsA6E26D806DA37eejj99@194.109.6.166>,
> Sun, 18 Dec 2016 10:45:51, Evertjan. <exxjxw.hannivoort@inter.nl.net>
> posted:
> 
>>Dr J R Stockton <reply1600@merlyn.demon.co.uk.invalid> wrote on 17 Dec
>>2016 in comp.lang.javascript:
>>
>>> In comp.lang.javascript message
>>> <XnsA6DFA5882E690eejj99@194.109.6.166>, Thu, 15 Dec 2016 16:16:20,
>>> Evertjan. <exxjxw.hannivoort@inter.nl.net> posted:
>>>
>>>>A [good, imho] definition of "ad hominem" is:
>>>>
>>>>Attacking your opponent's character or personal traits in an attempt
>>>>to undermine their argument.
>>>
>>> Does that agree with
>>>         <https://la.wikipedia.org/wiki/Argumentum_ad_hominem> ?
>>
>>Does it?
>>
>>Should it [need to be]?
> 
> Certainly it should agree, and modern usage should agree with the
> original.  The expression should not be misused in the way that
> "decimated" now is by /hoi polloi/. 

That would be an extreme [polluted/pollinated?] example. 

> But ISTR that your Latin is better than mine.

Thank you, John, for your trust, I like such a positive ad-hominem remark.

However, I did not read the la.wikipedia.org article, just because
methinks such agreement is just surmised autority and would not add to the
subject, if it agrees, because then I would think probable the Latin
version to be just a translation of a modern [en,fr,nl,du,etc] one. 

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

Andrew Poulos <ap_prog@hotmail.com> wrote on 20 Dec 2016 in 
comp.lang.javascript:

> "Hoi polloi" actually means "the majority" but I suspect you're using it 
> to mean "the many".

You are wrong, it isn't Swahili, in Greek it means "the many".

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Tue, 20 Dec 2016 11:28:27 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 20 Dec 2016 in 
>comp.lang.javascript:
>
>>>So if you want to use a different definition of 'Argumentum ad hominem',
>>>do so in discussion, not by pointing to sources in an attempt
>>>to "proove" the "right definition". That's what religions do/are for.
>> 
>>      Sources can include definitions.  That one did.
>> 
>
>Quite.
>
>But rather than accepting such definition because of authority,
>and Wikipedia does not even claim to be such an authority,
>in a discussion it suffices to agree upon a definition,
>than to argue over its "trueness".

     Posting a reference to a definition that it is a reasonable
assumption that some person/people worked on for a while to get right
is useful.  A half-definition which does not cover corner cases does
not make for good discussion.

>Example: If we both agree the sun to be a mouse, that is still better for a 
>fruitfull discussion, than that one of us would claim the sun to be just one 
>of a type of heavenly bodies among miriads and the other that it is the 
>single true god. 

     I would like to know what definition someone is operating off of.
Referring to outside authority and implicitly asking if that is what
he is operating off of is useful.

Sincerely,

Gene Wirchenko

On 20/12/2016 9:39 PM, Evertjan. wrote:
> Andrew Poulos <ap_prog@hotmail.com> wrote on 20 Dec 2016 in
> comp.lang.javascript:
>
>> "Hoi polloi" actually means "the majority" but I suspect you're using it
>> to mean "the many".
>
> You are wrong, it isn't Swahili, in Greek it means "the many".
>
When hoi polloi is used in English it can have other meanings as well 
including "ordinary people", "the common people", "multitude", "the 
masses", "the snobby elite"...

Andrew Poulos

Gene Wirchenko <genew@telus.net> wrote on 20 Dec 2016 in
comp.lang.javascript: 

>      Posting a reference to a definition that it is a reasonable
> assumption that some person/people worked on for a while to get right
> is useful.  A half-definition which does not cover corner cases does
> not make for good discussion.

What nonsense, a definition is the cornerstone of a definition.

[.]
>      I would like to know what definition someone is operating off of.
> Referring to outside authority and implicitly asking if that is what
> he is operating off of is useful.

I never "operate off", let alone "operate off of", 
and authority, also named faith, is always inferior to reason,
since it must imply the acceptance of undeclared reasoning.

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

Andrew Poulos <ap_prog@hotmail.com> wrote on 20 Dec 2016 in 
comp.lang.javascript:

> On 20/12/2016 9:39 PM, Evertjan. wrote:
>> Andrew Poulos <ap_prog@hotmail.com> wrote on 20 Dec 2016 in
>> comp.lang.javascript:
>>
>>> "Hoi polloi" actually means "the majority" but I suspect you're using it
>>> to mean "the many".
>>
>> You are wrong, it isn't Swahili, in Greek it means "the many".
>>
> When hoi polloi is used in English it can have other meanings as well 
> including "ordinary people", "the common people", "multitude", "the 
> masses", "the snobby elite"...

"Used in English" does not mean "actually means".

There are many foreign frases that are misused in English by miniglots.

How is your Swahili, btw?

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

In article <XnsA6E59DBCD57eejj99@194.109.6.166>, Evertjan.
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 20 Dec 2016 in
>comp.lang.javascript: 
>
>>      Posting a reference to a definition that it is a reasonable
>> assumption that some person/people worked on for a while to get right
>> is useful.  A half-definition which does not cover corner cases does
>> not make for good discussion.
>
>What nonsense, a definition is the cornerstone of a definition.
>
>[.]
>>      I would like to know what definition someone is operating off of.
>> Referring to outside authority and implicitly asking if that is what
>> he is operating off of is useful.
>
>I never "operate off", let alone "operate off of", 

This is perfectly good English if somewhat clumsy. One might rather say
"operating from" or "operating with".

-- 
"It is hard to imagine a more stupid decision or more dangerous way of 
making decisions than by putting those decisions in the hands of people 
who pay no price for being wrong."  --  Thomas Sowell

On Wed, 21 Dec 2016 00:03:38 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 20 Dec 2016 in
>comp.lang.javascript: 
>
>>      Posting a reference to a definition that it is a reasonable
>> assumption that some person/people worked on for a while to get right
>> is useful.  A half-definition which does not cover corner cases does
>> not make for good discussion.
>
>What nonsense, a definition is the cornerstone of a definition.
>
>[.]
>>      I would like to know what definition someone is operating off of.
>> Referring to outside authority and implicitly asking if that is what
>> he is operating off of is useful.
>
>I never "operate off", let alone "operate off of", 
>and authority, also named faith, is always inferior to reason,
>since it must imply the acceptance of undeclared reasoning.

     Since I did not invent the term, I must use some external source.
There is no way to reason a definition of that sort.

Sincerely,

Gene Wirchenko

Gene Wirchenko <genew@telus.net> wrote on 21 Dec 2016 in 
comp.lang.javascript:

>>I never "operate off", let alone "operate off of", 
>>and authority, also named faith, is always inferior to reason,
>>since it must imply the acceptance of undeclared reasoning.
> 
>      Since I did not invent the term, I must use some external source.
> There is no way to reason a definition of that sort.

Well, you could discuss a definition of a word or term,
but more often in a discussion it is about using a definition,
where it suffice to have a mutual agreement about such word.

The art of discussing is more awarding than the silly fight over a "true" 
definition. Shakespeare already smelled that.

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

Tim Streater <timstreater@greenbee.net> wrote on 21 Dec 2016 in 
comp.lang.javascript:

>>I never "operate off", let alone "operate off of", 
> 
> This is perfectly good English if somewhat clumsy. One might rather say
> "operating from" or "operating with".

Well, if clumsiness were "perfectly" good ...

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)

On Wed, 21 Dec 2016 10:01:01 +0100, "Evertjan."
<exxjxw.hannivoort@inter.nl.net> wrote:

>Gene Wirchenko <genew@telus.net> wrote on 21 Dec 2016 in 
>comp.lang.javascript:
>
>>>I never "operate off", let alone "operate off of", 
>>>and authority, also named faith, is always inferior to reason,
>>>since it must imply the acceptance of undeclared reasoning.
>> 
>>      Since I did not invent the term, I must use some external source.
>> There is no way to reason a definition of that sort.
>
>Well, you could discuss a definition of a word or term,
>but more often in a discussion it is about using a definition,
>where it suffice to have a mutual agreement about such word.

     And something posted on a Website might go into more detail.  It
is convenient to refer to such instead of typing it all in myself.

>The art of discussing is more awarding than the silly fight over a "true" 
>definition. Shakespeare already smelled that.

     So why do it?

Sincerely,

Gene Wirchenko

Gene Wirchenko <genew@telus.net> wrote on 21 Dec 2016 in 
comp.lang.javascript:

>>The art of discussing is more awarding than the silly fight over a "true" 
>>definition. Shakespeare already smelled that.
> 
>      So why do it?
> 

Do what? Smell? Discuss?

-- 
Evertjan.
The Netherlands.
(Please change the x'es to dots in my emailaddress)