Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:92901
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 74.125.82.47 as permitted sender)
To: internals@lists.php.net
References: <57211D05.6020002@fleshgrinder.com>
 <a266302a-1ad1-2e98-5be2-8c9b0eb7effc@gmail.com>
 <57224957.8090504@fleshgrinder.com>
 <5d8ef1e6-1d08-bf12-b481-4f72af3f6dd9@gmail.com>
 <5722629A.4050001@fleshgrinder.com>
Message-ID: <86108010-26a4-0f68-580d-6d3357ad3f7e@gmail.com>
Date: Thu, 28 Apr 2016 20:43:39 +0100
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:45.0) Gecko/20100101
 Thunderbird/45.0
MIME-Version: 1.0
In-Reply-To: <5722629A.4050001@fleshgrinder.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Subject: Re: [PHP-DEV] [RFC] PHP Annotations VS Attributes
From: rowan.collins@gmail.com (Rowan Collins)

Fleshgrinder wrote on 28/04/2016 20:20:
> On 4/28/2016 8:02 PM, Rowan Collins wrote:
>> Interesting; do you have a link to where this terminology is explained?
>> Most of the articles I've seen just refer to "attributes", and the link
>> you have doesn't really explain that at all, it has namespaces with
>> "annotation" in the name, but uses the word "attribute" everywhere in
>> the actual text.
>>
> Yes, I provided many in the initial message, the Wikipedia link [1]
> explains it in detail and you may use it as reference for all the other
> questions you have here, since it answers all of them.

I meant specifically in the context of C#/.net. You claimed a very 
specific usage within that framework, but all the articles I can find 
refer to them consistently as "attributes" in that context. Event the 
Wikipedia article:

 > In the C# programming language, attributes are [...] equivalent to 
annotations in Java.

That's pretty clear to me that the two languages call the same concept 
different things.


> The word construct "attribute specification" is completely right, it
> specifies which attribute should be applied to the data.

But it completely disagrees with your earlier claim that "The result of 
an annotation is an attribute." There is absolutely no usage of 
"annotation" in that page; there is just a description of syntax for 
applying "attributes".


>
> Method modifiers are a more specialized form of attributes and it makes
> sense to refer to them as such because it is less ambiguous than the
> word attributes.

It may make sense, but can you point me to any C#/.net documentation 
which describes that relationship? I'm talking about actual usage here, 
not theoretical definitions.


> As I said in the initial message, using the term /attribute/ is pretty
> much never wrong because the term /attribute/ is so generic. :P

What kind of answer is that? The page clearly describes a Perl feature 
very similar to the feature proposed for PHP, and it very clearly calls 
it "attributes". If it's "never wrong" for Perl, surely it's "never 
wrong" for PHP either?


> Actually I checked the dictionaries for the actual definition. This is
> also how I documented it in the initial message. All additional language
> links were only used to proof that Java is not the only language that
> uses the term and that the term is always used in the context.

I have already pointed out that 3 of those links do not back up your 
claim. You appear to dispute this, but I'm increasingly unclear on what 
grounds.

You are perfectly entitled to the opinion that C#, Perl, and Rust are 
*wrong* in their usage of the term, but they absolutely use that term in 
the same way as Hack, not in the way you wish to define it.


> That is why there is an empty line between the pages that are actually
> documenting the usage of an annotation functionality and the pages that
> are using the term annotation correctly in natural language to describe
> something. Again, it is about language and terminology.

OK, I'm completely lost now. I thought your argument was that the 
feature should under no circumstances be called "attributes", because 
that is too general a term, and that it should instead be called 
"annotations", because that is the only correct term. Then you link to a 
page which demonstrates *annotations* being used as a general term, and 
*attributes* being used for the feature being proposed.


> Me neither, I am saying that the term is too generic and that we should
> use the term annotation in order to make it unique, easily
> understandable, non-ambiguous in terms of natural language and not in
> terms of what others use or do.

Except that the Rust example demonstrates that "annotation" can be used 
just as generically and ambiguously as "attribute". There really is very 
little to choose between the two terms.

Regards,
-- 
Rowan Collins
[IMSoP]