<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: Cedric says no to AOP and annotations</title>
	<atom:link href="http://almaer.com/blog/cedric-says-no-to-aop-and-annotations/feed" rel="self" type="application/rss+xml" />
	<link>http://almaer.com/blog/cedric-says-no-to-aop-and-annotations</link>
	<description>blogging about life, the universe, and everything tech</description>
	<lastBuildDate>Tue, 03 Jan 2012 22:08:49 -0800</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.4</generator>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>By: James Strachan</title>
		<link>http://almaer.com/blog/cedric-says-no-to-aop-and-annotations/comment-page-1#comment-2463</link>
		<dc:creator>James Strachan</dc:creator>
		<pubDate>Sat, 15 May 2004 09:19:22 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/cedric-says-no-to-aop-and-annotations#comment-2463</guid>
		<description>Cedric - thats the whole point of constructor based dependency injection! Don&#039;t bother with pointless @Inject annotations or useless setters. Just write a constructor!
</description>
		<content:encoded><![CDATA[<p>Cedric &#8211; thats the whole point of constructor based dependency injection! Don&#8217;t bother with pointless @Inject annotations or useless setters. Just write a constructor!</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Cedric</title>
		<link>http://almaer.com/blog/cedric-says-no-to-aop-and-annotations/comment-page-1#comment-2462</link>
		<dc:creator>Cedric</dc:creator>
		<pubDate>Fri, 14 May 2004 22:44:38 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/cedric-says-no-to-aop-and-annotations#comment-2462</guid>
		<description>But why pollute your POJO and its type system by adding a setter that you will never invoke?

Now multiply this by the number of injections that you want and you won&#039;t even recognize your object any more because it will have all these useless methods.


</description>
		<content:encoded><![CDATA[<p>But why pollute your POJO and its type system by adding a setter that you will never invoke?</p>
<p>Now multiply this by the number of injections that you want and you won&#8217;t even recognize your object any more because it will have all these useless methods.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Jason Carreira</title>
		<link>http://almaer.com/blog/cedric-says-no-to-aop-and-annotations/comment-page-1#comment-2461</link>
		<dc:creator>Jason Carreira</dc:creator>
		<pubDate>Fri, 14 May 2004 22:15:45 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/cedric-says-no-to-aop-and-annotations#comment-2461</guid>
		<description>I still think the type-safe way annotations are being introduced is flawed for a lot of cases. It would be nice to have an additional facility for just generic annotated metadata which isn&#039;t typed or linked to a particular annotation interface. Sometimes you just want some data about a class that&#039;s outside the class itself.

For instance, the EJB annotations are only going to be usable in an environment with the j2ee.jar... It would be nice to just be able to introspect for some of this data without needing to be tied to the particular implementation. What if, instead, the definition of @Service was dependent on what implementation was available (or what code made use of the fact that @Service was tagged on a class). This would be a lot more powerful and dynamic, IMHO.
</description>
		<content:encoded><![CDATA[<p>I still think the type-safe way annotations are being introduced is flawed for a lot of cases. It would be nice to have an additional facility for just generic annotated metadata which isn&#8217;t typed or linked to a particular annotation interface. Sometimes you just want some data about a class that&#8217;s outside the class itself.</p>
<p>For instance, the EJB annotations are only going to be usable in an environment with the j2ee.jar&#8230; It would be nice to just be able to introspect for some of this data without needing to be tied to the particular implementation. What if, instead, the definition of @Service was dependent on what implementation was available (or what code made use of the fact that @Service was tagged on a class). This would be a lot more powerful and dynamic, IMHO.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: James Strachan</title>
		<link>http://almaer.com/blog/cedric-says-no-to-aop-and-annotations/comment-page-1#comment-2460</link>
		<dc:creator>James Strachan</dc:creator>
		<pubDate>Fri, 14 May 2004 21:46:42 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/cedric-says-no-to-aop-and-annotations#comment-2460</guid>
		<description>Absolutely agreed. We need to find a balance.

Slapping @Inject all over the code when we mean a setter seems insane and pointless. We&#039;ve had JavaBeans for many years - we all know what a setter is, we only need to mark things that look like setters but are not.

If we need to add metadata to code, sure annotations are the way. I just think we should consider very carefully when annotations are really required in code. Lets only force their introduction into source code when they are really required.

Note that the presence of annotations at runtime is quite different to how littered with annotations your source code can be. We&#039;re all agreeing with annotations in the bytecode for containers to use - I&#039;m just arguing for some restraint on annoation hell - even the hello-world EJB 3.0 example looks way too annotation polluted for me.
</description>
		<content:encoded><![CDATA[<p>Absolutely agreed. We need to find a balance.</p>
<p>Slapping @Inject all over the code when we mean a setter seems insane and pointless. We&#8217;ve had JavaBeans for many years &#8211; we all know what a setter is, we only need to mark things that look like setters but are not.</p>
<p>If we need to add metadata to code, sure annotations are the way. I just think we should consider very carefully when annotations are really required in code. Lets only force their introduction into source code when they are really required.</p>
<p>Note that the presence of annotations at runtime is quite different to how littered with annotations your source code can be. We&#8217;re all agreeing with annotations in the bytecode for containers to use &#8211; I&#8217;m just arguing for some restraint on annoation hell &#8211; even the hello-world EJB 3.0 example looks way too annotation polluted for me.</p>
]]></content:encoded>
	</item>
</channel>
</rss>

