<?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>Kommentare zu: JAVA-Klassen ohne LANG zu überlegen INSTRUMENTieren</title>
	<atom:link href="http://blog.ubigrate.de/2008/11/24/java-lang-instrument/feed/" rel="self" type="application/rss+xml" />
	<link>http://blog.ubigrate.de/2008/11/24/java-lang-instrument/</link>
	<description>Lückenlos zwischen digitaler und realer Welt</description>
	<lastBuildDate>Thu, 05 Jan 2012 08:44:33 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.2.1</generator>
	<item>
		<title>Von: Boris Petrovic</title>
		<link>http://blog.ubigrate.de/2008/11/24/java-lang-instrument/comment-page-1/#comment-2488</link>
		<dc:creator>Boris Petrovic</dc:creator>
		<pubDate>Mon, 27 Apr 2009 13:15:29 +0000</pubDate>
		<guid isPermaLink="false">http://blog.ubigrate.com/?p=362#comment-2488</guid>
		<description>Beitrag zum Thema finde ich sehr interesant. Ich habe auch manche Überlegungen mit java.lang.instrument in diese Richtung gemacht. Mir blieb immer dieser lätzten Schritt modify painlich. Bytecodes auswendig zu lernen finde ich nicht besonders toll. BCEL und änlichen Frameworks scheinen nicht kompatibel mit java.lang.instrument zu sein (oder täusche ich mich). 
Wäre sehr insteresant ein konkretes Beispiel mit modify zu sehen.

Gruss
Boris</description>
		<content:encoded><![CDATA[<p>Beitrag zum Thema finde ich sehr interesant. Ich habe auch manche Überlegungen mit java.lang.instrument in diese Richtung gemacht. Mir blieb immer dieser lätzten Schritt modify painlich. Bytecodes auswendig zu lernen finde ich nicht besonders toll. BCEL und änlichen Frameworks scheinen nicht kompatibel mit java.lang.instrument zu sein (oder täusche ich mich).<br />
Wäre sehr insteresant ein konkretes Beispiel mit modify zu sehen.</p>
<p>Gruss<br />
Boris</p>
]]></content:encoded>
	</item>
	<item>
		<title>Von: Metadaten, oder: Warum man Volt und milliVolt nicht einfach addieren kann. &#124; universal.adapter</title>
		<link>http://blog.ubigrate.de/2008/11/24/java-lang-instrument/comment-page-1/#comment-353</link>
		<dc:creator>Metadaten, oder: Warum man Volt und milliVolt nicht einfach addieren kann. &#124; universal.adapter</dc:creator>
		<pubDate>Tue, 09 Dec 2008 08:49:44 +0000</pubDate>
		<guid isPermaLink="false">http://blog.ubigrate.com/?p=362#comment-353</guid>
		<description>[...] Mechanismus&#8217; (siehe java.lang.instrument) eingewoben. Eine Einführung in diese Thematik ist hier zu finden. Um nun die Konsistenz zwischen Daten und Metadaten zu wahren muss einfach jeder [...]</description>
		<content:encoded><![CDATA[<p>[...] Mechanismus&#8217; (siehe java.lang.instrument) eingewoben. Eine Einführung in diese Thematik ist hier zu finden. Um nun die Konsistenz zwischen Daten und Metadaten zu wahren muss einfach jeder [...]</p>
]]></content:encoded>
	</item>
	<item>
		<title>Von: Tobias Nebel</title>
		<link>http://blog.ubigrate.de/2008/11/24/java-lang-instrument/comment-page-1/#comment-237</link>
		<dc:creator>Tobias Nebel</dc:creator>
		<pubDate>Tue, 25 Nov 2008 21:32:30 +0000</pubDate>
		<guid isPermaLink="false">http://blog.ubigrate.com/?p=362#comment-237</guid>
		<description>@Christoph
Also prinzipiell wollte ich hier nur einen Einstiegspunkt in Bytecode-Engineering aufzeigen. Detailiertere Betrachtungen sind insofern schwierig, da diese in die verschiedensten Richtungen ausschweifen könnten:
eine Instrumentierung könnte ja eine Vielzahl erdenklicher Veränderungen am vorhandenen Bytecode vornehmen...von Analysen, wie sie Profiler durchführen, über ergänzende Funktionalitäten, wie in der Aspekt-orientierten Programmierung, bis hin zur kompletten Neugenerierung von Klassen oder -bestandteilen ist da mehr drin, als man sich auf die Schnelle einfallen lassen kann. Hier sei &#039;mal dezent auf meinen nächsten Blog-Artikel verwiesen ;-)

Also was den Performanz-Vorteil gegenüber Compilern angeht geb&#039; ich dir soweit Recht, dass eine umfangreiche Analyse echt Zeit frisst! Wenn allerings überschaubare Sachen insturmentiert werden, dann kommst du sicher ohne Compiler besser. Abseits von der Performanz hast du durch die Bytecode-Analyse natürlich noch die Möglichkeit, Vorgänge auf der Bytecode-Ebene in die Java Sprachebene zu heben (du kannst so beispielsweise das Laden von Werten auf den Stack nachvollziehen).

Was unimplementierte Bytecode-Befehle angeht kann ich dir nicht wirklich viel sagen, da diese selbst für mich Neuland sind. Laut Spec sind diese Befehle einfach nur &quot;reserviert&quot; und &quot;derzeitig unimplementiert&quot;. Meine Vermutung wäre deshalb, dass (zumindest was die &quot;Volks-VM&quot; angeht) hier einfach garnichts passiert.

Viele Grüße!
...und ich hoffe dass wir jetzt &#039;ne heiße Diskussion losgerissen haben :-)</description>
		<content:encoded><![CDATA[<p>@Christoph<br />
Also prinzipiell wollte ich hier nur einen Einstiegspunkt in Bytecode-Engineering aufzeigen. Detailiertere Betrachtungen sind insofern schwierig, da diese in die verschiedensten Richtungen ausschweifen könnten:<br />
eine Instrumentierung könnte ja eine Vielzahl erdenklicher Veränderungen am vorhandenen Bytecode vornehmen&#8230;von Analysen, wie sie Profiler durchführen, über ergänzende Funktionalitäten, wie in der Aspekt-orientierten Programmierung, bis hin zur kompletten Neugenerierung von Klassen oder -bestandteilen ist da mehr drin, als man sich auf die Schnelle einfallen lassen kann. Hier sei &#8216;mal dezent auf meinen nächsten Blog-Artikel verwiesen <img src='http://blog.ubigrate.de/wp-includes/images/smilies/icon_wink.gif' alt=';-)' class='wp-smiley' /> </p>
<p>Also was den Performanz-Vorteil gegenüber Compilern angeht geb&#8217; ich dir soweit Recht, dass eine umfangreiche Analyse echt Zeit frisst! Wenn allerings überschaubare Sachen insturmentiert werden, dann kommst du sicher ohne Compiler besser. Abseits von der Performanz hast du durch die Bytecode-Analyse natürlich noch die Möglichkeit, Vorgänge auf der Bytecode-Ebene in die Java Sprachebene zu heben (du kannst so beispielsweise das Laden von Werten auf den Stack nachvollziehen).</p>
<p>Was unimplementierte Bytecode-Befehle angeht kann ich dir nicht wirklich viel sagen, da diese selbst für mich Neuland sind. Laut Spec sind diese Befehle einfach nur &#8220;reserviert&#8221; und &#8220;derzeitig unimplementiert&#8221;. Meine Vermutung wäre deshalb, dass (zumindest was die &#8220;Volks-VM&#8221; angeht) hier einfach garnichts passiert.</p>
<p>Viele Grüße!<br />
&#8230;und ich hoffe dass wir jetzt &#8216;ne heiße Diskussion losgerissen haben <img src='http://blog.ubigrate.de/wp-includes/images/smilies/icon_smile.gif' alt=':-)' class='wp-smiley' /> </p>
]]></content:encoded>
	</item>
	<item>
		<title>Von: Christoph Schmidt</title>
		<link>http://blog.ubigrate.de/2008/11/24/java-lang-instrument/comment-page-1/#comment-233</link>
		<dc:creator>Christoph Schmidt</dc:creator>
		<pubDate>Tue, 25 Nov 2008 17:18:13 +0000</pubDate>
		<guid isPermaLink="false">http://blog.ubigrate.com/?p=362#comment-233</guid>
		<description>Interessante Sache, wobei, wenn ich mir das Rudiment so anschaue, ja doch die Frage nach der notwendigen Mächtigkeit der modify()-Methode bleibt. 
Um darin sinnvoll instrumentieren zu können, muss man sich entweder auf &#039;markante&#039; ByteCodes verlassen (soweit ich mich erinnere gibt es ein paar reservierte, aber nicht genutzte ByteCodes in der Spec - wäre mal interessant zu wissen, was eine Standard-JRE mit einem solchen ByteCode macht - sofern die JRE da nicht streikt, könnte man für die Instrumentierung eventuell dort ansetzen.) oder den übergebenen Code selbst vollständig analysieren - beliebig mächtige Instrumentierung benötigt am Ende also vielleicht doch die selbe mächtige (aufwendige) Analyse des Codes wie beim Kompilieren. Ich kann mir dementsprechend gut vorstellen, dass beliebig mächtige Instrumentierungen nicht _viel_ schneller sind als die Arbeit mit dem Compiler. Allerdings bleibt natürlich der Dynamik-Aspekt als großer Vorteil.. 

Viele Grüße</description>
		<content:encoded><![CDATA[<p>Interessante Sache, wobei, wenn ich mir das Rudiment so anschaue, ja doch die Frage nach der notwendigen Mächtigkeit der modify()-Methode bleibt.<br />
Um darin sinnvoll instrumentieren zu können, muss man sich entweder auf &#8216;markante&#8217; ByteCodes verlassen (soweit ich mich erinnere gibt es ein paar reservierte, aber nicht genutzte ByteCodes in der Spec &#8211; wäre mal interessant zu wissen, was eine Standard-JRE mit einem solchen ByteCode macht &#8211; sofern die JRE da nicht streikt, könnte man für die Instrumentierung eventuell dort ansetzen.) oder den übergebenen Code selbst vollständig analysieren &#8211; beliebig mächtige Instrumentierung benötigt am Ende also vielleicht doch die selbe mächtige (aufwendige) Analyse des Codes wie beim Kompilieren. Ich kann mir dementsprechend gut vorstellen, dass beliebig mächtige Instrumentierungen nicht _viel_ schneller sind als die Arbeit mit dem Compiler. Allerdings bleibt natürlich der Dynamik-Aspekt als großer Vorteil.. </p>
<p>Viele Grüße</p>
]]></content:encoded>
	</item>
</channel>
</rss>

