[RFC] PHP Annotations VS Attributes

php.internals

Fleshgrinder

10 years ago
I am writing this in a separate thread because of the urgency that I see regarding the naming of past, current, and future proposals regarding this functionality. It was and is proposed to create this feature with the name *Attributes* as Facebook did in their Hack language. Main argument is to blindly follow /because/. On 4/25/2016 10:31 AM, Dmitry Stogov wrote:
> Different languages names this differently. > I may add an additional voting question - "annotation vs attributes?". >
It is true and only natural that different languages choose different names for equivalent features but this discussion is not about taste, style, nor coolness. It is about natural language, proper computer science terminology, and what PHP users will search for in search engines. I already tried to explain this in the actual thread but I guess my attempts resulted in more confusion than clarification, let me try again. #### ATTRIBUTE #### The word *attribute* has several meanings in computer science and this is mainly due to its extremely generic nature:
> a usually good quality or feature that someone or something has > > --- http://www.merriam-webster.com/dictionary/attribute
> In computing, an attribute is a specification that defines a property > of an object, element, or file. [...] For clarity, attributes should > more correctly be considered metadata. An attribute is frequently and > generally a property of a property. > > --- https://en.wikipedia.org/wiki/Attribute_%28computing%29
This pretty much sums it up already. An attribute is the metadata that is attached to an element of source code. This metadata is anything unessential that is additionally added but not necessarily required. class A { var $x; } The `class` and `var` keywords are essential in this example and define the actual element and the names are required too. public final class A { private static int $x = 42; } Class A has the attributes `public` and `final`. Property `$x` has the attributes `private`, `static`, `int`, and `42`. All of these attributes of the class and the property add additional metadata to the source code elements that define their qualities or features and consequently their behavior and usage. http://www.onelook.com/?w=attribute&ls=a http://encyclopedia2.thefreedictionary.com/attribute Sebastian Bergmann already explained this but I think it is important to be repeated and further clarified. The word attribute is often used to refer to properties with additional metadata (e.g. access modifiers, default values, ...; illustrated above) in an OO context. This makes the usage of the word attribute additionally to its generic nature ambiguous as well: https://en.wikipedia.org/wiki/Attribute_%28computing%29 http://encyclopedia2.thefreedictionary.com/instance+attribute https://en.wikipedia.org/wiki/Instance_variable http://encyclopedia2.thefreedictionary.com/static+attribute https://en.wikipedia.org/wiki/Static_variable *All* userland implementations that are called /attributes/ in the free and open world deal with completely different things: https://packagist.org/search/?q=attribute Last but not least, Perl has /attribute/ support. However, Perl actually uses it for interaction with *all* attributes that can be set. Hence, this is what attributes really do. http://perldoc.perl.org/attributes.html #### ANNOTATION ####
> Extra information associated with a particular point in a document or > program. Annotations may be added either by a compiler or by the > programmer. They are not usually essential to the correct function of > the program but give hints to improve performance. > > --- http://encyclopedia2.thefreedictionary.com/annotation
http://www.onelook.com/?w=annotation&ls=a The term *annotation* is not only used by Java: https://packagist.org/search/?q=annotation https://en.wikipedia.org/wiki/Annotation https://en.wikipedia.org/wiki/Ruby_character https://en.wikipedia.org/wiki/Java_annotation https://msdn.microsoft.com/en-us/library/dd901590%28VS.95%29.aspx http://docs.scala-lang.org/tutorials/tour/annotations.html https://kotlinlang.org/docs/reference/annotations.html https://www.python.org/dev/peps/pep-3107/ https://ghc.haskell.org/trac/ghc/wiki/Annotations http://ceylon-lang.org/documentation/1.2/tour/annotations/ http://clojure-doc.org/articles/ecosystem/core_typed/start/annotations.html https://www.dartlang.org/effective-dart/style/ ... https://rubygems.org/search?utf8=%E2%9C%93&query=annotation http://rustbyexample.com/scope/lifetime/explicit.html https://www.google.de/search?q=javascript+annotation ... Ignoring these facts just because Facebook did not do proper research is a total no go. It is also not up for a vote, it is just proper English and computer science terminology! Last but not least, it also ensures that users find the correct PHP manual page when they search for this new feature that might make it into core at some point. :)
-- Richard "Fleshgrinder" Fussenegger

Niklas Keller

10 years ago
Fleshgrinder <php@fleshgrinder.com> schrieb am Mi., 27. Apr. 2016 22:11:
> I am writing this in a separate thread because of the urgency that I see > regarding the naming of past, current, and future proposals regarding > this functionality. > > It was and is proposed to create this feature with the name *Attributes* > as Facebook did in their Hack language. Main argument is to blindly > follow /because/. > > On 4/25/2016 10:31 AM, Dmitry Stogov wrote: > > Different languages names this differently. > > I may add an additional voting question - "annotation vs attributes?". > > > > It is true and only natural that different languages choose different > names for equivalent features but this discussion is not about taste, > style, nor coolness. It is about natural language, proper computer > science terminology, and what PHP users will search for in search > engines. I already tried to explain this in the actual thread but I > guess my attempts resulted in more confusion than clarification, let me > try again. > > #### ATTRIBUTE #### > > The word *attribute* has several meanings in computer science and this > is mainly due to its extremely generic nature: > > > a usually good quality or feature that someone or something has > > > > --- http://www.merriam-webster.com/dictionary/attribute > > > In computing, an attribute is a specification that defines a property > > of an object, element, or file. [...] For clarity, attributes should > > more correctly be considered metadata. An attribute is frequently and > > generally a property of a property. > > > > --- https://en.wikipedia.org/wiki/Attribute_%28computing%29 > > This pretty much sums it up already. An attribute is the metadata that > is attached to an element of source code. This metadata is anything > unessential that is additionally added but not necessarily required. > > class A { > var $x; > } > > The `class` and `var` keywords are essential in this example and define > the actual element and the names are required too. > > public final class A { > private static int $x = 42; > } > > Class A has the attributes `public` and `final`. > Property `$x` has the attributes `private`, `static`, `int`, and `42`. > > All of these attributes of the class and the property add additional > metadata to the source code elements that define their qualities or > features and consequently their behavior and usage. > > http://www.onelook.com/?w=attribute&ls=a > http://encyclopedia2.thefreedictionary.com/attribute > > Sebastian Bergmann already explained this but I think it is important to > be repeated and further clarified. The word attribute is often used to > refer to properties with additional metadata (e.g. access modifiers, > default values, ...; illustrated above) in an OO context. This makes the > usage of the word attribute additionally to its generic nature ambiguous > as well: > > https://en.wikipedia.org/wiki/Attribute_%28computing%29 > > http://encyclopedia2.thefreedictionary.com/instance+attribute > https://en.wikipedia.org/wiki/Instance_variable > > http://encyclopedia2.thefreedictionary.com/static+attribute > https://en.wikipedia.org/wiki/Static_variable > > *All* userland implementations that are called /attributes/ in the free > and open world deal with completely different things: > > https://packagist.org/search/?q=attribute > > Last but not least, Perl has /attribute/ support. However, Perl actually > uses it for interaction with *all* attributes that can be set. Hence, > this is what attributes really do. > > http://perldoc.perl.org/attributes.html > > #### ANNOTATION #### > > > Extra information associated with a particular point in a document or > > program. Annotations may be added either by a compiler or by the > > programmer. They are not usually essential to the correct function of > > the program but give hints to improve performance. > > > > --- http://encyclopedia2.thefreedictionary.com/annotation > > http://www.onelook.com/?w=annotation&ls=a > > The term *annotation* is not only used by Java: > > https://packagist.org/search/?q=annotation > > https://en.wikipedia.org/wiki/Annotation > https://en.wikipedia.org/wiki/Ruby_character > https://en.wikipedia.org/wiki/Java_annotation > > https://msdn.microsoft.com/en-us/library/dd901590%28VS.95%29.aspx > http://docs.scala-lang.org/tutorials/tour/annotations.html > https://kotlinlang.org/docs/reference/annotations.html > https://www.python.org/dev/peps/pep-3107/ > https://ghc.haskell.org/trac/ghc/wiki/Annotations > http://ceylon-lang.org/documentation/1.2/tour/annotations/ > http://clojure-doc.org/articles/ecosystem/core_typed/start/annotations.html > https://www.dartlang.org/effective-dart/style/ > ... > > https://rubygems.org/search?utf8=%E2%9C%93&query=annotation > http://rustbyexample.com/scope/lifetime/explicit.html > https://www.google.de/search?q=javascript+annotation > ... > > Ignoring these facts just because Facebook did not do proper research is > a total no go. It is also not up for a vote, it is just proper English > and computer science terminology! > > Last but not least, it also ensures that users find the correct PHP > manual page when they search for this new feature that might make it > into core at some point. :) > -- > Richard "Fleshgrinder" Fussenegger >
I agree with all of that, +1.

Michał Brzuchalski

10 years ago
2016-04-27 22:53 GMT+02:00 Niklas Keller <me@kelunik.com>:
> Fleshgrinder <php@fleshgrinder.com> schrieb am Mi., 27. Apr. 2016 22:11: > > > I am writing this in a separate thread because of the urgency that I see > > regarding the naming of past, current, and future proposals regarding > > this functionality. > > > > It was and is proposed to create this feature with the name *Attributes* > > as Facebook did in their Hack language. Main argument is to blindly > > follow /because/. > > > > On 4/25/2016 10:31 AM, Dmitry Stogov wrote: > > > Different languages names this differently. > > > I may add an additional voting question - "annotation vs attributes?". > > > > > > > It is true and only natural that different languages choose different > > names for equivalent features but this discussion is not about taste, > > style, nor coolness. It is about natural language, proper computer > > science terminology, and what PHP users will search for in search > > engines. I already tried to explain this in the actual thread but I > > guess my attempts resulted in more confusion than clarification, let me > > try again. > > > > #### ATTRIBUTE #### > > > > The word *attribute* has several meanings in computer science and this > > is mainly due to its extremely generic nature: > > > > > a usually good quality or feature that someone or something has > > > > > > --- http://www.merriam-webster.com/dictionary/attribute > > > > > In computing, an attribute is a specification that defines a property > > > of an object, element, or file. [...] For clarity, attributes should > > > more correctly be considered metadata. An attribute is frequently and > > > generally a property of a property. > > > > > > --- https://en.wikipedia.org/wiki/Attribute_%28computing%29 > > > > This pretty much sums it up already. An attribute is the metadata that > > is attached to an element of source code. This metadata is anything > > unessential that is additionally added but not necessarily required. > > > > class A { > > var $x; > > } > > > > The `class` and `var` keywords are essential in this example and define > > the actual element and the names are required too. > > > > public final class A { > > private static int $x = 42; > > } > > > > Class A has the attributes `public` and `final`. > > Property `$x` has the attributes `private`, `static`, `int`, and `42`. > > > > All of these attributes of the class and the property add additional > > metadata to the source code elements that define their qualities or > > features and consequently their behavior and usage. > > > > http://www.onelook.com/?w=attribute&ls=a > > http://encyclopedia2.thefreedictionary.com/attribute > > > > Sebastian Bergmann already explained this but I think it is important to > > be repeated and further clarified. The word attribute is often used to > > refer to properties with additional metadata (e.g. access modifiers, > > default values, ...; illustrated above) in an OO context. This makes the > > usage of the word attribute additionally to its generic nature ambiguous > > as well: > > > > https://en.wikipedia.org/wiki/Attribute_%28computing%29 > > > > http://encyclopedia2.thefreedictionary.com/instance+attribute > > https://en.wikipedia.org/wiki/Instance_variable > > > > http://encyclopedia2.thefreedictionary.com/static+attribute > > https://en.wikipedia.org/wiki/Static_variable > > > > *All* userland implementations that are called /attributes/ in the free > > and open world deal with completely different things: > > > > https://packagist.org/search/?q=attribute > > > > Last but not least, Perl has /attribute/ support. However, Perl actually > > uses it for interaction with *all* attributes that can be set. Hence, > > this is what attributes really do. > > > > http://perldoc.perl.org/attributes.html > > > > #### ANNOTATION #### > > > > > Extra information associated with a particular point in a document or > > > program. Annotations may be added either by a compiler or by the > > > programmer. They are not usually essential to the correct function of > > > the program but give hints to improve performance. > > > > > > --- http://encyclopedia2.thefreedictionary.com/annotation > > > > http://www.onelook.com/?w=annotation&ls=a > > > > The term *annotation* is not only used by Java: > > > > https://packagist.org/search/?q=annotation > > > > https://en.wikipedia.org/wiki/Annotation > > https://en.wikipedia.org/wiki/Ruby_character > > https://en.wikipedia.org/wiki/Java_annotation > > > > https://msdn.microsoft.com/en-us/library/dd901590%28VS.95%29.aspx > > http://docs.scala-lang.org/tutorials/tour/annotations.html > > https://kotlinlang.org/docs/reference/annotations.html > > https://www.python.org/dev/peps/pep-3107/ > > https://ghc.haskell.org/trac/ghc/wiki/Annotations > > http://ceylon-lang.org/documentation/1.2/tour/annotations/ > > > http://clojure-doc.org/articles/ecosystem/core_typed/start/annotations.html > > https://www.dartlang.org/effective-dart/style/ > > ... > > > > https://rubygems.org/search?utf8=%E2%9C%93&query=annotation > > http://rustbyexample.com/scope/lifetime/explicit.html > > https://www.google.de/search?q=javascript+annotation > > ... > > > > Ignoring these facts just because Facebook did not do proper research is > > a total no go. It is also not up for a vote, it is just proper English > > and computer science terminology! > > > > Last but not least, it also ensures that users find the correct PHP > > manual page when they search for this new feature that might make it > > into core at some point. :) > > -- > > Richard "Fleshgrinder" Fussenegger > > > > I agree with all of that, +1. > > > >
Hi, personally I prefer Annotation word instead of Attributes because of my language (Polish) discrepancies in usage as "class attribute" in Polish means quite the same as "object property" in English and may came to missusage of that name - this info is also on Wikipedia https://pl.wikipedia.org/wiki/Atrybut_(programowanie)#Poj.C4.99cie_atrybutu_w_programowaniu_obiektowym Annotation in Polish in Software Development is uniquely associated with the Attributes in your meaning exactly the same as Java Annotaitons and this is clearly understood for eg. Cay S. Hortsmann in "Java 8" in translation into Polish is talking about Annotations. For eg. in Symfony docs translation into Polish http://symfony-docs.pl/bundles/SensioFrameworkExtraBundle/index.html also is usage of Annotation (Ctrl+F "adnotacje") - this is official documentation. Thats why IMHO Annotation name should be retained. Thanks, Regards,
-- Michał Brzuchalski

Lester Caine

10 years ago
On 27/04/16 21:11, Fleshgrinder wrote:
> It is about natural language, proper computer > science terminology, and what PHP users will search for in search > engines.
To add to your list ... https://www.phpdoc.org/docs/latest/guides/docblocks.html The glossary entry is rather bare, but I would dispute THEIR statement - "but also influences the way the application behaves." In my book, these comment blocks are 'annotation' is it's simplest form, and we add tags within that annotation to make particular details of that annotation both machine readable and humanly prominent. That some of these keys may be used to "influences the way the application behaves." is secondary? My continuing irritation is that while subsets keep getting discussed as duplicate elements outside of the phpdoc wrapper, there is no provision for the annotations that would actually help data validation.
-- Lester Caine - G8HFL ----------------------------- Contact - http://lsces.co.uk/wiki/?page=contact L.S.Caine Electronic Services - http://lsces.co.uk EnquirySolve - http://enquirysolve.com/ Model Engineers Digital Workshop - http://medw.co.uk Rainbow Digital Media - http://rainbowdigitalmedia.co.uk

Fleshgrinder

10 years ago
On 4/27/2016 11:36 PM, Lester Caine wrote:
> To add to your list ... > https://www.phpdoc.org/docs/latest/guides/docblocks.html > > The glossary entry is rather bare, but I would dispute THEIR statement - > "but also influences the way the application behaves." > > In my book, these comment blocks are 'annotation' is it's simplest form, > and we add tags within that annotation to make particular details of > that annotation both machine readable and humanly prominent. That some > of these keys may be used to "influences the way the application > behaves." is secondary? >
It is totally secondary but still possible, hence, stating it is correct. A problem is the that attributes that were added via annotations are per definition not guaranteed to be executed (influence the way the application behaves) and are as such not a good fit for design by contract, validation, nor security checks. However, "per definition" does not mean that one is not allowed to model it in such a way. On 4/27/2016 11:36 PM, Lester Caine wrote:
> My continuing irritation is that while subsets keep getting discussed as > duplicate elements outside of the phpdoc wrapper, there is no provision > for the annotations that would actually help data validation. >
Value objects are a better approach towards validation in the very core than annotations could ever be. Validation of user input should happen at the most outer layer to fail early. Validation of developers should happen via design by contract where we currently only have assert() at our disposal.
-- Richard "Fleshgrinder" Fussenegger

Rowan Collins

10 years ago
Fleshgrinder wrote on 27/04/2016 21:11:
> I am writing this in a separate thread because of the urgency that I see > regarding the naming of past, current, and future proposals regarding > this functionality.
While I personally prefer the name "annotations", I don't see it as particularly urgent, or nearly as clear-cut as you claim. I clicked through on your MSDN link [1] because I was pretty sure .net referred to them as "attributes", and am amused to find sentences like this:
> The System.ComponentModel.DataAnnotations namespace contains the
classes that are used as data attributes. In other words, the implementer of that particular library preferred the word "annotations", but the language/framework itself calls them "attributes"; here's a nice summary [2]:
> For example, the accessibility of a method in a class is specified by
decorating it with the /method-modifiers/ |public|, |protected|, |internal|, and |private|. C# enables programmers to invent new kinds of declarative information, called attributes. So, that's one rather large ecosystem that calls them "attributes". Your claims for Perl also don't make much sense:
> Last but not least, Perl has/attribute/ support. However, Perl actually > uses it for interaction with*all* attributes that can be set. Hence, > this is what attributes really do. > > http://perldoc.perl.org/attributes.html
None of the built-in attributes mentioned in that manual are standard syntax used in the majority of Perl programs; in fact, they are all marked as experimental, and most of the examples are of defining custom attributes. As far as I can see, this is Perl's version of precisely the feature that is being proposed for PHP. I haven't looked through any of your other links to see if you've fallen foul of similar confirmation bias, but am satisfied in my mind that there are plenty of people outside Hack who call them "attributes". [1] https://msdn.microsoft.com/en-us/library/dd901590%28VS.95%29.aspx [2] https://msdn.microsoft.com/en-us/library/aa664611%28v=vs.71%29.aspx Regards,
-- Rowan Collins [IMSoP]

Fleshgrinder

10 years ago
On 4/28/2016 11:36 AM, Rowan Collins wrote:
> While I personally prefer the name "annotations", I don't see it as > particularly urgent, or nearly as clear-cut as you claim. >
That's okay and why we are discussing things. ;) On 4/28/2016 11:36 AM, Rowan Collins wrote:
> I clicked through on your MSDN link [1] because I was pretty sure .net > referred to them as "attributes", and am amused to find sentences like > this: > >> The System.ComponentModel.DataAnnotations namespace contains the > classes that are used as data attributes. > > In other words, the implementer of that particular library preferred the > word "annotations", but the language/framework itself calls them > "attributes"; here's a nice summary [2]: > >> For example, the accessibility of a method in a class is specified by > decorating it with the /method-modifiers/ |public|, |protected|, > |internal|, and |private|. C# enables programmers to invent new kinds of > declarative information, called attributes. > > So, that's one rather large ecosystem that calls them "attributes". >
Actually Microsoft got it exactly right and they are explaining in depth what I wrote as well. The result of an annotation is an attribute. So it is only natural to call the classes attributes. public class Customer { [DataType(DataType.EmailAddress)] public string EmailAddress { get; set; } } The `[DataType(DataType.EmailAddress)]` is the annotation and the attribute that we add to the property is a DataTypeAttribute of DataType EmailAddress. https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.datatypeattribute%28v=vs.95%29.aspx Note that you could achieve the above in PHP with the property type RFC: class Customer { public EmailAddress $email; } Here public and EmailAddress are attributes of the instance variable email and hence properties of a property that together result in a class or instance attribute. On 4/28/2016 11:36 AM, Rowan Collins wrote:
> Your claims for Perl also don't make much sense: > >> Last but not least, Perl has/attribute/ support. However, Perl actually >> uses it for interaction with*all* attributes that can be set. Hence, >> this is what attributes really do. >> >> http://perldoc.perl.org/attributes.html > > None of the built-in attributes mentioned in that manual are standard > syntax used in the majority of Perl programs; in fact, they are all > marked as experimental, and most of the examples are of defining custom > attributes. As far as I can see, this is Perl's version of precisely the > feature that is being proposed for PHP. >
The name they chose is okay because Perl does not offer any other way of adding attributes to any kind of data in any way (at least none that I am aware off but I am not a Perl programmer). Hence, it is not too dangerous to call this functionality attributes as it would be in our context where many other attributes are already available. The fact that it is experimental does not add anything to this discussion. On 4/28/2016 11:36 AM, Rowan Collins wrote:
> I haven't looked through any of your other links to see if you've fallen > foul of similar confirmation bias, but am satisfied in my mind that > there are plenty of people outside Hack who call them "attributes". > > > [1] https://msdn.microsoft.com/en-us/library/dd901590%28VS.95%29.aspx > [2] https://msdn.microsoft.com/en-us/library/aa664611%28v=vs.71%29.aspx > > Regards,
No confirmation bias and as I said, Microsoft got it completely right. To give you an analogy, Microsoft is calling the egg an egg and the chicken a chicken. We would be calling a chicken an egg because it is able to create eggs. In other words: an *annotation* allows you to add additional custom *attributes* to data that cannot be added by other means. :)
-- Richard "Fleshgrinder" Fussenegger

Rowan Collins

10 years ago
Fleshgrinder wrote on 28/04/2016 18:33:
> Actually Microsoft got it exactly right and they are explaining in depth > what I wrote as well. The result of an annotation is an attribute. So it > is only natural to call the classes attributes. > > public class Customer { > > [DataType(DataType.EmailAddress)] > public string EmailAddress { get; set; } > } > > The `[DataType(DataType.EmailAddress)]` is the annotation and the > attribute that we add to the property is a DataTypeAttribute of DataType > EmailAddress.
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. According to this page, the syntax which applies an attribute to some code is called an "attribute specification": https://msdn.microsoft.com/en-us/library/aa664616.aspx
> Here public and EmailAddress are attributes of the instance variable > email and hence properties of a property that together result in a class > or instance attribute.
Again, I've not seen anything saying that .net refers to the "public" keyword as an "attribute", or in any way treats it as equivalent to the attribute (or, if you insist, annotation) syntax. In fact, the article I quoted earlier explicitly distinguishes the two, referring to "public" etc as "method-modifiers", and seems clear to me that they are not the same thing as attributes: https://msdn.microsoft.com/en-us/library/aa664611%28v=vs.71%29.aspx
> The name they chose is okay because Perl does not offer any other way of > adding attributes to any kind of data in any way (at least none that I > am aware off but I am not a Perl programmer). Hence, it is not too > dangerous to call this functionality attributes as it would be in our > context where many other attributes are already available.
Surely under your definition scope modifiers like "local"/"global" and "my"/"our" would be "attributes"? I think you're really clutching at straws to distinguish this case from any of the others, just because it doesn't agree with your assumptions.
> >> I haven't looked through any of your other links to see if you've fallen >> foul of similar confirmation bias, but am satisfied in my mind that >> there are plenty of people outside Hack who call them "attributes". > No confirmation bias
By "confirmation bias", I meant that you'd gone out looking for confirmation that people called them "annotations", rather than researching what each language calls them. For instance, you linked to a Rust page, which happened to contain the word "annotation", but on closer inspection is actually using the terms in exactly the opposite way from you: the "lifetime annotation" here is a specific syntax to do with lifetimes, and is an "annotation" in the loose sense of "you are annotating the source code". Meanwhile, in the menu on the left, we can see a section on "Attributes", which look much more like arbitrary metadata of the sort we are discussing right now: http://rustbyexample.com/attribute.html I think a survey of what different languages call their metadata features would be interesting, but so far, I'm not seeing a clear bias in favour of one or the other. Like I say, I personally prefer the term "annotations", but I'm not going to discount the evidence that major languages like C#/.net, Perl, and Rust have chosen the name "attributes" instead. Regards,
-- Rowan Collins [IMSoP]

Fleshgrinder

10 years ago
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. Emphasize mine:
> You can also use *attributes* to control memory placement, code > generation options or call/return conventions within the function > being *annotated*. > > --- https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
We /annotate/ data and by doing so we add /attributes/. The C language is a very good example where all attributes are directly called attributes because there is no other system available to add attributes. In PHP we have various means to add attributes, so does Java. *That* is why it is not a good idea to call a specific functionality /attributes/. On 4/28/2016 8:02 PM, Rowan Collins wrote:
> According to this page, the syntax which applies an attribute to some > code is called an "attribute specification": > https://msdn.microsoft.com/en-us/library/aa664616.aspx >
The word construct "attribute specification" is completely right, it specifies which attribute should be applied to the data. The functionality at our disposal to do so---addition and specification of attributes---is through annotating them. Hence, calling the functionality ... - Custom Attributes - Attribute Specifiers - Custom Attribute Specifiers - Extended Attributes ... or something in this vain would get my +1. However, all of them are rather bulky. On 4/28/2016 8:02 PM, Rowan Collins wrote:
> Again, I've not seen anything saying that .net refers to the "public" > keyword as an "attribute", or in any way treats it as equivalent to the > attribute (or, if you insist, annotation) syntax. In fact, the article I > quoted earlier explicitly distinguishes the two, referring to "public" > etc as "method-modifiers", and seems clear to me that they are not the > same thing as attributes: > https://msdn.microsoft.com/en-us/library/aa664611%28v=vs.71%29.aspx >
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. [1] BTW: /public/, /protected/, and /private/ are a special form of modifiers in general and called *access modifiers*: https://en.wikipedia.org/wiki/Access_modifiers On 4/28/2016 8:02 PM, Rowan Collins wrote:
>> The name they chose is okay because Perl does not offer any other way of >> adding attributes to any kind of data in any way (at least none that I >> am aware off but I am not a Perl programmer). Hence, it is not too >> dangerous to call this functionality attributes as it would be in our >> context where many other attributes are already available. > > Surely under your definition scope modifiers like "local"/"global" and > "my"/"our" would be "attributes"? I think you're really clutching at > straws to distinguish this case from any of the others, just because it > doesn't agree with your assumptions. >
As I said in the initial message, using the term /attribute/ is pretty much never wrong because the term /attribute/ is so generic. :P The only data without any kind of attributes is raw binary data without any meaning. Note that random data does not count, since randomness would be an attribute of the data.
> a usually good quality or feature that someone or something has > > --- http://www.merriam-webster.com/dictionary/attribute
On 4/28/2016 8:02 PM, Rowan Collins wrote:
> By "confirmation bias", I meant that you'd gone out looking for > confirmation that people called them "annotations", rather than > researching what each language calls them. >
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. On 4/28/2016 8:02 PM, Rowan Collins wrote:
> For instance, you linked to a Rust page, which happened to contain the > word "annotation", but on closer inspection is actually using the terms > in exactly the opposite way from you: the "lifetime annotation" here is > a specific syntax to do with lifetimes, and is an "annotation" in the > loose sense of "you are annotating the source code". Meanwhile, in the > menu on the left, we can see a section on "Attributes", which look much > more like arbitrary metadata of the sort we are discussing right now: > http://rustbyexample.com/attribute.html >
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. Here is the relevant formatting again, note the dots and empty line: On 4/27/2016 10:11 PM, Fleshgrinder wrote:
> http://ceylon-lang.org/documentation/1.2/tour/annotations/ > http://clojure-doc.org/articles/ecosystem/core_typed/start/annotations.html > https://www.dartlang.org/effective-dart/style/ > ... > > https://rubygems.org/search?utf8=%E2%9C%93&query=annotation > http://rustbyexample.com/scope/lifetime/explicit.html > https://www.google.de/search?q=javascript+annotation > ... >
On 4/28/2016 8:02 PM, Rowan Collins wrote:
> I think a survey of what different languages call their metadata > features would be interesting, but so far, I'm not seeing a clear bias > in favour of one or the other. > > Like I say, I personally prefer the term "annotations", but I'm not > going to discount the evidence that major languages like C#/.net, Perl, > and Rust have chosen the name "attributes" instead. > > Regards,
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. [1] https://en.wikipedia.org/wiki/Attribute_%28computing%29
-- Richard "Fleshgrinder" Fussenegger

Rowan Collins

10 years ago
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]

Fleshgrinder

10 years ago
On 4/28/2016 9:43 PM, Rowan Collins wrote:
> 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. >
Erm, actually I did not claim anything and applied proper terminology to the C# syntax. However, if it is so important for you to stick with C# and .NET then let's do this. I previously claimed that Microsoft does a perfect job. That claim was based on the fact that the feature is called "Data Annotations" and that one can apply and create custom "Attributes" (Metadata). [1] I still stand to that claim because this is exactly how the computer science terminology defines these terms.
> We can easily add validation to our application by adding Data > Annotations to our model classes. Data Annotations allow us to > describe the rules we want applied to our model properties, [...] > > ---
http://www.asp.net/mvc/overview/older-versions/mvc-music-store/mvc-music-store-part-6
> When you use the Data Annotations Model Binder, you use validator > attributes to perform validation. > > ---
http://www.asp.net/mvc/overview/older-versions-1/models-data/validation-with-the-data-annotation-validators-cs
> --- https://www.youtube.com/watch?v=Dllb1cDDsL0
That being said, others are not so nice to Microsoft and directly call the usage of the term "Attributes" in this context a MINFU because they should call it "Annotations". [2] We already know from various sources (see initial message) that attributes are more generally just metadata. Hence, I do not agree that the usage of the term "Attribute" in the context Microsoft uses it is a MINFU. One simply should not look at the term outside of the extension/library/namespace "Data Annotations" and everything is fine. The fact that .NET documentation is most of the time only talking about "Attributes" is because the documentation explains those classes and their usage. I do not understand why this means for you that the whole feature is called attributes. On 4/28/2016 9:43 PM, Rowan Collins wrote:
>> 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". >
You need to keep in mind that they are talking about "Data Annotation Attributes" in all of the documentation. On 4/28/2016 9:43 PM, Rowan Collins wrote:
> 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. >
I am sorry but this is about theoretical definition and not about some company chose to call it. Actually I am arguing against blindly following these companies (Facebook and/or Microsoft) and complying with the theoretical definitions. On 4/28/2016 9:43 PM, Rowan Collins wrote:
>> 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? >
Notice the :P at the end of the sentence. Usage of the term /attribute/ standalone is pretty much never wrong but always endlessly ambiguous and that is exactly the problem! On 4/28/2016 9:43 PM, Rowan Collins wrote:
> 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. >
I already went into more detail regarding C#/.NET at the beginning. As I wrote in the initial message regarding Perl. If the linked feature is *the only way* to add attributes than naming it attributes (standalone) is fine. However, if there are other means than same logic applies. I really do not understand why the usage of the term annotation is wrong in the Rust example. It is a hint for the compiler that can be added by the programmer or the compiler. That's pretty much a perfect usage according to the definition of an annotation.
> Extra information associated with a particular point in a document or > program. Annotations may be added either by a compiler or by the > programmer. They are not usually essential to the correct function of > the program but give hints to improve performance. > > --- http://encyclopedia2.thefreedictionary.com/annotation
On 4/28/2016 9:43 PM, Rowan Collins wrote:
> 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. >
C#/.NET calls them "Data Annotation Attributes" and not "Attributes" (see above). Perl does but I am still not sure if it is wrong or right in their context and included an /if/ in my initial review of their usage of the word. In case of doubt it's wrong I guess. Hack definitely uses it wrong. Also note that the current Attributes proposal is in some way closer to "Attribute Grammar" [3] than to annotations. I just hope that we can make an annotation system out of it and not end up with an attribute grammar system (or would we have to call it /attribution/ system then). On 4/28/2016 9:43 PM, Rowan Collins wrote:
> 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. >
> Declarations can be annotated with ‘attributes’ in Rust. > > --- https://doc.rust-lang.org/book/attributes.html
That is exactly the definition I gave in the initial message. There is no annotation system in Rust:
> Currently, you are not allowed to create your own attributes, the > Rust compiler defines them. > > --- https://doc.rust-lang.org/book/attributes.html
I am repeating myself but: @deprecated function f() {} We annotated (`@`) the function /f/ with the `deprecated` attribute, hence, _deprecated_ is now an attribute of function /f/ because we annotated it.
> Allows use of the #[start] attribute, which changes the entry point > into a Rust program. This capability, especially the signature for > the annotated function, is subject to change. > > --- https://doc.rust-lang.org/reference.html
The past and current RFCs are not proposing any attributes, they are proposing a system to annotate data with custom attributes. [1] http://dataannotationsextensions.org/ [2] https://www.it-visions.de/glossar/alle/454/MetaAttribut.aspx (German) [3] https://en.wikipedia.org/wiki/Attribute_grammar
-- Richard "Fleshgrinder" Fussenegger

Rowan Collins

10 years ago
On 30/04/2016 12:09, Fleshgrinder wrote:
> Erm, actually I did not claim anything [...] I previously claimed that Microsoft does a perfect job.
Just thought I'd point out this contradiction.
> That claim was based on the fact that the feature is called "Data Annotations" and that > one can apply and create custom "Attributes" (Metadata).
It seems to me that "Data Annotations" are one particular use of a language feature which is called "attributes". Looking through the list of descendants of the base Attribute class [1], I can see lots of different usages, most of which don't refer to "annotations" anywhere that I can see, only to "applying the attribute". This is true even in prose introductions such "Controlling XML Serialization Using Attributes" [2] which has sentences like "Attributes can be used to control the XML serialization of an object or to create an alternate XML stream from the same set of classes." and "By applying a XmlArrayAttribute, you can change the name of the XML element, as follows." [1] https://msdn.microsoft.com/en-us/library/system.attribute.aspx [2] https://msdn.microsoft.com/en-us/library/2baksw0z.aspx
> One simply should not look at the term outside of the > extension/library/namespace "Data Annotations" and everything is fine.
Why should we not look outside that namespace? What about that namespace makes it so special? If we transpose that logic to PHP, are you saying that it's OK for php.net to refer to "attributes" to discuss the feature, as long as Doctrine carries on using "annotations" for its usage of that feature?
> The fact that .NET documentation is most of the time only talking about > "Attributes" is because the documentation explains those classes and > their usage.
Which classes?
> I do not understand why this means for you that the whole > feature is called attributes.
Because the documentation talking about the feature calls it that. Repeatedly. "The common language runtime allows you to add keyword-like descriptive declarations, called attributes..." https://msdn.microsoft.com/en-us/library/5x6cd29c.aspx "Apply the attribute to the code element by placing it immediately before the element." https://msdn.microsoft.com/en-us/library/bfz783fz.aspx "Attributes provide a powerful method of associating metadata, or declarative information, with code..." https://msdn.microsoft.com/en-us/library/z0w1kczw.aspx Helpfully, Microsoft make the C# Language Specification readily available, so I downloaded that [https://www.microsoft.com/en-us/download/details.aspx?id=7029] The word "annotation" is used in only one context: "variance annotations", which are the "in" and "out" keywords that allow a Generic type parameter to be co- or contra-variant, and nothing to do with the feature we are discussing. The word "annotate" is also used in reference to documentation comments, and in the following sentence:
> When an optional parameter is annotated with one of the caller info
attributes, omitting the corresponding argument in a call does not necessarily cause the default parameter value to be substituted. As far as I can see, it's not being used as a specific term in that sentence, and you could safely substitute "is marked with". "Attribute" meanwhile appears 19 times *in the Table of Contents*, all describing the feature we are discussing - the ability to add some syntax next to some code to apply metadata retrievable by reflection. The Appendix contains a set of grammar constructions for the grammar of the "[ Foo (Bar) ]" syntax used to apply attributes; the grammar rules all use the word "attribute", never "annotation".
> I am sorry but this is about theoretical definition and not about some > company chose to call it. Actually I am arguing against blindly > following these companies (Facebook and/or Microsoft) and complying with > the theoretical definitions.
Language is a funny thing: words mean what they mean because we agree on that meaning, and understand each other when we use it. A "theoretical definition" is no use at all if it's not how people actually use a word. Computer Science terms are doubly-cursed here, because rather than coining new words, we tend to stretch metaphorical use of existing terms from other fields, even when those fields overlap with our own. If a language as popular and influential as C# calls this feature "attributes", as I hope I've demonstrated it does, then it's hard to say that that's the "wrong" name - it is the name everybody in that community uses, and they all agree and understand its meaning.
> As I wrote in the initial message regarding Perl. If the linked feature > is *the only way* to add attributes than naming it attributes > (standalone) is fine. However, if there are other means than same logic > applies.
I still don't really understand what you mean by this. As far as I can see, the feature in Perl is exactly equivalent to the one proposed for PHP. Do you mean there is something in PHP which you consider to have prior claim to the word "attributes"?
> > I really do not understand why the usage of the term annotation is wrong > in the Rust example. It is a hint for the compiler that can be added by > the programmer or the compiler. That's pretty much a perfect usage > according to the definition of an annotation.
I didn't say it was "wrong", I said it showed that "annotation" is just as ambiguous a term as "attribute". Pretty much any syntax can be referred to as an "annotation" (see the C# "in"/"out" example earlier), just as pretty much any modifier or property can be referred to as an "attribute". So in an ideal world, we wouldn't use either term if we wanted to unambiguously refer to a new feature. At best, the Rust example is irrelevant to the discussion; at worst, it weakens the case for "annotation" being an unambiguous term, which I thought was part of your argument.
> The past and current RFCs are not proposing any attributes, they are > proposing a system to annotate data with custom attributes.
Absolutely! But all we're deciding is what the language will call the overall feature - what page it will be on in the manual, what word will be used in the error messages, etc. In some languages, like Java, those resources would refer to "Annotations"; in other languages, like C#, those resources would refer to "Attributes". Both terms have advantages and disadvantages, precedents and connotations - and both have potential ambiguities with other uses of the normal English words that have been borrowed. In the end, it really is mostly a matter of taste. Regards,
-- Rowan Collins [IMSoP]

Fleshgrinder

10 years ago
On 4/30/2016 11:52 PM, Rowan Collins wrote:
> Just thought I'd point out this contradiction. > > It seems to me that "Data Annotations" are one particular use of a > language feature which is called "attributes". Looking through the list > of descendants of the base Attribute class [1], I can see lots of > different usages, most of which don't refer to "annotations" anywhere > that I can see, only to "applying the attribute". This is true even in > prose introductions such "Controlling XML Serialization Using > Attributes" [2] which has sentences like "Attributes can be used to > control the XML serialization of an object or to create an alternate XML > stream from the same set of classes." and "By applying a > XmlArrayAttribute, you can change the name of the XML element, as follows." >
I guess I am wrong then at it truly is MINFU as others claim. On 4/30/2016 11:52 PM, Rowan Collins wrote:
> Why should we not look outside that namespace? What about that namespace > makes it so special? > > If we transpose that logic to PHP, are you saying that it's OK for > php.net to refer to "attributes" to discuss the feature, as long as > Doctrine carries on using "annotations" for its usage of that feature? >
Annotations are generally ignored by the compiler but are retrievable via reflection at runtime:
> Unlike comments, annotations are reflective in that they are embedded > in the files generated by the compiler and may be retrievable at > run-time. > > --- http://c2.com/cgi/wiki?AnnotationMetadata
> metadata added to a document or program > > --- https://en.wiktionary.org/wiki/annotation
While attributes are part of the actual program, we already had public, protected, and private but there are many more like final, abstract, static and properties of objects are also commonly called attributes.
> An option or setting belonging to some object. > > A semantic item with which a method or other code element may be > decorated. > > Properties can /be/ marked as obsolete with an attribute, which will > cause the compiler to generate a warning if they are used. > > --- https://en.wiktionary.org/wiki/attribute
> Class member variables are called "properties". You may also see them > referred to using other terms such as "attributes" or "fields", but > for the purposes of this reference we will use "properties". > > --- https://secure.php.net/language.oop5.properties
On 4/30/2016 11:52 PM, Rowan Collins wrote:
> Language is a funny thing: words mean what they mean because we agree on > that meaning, and understand each other when we use it. A "theoretical > definition" is no use at all if it's not how people actually use a word. > Computer Science terms are doubly-cursed here, because rather than > coining new words, we tend to stretch metaphorical use of existing terms > from other fields, even when those fields overlap with our own. > > If a language as popular and influential as C# calls this feature > "attributes", as I hope I've demonstrated it does, then it's hard to say > that that's the "wrong" name - it is the name everybody in that > community uses, and they all agree and understand its meaning. >
That is why we use dictionaries. On 4/30/2016 11:52 PM, Rowan Collins wrote:
> I still don't really understand what you mean by this. As far as I can > see, the feature in Perl is exactly equivalent to the one proposed for > PHP. Do you mean there is something in PHP which you consider to have > prior claim to the word "attributes"? >
Yes and I explained it multiple times already: public, protected, private, final, abstract, static, ... all of them are attributes that are applied by the compiler to alter data and they are reflective. However, one could argue that the properties themselves are attributes. That is what Sebastian Bergman complained about with the term. It is simply too ambiguous and he is correct there. Hence, it is better to talk about public, protected, and private solely as /access modifiers/ and final, abstract, and static simply as /keywords/. The latter might be a very broad term but it is at least unambiguous: http://onelook.com/?w=keyword&ls=a On 4/30/2016 11:52 PM, Rowan Collins wrote:
> I didn't say it was "wrong", I said it showed that "annotation" is just > as ambiguous a term as "attribute". Pretty much any syntax can be > referred to as an "annotation" (see the C# "in"/"out" example earlier), > just as pretty much any modifier or property can be referred to as an > "attribute". So in an ideal world, we wouldn't use either term if we > wanted to unambiguously refer to a new feature. At best, the Rust > example is irrelevant to the discussion; at worst, it weakens the case > for "annotation" being an unambiguous term, which I thought was part of > your argument. >
I disagree in the context of programming. There are multiple dictionaries available (and linked in this thread) that define the term over and over again in the same manner. However, the term attribute changes its meaning based on context. On 4/30/2016 11:52 PM, Rowan Collins wrote:
> Absolutely! But all we're deciding is what the language will call the > overall feature - what page it will be on in the manual, what word will > be used in the error messages, etc. In some languages, like Java, those > resources would refer to "Annotations"; in other languages, like C#, > those resources would refer to "Attributes". > > Both terms have advantages and disadvantages, precedents and > connotations - and both have potential ambiguities with other uses of > the normal English words that have been borrowed. In the end, it really > is mostly a matter of taste. >
Very true but the last sentence is not in my book; maybe in .NET, Perl, and Hack. I guess we can summarize: - .NET world, Perl, and Hack are different than others. - Rust is complicated and is definitely different than others. - All others use the term according to most/all dictionaries. - Richard thinks annotations is the correct term. [1] - Rowan likes annotations but thinks attributes are equally suited. I can live with that. Anyone can read our discussion and make up their mind on their own (and hopefully share it with us). [1] Unless of course---and I wrote that before---we extend the name of the new functionality to be more precise: - Attribute Grammar (what the current proposal effectively is) - Meta-Attributes - Custom Attributes - Annotation Attributes - Aspects [2] - ... [2] https://en.wiktionary.org/wiki/aspect
> In aspect-oriented programming, a feature or component that can be > applied to parts of a program independent of any inheritance > hierarchy.
-- Richard "Fleshgrinder" Fussenegger

Lester Caine

10 years ago
On 01/05/16 11:19, Fleshgrinder wrote:
>> Both terms have advantages and disadvantages, precedents and >> > connotations - and both have potential ambiguities with other uses of >> > the normal English words that have been borrowed. In the end, it really >> > is mostly a matter of taste. >> > > Very true but the last sentence is not in my book; maybe in .NET, Perl, > and Hack. > > I guess we can summarize: > > - .NET world, Perl, and Hack are different than others. > - Rust is complicated and is definitely different than others. > - All others use the term according to most/all dictionaries. > > - Richard thinks annotations is the correct term. [1] > - Rowan likes annotations but thinks attributes are equally suited. > > I can live with that. Anyone can read our discussion and make up their > mind on their own (and hopefully share it with us).
My own 'working process' has always looked at annotation as the block of tags being added to an object. Then calling some elements of the annotation 'attributes' just dovetails in, just as other annotation may highlight access control or authorship. I've never though as the whole lot as individual attributes.
> [1] Unless of course---and I wrote that before---we extend the name of > the new functionality to be more precise: > > - Attribute Grammar (what the current proposal effectively is) > - Meta-Attributes > - Custom Attributes > - Annotation Attributes > - Aspects [2] > - ...
Which simply highlights a working practice we have been following since docBloc annotation started? What *IS* now making a lot more sense to me is the way things that I've followed the practices inherited from the original PHP4 code have been morphed into things like 'reflections'. I still don't see the entire need for this layer of complexity, and the Drupal comment that they don't use them makes sense since their code base pre-dates the need and uses 'more traditional' methods to provide the same results? If you have never had the need for reflections adding their use is a strain. If a variable is public, but should only be accessible via other functions such as getter and setter then the underlying value variable needs to be private? So if all the values are private and wrapped in code, then any value can be extended to also provide additional metadata?
-- Lester Caine - G8HFL ----------------------------- Contact - http://lsces.co.uk/wiki/?page=contact L.S.Caine Electronic Services - http://lsces.co.uk EnquirySolve - http://enquirysolve.com/ Model Engineers Digital Workshop - http://medw.co.uk Rainbow Digital Media - http://rainbowdigitalmedia.co.uk