AnnotationProcessor - Revision history

JaroslavTulach: /* 2009 - the Year of Annotations!? */

JaroslavTulach — Wed, 22 Jul 2020 04:21:33 GMT

2009 - the Year of Annotations!?

←Older revision		Revision as of 04:21, 22 July 2020
Line 7:		Line 7:
	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

-	==== 2009 - the Year of Annotations!? ====	+	==== [[TheYearOfAnnotations2009\|2009 - the Year of Annotations]]!? ====

	{{:TheYearOfAnnotations2009}}		{{:TheYearOfAnnotations2009}}

JaroslavTulach at 04:20, 22 July 2020

JaroslavTulach — Wed, 22 Jul 2020 04:20:45 GMT

←Older revision		Revision as of 04:20, 22 July 2020
Line 6:		Line 6:

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.
		+
		+	==== 2009 - the Year of Annotations!? ====
		+
		+	{{:TheYearOfAnnotations2009}}

JaroslavTulach at 16:39, 22 February 2019

JaroslavTulach — Fri, 22 Feb 2019 16:39:00 GMT

←Older revision		Revision as of 16:39, 22 February 2019
Line 3:		Line 3:
	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!		[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!

-	Where is the limit? As [[LiveDB]] essay shows, there is none - download your database schema and include it ~~into~~ your compilation!	+	Where is the limit? As [[LiveDB]] essay shows, there is none - download your database schema and include it as [[LiveDB\|metadata of your compilation]!

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

JaroslavTulach at 16:38, 22 February 2019

JaroslavTulach — Fri, 22 Feb 2019 16:38:25 GMT

←Older revision		Revision as of 16:38, 22 February 2019
Line 2:		Line 2:

	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!		[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!
		+
		+	Where is the limit? As [[LiveDB]] essay shows, there is none - download your database schema and include it into your compilation!

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

193.9.13.137 at 11:22, 22 November 2012

193.9.13.137 — Thu, 22 Nov 2012 11:22:30 GMT

←Older revision		Revision as of 11:22, 22 November 2012
Line 1:		Line 1:
-	Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an {{JDK\|javax/annotation/processing\|Processor}} in ~~the~~ [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.	+	Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering a {{JDK\|javax/annotation/processing\|Processor}} in a [[JAR]] file of the [[API]] containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.

	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!		[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

JaroslavTulach at 15:32, 20 April 2011

JaroslavTulach — Wed, 20 Apr 2011 15:32:36 GMT

←Older revision		Revision as of 15:32, 20 April 2011
Line 1:		Line 1:
-	Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an ~~[http://java.sun.com/javase/6/docs/api/~~javax/annotation/processing/Processor~~.html AnnotationProcessor]~~ in the [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.	+	Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an {{JDK\|javax/annotation/processing\|Processor}} in the [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.

	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!		[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

JaroslavTulach at 04:44, 5 August 2009

JaroslavTulach — Wed, 05 Aug 2009 04:44:26 GMT

←Older revision		Revision as of 04:44, 5 August 2009
Line 1:		Line 1:
	Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an [http://java.sun.com/javase/6/docs/api/javax/annotation/processing/Processor.html AnnotationProcessor] in the [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.		Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an [http://java.sun.com/javase/6/docs/api/javax/annotation/processing/Processor.html AnnotationProcessor] in the [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.

-	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 7.0 [[TheYearOfAnnotations2009\|released in 2009]].	+	[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers\|layer XML file systems]]. This feature is available since version 6.7 [[TheYearOfAnnotations2009\|released in 2009]]. Get more details about [[CompileTimeCache]]s!

	There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.		There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.

Apidesign: New page: Since JDK 1.6, its JavaC comes with standardized API for compile time processing of Annotations. Just by writing and registering an [http://java.sun.com/javase/6/docs/api/j...

Apidesign — Fri, 12 Dec 2008 09:02:36 GMT

New page: Since JDK 1.6, its JavaC comes with standardized API for compile time processing of Annotations. Just by writing and registering an [http://java.sun.com/javase/6/docs/api/j...

New page

Since [[JDK]] 1.6, its [[JavaC]] comes with standardized [[API]] for compile time processing of [[Annotations]]. Just by writing and registering an [http://java.sun.com/javase/6/docs/api/javax/annotation/processing/Processor.html AnnotationProcessor] in the [[JAR]] file containing also the [[Annotations]], one can effectively extend the compile time semantics of the [[Java]] language. By hooking into the compilation process of everyone using the [[JAR]] library, one can analyse all the [[Annotations]] usages, process them and generate additional files that can be then consumed during runtime.

[[NetBeans]] uses this style to convert nicely looking [[Annotations]] into a bit messy, yet powerful, [[NetBeansLayers|layer XML file systems]]. This feature is available since version 7.0 [[TheYearOfAnnotations2009|released in 2009]].

There are very interesting aspects for [[BackwardCompatibility]]. By having own processor code running during compilation, one can keep own annotation unchanged across multiple releases, yet each of the new releases can generate something different during the compilation. As a result, one can deliver performance improvements, or even slightly shift mean of the [[API]] just by letting people compile their applications against new version of own libraries.