<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	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/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>tessarakt - das vierdimensionale B-L-O-G &#187; Informatik</title>
	<atom:link href="http://blog.tessarakt.de/kategorien/informatik/feed/" rel="self" type="application/rss+xml" />
	<link>http://blog.tessarakt.de</link>
	<description></description>
	<lastBuildDate>Sun, 05 Feb 2012 10:48:35 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3</generator>
		<item>
		<title>Patch-Queue &#8211; wie organisieren?</title>
		<link>http://blog.tessarakt.de/archiv/2012/01/13/patch-queue-wie-organisieren/</link>
		<comments>http://blog.tessarakt.de/archiv/2012/01/13/patch-queue-wie-organisieren/#comments</comments>
		<pubDate>Fri, 13 Jan 2012 13:47:36 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1345</guid>
		<description><![CDATA[Ich habe in letzter Zeit angefangen, Patches für ein Open-Source-Projekt (Boost, konkret die Graph Library) zu erstellen. Da ich selbst dort keine Commit-Rechte habe, bin ich darauf angewiesen, dass Entwickler mit solchen Rechten meine Änderungen für mich einchecken. Und da &#8230; <a href="http://blog.tessarakt.de/archiv/2012/01/13/patch-queue-wie-organisieren/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Ich habe in letzter Zeit angefangen, Patches für ein Open-Source-Projekt (Boost, konkret die Graph Library) zu erstellen. Da ich selbst dort keine Commit-Rechte habe, bin ich darauf angewiesen, dass Entwickler mit solchen Rechten meine Änderungen für mich einchecken. Und da die auch nicht 24h verfügbar sind, dauert es eine Weile, bis die Sachen eingecheckt sind. Ich will aber ggf. mit Folgeänderungen weitermachen, die die vom ersten Patch geänderten Stellen nochmals ändern. Und da geht dann schnell das Chaos los <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_sad.gif' alt=':-(' class='wp-smiley' /> </p>
<p>Bevor jetzt gleich tolle Tipps kommen, dass das mit diesem oder jenem Versionsverwaltungssystem ja alles ganz einfach geht: Das Chaos dürfte zuallererstmal dadurch verursacht sein, dass ich gar nicht so recht weiß, was ich von einer Lösung erwarte. Der erste Schritt ist also eine saubere Anforderungsanalyse:</p>
<ul>
<li>Diff gegen noch nicht eingecheckte Patches: Ich möchte sehen, welche Änderungen sich in meiner working copy befinden, die über die bereits erzeugten (aber noch nicht eingecheckten) Patches hinausgehen. Die Differenz zum Trunk reicht also nicht.</li>
<li>Status von Patches: Ich muss Patches als erledigt markieren können, wenn sie eingecheckt sind.</li>
<li>Zusammenfassen von Patches: Wenn ich Patches noch nicht eingesendet habe (oder ggf. auch dann noch), will ich mehrere Patches zu einem großen zusammenfassen können.</li>
<li>Selektives Anwenden von Patches: Ich will leicht meine/eine Working Copy auf einen Stand bringen können, der den Trunk (oder eine bestimmte Revision) und nur bestimmte Patches enthält. Das ist beispielsweise nötig, um zu prüfen, dass die voneinander unabhängig sind.</li>
<li>Unterstützung bei der Erstellung von Patches: Optimal (aber auch optional und eher nice-to-have) wäre, aus den lokalen Änderungen in der lokalen working copy gegenüber dem Trunk (ggf. zuzüglich einer Auswahl von Patches) einen Patch erstellen zu können &#8211; aber nicht mit sämtlichen Änderungen, sondern Auswahlmöglichkeiten bezüglich der Dateien und der einzelnen Änderungen darin. Das geht aber zur Not auch manuell, ggf. mit Nachbearbeiten.</li>
</ul>
<p>Hat jemand eine Idee, wie man diese Funktionalität am besten umsetzt? Gibt es für so etwas fertige Tools? Ist es vielleicht mit bestimmten Versionsverwaltungssystemen besonders einfach? Git wird ja ständig für alles Mögliche in höchsten Tönen gelobt. Nutzt es vielleicht auch hier? Wenn ja, wie lassen sich obige Anforderungen auf die Begrifflichkeiten von Git (oder einem anderen System) abbilden?</p>
<p><img src="http://vg02.met.vgwort.de/na/abcf52ff00c6476eb720a08fd623d895" width="1" height="1" alt=""></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2012/01/13/patch-queue-wie-organisieren/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Boost, LEDA und meine wiederhergestellte Ehre</title>
		<link>http://blog.tessarakt.de/archiv/2011/12/13/boost-leda-und-meine-wiederhergestellte-ehre/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/12/13/boost-leda-und-meine-wiederhergestellte-ehre/#comments</comments>
		<pubDate>Tue, 13 Dec 2011 19:43:30 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1335</guid>
		<description><![CDATA[Neulich, als ich gerade Urlaub hatte, standen bei mir im Büro zwei Studenten, die einen Fehler in meiner Boost-Implementierung entdeckt haben wollten (wie mir danach mein Büromitbewohner berichtete). Zumindest habe ich mich gefreut, dass den Code jemand benutzen wollte. Allerdings &#8230; <a href="http://blog.tessarakt.de/archiv/2011/12/13/boost-leda-und-meine-wiederhergestellte-ehre/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Neulich, als ich gerade Urlaub hatte, standen bei mir im Büro zwei Studenten, die einen Fehler in meiner Boost-Implementierung entdeckt haben wollten (wie mir danach mein Büromitbewohner berichtete). Zumindest habe ich mich gefreut, dass den Code jemand benutzen wollte. Allerdings haben die beiden sich dann nicht mehr gemeldet. Über Umwege erfuhr ich dann am Wochenende, was der Fehler ist: Es fehlt <a href="http://svn.boost.org/svn/boost/trunk/boost/graph/leda_graph.hpp">in <code>leda_graph.hpp</code></a> eine spitze Klammer:</p>
<pre class="brush: cpp; title: ; notranslate">  template &lt;class vtype, class etype, class PropertyTag, class Key&gt;
  inline
  typename boost::property_traits&lt;
    typename boost::property_map&lt;leda::GRAPH&lt;vtype, etype&gt;,PropertyTag&gt;::const_type
::value_type
  get(PropertyTag p, const leda::GRAPH&lt;vtype, etype&gt;&amp; g, const Key&amp; key) {
    return get(get(p, g), key);
  }</pre>
<p>Es hat also nicht nur jemand diese Templates auf bisher ungetestete Art und Weise verwendet &#8211; das hier knallt schon, wenn man <code>leda_graph.hpp</code> nur einbindet &#8230; Dass ich <em>diesen</em> Fehler verursacht haben sollte, erschien mir etwas unplausibel &#8211; denn ich habe den Header ja damals benutzt, und mein Programm kompilierte. Also habe ich mir die SVN-Historie angeschaut.</p>
<pre class="brush: plain; title: ; notranslate">------------------------------------------------------------------------
r36836 | dgregor | 2007-01-29 20:29:06 +0100 (Mo, 29. Jan 2007) | 2 Zeilen

Improvements to LEDA adaptors, from Jens Mueller</pre>
<pre class="brush: plain; title: ; notranslate">
@@ -528,11 +884,11 @@
   inline
   typename boost::property_traits&lt;
     typename boost::property_map&lt;leda::GRAPH&lt;vtype, etype&gt;,PropertyTag&gt;::const_type
-  &gt;::value_type
+::value_type
   get(PropertyTag p, const leda::GRAPH&lt;vtype, etype&gt;&amp; g, const Key&amp; key) {
     return get(get(p, g), key);
   }
</pre>
<p>Die ersten Indizien sprachen aber gegen mich: In dem Checkin meines Patches von Douglas Gregor wurde auch das > entfernt. Trotzdem: Irgendwie konnte das doch nicht sein. Also habe ich <a href="http://thread.gmane.org/gmane.comp.lib.boost.devel/153254/focus=153834">die Mail</a> herausgesucht, mit der ich den Patch eingereicht habe. Anscheinend habe ich damals den Programmcode <em>im Body</em> der Mail verschickt, statt als Anhang. Klar, mit der Policy von Boost, die Zeilen auf lesbare Länge zu begrenzen, hat das ja auch wunderbar funktioniert. Allerdings wurde dabei offenbar ein  &gt; als gequoteter Text interpretiert. Douglas hat dann einfach den Text in eine Datei kopiert und das fehlende &gt; nicht bemerkt. Jens nix schuld, meine Ehre ist wiederhergestellt. Und da es keine automatisierten Tests für die LEDA-Bindings gibt (dafür bräuchte man ja eine LEDA-Installation, und die gab es damals nur gegen Geld), ist das niemandem aufgefallen. Viel irritierender finde ich aber, dass den Fehler vier Jahre lang niemand bemerkt hat <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_sad.gif' alt=':-(' class='wp-smiley' /> </p>
<p>Naja, jedenfalls wurde mir damals angeboten, Maintainer der LEDA-Bindings zu werden. Inzwischen gibt es <a href="http://www.algorithmic-solutions.com/leda/ledak/index.htm">eine kostenlose Version der LEDA-Bibliothek</a>. Insofern eine gute Gelegenheit, auf das Angebot zurückzukommen. Anscheinend hat sich auch niemand um die Datei gekümmert, und <a href="https://svn.boost.org/trac/boost/ticket/1326">sogar Verbesserungsvorschläge mit fertigen Patches</a> wurden nicht bearbeitet. Vielleicht würde es sich ja lohnen, die wieder hervorzukramen &#8230;</p>
<p><img src="http://vg02.met.vgwort.de/na/1a5161d53f164bd2bc49269b37b6d61c" width="1" height="1" alt=""></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/12/13/boost-leda-und-meine-wiederhergestellte-ehre/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Thunderbird-Addons: Optionen</title>
		<link>http://blog.tessarakt.de/archiv/2011/07/23/thunderbird-addons-optionen/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/07/23/thunderbird-addons-optionen/#comments</comments>
		<pubDate>Sat, 23 Jul 2011 09:02:41 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1269</guid>
		<description><![CDATA[Heute schauen wir uns, wieder am Beispiel von Quicker Filer 0.5.1, an, wie man in einem Thunderbird-Addon Einstellungen benutzt, die als Preferences persistiert werden. In der install.rdf heißt es: Damit wird ein Einstellungsdialog definiert. Standardmäßig wird dieser als Dialogfenster geöffnet. &#8230; <a href="http://blog.tessarakt.de/archiv/2011/07/23/thunderbird-addons-optionen/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Heute schauen wir uns, wieder am Beispiel von <a href="https://addons.mozilla.org/en-us/thunderbird/addon/quicker-filer/versions/?page=1#version-0.5.1">Quicker Filer 0.5.1</a>, an, wie man in einem Thunderbird-Addon Einstellungen benutzt, die als Preferences persistiert werden.</p>
<p>In der <code>install.rdf</code> heißt es:</p>
<pre class="brush: xml; title: ; notranslate">
&lt;em:optionsURL&gt;chrome://quickerfiler/content/options.xul&lt;/em:optionsURL&gt;
</pre>
<p>Damit wird <a href="https://developer.mozilla.org/en/Install_Manifests#optionsURL">ein Einstellungsdialog definiert</a>. <a href="https://developer.mozilla.org/en/Install_Manifests#optionsType">Standardmäßig</a> wird dieser als Dialogfenster geöffnet. Über die Definition des Content Packages in der <code>chrome.manifest</code> (vgl. <a href="http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/">dieses Posting)</a> ergibt sich also, dass der Dialog in <code>content/options.xul</code> definiert ist.</p>
<p>Gehen wir das also der Reihe nach durch.</p>
<pre class="brush: xml; title: ; notranslate">
&lt;?xml version=&quot;1.0&quot;?&gt;
&lt;?xml-stylesheet href=&quot;chrome://global/skin/&quot; type=&quot;text/css&quot;?&gt;
</pre>
<p>Hier wird <a href="https://developer.mozilla.org/en/XUL_Tutorial/Adding_Style_Sheets">ein Stylesheet eingebunden</a>, und zwar ein recht generisches.</p>
<pre class="brush: xml; title: ; notranslate">
&lt;prefwindow id=&quot;quickerfilerPrefWindow&quot; title=&quot;Quicker Filer - Options&quot; xmlns=&quot;http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul&quot;
  buttons=&quot;accept,cancel&quot; height=&quot;550&quot;&gt;
</pre>
<p>Das Fenster ist ein <code>prefwindow</code>, also speziell für Einstellungsdialoge vorgesehen. Es gibt <a href="https://developer.mozilla.org/en/Preferences/Preferences_system">weiterführende Dokumentation</a>, die aber bis auf ein Beispiel und einen Hinweis, wie man so ein Fenster aufruft, keine wesentlichen Infos enthält. Also gehen wir weiter unsere Datei im Detail durch.</p>
<p>Zwei der Attribute sind selbsterklärend: <a href="https://developer.mozilla.org/en/XUL/prefwindow#a-title"><code>title</code></a> definiert den Fenstertitel und <a href="https://developer.mozilla.org/en/XUL/Attribute/height"><code>height</code></a> setzt die bevorzugte Höhe des Fensters in Pixeln. <a href="https://developer.mozilla.org/en/XUL/Attribute/buttons"><code>buttons</code></a> definiert, welche Schaltflächen angezeigt werden, hier also <em>OK</em> und <em>Abbrechen</em>. Das dürfte üblicherweise eine gute Wahl sein.</p>
<pre class="brush: xml; title: ; notranslate">
  &lt;script type=&quot;application/x-javascript&quot; src=&quot;chrome://quickerfiler/content/options.js&quot;/&gt;
</pre>
<p>Hier wird ein Script eingebunden. Es definiert einigige Funktionen, die dann in Event-Handlern aufgerufen werden &#8211; dazu also unten mehr.</p>
<pre class="brush: xml; title: ; notranslate">
  &lt;prefpane id=&quot;quickerfilerOptions.general.prefpane&quot; label=&quot;General&quot; selected=&quot;true&quot;&gt;
</pre>
<p>Eine <a href="https://developer.mozilla.org/en/XUL/prefpane"><code>prefpane</code></a> ist ein Panel, also wohl eine Seite, mit Einstellungen. Der Inhalt kann entweder aus einer gesonderten <code>.xul</code>-Datei geladen oder &#8211; wie hier &#8211; inline definiert werden.</p>
<p><a href="https://developer.mozilla.org/en/XUL/prefpane#a-label"><code>label</code></a> definiert eine Beschriftung. Ob es tatsächlich vorgesehen ist, <a href="https://developer.mozilla.org/en/XUL/prefpane#a-prefpane.selected"><code>selected</code></a> direkt zu setzen, bezweifle ich gerade ein wenig &#8230;</p>
<pre class="brush: xml; title: ; notranslate">
    &lt;preferences&gt;
      &lt;preference id=&quot;extensions.quickerfiler.defaultfolder.text&quot;        name=&quot;extensions.quickerfiler.defaultfolder.text&quot;        type=&quot;string&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.search.root&quot;               name=&quot;extensions.quickerfiler.search.root&quot;               type=&quot;string&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.search.root.account&quot;       name=&quot;extensions.quickerfiler.search.root.account&quot;       type=&quot;string&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.search.root.folder.text&quot;   name=&quot;extensions.quickerfiler.search.root.folder.text&quot;   type=&quot;string&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.mkdir.enable&quot;              name=&quot;extensions.quickerfiler.mkdir.enable&quot;              type=&quot;bool&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.debug.enable&quot;              name=&quot;extensions.quickerfiler.debug.enable&quot;              type=&quot;bool&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.suggestlastfolder.enable&quot;  name=&quot;extensions.quickerfiler.suggestlastfolder.enable&quot;  type=&quot;bool&quot;/&gt;
      &lt;preference id=&quot;extensions.quickerfiler.copysentmessage.enable&quot;    name=&quot;extensions.quickerfiler.copysentmessage.enable&quot;    type=&quot;bool&quot;/&gt;
    &lt;/preferences&gt;
</pre>
<p><a href="https://developer.mozilla.org/en/XUL/preferences">Dieser Block</a> beschreibt die Einstellungen, die in der <code>prefpane</code> geändert werden. Er besteht aus einzelnen <a href="https://developer.mozilla.org/en/Preferences_System/preference"><code>preference</code></a>-Elementen.</p>
<p>Die Attribute sind wieder recht selbsterklärend. <a href="https://developer.mozilla.org/en/Preferences_System/preference#a-preference.name"><code>name</code></a> setzt den Namen der zu ändernden Einstellung (hier zweckmäßigerweise identisch zur ID des jeweiligen Elements), <a href="https://developer.mozilla.org/en/Preferences_System/preference#a-preference.type"><code>type</code></a> legt fest, von welchem Typ der Wert ist. </p>
<pre class="brush: xml; title: ; notranslate">
    &lt;vbox&gt;
</pre>
<p>Die <a href="https://developer.mozilla.org/en/XUL/vbox"><code>vbox</code></a> dient der Gliederung bzw. Layout-Zwecken.</p>
<pre class="brush: xml; title: ; notranslate">
      &lt;groupbox&gt;
        &lt;caption label=&quot;Default folder&quot;/&gt;
        &lt;description&gt;Default folder for instant copy/move&lt;/description&gt;
        &lt;textbox id=&quot;quickerfiler.defaultfolder.textbox&quot;
          preference=&quot;extensions.quickerfiler.defaultfolder.text&quot;
          type=&quot;autocomplete&quot;
          autocompletesearch=&quot;quickerfiler-autocomplete&quot;
          tabScrolling=&quot;true&quot;
          autoFill=&quot;true&quot;
          forceComplete=&quot;true&quot;
          showcommentcolumn=&quot;false&quot; /&gt;
      &lt;/groupbox&gt;
</pre>
<p>Die <a href="https://developer.mozilla.org/en/XUL/groupbox"><code>groupbox</code></a> dient der Gruppierung von Elementen und wird in der Regel mit Umriss gezeichnet. Die <a href="https://developer.mozilla.org/en/XUL/caption"><code>caption</code></a> wird in diesem Umnriss gezeichnet. Die <a href="https://developer.mozilla.org/en/XUL/description"><code>description</code></a> ist ein Textblock, der einfach angezeigt wird.</p>
<p>Die <a href="https://developer.mozilla.org/en/XUL/textbox"><code>textbox</code></a> kann Auto-Vervollständigung und entspricht der <a href="http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/">im letzten Artikel</a> schon genauer erklärten. Genaueres also dort, und die Erläuterung, wie Auto-Vervollständigung im Hintergrund funktioniert, schieben wir immer noch nach hinten.</p>
<pre class="brush: xml; title: ; notranslate">
      &lt;groupbox&gt;
        &lt;caption label=&quot;Search Root&quot;/&gt;
        &lt;description&gt;Determines the scope of the folder list&lt;/description&gt;
        &lt;radiogroup id=&quot;quickerfiler.search.root.radiogroup&quot;
          preference=&quot;extensions.quickerfiler.search.root&quot;&gt;
</pre>
<p>Es folgt eine weitere <code>groupbox</code> mit <code>caption</code> und <code>description</code>. <a href="https://developer.mozilla.org/en/XUL/radiogroup"><code>radiogroup</code></a> definiert eine Gruppe von Radio-Buttons. Es ist die zugehörige <a href="https://developer.mozilla.org/en/XUL/radiogroup#a-preference"><code>preference</code></a> angegeben. Wohlgemerkt verweist der Wert auf die <em>ID</em> des entsprechenden <code>preference</code>-Elements!</p>
<pre class="brush: xml; title: ; notranslate">
          &lt;radio id=&quot;quickerfiler.search.root.allfolders.radio&quot;
            label=&quot;All folders&quot;
            value=&quot;msgaccounts:/&quot;/&gt;
</pre>
<p>Hier wird ein einzelner <a href="https://developer.mozilla.org/en/XUL/radio">Radio-Button</a> definiert. Die Dokumentation weiß anscheinend nicht so recht, dass <a href="https://developer.mozilla.org/en/XUL/radio#a-value">das <code>value</code>-Attribut</a> im Zusammenhang mit Preferences eine feste Bedeutung hat. Vermutlich sollte man das mal explizit dokumentieren. <a href="https://developer.mozilla.org/en/XUL/radio#a-label"><code>label</code></a> definiert die Beschriftung des Radio-Buttons.</p>
<pre class="brush: xml; title: ; notranslate">
          &lt;hbox&gt;
            &lt;radio id=&quot;quickerfiler.search.root.account.radio&quot;
              label=&quot;This account&quot;
              value=&quot;-- account --&quot;/&gt;

            &lt;hbox flex=&quot;1&quot; pack=&quot;end&quot;&gt;
</pre>
<p>Hier wird es layouttechnisch interessant. Der Radio-Button wird zusammen mit der <code>menulist</code> in eine <a href="https://developer.mozilla.org/en/XUL/hbox"><code>hbox</code></a> gesteckt. Die <code>menulist</code> wird nochmal in eine eigene <code>hbox</code> gesteckt, bei der zwei Attribute gesetzt sind. <a href="https://developer.mozilla.org/en/XUL/Attribute/flex"><code>flex="1"</code></a> sorgt dafür, dass sie sämtlichen freien Platz verbraucht. <a href="https://developer.mozilla.org/en/XUL/Attribute/pack"><code>pack="end"</code></a> lässt die <code>menulist</code> nach rechts rutschen. Was mir hier nicht klar ist:</p>
<ul>
<li>Warum ist <code>pack="end"</code> noch nötig, wenn <code>flex="1"</code> angegeben ist? Wie kann in dem Fall noch Platz übrig sein?</li>
<li>Warum ist die <code>menulist</code> nochmal in eine <code>hbox</code> verpackt? Man könnte diese Attribute auch auf der <code>menulist</code> spezifizieren. Erzielt das ggf. auch den gewünscht Effekt? Wenn nein, warum nicht? Wenn ja, warum sollte man es so wie hier machen?</li>
</ul>
<pre class="brush: xml; title: ; notranslate">
              &lt;menulist id=&quot;quickerfiler.search.root.account.menulist&quot;
                preference=&quot;extensions.quickerfiler.search.root.account&quot;
                sortResource=&quot;http://home.netscape.com/NC-rdf#Name&quot;
                sortDirection=&quot;ascending&quot;
                datasources=&quot;rdf:msgaccountmanager rdf:mailnewsfolders&quot;
                containment=&quot;http://home.netscape.com/NC-rdf#child&quot;
                ref=&quot;msgaccounts:/&quot; flex=&quot;1&quot;&gt;
</pre>
<p><a href="https://developer.mozilla.org/en/XUL/menulist"><code>menulist</code></a> definiert eine Dropdown-Auswahlliste. <a href=" https://developer.mozilla.org/en/XUL/menulist#a-preference"><code>preference</code></a> legt wieder fest, welche Einstellung gesetzt wird. <code>flex="1"</code> (nochmal!) sorgt dafür, dass die <code>menulist</code> die komplette Breite ausfüllt.</p>
<p>Die restlichen Attribute (<a href="https://developer.mozilla.org/en/XUL/Attribute/sortResource"><code>sortResource</code></a>, <a href="https://developer.mozilla.org/en/XUL/Attribute/sortDirection"><code>sortDirection</code></a>, <a href="https://developer.mozilla.org/en/XUL/Attribute/datasources"><code>datasources</code></a>, <a href="https://developer.mozilla.org/en/XUL/Attribute/containment"><code>containment</code></a>, <a href=" https://developer.mozilla.org/en/XUL/Attribute/ref"><code>ref</code></a>) beziehen sich darauf, wie man den Inhalt der Liste dynamisch aus einer RDF-Datenquelle zusammenstellen lässt.</p>
<p>Dazu dient auch das darauffolgende <a href="https://developer.mozilla.org/en/XUL/template"><code>template</code></a>:</p>
<pre class="brush: xml; title: ; notranslate">
                &lt;template xmlns:nc=&quot;http://home.netscape.com/NC-rdf#&quot;&gt;
                  &lt;rule nc:ServerType=&quot;nntp&quot;/&gt;
                  &lt;rule nc:IsDeferred=&quot;true&quot;/&gt;
                  &lt;rule nc:IsServer=&quot;true&quot;&gt;
                    &lt;menupopup&gt;
                      &lt;menuitem uri=&quot;...&quot;
                        value=&quot;...&quot;
                        label=&quot;rdf:http://home.netscape.com/NC-rdf#Name&quot;/&gt;
                    &lt;/menupopup&gt;
                  &lt;/rule&gt;
                &lt;/template&gt;
</pre>
<p>Dafür gibt es eine <a href="https://developer.mozilla.org/en/XUL/Template_Guide">eigene Anleitung</a>, und <a href="http://www.jerf.org/resources/xblinjs/whyNotMozilla/notXulTemplates.html">jemanden, der das alles für großen Schrott hält.</a></p>
<p>Insofern verschieben wir das lieber auf später &#8211; bis ich rausgefunden habe, ob das überhaupt etwas taugt. Jedenfalls erstellt das Template wohl ein <a href="https://developer.mozilla.org/en/XUL/menupopup"><code>menupopup</code></a> mit vielen <a href="https://developer.mozilla.org/en/XUL/menuitem"><code>menuitem</code></a>s &#8211; aber ich verstehe schon nicht, warum/ob da nur ein <code>menupopup</code>, aber mehrere <code>menuitem</code>s rauskommen &#8230;</p>
<p>Danach wird es zum Glück erstmal unspannend &#8211; daran merkt man, dass etwas hängen bleibt &#8230; Es werden einige noch offene Elemente geschlossen, und dann kommt eine weitere Radiobox, verbunden mit der Möglichkeit, einen Ordner auszuwählen . Hier kommt wieder die altbekannte Textbox mit Autovervollständigen zum Einsatz. So weit unproblematisch, aber da ist eine Sache, der ich noch auf den Grund gehen muss: In den Einstellungen wird definiert, was die Wurzel für die Suche nach Ordnern ist &#8211; es wäre aber unschön, wenn diese Einstellung auch bei der Festlegung der Wurzel zum Tragen kommt. Ich muss dementsprechend mal ergründen, warum sie es nicht tut &#8211; bzw., ob sie es vielleicht doch tut &#8211; das wäre dann wohl ein Bug.</p>
<p>Danach geht es auch <em>relativ</em> unspannend weiter:</p>
<pre class="brush: xml; title: ; notranslate">
      &lt;groupbox&gt;
        &lt;caption label=&quot;Suggest last folder&quot;/&gt;
        &lt;description&gt;Search box fill be filled with the last transfer folder used&lt;/description&gt;
        &lt;checkbox label=&quot;Suggest last folder&quot; preference=&quot;extensions.quickerfiler.suggestlastfolder.enable&quot;/&gt;
      &lt;/groupbox&gt;
</pre>
<p>Hier kommt zum ersten Mal eine <a href="https://developer.mozilla.org/en/XUL/checkbox"><code>checkbox</code></a> vor. Die hat ein <a href="https://developer.mozilla.org/en/XUL/checkbox#a-label"><code>label</code></a> und ist an eine bestimmte <a href="https://developer.mozilla.org/en/XUL/checkbox#a-preference"><code>preference</code></a> gebunden &#8211; alles easy. Danach kommen noch weitere <code>checkbox</code>es, die ich wiederum überspringe. Interessant ist in dem Zusammenhang nur die Entdeckung der Einstellung <code>quickerfiler.debug.enable</code>. Unter Linux habe ich nämlich Probleme &#8211; vielleicht hilft das ja beim Debuggen.</p>
<p>Jedenfalls ist damit:   </p>
<pre class="brush: xml; title: ; notranslate">
  &lt;/prefpane&gt;
</pre>
<p>die erste Seite der Einstellungen fertig. Es folgt die zur Festlegung der Tastenkombinationen.</p>
<pre class="brush: xml; title: ; notranslate">
  &lt;prefpane id=&quot;quickerfilerOptions.shortcuts.prefpane&quot;
            label=&quot;Keyboard Shortcut&quot;
            onpaneload=&quot;sQuickerFilerOptions.onPaneLoad();&quot;&gt;
    &lt;preferences&gt;
      &lt;preference id=&quot;extensions.quickerfiler.shortcuts.copy.key&quot;
                  name=&quot;extensions.quickerfiler.shortcuts.copy.key&quot;
                  type=&quot;string&quot;/&gt;

       &lt;!-- ... --&gt;     

      &lt;preference id=&quot;extensions.quickerfiler.shortcuts.selfolder.modifiers&quot;
                  name=&quot;extensions.quickerfiler.shortcuts.selfolder.modifiers&quot;
                  type=&quot;string&quot;/&gt;
    &lt;/preferences&gt;
</pre>
<p>Zu Beginn wird wieder definiert, welche Einstellungen auf dieser Seite geändert werden können. Für diverse Aktionen (<code>copy</code>, <code>move</code>, <code>inscopy</code>, <code>insmove</code>, <code>selfolder</code>) wird jeweils eine Einstellung <code>key</code> und eine Einstellung <code>modifiers</code>. Aus Gründen ist das etwas gekürzt.</p>
<p><a href="https://developer.mozilla.org/en/XUL/prefpane#a-onpaneload"><code>onpaneload</code></a> definiert, dass beim Laden der Seite folgende Funktion ausgeführt wird:</p>
<pre class="brush: jscript; title: ; notranslate">
onPaneLoad: function onPaneLoad()
{
  this.updateTreeView();
},
</pre>
<p>Die Funktion <code>updateTreeView()</code> füllt anscheinend einen Treeview anhand der Einstellungen mit den bis jetzt definierten Tastenkürzeln. Die genaue Funktionsweise schaue ich mir an, sobald ich die UI-Elemente selbst angeschaut habe.</p>
<p>In einer <code>vbox</code> folgt dann folgende <code>groupbox</code>:</p>
<pre class="brush: xml; title: ; notranslate">
      &lt;groupbox&gt;
        &lt;caption label=&quot;Available shortcuts&quot;/&gt;

        &lt;tree id=&quot;quickerfilerOptions.shortcuts.availableShortcutsTree&quot;
          onselect=&quot;sQuickerFilerOptions.onAvailableShortcutsTreeSelect();&quot;
          rows=&quot;5&quot; hidecolumnpicker=&quot;true&quot; seltype=&quot;single&quot;&gt;

          &lt;treecols&gt;
            &lt;treecol id=&quot;nameColumn&quot; label=&quot;Name&quot; flex=&quot;1&quot;/&gt;
            &lt;treecol id=&quot;shortcutColumn&quot; label=&quot;Shortcut&quot; flex=&quot;2&quot;/&gt;
          &lt;/treecols&gt;
</pre>
<p>Bis hierhin wurde ersteinmal die Struktur des Baums definiert. Das Hauptelement ist ein <a href="https://developer.mozilla.org/en/XUL/tree"><code>tree</code></a>. <a href="https://developer.mozilla.org/en/XUL/tree#a-tree.onselect"><code>onselect</code></a> wird ausgeführt, wenn eine Zeile im Baum ausgewählt wird. Hier werden wohl die Controls für die Auswahl der Tastenkombination für die entsprechende Aktion gesetzt. Genaueres dann unten, wenn wir uns anschauen, wie der Inhalt aufgebaut ist und initialisiert wird. <a href=" https://developer.mozilla.org/en/XUL/tree#a-rows"><code>rows</code></a> gibt an, wieviele Zeilen gleichzeitig angezeigt werden. Das ist hier gerade die Anzahl der insgesamt existierenden Zeilen. <code><a href="https://developer.mozilla.org/en/XUL/tree#a-seltype">seltype</a>="single"</code> bedeutet, dass es nicht möglich ist, mehrere Zeilen auf einmal auszuwählen. <code><a href="https://developer.mozilla.org/en/XUL/tree#a-hidecolumnpicker">hidecolumnpicker</a>="true"</code> schließlich blendet das &#8220;Menü&#8221; zum Anzeigen und Verstecken einzelner Spalten aus. <a href="https://developer.mozilla.org/en/XUL/treecols"><code>treecols</code></a> enthält einzelne <a href="https://developer.mozilla.org/en/XUL/treecol"><code>treecol</code></a>-Elemente. Deren <a href=" https://developer.mozilla.org/en/XUL/treecol#a-label"><code>label</code></a>-Attribut legt die Spaltenüberschrift fest.</p>
<p><code>tree</code>s sind im übrigen keine triviale Angelegenheit, weshalb es dazu auch <a href="https://developer.mozilla.org/en/XUL_Tutorial/Trees">ein Tutorial</a> gibt. Im allgemeinen Fall können sie aus beliebigen Datenquellen mit großen Datenmengen dynamisch befüllt werden &#8211; beispielsweise die Nachrichten in einer Newsgroup. Diese Datenquellen heißen <em>tree views</em>. Netterweise gibt es auch einen vordefinierten treeview, bei dem die Daten aus XUL-Elementen kommen. Das nennt sich dann <em>content tree</em>. Was man dabei beachten muss: Dadurch, dass die Daten durch einen <em>tree view</em> geschleift werden, ist man nicht sehr flexibel, was man hier angeben kann. Es können wirklich nur für jede Tabellenzelle ein Text und ein Icon angegeben werden. Wie es das Tutorial ausdrückt:</p>
<blockquote><p>Having said that the data to be displayed in a tree comes from a view and not from XUL tags, there happens to be a built-in tree view which gets its data from XUL tags.
</p></blockquote>
<p>Der Rest ist dann unspektakulär:</p>
<pre class="brush: xml; title: ; notranslate">
          &lt;treechildren&gt;
            &lt;treeitem&gt;
              &lt;treerow&gt;
                &lt;treecell label=&quot;Copy&quot; value=&quot;copy&quot;/&gt;
                &lt;treecell label=&quot;disabled&quot;/&gt;
              &lt;/treerow&gt;
            &lt;/treeitem&gt;
            &lt;!-- vier weitere &lt;treeitem&gt;-Elemente für die anderen Aktionen --&gt;
          &lt;/treechildren&gt;
        &lt;/tree&gt;
      &lt;/groupbox&gt;
</pre>
<p>Das Hauptelement ist <a href="https://developer.mozilla.org/en/XUL/treechildren"><code>treechildren</code></a>. Dazu sagt die Doku:</p>
<blockquote><p>This element is the body of the tree. For content trees, the content will be placed inside this element. This element is also used to define container rows in the tree.</p></blockquote>
<p>Zum Glück haben wir einen <em>content tree</em>. Wie der Inhalt sonst definiert wird, oder was <em>container rows</em> sein sollen, steht da nämlich leider nicht.</p>
<p>Darin sind dann fünf <a href="https://developer.mozilla.org/en/XUL/treeitem"><code>treeitem</code></a>s, die jeweils eine <a href="https://developer.mozilla.org/en/XUL/treerow"><code>treerow</code></a> enthalten. Darin wiederum ist dann jeweils eine <a href="https://developer.mozilla.org/en/XUL/treecell"><code>treecell</code></a> pro Spalte. Dabei ist jeweils das Attribut <a href="https://developer.mozilla.org/en/XUL/treecell#a-label"><code>label</code></a> gesetzt, und in der linken Spalte noch <a href="https://developer.mozilla.org/en/XUL/treecell#a-value"><code>value</code></a>, offenbar zum Wiederfinden aus Scripts.</p>
<p>Und mit den oben noch zurückgestellten Scripts machen wir jetzt auch weiter. Zuerst die Funktion updateTreeView(), die (unter anderem) beim Laden der Pane ausgeführt wird:</p>
<pre class="brush: jscript; title: ; notranslate">
  updateTreeView: function updateTreeView()
  {
    var tree = document.getElementById('quickerfilerOptions.shortcuts.availableShortcutsTree');
    var rowCount = tree.view.rowCount;

    for(var i = 0; i&lt;rowCount; i++)
    {
      var shortcut = tree.view.getCellValue(i, tree.columns[0]);
      var key = document.getElementById('extensions.quickerfiler.shortcuts.'+shortcut+'.key').value;
      var modifiers = document.getElementById('extensions.quickerfiler.shortcuts.'+shortcut+'.modifiers').value;

      if(key != undefined &amp;&amp; key != '')
      {
        var text = &quot;&quot;;
        if(modifiers)
          text = modifiers.toUpperCase().split(' ').sort().join(' + ');
        if(text)
          text += ' + ';
        text += key.toUpperCase();

        tree.view.setCellText(i, tree.columns[1], text);
      }
      else
      {
        tree.view.setCellText(i, tree.columns[1], 'disabled');
      }
    }
  }
</pre>
<p>Diese Funktion holt sich zunächst das <code><br />
<tree></code>-Element und geht alle Tabellenzeilen durch: Die Variable <code>shortcut</code> wird auf den <code>value</code> der Tabellenzelle in der ersten Spalte gesetzt. Dieses Attribut dient also, wie oben vermutet, nur dem &#8220;Wiedererkennen&#8221;. <code>key</code> und <code>modifiers</code> werden auf den Wert der entsprechenden Preferences gesetzt (ausgelesen aus den jeweiligen <code>preference</code>-Elementen). Falls diese Werte sinnvoll sind, wird daraus ein String zusammengebastelt, der dann in der zweiten Tabellenspalte angezeigt wird.</p>
<p>Interessant dürften noch die aufgerufenen Methoden (und benutzten Eigenschaften) des <em>tree view</em> (<a href="https://developer.mozilla.org/en/XUL/tree#p-view"><code>tree.view</code></a>) sein, die im <a href="https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsITreeView">Interface <code>nsITreeView</code></a> definiert sind:</p>
<ul>
<li><a href="https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsITreeView#Attributes"><code>rowCount</code></a>: Die Anzahl der Zeilen (hier: 5).</li>
<li><a href="https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsITreeView#getCellValue%28%29"><code>getCellValue(row, col)</code></a>: Holt den Wert der Zelle (der als Attribut angegeben wurde). <a href="https://developer.mozilla.org/en/XUL/tree#p-columns"><code>tree.columns[0]</code></a> liefert die erste (nullte &#8230;) Spalte als Objekt.</li>
<li><a href="https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsITreeView#setCellText%28%29"><code>setCellText(row, col, value)</code></a> wird mit einem Spaltenindex, einem Spaltenobjekt und dem neuen Text der Zelle aufgerufen.</li>
</ul>
<p>Ebenfalls bereits bemerkt hatten wir die Funktion <code>onAvailableShortcutsTreeSelect</code>. Die stellen wir auch weiterhin zurück, da sie Elemente bearbeitet, die wir noch nicht angeschaut haben.</p>
<p>In <code>options.xul</code> kommt nun eine weitere <code>groupbox</code>:</p>
<pre class="brush: xml; title: ; notranslate">
&lt;groupbox id=&quot;quickerfilerOptions.shortcuts.settingsGroupbox&quot; hidden=&quot;true&quot;&gt;
  &lt;caption label=&quot;Shortcut Settings&quot;/&gt;
  &lt;description&gt;These settings apply to the selected shortcut above&lt;/description&gt;

  &lt;hbox&gt;
    &lt;vbox&gt;
      &lt;groupbox&gt;
        &lt;caption label=&quot;Key&quot;/&gt;

        &lt;menulist id=&quot;quickerfilerOptions.shortcuts.shortcutKey&quot;
          oncommand=&quot;sQuickerFilerOptions.onShortcutKeyMenulistCommand();&quot;&gt;
          &lt;menupopup&gt;
            &lt;menuitem value=&quot;&quot; label=&quot;disabled&quot;/&gt;

            &lt;menuitem value=&quot;A&quot; label=&quot;A&quot;/&gt;
             &lt;!-- ... --&gt;
            &lt;menuitem value=&quot;Z&quot; label=&quot;Z&quot;/&gt;

            &lt;menuitem value=&quot;/&quot; label=&quot;/&quot;/&gt;
             &lt;!-- ... --&gt;
            &lt;menuitem value=&quot;]&quot; label=&quot;]&quot;/&gt;
          &lt;/menupopup&gt;
        &lt;/menulist&gt;
      &lt;/groupbox&gt;
    &lt;/vbox&gt;

    &lt;groupbox flex=&quot;1&quot;&gt;
      &lt;caption label=&quot;Modifiers&quot;/&gt;

      &lt;checkbox id=&quot;quickerfilerOptions.shortcuts.shortcutModifier.accel&quot;
        label=&quot;Accel&quot;
        value=&quot;accel&quot;
        oncommand=&quot;sQuickerFilerOptions.onShortcutModifierCommand();&quot;/&gt;
      &lt;!-- und dasselbe für alt, control, meta und shift --&gt;
    &lt;/groupbox&gt;
  &lt;/hbox&gt;
&lt;/groupbox&gt;
</pre>
<p>Zu beachten ist, dass diese <code>groupbox</code> anfangs versteckt ist (<a href="https://developer.mozilla.org/en/XUL/Attribute/hidden"><code>hidden="true"</code></a>)! Sichtbar gemacht wird sie per Script (siehe unten), sobald im Treeview ein Befehl ausgewählt wird. Die eigentlichen Controls sind dann eine Dropdown-Liste (<a href="https://developer.mozilla.org/en/XUL/menulist"><code>menulist</code></a>), die alle möglichen Tasten enthält, und <a href="https://developer.mozilla.org/en/XUL/checkbox"><code>checkbox</code></a>es für die verschiedenen Modifier. Das ist jetzt hinreichend langweilig, dass es der geneigte Leser gerne eigenständig in der Dokumentation nachlesen darf. Für Veränderungen sind Event-Listener definiert, auf die ich später noch eingehe. Damit ist die Beschreibung des Fensters dann auch schon zu Ende.</p>
<p>Jetzt also die Funktion, die ausgeführt wird, wenn man ein Kommando auswählt, um dafür ein Tastenkürzel zu vergeben:</p>
<pre class="brush: jscript; title: ; notranslate">
onAvailableShortcutsTreeSelect: function onAvailableShortcutsTreeSelect()
  {
    var tree = document.getElementById('quickerfilerOptions.shortcuts.availableShortcutsTree');
    var shortcut = tree.view.getCellValue(tree.currentIndex, tree.columns[0]);

    var keyEl = document.getElementById('extensions.quickerfiler.shortcuts.'+shortcut+'.key');
    var key = &quot;&quot;;
    var modifiers = &quot;&quot;;
    if(keyEl!=null)
    {
      key = keyEl.value;
      if(key==null)
        key = &quot;&quot;;
      else
        modifiers = document.getElementById('extensions.quickerfiler.shortcuts.'+shortcut+'.modifiers').value;
    }

    document.getElementById('quickerfilerOptions.shortcuts.settingsGroupbox').hidden = false;
    document.getElementById('quickerfilerOptions.shortcuts.shortcutKey').value = key.toUpperCase();

    for(var i in this.mModifiers)
    {
      document.getElementById('quickerfilerOptions.shortcuts.shortcutModifier.'+this.mModifiers[i]).checked = (modifiers.indexOf(this.mModifiers[i])&gt;-1)
    }

      this.updateTreeView();
  }
</pre>
<p>Zunächst wird die aktuell ausgewählte Zeile der <code>treelist</code> bestimmt (<a href="https://developer.mozilla.org/en/XUL/tree#p-currentIndex"><code>tree.currentIndex</code></a>). Diese Eigenschaft funktioniert nur bei <code>seltype="single"</code>, aber das ist hier ja gesetzt. <code>keyEl</code> wird dann auf das <code>preference</code>-Element gesetzt. Ggf. werden aus diesem und dem für die Modifiers die entsprechenden Werte ausgelesen. Dann wird die <code>groupbox</code> angezeigt (<code>hidden</code> wird auf <code>false</code> gesetzt), der passende Eintrag der <code>menulist</code> wird selektiert, und die Chechboxes der entsprechenden Modifiers ggf. angekreuzt.</p>
<p>Bleiben noch die zwei Event-Listener, die auf Veränderungen an diesen Elementen reagieren:</p>
<pre class="brush: jscript; title: ; notranslate">
  onShortcutKeyMenulistCommand: function onShortcutKeyMenulistCommand()
  {
    // User selected another shortcut key from the pop up menu,
    // set this as new shortcut key for the current selected command:
    var tree = document.getElementById('quickerfilerOptions.shortcuts.availableShortcutsTree')
    var shortcut = tree.view.getCellValue(tree.currentIndex, tree.columns[0]);

    document.getElementById('extensions.quickerfiler.shortcuts.' + shortcut + '.key').value =
      document.getElementById('quickerfilerOptions.shortcuts.shortcutKey').value;

    this.updateTreeView();
  }
</pre>
<p>Eigentlich recht selbsterklärend: Wenn eine andere Taste ausgewählt wurde, wird die entsprechende <code>preference</code> gesetzt. <code>updateTreeView()</code> setzt dann für alle Zeilen des treeview die Werte neu (was im Grunde Overkill ist &#8211; aber immerhin bleiben die Zeilen an sich erhalten &#8211; sonst ginge bestimmt auch der <a href="http://de.wikipedia.org/wiki/Fokus_%28GUI%29">Fokus</a> verloren).</p>
<pre class="brush: jscript; title: ; notranslate">
  onShortcutModifierCommand: function onShortcutModifierCommand()
  {
    var tree = document.getElementById('quickerfilerOptions.shortcuts.availableShortcutsTree');
    var shortcut = tree.view.getCellValue(tree.currentIndex, tree.columns[0]);

    var modifiers = [];
    for(var i in this.mModifiers)
    {
      if(document.getElementById('quickerfilerOptions.shortcuts.shortcutModifier.'+this.mModifiers[i]).checked)
        modifiers.push(this.mModifiers[i]);
    }

    document.getElementById('extensions.quickerfiler.shortcuts.'+shortcut+'.modifiers').value = modifiers.join(' ');

    this.updateTreeView();
  }
</pre>
<p>Auch das ist wieder selbsterklärend: Wenn sich ein Modifier geändert hat, wird die komplette Liste wieder erstellt und in der Preference gespeichert, danach werden die Werte des <code>treelist</code> neu gesetzt.</p>
<p>Damit wären wir auch am Ende dieses Teils unseres kleinen Kurses. Zum Lernen ist dieses Beispiel ja ganz nett &#8211; aber um einfach nur eine Tastenkombination zu setzen, ist das doch ziemlich viel Aufwand. Schöner wäre ein eigenes XUL-Control, bei dem man die Tastenkombination einfach ein<em>tippen</em> kann. Daher habe ich das in <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=673669">Bug 673669</a> vorgeschlagen.</p>
<p>Und wieder der obligatorische Hinweis: Code-Schnipsel stammen aus Quicker Filer 0.5.1, sind Copyright (C) 2010 Eivind Rovik und stehen unter <a href="http://www.gnu.org/licenses/">GPL</a> (Version 3 oder jede spätere Version).<img src="http://vg07.met.vgwort.de/na/9a52204ae3594355bbc9039df0a4a9f1" width="1" height="1" alt=""></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/07/23/thunderbird-addons-optionen/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Properties in Tomcat</title>
		<link>http://blog.tessarakt.de/archiv/2011/07/11/properties-in-tomcat/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/07/11/properties-in-tomcat/#comments</comments>
		<pubDate>Mon, 11 Jul 2011 11:39:28 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1221</guid>
		<description><![CDATA[Wenn man danach sucht, wie man Properties in Webapps bzw. Servlets lädt, findet man viel Unsinn, bzw. nicht richtig durchdachte oder unvollständige Lösungen. Das hier ist daher ein Versuch, für mich selbst mal einen funktionierenden Ansatz zusammenzuschreiben. Ausgangspunkt war dieser &#8230; <a href="http://blog.tessarakt.de/archiv/2011/07/11/properties-in-tomcat/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Wenn man danach sucht, wie man Properties in Webapps bzw. Servlets lädt, findet man viel Unsinn, bzw. nicht richtig durchdachte oder unvollständige Lösungen. Das hier ist daher ein Versuch, für mich selbst mal einen funktionierenden Ansatz zusammenzuschreiben.</p>
<p>Ausgangspunkt war <a href="http://jaitechwriteups.blogspot.com/2007/01/how-to-read-properties-file-in-web.html">dieser Blog-Eintrag</a>. Zum Zugriff auf eine Properties-Datei wird dort folgender Code verwendet:</p>
<pre class="brush: java; title: ; notranslate">
InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(&quot;myApp.properties&quot;);
Properties properties = new Properties();
properties.load(inputStream);
</pre>
<p>So weit, so gut. OK, das Laden von Konfiguration über einen Classloader erscheint auf den ersten Blick merkwürdig. Aber sei es drum &#8230;</p>
<p>Bloß: Wo lege ich die Konfigurationsdatei jetzt ab, so dass sie auch gefunden wird? Im WAR/AAR jedenfalls nicht &#8211; ich will diese Archive ja nicht neu packen, bloß weil sich (Deployment-spezifische) Einstellungen ändern. <a href="http://pragmaticjava.blogspot.com/2009/01/tomcat-6-and-class-loading.html">Ein anderes Blog</a> brachte dann eine Lösung, jedenfalls für Tomcat: Man soll den <em>shared class loader</em> benutzen. Also habe ich meine Datei in <code>$CATALINA_HOME/shared/classes</code> angelegt. Schnell noch die Property <code>shared.loader</code> in <code>conf/catalina.properties</code> angepasst &#8230; Doch halt: Die ist schon da und ist leer, was laut Kommentar heißt, dass in <code>$CATALINA_HOME/shared</code> gesucht wird. Für mein Empfinden ist das etwas anderes als <code>$CATALINA_HOME/shared/classes</code>. Naja, egal. Ich hatte keine Lust auf weiteres Ausprobieren und habe die Property einfach neu gesetzt:</p>
<pre class="brush: plain; title: ; notranslate">
shared.loader=${catalina.home}/shared/classes
</pre>
<p>Das tut jetzt sowohl für Webapps/Servlets als auch für Axis2-Webservices. Prima.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/07/11/properties-in-tomcat/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Thunderbird-Addons: Chrome-Manifest, XUL-Overlays</title>
		<link>http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/#comments</comments>
		<pubDate>Sun, 10 Jul 2011 12:47:55 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Software]]></category>
		<category><![CDATA[mozilla]]></category>
		<category><![CDATA[thunderbird]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1243</guid>
		<description><![CDATA[Und weiter geht es da, wo der letzte Teil aufgehört hat: Was steht eigentlich in diesem Chrome Registration Manifest so drin? Beispiel ist wieder Quicker Filer 0.5.1. Die chrome.manifest sieht dort so aus: Der Reihe nach: Die erste Zeile ist &#8230; <a href="http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Und weiter geht es da, wo <a href="http://blog.tessarakt.de/archiv/2011/07/09/thunderbird-addons-grundstruktur/">der letzte Teil</a> aufgehört hat: Was steht eigentlich in diesem <a href="https://developer.mozilla.org/en/Chrome_Registration#The_Chrome_Registry">Chrome Registration Manifest</a> so drin? Beispiel ist wieder <a href="https://addons.mozilla.org/en-us/thunderbird/addon/quicker-filer/versions/?page=1#version-0.5.1">Quicker Filer 0.5.1</a>. Die <code>chrome.manifest</code> sieht dort so aus:</p>
<pre class="brush: plain; title: ; notranslate">
content     quickerfiler    content/

overlay chrome://messenger/content/messenger.xul chrome://quickerfiler/content/messengeroverlay.xul
overlay chrome://messenger/content/messengercompose/messengercompose.xul chrome://quickerfiler/content/messengercomposeoverlay.xul

component {1C28D908-9DD7-11E0-B67F-DCD94724019B} components/quickerfilerautocomplete.js
contract @mozilla.org/autocomplete/search;1?name=quickerfiler-autocomplete {1C28D908-9DD7-11E0-B67F-DCD94724019B}
</pre>
<p>Der Reihe nach:</p>
<ul>
<li>Die erste Zeile ist ein sog. <a href="https://developer.mozilla.org/en/Chrome_Registration#content"><em>content package</em></a>.<br />
Das erste <code>content</code> ist ein Schlüsselwort. <code>quickerfiler</code> ist der Name des Packages. <code>content/</code> ist ein URI, der auf den Inhalt des Packages zeigt &#8211; in diesem Fall ein relativer Pfad. Diese Registrierung sorgt dafür, dass Chrome-URIs der Form <code>chrome://quickerfiler/content/...</code> (man beachte, dass auch hier <code>content</code> auftaucht!) aufgelöst werden können, also die entsprechenden Dateien gefunden werden.</li>
<li>Die zweite und dritte Zeile <a href="https://developer.mozilla.org/en/Chrome_Registration#overlay">definieren</a> <a href="https://developer.mozilla.org/en/XUL_Overlays">XUL-Overlays</a>, also Erweiterungen von bestehenden Sichten der Benutzeroberfläche. Vorliegend werden das Hauptfenster (3-pane window) und das Fenster zum Verfassen neuer Mails erweitert &#8211; dazu aber später mehr.</li>
<li>Schließlich folgen noch die Definition <a href="https://developer.mozilla.org/en/Chrome_Registration#component">einer Komponente</a> und <a href="https://developer.mozilla.org/en/Chrome_Registration#contract">eines sog. Contracts</a> (also einer Schnittstelle mit einer Implementierung). Mehr über Komponenten im allgemeinen und diese spezielle später.</li>
</ul>
<p>Kommen wir also zu den XUL-Overlays. <code>content/messengeroverlay.xul</code> sieht wie folgt aus:</p>
<pre class="brush: xml; title: ; notranslate">
&lt;?xml version=&quot;1.0&quot;?&gt;
&lt;window xmlns=&quot;http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul&quot;&gt;
  &lt;script type=&quot;application/x-javascript&quot; src=&quot;chrome://quickerfiler/content/messengeroverlay.js&quot;/&gt;
  &lt;keyset&gt;
    &lt;key id=&quot;quickerfiler_key_move&quot;    oncommand=&quot;sQuickerFilerMessengerOverlay.openDialog('move');&quot; modifiers=&quot;alt&quot; key=&quot;q&quot; /&gt;
    &lt;key id=&quot;quickerfiler_key_copy&quot;    oncommand=&quot;sQuickerFilerMessengerOverlay.openDialog('copy');&quot; /&gt;
    &lt;key id=&quot;quickerfiler_key_insmove&quot; oncommand=&quot;sQuickerFilerMessengerOverlay.openDialog('insmove');&quot; /&gt;
    &lt;key id=&quot;quickerfiler_key_inscopy&quot; oncommand=&quot;sQuickerFilerMessengerOverlay.openDialog('inscopy');&quot; /&gt;
    &lt;key id=&quot;quickerfiler_key_selfolder&quot; oncommand=&quot;sQuickerFilerMessengerOverlay.openDialog('selfolder');&quot;  modifiers=&quot;alt&quot; key=&quot;r&quot; /&gt;
  &lt;/keyset&gt;
&lt;/window&gt;
</pre>
<p>Das Ganze ist, wie schon erwähnt, ein Overlay für <a href="http://mxr.mozilla.org/comm-central/source/mail/base/content/messenger.xul">messenger.xul</a>, das Hauptfenster von Thunderbird. Dieses Hauptfenster ist ziemlich kompliziert und importiert noch diverse andere XUL-Dokumente. Aber zum Glück kommt es darauf nicht wirklich an &#8211; das Overlay definiert einfach Aktionen, die mit Tastenkombinationen ausgelöst werden können und legt fest, welche Javascript-Kommandos in dem Fall ausgeführt werden. Die Ergänzung von Kontextmenüs o.ä. wäre vermutlich sehr viel komplizierter &#8230;</p>
<p>Die Bedeutung des <a href="https://developer.mozilla.org/en/XUL/script"><code>script</code></a>-Elements ist ziemlich offensichtlich, genau wie die von <a href=" https://developer.mozilla.org/en/XUL/keyset"><code>keyset</code></a> und <a href="https://developer.mozilla.org/en/XUL/key"><code>key</code></a>. Außerdem gibt es noch <a href="https://developer.mozilla.org/en/XUL_Tutorial/Keyboard_Shortcuts">ein Tutorial zu dem ganzen Thema</a>. Was vielleicht noch interessant ist, dass nur zwei der <code>key</code>-Elemente auch tatsächlich schon eine Tastenkombination festlegen. Das geschieht zur Laufzeit: <code>content/messengeroverlay.js</code> registriert folgenden Event-Handler:</p>
<pre class="brush: jscript; title: ; notranslate">
window.addEventListener('load', function () { sQuickerFilerMessengerOverlay.onLoad(); }, false);
</pre>
<p>Dieser Listener wird <a href="https://developer.mozilla.org/en/DOM/element.addEventListener">zum Fenster hinzugefügt</a> also ausgeführt, wenn das Fenster (in diesem Fall also das Hauptfenster von Thunderbird <a href="https://developer.mozilla.org/en/XUL/Events#Inherited_DOM_events">geladen ist</a>. <code>sQuickerFilerMessengerOverlay.onLoad()</code> lädt die Tastenkombinationen aus den Preferences und setzt die entsprechenden Eigenschaften der <code>key</code>-Elemente.</p>
<p>Das andere Overlay ist <code>content/messengercomposeoverlay.xul</code>:</p>
<pre class="brush: xml; title: ; notranslate">
&lt;?xml version=&quot;1.0&quot;?&gt;

&lt;overlay id=&quot;sample&quot; xmlns=&quot;http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul&quot;&gt;

  &lt;script type=&quot;application/x-javascript&quot; src=&quot;chrome://quickerfiler/content/common.js&quot;/&gt;
  &lt;script type=&quot;application/x-javascript&quot; src=&quot;chrome://quickerfiler/content/messengercomposeoverlay.js&quot;/&gt;

  &lt;vbox id=&quot;addresses-box&quot;&gt;
    &lt;toolbox id=&quot;quickerfiler.CopyToFolderToolbox&quot;&gt;
      &lt;hbox align=&quot;center&quot;&gt;
        &lt;label value=&quot;Copy message to:&quot; /&gt;
        &lt;textbox id=&quot;quickerfiler.CopyToFolder&quot; flex=&quot;1&quot; class=&quot;toolbar&quot; disableonsend=&quot;true&quot;
          type=&quot;autocomplete&quot;
          autocompletesearch=&quot;quickerfiler-autocomplete&quot;
          maxrows=&quot;14&quot;
          tabscrolling=&quot;true&quot;
          autoFill=&quot;true&quot;
          forcecomplete=&quot;true&quot;
          showcommentcolumn=&quot;false&quot; /&gt;
      &lt;/hbox&gt;
    &lt;/toolbox&gt;
  &lt;/vbox&gt;

&lt;/overlay&gt;</pre>
<p>Dieses Overlay erweitert <a href="http://mxr.mozilla.org/comm-central/source/mail/components/compose/content/messengercompose.xul"><code>messengercompose.xul</code></a>.</p>
<p>Die <code>script</code>-Elemente sind wieder selbsterklärend. Allerdings fällt auf, dass weiter unten keine Javascript-Befehle enthalten sind. Warum wird also überhaupt Code aufgerufen? Nun, <code>content/messengercompose.js</code> enthält folgende Befehle (die beim Laden des Skripts ausgeführt werden):</p>
<pre class="brush: jscript; title: ; notranslate">
window.addEventListener('load', function () { sQuickerFilerMessengerComposeOverlay.onOpen(); }, false);
window.addEventListener('compose-window-reopen', function () { sQuickerFilerMessengerComposeOverlay.onOpen(); }, true);
window.addEventListener(&quot;compose-send-message&quot;, function(aEvent) { sQuickerFilerMessengerComposeOverlay.sendEventHandler(aEvent); }, true);
</pre>
<p>Zur genauen Bedeutung der Events später mehr, wenn ich mir den Code anschaue. </p>
<p>Die <code><vbox id="addresses-box"></code> taucht bereits im Dokument auf. Das heißt also, das dieses Element vom Overlay erweitert wird &#8211; in diesem Fall wird eine <a href="https://developer.mozilla.org/en/XUL/toolbox"><code>toolbox</code></a> hinzugefügt (unter der Empfängerliste und der Betreffzeile. Warum ausgerechnet eine <code>toolbox</code>, ist mir übrigens nicht klar. Laut Dokumentation dienen diese als Container für <code>toolbar</code>s &#8211; eine solche taucht hier aber nicht auf (ah, halt: Die Textbox unten hat <code>class="toolbar"</code> &#8211; vielleicht hat das ja etwas zu bedeuten). Darin ist dann eine <a href="https://developer.mozilla.org/en/XUL/hbox"><code>hbox</code></a>, ein einfacher Container, der der Gruppierung dient. Das <a href="https://developer.mozilla.org/en/XUL/label"><code>label</code></a> ist ebenfalls uninteressant (außer vielleicht für die Frage, wie das Ganze layouttechnisch funktioniert &#8211; dazu vielleicht ein anderes Mal mehr).</p>
<p>Das Spannende ist dagegen die <a href="https://developer.mozilla.org/en/XUL/textbox"><code>textbox</code></a>. Gehen wir einfach die Attribute einzeln durch:</p>
<ul>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/flex"><code>flex</code></a>: Dieses Attribut legt fest, wie freier Platz zwischen Elementen verschoben wird. In diesem Fall geht also sämtlicher freier Platz an diese Textbox.</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/class"><code>class</code></a>: Dieses Element wird in Stylesheets benutzt. Das deutet darauf hin, dass die Verwendung des <code>toolbox</code>-Elements auch nur layouttechnische Gründe hat.</li>
<li><code>disableonsend</code>: Hier fehlt auf MDN Dokumentation, siehe <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=670512">Mozilla-Bug 670512</a>.</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/textbox.type"><code>type</code></a>: Gibt den Typ der <code>textbox</code> an, wenn es nicht nur ein simples Textfeld sein soll. In diesem Fall, <code>autocomplete</code>, ist die Sache so kompliziert, dass es <a href="https://developer.mozilla.org/En/XUL/Textbox_%28XPFE_autocomplete%29">gesonderte Dokumentation</a> dazu gibt. Die folgenden Attribute sind alle spezifisch für <code>autocomplete</code>. Im Zusammenhang ist das wohl Thema für einen eigenen Artikel &#8230;</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/autocompletesearch"><code>autocompletesearch</code></a>: Gibt an, wo die Vorschläge für die Autocompletion herkommen, in diesem Fall von einer speziellen Komponente statt von einer der vordefinierten</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/maxrows"><code>maxrows</code></a>: Wie viele Vorschläge werden auf einmal angezeigt, also wie hoch ist das &#8220;Menü&#8221; höchstens?</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/tabscrolling"><code>tabscrolling</code></a>: In diesem Fall iteriert man mit Tab durch die Vorschläge, anstatt zum nächsten Element zu gehen.</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/autofill"><code>autoFill</code></a>: Es findet automatische Vervollständigung während des Tippens statt.</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/forcecomplete"><code>forcecomplete</code></a>: Wenn man zu einem anderen Element geht, wird die Eingabe zwangsweise zu einem Vorschlag vervollständigt. Das heißt aber offenbar nicht, dass es nicht möglich ist, auch anderen Text einzugeben als einen der Vorschläge.</li>
<li><a href="https://developer.mozilla.org/en/XUL/Attribute/showcommentcolumn"><code>showcommentcolumn</code></a>: Es werden zu den Vorschlägen keine weiteren Kommentare angezeigt.</li>
</ul>
<p>Außerdem gibt es noch zwei eigenständige XUL-Dialoge, <code>options.xul</code> und <code>quickerfilerdialog.xul</code>. Auf die werde ich eingehen, wenn ich alles andere durchhabe und dort noch interessante neue Dinge finde. Als nächstes sind erstmal der Javascript-Code der bisher vorgestellten Funktionalität sowie die Komponente für die Autovervollständigung dran. Es wird also unter anderem um <a href="https://developer.mozilla.org/en/XPCOM">XPCOM</a> gehen.</p>
<p>Wieder der obligatorische Hinweis: Code-Schnipsel stammen aus Quicker Filer 0.5.1, sind Copyright (C) 2010 Eivind Rovik und stehen unter <a href="http://www.gnu.org/licenses/">GPL</a> (Version 3 oder jede spätere Version).<img src="http://vg07.met.vgwort.de/na/b630b21fd21945db8c450bf2e6f0f210" width="1" height="1" alt=""></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/07/10/thunderbird-addons-chrome-manifest-xul-overlays/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Thunderbird-Addons: Grundstruktur</title>
		<link>http://blog.tessarakt.de/archiv/2011/07/09/thunderbird-addons-grundstruktur/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/07/09/thunderbird-addons-grundstruktur/#comments</comments>
		<pubDate>Sat, 09 Jul 2011 06:44:12 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Software]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1230</guid>
		<description><![CDATA[Ich hatte ja gerade angedroht, hier mal ein Thunderbird-Addon genauer unter die Lupe zu nehmen, nämlich Quicker Filer, konkret die gerade aktuelle Version 0.5.1. Packt man das Archiv quicker_filer-0.5.1-tb.xpi aus (mit unzip), kommen folgende Dateien zum Vorschein: ./chrome.manifest ./content ./content/common.js &#8230; <a href="http://blog.tessarakt.de/archiv/2011/07/09/thunderbird-addons-grundstruktur/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Ich hatte ja gerade <a href="http://blog.tessarakt.de/archiv/2011/07/09/mail-ordner-suchen/">angedroht</a>, hier mal ein Thunderbird-Addon genauer unter die Lupe zu nehmen, nämlich Quicker Filer, konkret <a href="https://addons.mozilla.org/en-us/thunderbird/addon/quicker-filer/versions/?page=1#version-0.5.1">die gerade aktuelle Version 0.5.1</a>.</p>
<p>Packt man das Archiv <code>quicker_filer-0.5.1-tb.xpi</code> aus (mit unzip), kommen folgende Dateien zum Vorschein:</p>
<blockquote><p>
<code>./chrome.manifest<br />
./content<br />
./content/common.js<br />
./content/options.js<br />
./content/options.xul<br />
./content/messengercomposeoverlay.xul<br />
./content/quickerfilerdialog.xul<br />
./content/quickerfilerdialog.js<br />
./content/messengeroverlay.js<br />
./content/messengercomposeoverlay.js<br />
./content/messengeroverlay.xul<br />
./components<br />
./components/quickerfilerautocomplete.js<br />
./install.rdf</code></p></blockquote>
<p>Einen Überblick, wie die Struktur so einer Extension aussehen soll, gibt <a href="https://developer.mozilla.org/en/Building_an_Extension">diese Anleitung</a>. Die Struktur so eines <em>Bundles</em> ist auch nochmal <a href="https://developer.mozilla.org/en/Bundles">hier</a> erläutert, wobei sich da einiges zu überschneiden scheint.</p>
<p>Ausgangspunkt ist jedenfalls erstmal die <code>install.rdf</code>, also ein <a href="https://developer.mozilla.org/en/Install_Manifests">Install Manifest</a>. Im vorliegenden Fall sieht das so aus:</p>
<pre class="brush: xml; title: ; notranslate">
&lt;?xml version=&quot;1.0&quot;?&gt;

&lt;RDF xmlns=&quot;http://www.w3.org/1999/02/22-rdf-syntax-ns#&quot;
     xmlns:em=&quot;http://www.mozilla.org/2004/em-rdf#&quot;&gt;

  &lt;Description about=&quot;urn:mozilla:install-manifest&quot;&gt;
    &lt;em:id&gt;qfiler@eivind.rovik&lt;/em:id&gt;
    &lt;em:name&gt;Quicker Filer&lt;/em:name&gt;
    &lt;em:version&gt;0.5.1&lt;/em:version&gt;
    &lt;em:description&gt;Quicker Filer [...]&lt;/em:description&gt;
    &lt;em:creator&gt;Eivind Rovik&lt;/em:creator&gt;
    &lt;em:type&gt;2&lt;/em:type&gt;

    &lt;em:optionsURL&gt;chrome://quickerfiler/content/options.xul&lt;/em:optionsURL&gt;

    &lt;em:targetApplication&gt;
      &lt;Description&gt;
        &lt;em:id&gt;{3550f703-e582-4d05-9a08-453d09bdfdc6}&lt;/em:id&gt;
        &lt;em:minVersion&gt;3.0&lt;/em:minVersion&gt;
        &lt;em:maxVersion&gt;5.*&lt;/em:maxVersion&gt;
      &lt;/Description&gt;
    &lt;/em:targetApplication&gt;

  &lt;/Description&gt;
&lt;/RDF&gt;
</pre>
<p>Das &#8220;basic layout&#8221; stimmt also überein. Gehen wir die Eigenschaften mal der Reihe nach durch, erst die erforderlichen:</p>
<ul>
<li><code>id</code>: Hier im @-Format angegeben &#8211; das ist in der Tat deutlich anschaulicher als GUIDs &#8230;</li>
<li><code>version</code>: Auch wenn man <a href="https://developer.mozilla.org/en/Toolkit_version_format">daraus durchaus eine Wissenschaft machen kann</a>, ist es in diesem Fall recht einfach: Drei Zahlen, durch Punkte getrennt.</li>
<li><code>type</code>: Hier wird es unintuitiv. &#8220;2&#8243; steht für eine Extension &#8211; also das, worum es mir gerade auch geht.</li>
<li><code>targetApplication</code>: Was hier zulässige Werte für <code>id</code> sind, ist <a href="https://addons.mozilla.org/en-US/firefox/pages/appversions/">auf dieser Seite</a> aufgelistet. Thunderbird ist <code>{3550f703-e582-4d05-9a08-453d09bdfdc6}</code>. <code>minVersion</code> und <code>maxVersion</code> sagen aus, mit welchen Thunderbird-Versionen das Addon kompatibel ist, in diesem Fall also alle Versionen von 3.0 bis zu 5.* (das .* spielt mit dem Rapid Release Scheme wohl eh keine Rolle mehr &#8230;).</li>
<li><code>name</code>: Der Name des Addons, hier also Quicker Filer.</li>
</ul>
<p>Außerdem gibt es noch optionale Eigenschaften. Ich gehe jetzt nur auf die ein, die bei Quicker Filer gesetzt sind:</p>
<ul>
<li><code>description</code>: Eine einzeilige Beschreibung, die im UI (also dem Addon-Manager) angezeigt wird.</li>
<li><code>creator</code>: Der Name des Entwicklers</li>
<li><code>optionsURL:</code> Die <code>chrome</code>-URL eines Einstellungsdialogs für das Addon. Dazu in einem späteren Post mehr.</li>
</ul>
<p>Schauen wir uns anhand <a href="https://developer.mozilla.org/en/Bundles">der bereits genannten Seite</a> die restlichen Dateien an:</p>
<ul>
<li><code>chrome.manifest</code>: Ein sog. <a href="https://developer.mozilla.org/en/Chrome_Registration#The_Chrome_Registry">Chrome Registration Manifest</a>. <em>Chrome</em> ist alles, was zum UI der eigentlichen Anwendung gehört &#8211; bei Thunderbird also alles bis auf die angezeigten Mails, und eventuell auch angezeigte Webseiten. Im Prinzip wird dort der Aufbau des Pakets beschrieben &#8211; auf die Details werde ich in einem späteren Posting eingehen.</li>
<li><code>components</code>: In diesem Verzeichnis liegen XPCOM-Komponenten &#8211; auch dazu später mehr.</li>
<li><code>content</code>: Der Name dieses Verzeichnisses folgt keiner besonderen Konvention. In dem Verzeichnis liegen Teile des User-Interfaces, diese müssen aber in <code>chrome.manifest</code> registriert werden. Dazu also später mehr.</li>
</ul>
<p>Damit endet der Überblick über die Struktur eines Addons und damit der erste Teil einer vermutlich längeren Serie von Postings. Zur Sicherheit noch der obligatorische Hinweis: Code-Schnipsel stammen aus Quicker Filer 0.5.1, sind Copyright (C) 2010 Eivind Rovik und stehen unter <a href="http://www.gnu.org/licenses/">GPL</a> (Version 3 oder jede spätere Version).<img src="http://vg07.met.vgwort.de/na/2f2b9835e74f4595868b79077b1935d4" width="1" height="1" alt=""></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/07/09/thunderbird-addons-grundstruktur/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Begriff gesucht</title>
		<link>http://blog.tessarakt.de/archiv/2011/04/17/begriff-gesucht/</link>
		<comments>http://blog.tessarakt.de/archiv/2011/04/17/begriff-gesucht/#comments</comments>
		<pubDate>Sat, 16 Apr 2011 23:05:44 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1201</guid>
		<description><![CDATA[Ich fange mal mit einem Beispiel an: Ein Compiler übersetzt ja ein Programm von einer Hochsprache in Maschinencode (jetzt mal ganz platt ausgedrückt). Operational gesehen ist das das Gleiche. Aber dabei geht (insbesondere, wenn man Optimierungen anwendet), Struktur verloren. Das &#8230; <a href="http://blog.tessarakt.de/archiv/2011/04/17/begriff-gesucht/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Ich fange mal mit einem Beispiel an: Ein Compiler übersetzt ja ein Programm von einer Hochsprache in Maschinencode (jetzt mal ganz platt ausgedrückt). Operational gesehen ist das das Gleiche. Aber dabei geht (insbesondere, wenn man Optimierungen anwendet), Struktur verloren. Das führt dann beispielsweise dazu, dass Debugger nicht mehr richtig funktionieren (oder jedenfalls sehr viel schwerer zu schreiben sind). Wenn man das vermeidet und dafür sorgt, dass die Information aus dem Hochsprachenprogramm auch auf Maschinencodeebene verfügbar ist &#8211; wie könnte man das nennen? &#8220;Semantikerhaltende Transformation&#8221; trifft es nicht &#8211; die Semantik (im Sinne von Ausführungssemantik) bleibt ja erhalten. Vielleicht &#8220;strukturerhaltende Transformation&#8221;?</p>
<p>Oder vielleicht gibt es sogar Literatur, die sich mit dieser eher philosophischen Frage befasst?</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2011/04/17/begriff-gesucht/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Native Libraries in Java</title>
		<link>http://blog.tessarakt.de/archiv/2010/02/02/native-libraries-in-java/</link>
		<comments>http://blog.tessarakt.de/archiv/2010/02/02/native-libraries-in-java/#comments</comments>
		<pubDate>Tue, 02 Feb 2010 14:11:55 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1047</guid>
		<description><![CDATA[Java erlaubt das Einbinden &#8220;nativer&#8221; Bibliotheken (also .so bzw. .dll, C-Bibliotheken halt). Allerdings gibt es da einige Tücken: Die Bibliothek muß mit System.loadLibrary("name"); explizit geladen werden. Sie ist dann nur in dem Classloader verfügbar, mit dem sie geladen wurde. Das &#8230; <a href="http://blog.tessarakt.de/archiv/2010/02/02/native-libraries-in-java/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Java erlaubt das Einbinden &#8220;nativer&#8221; Bibliotheken (also .so bzw. .dll, C-Bibliotheken halt). Allerdings gibt es da einige Tücken: Die Bibliothek muß mit <code>System.loadLibrary("name");</code> explizit geladen werden. Sie ist dann nur in dem Classloader verfügbar, mit dem sie geladen wurde. Das allein ist noch nicht weiter schlimm &#8211; allerdings läßt sich eine Bibliothek auch nur einmal laden. Und &#8220;einmal&#8221; heißt einmal: Einmal in der Lebenszeit der gesamten JVM. Da ist es auch egal, ob es den Classloader noch gibt etc.</p>
<p>Problematisch wird das zum Beispiel in einem Servlet-Container. Gegeben seien zwei Servlets A und B, die beide libname.so verwenden wollen. Das zweite Servlet, das die Lib laden will, bekommt dann einen UnsatisfiedLinkError. Ein im Netz vorgeschlagener Workaround ist, dafür zu sorgen, daß die Lib vom System-Classloader geladen wird. Hört sich etwas kompliziert an &#8230; Eine etwas einfachere Möglichkeit, die auch prompt funktionierte: Einfach die Bibliothek verdoppeln (<code>cp libname.so libname2.so</code>), im zweiten Servlet <code>System.loadLibrary("name2");</code> ausführen. Wenn die Libraries eh irgendwo lokal rumflattern, paßt das &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2010/02/02/native-libraries-in-java/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Nominatim</title>
		<link>http://blog.tessarakt.de/archiv/2010/01/20/nominatim/</link>
		<comments>http://blog.tessarakt.de/archiv/2010/01/20/nominatim/#comments</comments>
		<pubDate>Wed, 20 Jan 2010 17:37:57 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Netzkultur]]></category>
		<category><![CDATA[Web]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=1045</guid>
		<description><![CDATA[Als ich gerade auf Openstreetmap.org war, habe ich gemerkt, daß dort jetzt ein neuer Geocoder im Einsatz ist, der offenbar deutlich besser funktioniert (und auch schneller reagiert, aber das muß ja nichts mit der Software zu tun haben) als der &#8230; <a href="http://blog.tessarakt.de/archiv/2010/01/20/nominatim/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Als ich gerade auf <a href="http://www.openstreetmap.org/">Openstreetmap.org</a> war, habe ich gemerkt, daß dort jetzt ein neuer Geocoder im Einsatz ist, der offenbar deutlich besser funktioniert (und auch schneller reagiert, aber das muß ja nichts mit der Software zu tun haben) als der alte. Reverse-Geocoding kann er auch. Das macht für viele Usecases Google Maps überflüssig. Well done, <a href="http://wiki.openstreetmap.org/wiki/Nominatim">Nominatim</a>.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2010/01/20/nominatim/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Intervall-Kalender-Kontrollelement</title>
		<link>http://blog.tessarakt.de/archiv/2009/07/31/intervall-kalender-kontrollelement/</link>
		<comments>http://blog.tessarakt.de/archiv/2009/07/31/intervall-kalender-kontrollelement/#comments</comments>
		<pubDate>Fri, 31 Jul 2009 14:23:34 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=942</guid>
		<description><![CDATA[In vielen Webanwendungen ist es nötig, Zeitspannen (Anfangs- und Enddatum) auszuwählen. Ein gutes Beispiel sind Reiseseiten. Leider sind diese Controls oftmals grottig programmiert. Eine ziemlich vorbildliche Lösung hat Opodo.de. Die Kernfeatures: Wenn man einen Tag auswählt, der im aktuellen Monat &#8230; <a href="http://blog.tessarakt.de/archiv/2009/07/31/intervall-kalender-kontrollelement/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>In vielen Webanwendungen ist es nötig, Zeitspannen (Anfangs- und Enddatum) auszuwählen. Ein gutes Beispiel sind Reiseseiten. Leider sind diese Controls oftmals grottig programmiert.</p>
<p>Eine ziemlich vorbildliche Lösung hat <a href="http://www.opodo.de">Opodo.de</a>. Die Kernfeatures:</p>
<ul>
<li>Wenn man einen Tag auswählt, der im aktuellen Monat in der Vergangenheit liegt, springt er auf den nächsten Monat.</li>
<li>Das Enddatum wird erhöht, wenn man das Startdatum ändert. Man muß also nicht die ganze Liste durchscrollen, um den gleichen Monat nochmal auszuwählen.</li>
<li>Das Control ist brauchbar mit der Tastatur (auch Zifferneingabe) zu bedienen.</li>
</ul>
<p>IMO gehört sowas in jedes AJAX-Toolkit.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2009/07/31/intervall-kalender-kontrollelement/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Computerzeitung</title>
		<link>http://blog.tessarakt.de/archiv/2009/07/12/computerzeitung/</link>
		<comments>http://blog.tessarakt.de/archiv/2009/07/12/computerzeitung/#comments</comments>
		<pubDate>Sun, 12 Jul 2009 15:23:25 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=931</guid>
		<description><![CDATA[Letzte Woche bekam ich einen erfreulichen Brief von der Gesellschaft für Informatik: Die unsägliche Computerzeitung wird eingestellt. (&#8220;muß ich Ihnen leider mitteilen&#8221;, &#8220;Wir bedauern die Einstellung der Computerzeitung.&#8221;) Der Beitrag wird nicht erhöht. Für den Beitrag gibt es künftig eine &#8230; <a href="http://blog.tessarakt.de/archiv/2009/07/12/computerzeitung/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Letzte Woche bekam ich einen erfreulichen Brief von der Gesellschaft für Informatik:</p>
<ul>
<li>Die unsägliche Computerzeitung wird eingestellt. (&#8220;muß ich Ihnen leider mitteilen&#8221;, &#8220;Wir bedauern die Einstellung der Computerzeitung.&#8221;)</li>
<li>Der Beitrag wird nicht erhöht.</li>
<li>Für den Beitrag gibt es künftig eine Spendenquittung.</li>
</ul>
<p>Insgesamt also nicht nur eine gute, sondern eine sehr gute Nachricht <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_smile.gif' alt=':-)' class='wp-smiley' /> </p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2009/07/12/computerzeitung/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>OSOR</title>
		<link>http://blog.tessarakt.de/archiv/2009/03/16/osor/</link>
		<comments>http://blog.tessarakt.de/archiv/2009/03/16/osor/#comments</comments>
		<pubDate>Mon, 16 Mar 2009 00:51:57 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Politik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=822</guid>
		<description><![CDATA[Durch Zufall habe ich gerade ein Projekt gefunden, das ich noch nicht kannte: das Open Source Observatory and Repository (OSOR). Es gibt dabei um Open-Source-Software für Behörden.]]></description>
			<content:encoded><![CDATA[<p><a href="http://www.linux-community.de/Internal/Nachrichten/Muenchen-gibt-Quellcode-von-OpenOffice-Ergaenzung-frei">Durch Zufall</a> habe ich gerade ein Projekt gefunden, das ich noch nicht kannte: das <a href="http://www.osor.eu/">Open Source Observatory and Repository (OSOR)</a>. Es gibt dabei um Open-Source-Software für Behörden.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2009/03/16/osor/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Tiles@Home</title>
		<link>http://blog.tessarakt.de/archiv/2008/07/16/tileshome/</link>
		<comments>http://blog.tessarakt.de/archiv/2008/07/16/tileshome/#comments</comments>
		<pubDate>Wed, 16 Jul 2008 19:05:41 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Allgemein]]></category>
		<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[Reisen]]></category>
		<category><![CDATA[Verkehr]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=611</guid>
		<description><![CDATA[Ich hoffe doch, daß das Projekt Openstreetmap hinlänglich bekannt ist. Eine Version der Karten wird verteilt, also von vielen Leuten auf dem PC zu Hause etc., gerendet: Dieses Projekt nennt sich Tiles at Home. Seit Anfang der Woche wurde dort &#8230; <a href="http://blog.tessarakt.de/archiv/2008/07/16/tileshome/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Ich hoffe doch, daß das Projekt <a href="http://www.openstreetmap.org/">Openstreetmap</a> hinlänglich bekannt ist. Eine Version der Karten wird verteilt, also von vielen Leuten auf dem PC zu Hause etc., gerendet: Dieses Projekt nennt sich Tiles at Home.</p>
<p>Seit Anfang der Woche wurde dort ein neuer Server installiert, der endlich mit mehr als ein paar Dutzend Clients klarkommt, und die <a href="http://tah.openstreetmap.org/Request/show/">Zahl der offenen Aufträge</a> scheint rapide anzusteigen. Wenn ihr also Openstreetmap unterstützen wollt: <a href="http://wiki.openstreetmap.org/index.php/Tiles@home">Mitmachen!</a></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2008/07/16/tileshome/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Efficient XML Interchange</title>
		<link>http://blog.tessarakt.de/archiv/2008/04/14/efficient-xml-interchange/</link>
		<comments>http://blog.tessarakt.de/archiv/2008/04/14/efficient-xml-interchange/#comments</comments>
		<pubDate>Mon, 14 Apr 2008 22:28:33 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Web]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=582</guid>
		<description><![CDATA[Ich hab&#8217;s ja eigentlich schon immer gesagt: XML ist eigentlich toll, aber das Serialisierungsformat ist Bloat. Und was sehe ich heute, als ich (aus ganz anderen Gründen) auf der W3C-Seite rumsurfe? Die sind gerade dabei, sowas zu entwickeln: The development &#8230; <a href="http://blog.tessarakt.de/archiv/2008/04/14/efficient-xml-interchange/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Ich hab&#8217;s ja eigentlich schon immer gesagt: XML ist eigentlich toll, aber das Serialisierungsformat ist Bloat. Und was sehe ich heute, als ich (aus ganz anderen Gründen) auf der W3C-Seite rumsurfe? <a href="http://www.w3.org/XML/EXI/">Die</a> sind gerade dabei, sowas zu entwickeln:</p>
<blockquote><p>The development of the Efficient XML Interchange (EXI) format was guided by five design principles, namely, the format had to be general, minimal, efficient, flexible, and interoperable. The format satisfies these prerequisites, achieving generality, flexibility, and performance while at the same time keeping complexity in check.</p></blockquote>
<p>Warum nicht gleich so <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_smile.gif' alt=':-)' class='wp-smiley' /> </p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2008/04/14/efficient-xml-interchange/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Zentralität</title>
		<link>http://blog.tessarakt.de/archiv/2008/03/02/zentralitat/</link>
		<comments>http://blog.tessarakt.de/archiv/2008/03/02/zentralitat/#comments</comments>
		<pubDate>Sat, 01 Mar 2008 23:14:12 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Wissenschaft]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2008/03/02/zentralitat/</guid>
		<description><![CDATA[Mir ist gerade aufgefallen, daß Zentralität sowohl ein Fachbegriff in der Informatik (dort speziell in der Graphentheorie) als auch in der Soziologie (dort speziell in der empirischen Sozialforschung) ist. Ob sich da wohl Verbindungen finden lassen?]]></description>
			<content:encoded><![CDATA[<p>Mir ist gerade aufgefallen, daß Zentralität sowohl ein Fachbegriff in der Informatik (dort speziell in der Graphentheorie) als auch in der Soziologie (dort speziell in der empirischen Sozialforschung) ist.</p>
<p>Ob sich da wohl Verbindungen finden lassen?</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2008/03/02/zentralitat/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Opensource-Heizungsregelung</title>
		<link>http://blog.tessarakt.de/archiv/2008/02/09/opensource-heizungsregelung/</link>
		<comments>http://blog.tessarakt.de/archiv/2008/02/09/opensource-heizungsregelung/#comments</comments>
		<pubDate>Sat, 09 Feb 2008 17:30:19 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Technik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2008/02/09/opensource-heizungsregelung/</guid>
		<description><![CDATA[In unserer WG haben wir eine Etagenheizung ohne Außentemperaturfühler, und Heizkörper mit einfachen Reglern ohne Thermostat. Das Ganze verstößt nicht nur gegen die Energieeinsparungsverordnung (&#8220;Zentralheizungen müssen beim Einbau in Gebäude mit zentralen selbsttätig wirkenden Einrichtungen zur Verringerung und Abschaltung der &#8230; <a href="http://blog.tessarakt.de/archiv/2008/02/09/opensource-heizungsregelung/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>In unserer WG haben wir eine Etagenheizung ohne Außentemperaturfühler, und Heizkörper mit einfachen Reglern ohne Thermostat. Das Ganze verstößt nicht nur gegen die <a href="http://www.gesetze-im-internet.de/enev_2007/index.html">Energieeinsparungsverordnung</a> (&#8220;Zentralheizungen müssen beim Einbau in Gebäude mit zentralen selbsttätig wirkenden Einrichtungen zur Verringerung und Abschaltung der Wärmezufuhr sowie zur Ein- und Ausschaltung elektrischer Antriebe in Abhängigkeit von der Außentemperatur oder einer anderen geeigneten Führungsgröße und der Zeit ausgestattet werden.&#8221; (§ 14), ), sondern ist auch extrem nervig, weil man in den Räumen keine konstante Temperatur halten kann.</p>
<p>Mein Mitbewohner hat sich schon einen elektronischen Heizungsthermostat gekauft (aber noch nicht montiert). Klar, als Wiwi guckt er erstmal, was es auf dem Markt gibt.</p>
<p>Ich finde die Teile irgendwie etwas unflexibel, und wenn man was besseres will (mit zentralem Regler, der die Ventile per Funk steuert), wird man für Steuerung und zwei Regler leicht deutlich über 100 € los. Als Informatiker frage ich mich da: Gibt es da nicht auch eine Open-Source-Lösung? Naja, wohl nichts Fertiges, aber die Möglichkeiten werden schon diskutiert. Gefunden habe ich da eine Diskussion <a href="http://www.mikrocontroller.net/topic/17603">in einem Webforum</a> und <a href="http://groups.google.de/group/de.sci.electronics/tree/browse_frm/thread/8da73d7b10113a46/994189d129a732a3?rnum=1&#038;hl=de&#038;q=ethernet+author%3AHeier&#038;_done=%2Fgroup%2Fde.sci.electronics%2Fbrowse_frm%2Fthread%2F8da73d7b10113a46%2F994189d129a732a3%3Ftvc%3D1%26hl%3Dde%26#doc_994189d129a732a3">in der Newsgroup de.sci.electronics</a>. Werde mir das mal durchlesen und gucken, was realistischerweise machbar ist.</p>
<p>Damit wären ja schon coole Sachen denkbar: Koppelung mit Wettervorhersage, Ferneinschaltung von der Uni aus, bevor man nach Hause kommt, etc. pp.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2008/02/09/opensource-heizungsregelung/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>VMWare: NTFS-Partition vergrößern mit Linux-Bordmitteln</title>
		<link>http://blog.tessarakt.de/archiv/2008/01/18/vmware-ntfs-partition-vergrosern-mit-linux-bordmitteln/</link>
		<comments>http://blog.tessarakt.de/archiv/2008/01/18/vmware-ntfs-partition-vergrosern-mit-linux-bordmitteln/#comments</comments>
		<pubDate>Fri, 18 Jan 2008 15:47:42 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2008/01/18/vmware-ntfs-partition-vergrosern-mit-linux-bordmitteln/</guid>
		<description><![CDATA[Da ich das Ganze schonmal gemacht habe und nicht mehr ganz zusammenbekomme, wird es dieses Mal notiert. Erster Schritt: Die VMWare-Platte vergrößern, mit vmware-vdiskmanager -x 20Gb WindowsXPPro32bit.vmdk Dann die VM mit einer gparted-Boot-CD starten. Dazu muß man darauf achten, daß &#8230; <a href="http://blog.tessarakt.de/archiv/2008/01/18/vmware-ntfs-partition-vergrosern-mit-linux-bordmitteln/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Da ich das Ganze schonmal gemacht habe und nicht mehr ganz zusammenbekomme, wird es dieses Mal notiert.</p>
<p>Erster Schritt: Die VMWare-Platte vergrößern, mit<br />
<code>vmware-vdiskmanager -x  20Gb WindowsXPPro32bit.vmdk</code></p>
<p>Dann die VM mit einer gparted-Boot-CD starten. Dazu muß man darauf achten, daß das VM-Fenster auch wirklich den Tastatur-Fokus hat und dann beim Power-On der VM auf die Esc-Taste hacken.</p>
<p>gparted startet dann, und man sieht, daß die Platte freien Speicherplatz hat. Mit <em>Resize/Move</em> kann man dann die Partition vergrößern.</p>
<p>Dabei laufen die Schritte</p>
<ul>
<li>calibrate /dev/hda1</li>
<li>calculate new size and position of /dev/hda1</li>
<li>grow partition from 11.99 GiB to 19.99 GiB</li>
<li>check filesystem on /dev/hda1 for errors and (if possible) fix them</li>
</ul>
<p>problemlos durch, aber bei &#8220;grow filesystem to fill the partition&#8221; hapert es.</p>
<p>Also ein Terminal starten, und dort erst mal <code>ntfsresize</code> ein paar Infos ausspucken lassen.</p>
<p>Dabei stehen dann unter anderem die aktuelle Größe von &#8220;volume&#8221; (also Dateisystem) und &#8220;device&#8221; (also Partition).</p>
<p>Erstmal <code>ntfsresize -n -s <Größe des device> /dev/hda1</code> &#8211; Simulation klappt.</p>
<p>Problem: Ich habe das Windows falsch heruntergefahren, Journal ist hinüber, also nochmal Rebooten (also: gleich darauf achten, das Windows sauber herunterzufahren). Das kostet also wieder ein Minuten.</p>
<p>Danach ging es dann ohne &#8220;-n&#8221; wunderbar. Also <code>reboot</code> eintippen, und gut. Beim nächsten Neustart überprüft Windows dann automatisch das Dateisystem, und dann ist alles fertig &#8211; man hat eine größere Platte.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2008/01/18/vmware-ntfs-partition-vergrosern-mit-linux-bordmitteln/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Visual Studio SP1</title>
		<link>http://blog.tessarakt.de/archiv/2007/12/02/visual-studio-sp1/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/12/02/visual-studio-sp1/#comments</comments>
		<pubDate>Sun, 02 Dec 2007 12:02:44 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/12/02/visual-studio-sp1/</guid>
		<description><![CDATA[Gerade habe ich unter Windows mal routinemäßig Updates installiert. Aber für das hier: Visual Studio 2005 Service Pack 1 Date last published: 4/5/2007 Visual Studio 2005 Service Pack 1 updates Microsoft Visual Studio 2005, Microsoft Visual Studio 2005 Team System, &#8230; <a href="http://blog.tessarakt.de/archiv/2007/12/02/visual-studio-sp1/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Gerade habe ich unter Windows mal routinemäßig Updates installiert. Aber für das hier:</p>
<blockquote><p>Visual Studio 2005 Service Pack 1<br />
Date last published: 4/5/2007<br />
Visual Studio 2005 Service Pack 1 updates Microsoft Visual Studio 2005, Microsoft Visual Studio 2005 Team System, Microsoft Visual Studio 2005 Tools for the Microsoft Office System, and Microsoft Visual Studio 2005 Team Explorer with the latest security and stability enhancements to help keep those systems up-to-date, reliable, and secure.  The goal of all of our service packs is to increase the overall quality of the existing product features while maintaining a high level of compatibility. <strong>The installation of this service pack might take up to several hours.</strong> After you install this item, you may have to restart your computer.<br />
System Requirements<br />
Recommended CPU: Not specified.<br />
Recommended memory: Not specified.<br />
<strong>Recommended hard disk space: 6200 MB</strong> </p></blockquote>
<p>muß ich erstmal die Platte vergrößern &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/12/02/visual-studio-sp1/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Character Description Language</title>
		<link>http://blog.tessarakt.de/archiv/2007/11/24/character-description-language/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/11/24/character-description-language/#comments</comments>
		<pubDate>Sat, 24 Nov 2007 00:00:27 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Sprache]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/11/24/character-description-language/</guid>
		<description><![CDATA[I just stumbled across some pretty cool project at the junction of linguistics and IT. Of course, again, it concerns Chinese language processing &#8230; The Character Description Language&#8216;s aim is to provide a description language for Han ideographs. The project &#8230; <a href="http://blog.tessarakt.de/archiv/2007/11/24/character-description-language/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>I just stumbled across some pretty cool project at the junction of linguistics and IT. Of course, again, it concerns Chinese language processing &#8230;</p>
<p>The <a href="http://www.wenlin.com/cdl/">Character Description Language</a>&#8216;s aim is to provide a description language for Han ideographs. The project seems to be well-organized, and they have captured 56k CJK characters, including all from the <acronym title="Basic Multilingual Plane">BMP</acronym>.</p>
<p>This data would probably be very useful for developing an Input Method Engine using a graphic tablet, or showing the decomposition of characters into their constituent parts. Alas, I have as of yet not been able to find the database &#8211; is it commercial stuff (namely, <a href="http://www.wenlin.com/">Wenlin</a>) safely locked away from the interested public? That would really be a pity &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/11/24/character-description-language/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Paper eingereicht</title>
		<link>http://blog.tessarakt.de/archiv/2007/05/30/paper-eingereicht/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/05/30/paper-eingereicht/#comments</comments>
		<pubDate>Wed, 30 May 2007 11:30:27 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/05/30/paper-eingereicht/</guid>
		<description><![CDATA[Das Wochenende war mal echt Streß. Diverse Nachtstunden habe ich mit der Arbeit an meinem Paper für AGTIVE 2007 verbracht, dazu haben wir uns noch an den Feiertagen (Pfingstsonntag und -montag) im Institut gesprochen, um uns gegenseitig Hilfestellung bei Messungen, &#8230; <a href="http://blog.tessarakt.de/archiv/2007/05/30/paper-eingereicht/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Das Wochenende war mal echt Streß. Diverse Nachtstunden habe ich mit der Arbeit an meinem Paper für <a href="http://www.se.eecs.uni-kassel.de/se/index.php?642">AGTIVE 2007</a> verbracht, dazu haben wir uns noch an den Feiertagen (Pfingstsonntag und -montag) im Institut gesprochen, um uns gegenseitig Hilfestellung bei Messungen, Formulierungen etc. zu geben. Gestern war dann Endspurt: 23:00 war die offizielle Deadline (da die wohl bei der Angabe der Zeitzone GMT+1 nicht an die Sommerzeit gedacht haben, eigentlich doch 24:00), bis dahin wurde noch fleißig an den Papers geschraubt. Kurz vor dem echten Endspurt gab es um ca. 20:00 noch Pizza, und nach Abgabe wurde dann eine Flasche Diabetikersekt geleert (das Zeug steht hier haufenweise im Kühlschrank) &#8230;</p>
<p>Mal sehen, ob es angenommen wird, cool wär&#8217;s ja schon &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/05/30/paper-eingereicht/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Branchen mit SVN</title>
		<link>http://blog.tessarakt.de/archiv/2007/02/26/branchen-mit-svn/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/02/26/branchen-mit-svn/#comments</comments>
		<pubDate>Mon, 26 Feb 2007 16:42:40 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/02/26/branchen-mit-svn/</guid>
		<description><![CDATA[Bruncanchen mit SVN ist ganz einfach, denkt man. Einfach ein svn copy, und im Nu hat man eine neue lazy copy, in der man nach Belieben Änderungen vornehmen kann. So dachte ich mir auch, als ich das Projekt für meine &#8230; <a href="http://blog.tessarakt.de/archiv/2007/02/26/branchen-mit-svn/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Br<del datetime="2007-02-26T16:36:05+00:00">unc</del>anchen mit <a href="http://subversion.tigris.org/">SVN</a> ist ganz einfach, denkt man. Einfach ein svn copy, und im Nu hat man eine neue <em>lazy copy</em>, in der man nach Belieben Änderungen vornehmen kann.</p>
<p>So dachte ich mir auch, als ich das Projekt für meine Studienarbeit vom Kollegen geforkt habe. Aber Pustekuchen &#8211; dafür braucht man Schreibzugriffe auf das gemeinsame Oberverzeichnis, die ich nicht hatte. Also Arbeitskopie (Revision 336) ausgecheckt bzw. exportiert, in einen Checkout meines eigenen Pfades kopiert, und wieder eingecheckt. Damit sind dann natürlich die Log-Messages weg.</p>
<p>Heute habe ich dann einen Merge der Änderungen meines Kollegen von Revision 336 bis 476 abgeschlossen. Und was sehe ich da? Er hat die Log-Messages neu hinzugekommener Dateien einwandfrei übernommen. Das also geht von den Berechtigungen her. Wenn ich also statt des nicht erlaubten svn copy einen Merge von r1 bis r336, Ziel: mein Pfad, gemacht hätte, hätte ich (fast?) dasselbe Ergebnis erzielt, also alle Log-Einträge behalten etc. Schon irgendwie merkwürdig &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/02/26/branchen-mit-svn/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>BFS &#8211; generic and fast</title>
		<link>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generic-and-fast/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generic-and-fast/#comments</comments>
		<pubDate>Sun, 04 Feb 2007 19:36:27 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/02/04/bfs-generic-and-fast/</guid>
		<description><![CDATA[This weekend, originally I wanted to implement special BFS procedures for my student job, of course using generic programming and the like. Looking at the normal BFS implementation in Boost I noticed that it needs a ColorMap and allocates one &#8230; <a href="http://blog.tessarakt.de/archiv/2007/02/04/bfs-generic-and-fast/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p><span xml:lang="en">This weekend, originally I wanted to implement special BFS procedures for my student job, of course using generic programming and the like. Looking at the normal <a href="http://www.boost.org/libs/graph/doc/breadth_first_search.html">BFS implementation in Boost</a> I noticed that it needs a ColorMap and allocates one as the default behavior. However, in many applications of breadth-first search one can use another map for this purpose, like one for distance or predecessors, and interpret a special value like -1 or the null pointer as <em>white</em>, i.e. not visited. Then one can no longer distinguish between gray and black nodes, though (I have not understood how this can become relevant for BFS &#8211; for DFS it&#8217;s clear), but one does not have to anyway in most applications. Doing so, one saves the memory for another map &#8211; normally one byte per vertex &#8211; and the overhead for updating it.</span></p>
<p><span xml:lang="en">So I started working on an implementation of the <a href="http://www.boost.org/libs/property_map/ReadWritePropertyMap.html">ReadWritePropertyMap</a> concept that is initialized with another map and a value for &#8220;white&#8221; and when queried for the color of a vertex reads the value of the underlying map and determines whether it is white. Write operations just do nothing. This was not totally easy, as with all this template stuff, even small mistakes lead to very long diagnostics. But the result is now <a href="http://article.gmane.org/gmane.comp.lib.boost.user/24578">here</a>. So now there remains just the issue with the Koenig lookup, but I hope this will be solved as well &#8230;</span></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generic-and-fast/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>BFS generisch und schnell</title>
		<link>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generisch-und-schnell/</link>
		<comments>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generisch-und-schnell/#comments</comments>
		<pubDate>Sun, 04 Feb 2007 19:19:11 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2007/02/04/bfs-generisch-und-schnell/</guid>
		<description><![CDATA[Dieses Wochenende wollte ich eigentlich Spezialbreitensuchmethoden für meinen Hiwi-Job implementieren, natürlich generisch und so. Beim Anschauen der normalen BFS in Boost fiel mir auf, daß das Teil ja eine ColorMap benötigt und standardmäßig eine anlegt. Dabei kann man ja für &#8230; <a href="http://blog.tessarakt.de/archiv/2007/02/04/bfs-generisch-und-schnell/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Dieses Wochenende wollte ich eigentlich Spezialbreitensuchmethoden für meinen Hiwi-Job implementieren, natürlich generisch und so. Beim Anschauen der normalen <a href="http://www.boost.org/libs/graph/doc/breadth_first_search.html">BFS in Boost</a> fiel mir auf, daß das Teil ja eine ColorMap benötigt und standardmäßig eine anlegt. Dabei kann man ja für viele Anwendungen der Breitensuche dafür eine andere Map, zum Beispiel für Distanz oder Vorgänger, verwenden, und einen speziellen Wert, wie -1 oder den Nullpointer, als <em>weiß</em>, also unbesucht, ansehen. Dann kann man zwar nicht mehr zwischen grauen und schwarzen Knoten unterscheiden (mir ist noch nicht ganz klar geworden, welche Relevanz das überhaupt bei BFS haben kann &#8211; bei DFS ist es klar), aber das muß man ja in den meisten Anwendungen auch nicht. Damit spart man dann den Speicherplatz für eine weitere Map &#8211; immerhin im Regelfall ein Byte pro Knoten &#8211; und den Overhead für das Update derselben.</p>
<p>Also hab ich mich daran gemacht, eine Implementierung des Konzepts <a href="http://www.boost.org/libs/property_map/ReadWritePropertyMap.html">ReadWritePropertyMap</a> zu erstellen, die mit einer anderen Map und einem &#8220;Weiß-Wert&#8221; initialisiert wird und bei Anfragen nach der Farbe eines Knoten den Wert aus der zugrundeliegenden Map liest und guckt, ob der Knoten weiß ist. Schreibzugriffe gehen einfach ins leere. Das Ganze war nicht ganz einfach, da mit dem Template-Geraffel auch kleine Fehler zu ellenlangen Fehlermeldungen führen. Aber das Ergebnis ist jetzt <a href="http://article.gmane.org/gmane.comp.lib.boost.user/24578">hier</a>. Bleibt nur noch die Sache mit dem Koenig-Lookup, aber die wird mir hoffentlich auch jemand beantworten. </p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2007/02/04/bfs-generisch-und-schnell/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Statische Polymorphie dynamisch machen</title>
		<link>http://blog.tessarakt.de/archiv/2006/12/30/statische-polymorphie-dynamisch-machen/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/12/30/statische-polymorphie-dynamisch-machen/#comments</comments>
		<pubDate>Sat, 30 Dec 2006 10:30:02 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=408</guid>
		<description><![CDATA[Modernes C++ benutzt häufig statische Polymorphie, die auf Templates basiert. Das allerdings kann nicht nur zu Code-Bloat führen, sondern macht es auch unmöglich, die Objekte einer Klasse, die ein bestimmtes Konzept modelliert, in einer separat kompilierten Bibliothek zu benutzen &#8211; &#8230; <a href="http://blog.tessarakt.de/archiv/2006/12/30/statische-polymorphie-dynamisch-machen/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Modernes C++ benutzt häufig statische Polymorphie, die auf Templates basiert. Das allerdings kann nicht nur zu Code-Bloat führen, sondern macht es auch unmöglich, die Objekte einer Klasse, die ein bestimmtes Konzept modelliert, in einer separat kompilierten Bibliothek zu benutzen &#8211; denn die kennt den Typ des Objekts ja nicht.</p>
<p>In <a href="https://graph-tool.forked.de/">graph-tool</a>, genauer in <a href="https://projects.forked.de/graph-tool/browser/trunk/src/graph/graphml.hpp">graphml.hpp</a>, bin ich auf eine schöne Musterimplementierung eines Wrappers gestoßen, der gewissermaßen statische Polymorphie in dynmische Polymorphie verwandelt.</p>
<p>Zum Anwendungsfall:</p>
<p>Es geht darum, GraphML-Dateien einzulesen. Dafür hat der Benutzer der Bibliothek ein Objekt einer Klasse, die das Konzept MutableGraph modelliert. Die Klasse <code>mutate_graph</code> stellt dann eine einheitliche Laufzeitschnittstelle für MutableGraphs zur Verfügung, die Wrapper für jeden einzelnen MutableGraph sind dann <code>template<typename MutableGraph> class mutate_graph_impl</code>, die von <code>mutate_graph</code> erben. Wo die Schnittstellen dann immer noch unterschiedlich sind, weil sie abhängige Typen verwenden, werden diese in <code>boost::any</code> gewrappt. </p>
<p>Et voilà &#8211; wir haben eine einheitliche Schnittstelle für MutableGraphs. Geht analog natürlich für fast beliebige andere Konzepte.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/12/30/statische-polymorphie-dynamisch-machen/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Begleitmaterial</title>
		<link>http://blog.tessarakt.de/archiv/2006/09/13/begleitmaterial/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/09/13/begleitmaterial/#comments</comments>
		<pubDate>Wed, 13 Sep 2006 17:23:30 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/?p=388</guid>
		<description><![CDATA[Die Idealvorstellung vieler Profs, die ihre Vorlesungen mit Beamerfolien halten, ist ja vermutlich oft, daß sich die Studenten auf den vorher ausgedruckten Folien Notizen machen. Mag ja sein, daß das was bringt, aber ich weiß da nie, was ich aufschreiben &#8230; <a href="http://blog.tessarakt.de/archiv/2006/09/13/begleitmaterial/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Die Idealvorstellung vieler Profs, die ihre Vorlesungen mit Beamerfolien halten, ist ja vermutlich oft, daß sich die Studenten auf den vorher ausgedruckten Folien Notizen machen. Mag ja sein, daß das was bringt, aber ich weiß da nie, was ich aufschreiben soll. Entweder ist der Stoff eine Ansammlung von Fakten und die Erläuterungen dazu bloßes Rumgelaber, oder aber der Stoff ist so kompliziert, daß ich hinreichend damit beschäftigt bin, ihn zu verstehen und weder die Denkkapazität noch das Stoffverständnis habe, um zu entscheiden, was wichtig ist.</p>
<p>Umso wichtiger, daß man den Stoff hinterher nochmal nachvollziehen kann. Eine Möglichkeit: Der Prof hat seine Vorlesung auf Video aufzeichnen lassen. Suboptimal, denn nochmal will ich mir das Zeug eigentlich nicht anhören müssen. Zweite Möglichkeit: Die Folien sind hinreichend ausführlich und selbsterklärend, daß das geht. Schon besser, aber es fehlt immer noch die zweite Sichtweis, mit der man es dann vielleicht besser versteht. Dritte Möglichkeit: Es gibt ein Buch (oder mehrere Bücher), an die sich die Vorlesung über weite Strecken hält, einschließlich Notationen und Begriffen. Das ist IMO der Idealzustand, weil Bücher meist wirklich aus sich heraus verständlich sind.</p>
<p>Und diesen Fall darf ich zum Glück gerade bei der Vorbereitung auf die Übersetzerbau-Prüfung erleben. Die Folien von Prof. Goos entsprechen bei vielen &#8220;klassischen&#8221; Kapiteln inhaltlich sehr stark dem Buch von Goos und Waite: Compiler Construction. Das Buch ist naturgemäß an vielen Stellen um einiges tiefgehender, aber dieser Tiefgang hilft eher beim Verständnis, als daß er verwirrt.</p>
<p>Heute habe ich mir den Zusammenhang zwischen LR(1), LR(0), SLR(1) und LALR(1) reingezogen &#8211; und verstanden! Und ich muß sagen: Ein gutes Gefühl!</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/09/13/begleitmaterial/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Fakultätsfest</title>
		<link>http://blog.tessarakt.de/archiv/2006/07/23/fakultatsfest/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/07/23/fakultatsfest/#comments</comments>
		<pubDate>Sun, 23 Jul 2006 19:44:02 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Freizeit]]></category>
		<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/07/23/fakultatsfest/</guid>
		<description><![CDATA[Für den diesjährigen Tag der Informatik der Fakultät für Informatik der Uni Karlsruhe wurde die Werbetrommel mal richtig ordentlich gerührt: Die Einladung gab es nicht nur in allen möglichen Vorlesungen, nein, auch auf der Website der Uni und sogar der &#8230; <a href="http://blog.tessarakt.de/archiv/2006/07/23/fakultatsfest/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Für den diesjährigen <a href="http://www.ira.uka.de/tdi/">Tag der Informatik</a> der Fakultät für Informatik der Uni Karlsruhe wurde die Werbetrommel mal richtig ordentlich gerührt: Die Einladung gab es nicht nur in allen möglichen Vorlesungen, nein, auch auf der Website der Uni und sogar der Stadt Karlsruhe erschien ein Hinweis. Zum Glück wurde da aber das Freibier nicht erwähnt, wer weiß, wieviele Leute sonst den Bierstand gestürmt hätten &#8230;</p>
<p>Das Vortragsprogramm hab ich dieses Jahr leider verpaßt (auch wenn es laut Oli recht interessant gewesen sein soll), aber zum Fest war ich dann natürlich da.</p>
<p>Eine Portion Häppchen hab ich auch ergattert, wobei ich zum Glück recht weit vorne stand, als ich vorhatte, mir nochwas nachzuholen, war die Schlange ziemlich lang, und danach waren die Häppchen dann alle.</p>
<p><a href="http://www.flickr.com/photos/83837423@N00/195379499/" title="Photo Sharing"><img src="http://static.flickr.com/74/195379499_2187b3d48b.jpg" width="500" height="375" alt="pict2046.jpg" /></a></p>
<p>Dafür floß das Freibier wirklich reichlich. Nachdem Frau Prof. Zitterbart um ca. 19:00 das symbolische Faß angestochen hatte, gab es bis 21:30 alle Getränke kostenlos &#8211; in der Zeit hatte ich dann drei (oder waren&#8217;s vier) Bier und zwei Grape intus. Meine Helferbons für meine Schicht am Bierstand gab es zum Glück auch schon, so daß ich dazu ein leckeres Steakbrötchen essen konnte.</p>
<p>Danach wurde es dann aber schwierig: Ich mußte die Zeit bis zu meiner Schicht um 1 Uhr überbrücken. Und die Stimmung war, gelinde gesagt, ziemlich chillig, obwohl im Zelt (in dem sich kaum jemand aufhielt) eine Band spielte. OK, bis kurz nach zwölf ging es halbwegs, dann nochmal kurz nach Hause, und am Bierstand gab es dann doch noch recht viel zu tun, so daß ich recht schnell wieder wach wurde. Am Stand dann nochmal so drei bis vier Bier konsumiert, zum Glück konnte ich am Samstag ausschlafen (auch wenn&#8217;s nicht wirklich erholsam war, viel zu heiß &#8230;).</p>
<p>Und mein auf der Wiese verlorenes Brillenetui samt Sonnenbrille fand sich dann am nächsten auch bei den Fundsachen an. Juchu!</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/07/23/fakultatsfest/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>C++ und generisches Programmieren</title>
		<link>http://blog.tessarakt.de/archiv/2006/05/11/c-und-generisches-programmieren/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/05/11/c-und-generisches-programmieren/#comments</comments>
		<pubDate>Thu, 11 May 2006 08:59:42 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/05/11/c-und-generisches-programmieren/</guid>
		<description><![CDATA[Im Moment beschäftige ich mich gerade mit C++. Im Stroustrup (dem Stroustrup, also The C++ Programming Language. Special Edition.) bin ich inzwischen bei der Standardbibliothek angekommen, parallel habe ich angefangen, C++ Template Metaprogramming. Concepts, Tools, and Techniques from Boost and &#8230; <a href="http://blog.tessarakt.de/archiv/2006/05/11/c-und-generisches-programmieren/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Im Moment beschäftige ich mich gerade mit C++. Im Stroustrup (<em>dem</em> Stroustrup, also <a href="http://www.amazon.de/exec/obidos/ASIN/0201700735/aldiarchiv-21"><em>The C++ Programming Language. Special Edition.</em></a>) bin ich inzwischen bei der Standardbibliothek angekommen, parallel habe ich angefangen, <a href="http://www.amazon.de/exec/obidos/ASIN/0321227255"><em>C++ Template Metaprogramming. Concepts, Tools, and Techniques from Boost and Beyond</em></a> zu lesen &#8211; übrigens erstaunlich leicht lesbar. Diese <em>C++ In-Depth</em>-Serie scheint sehr empfehlenswert zu sein &#8230;</p>
<p>Vielleicht sollte ich noch kurz ausholen, wie ich zu C++ gekommen bin. Aus einem Problem bei Hennings 3D-Engine (Dreiecke &#8211; wenn möglich &#8211; zu Vierecken zusammenfassen, was auf einer geschlossenen Oberfläche immer möglich sei) entwickelte sich die Frage, wie man Matchings in nicht bipartiten Graphen findet. Des Problems Lösung: Der &#8220;Paths, Trees, and Flowers&#8221;-Algorithmus von Edmonds, Laufzeit: O(|V|*|E|*alpha(|V|*|E|)). Davon habe ich mir dann interessehalber mal das Paper besorgt, erschienen im Canadian Journal of Mathematics. Leider nicht online erhältlich, der Zeitschriftenband sollte aber in der Bibliothek <a href="http://www.uni-karlsruhe.de/">jeder besseren Uni</a> mit Mathe-Fakultät zu finden sein. Das Paper war dann irgendwie ziemlich langatmig, ich habe es immer noch nicht ganz durch <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_neutral.gif' alt=':-|' class='wp-smiley' /> . Also habe ich mich auf die Suche nach einer Implementierung dieses Algorithmus gemacht. <a href="http://boost-consulting.com/boost/libs/graph/doc/maximum_matching.html">Fündig</a> wurde ich bei der <a href="http://www.boost.org/libs/graph/doc/index.html">Boost Graph Library</a>. Da ich in meinem Hiwi-Job Graphenalgorithmen implementiere, hat mich das natürlich gleich interessiert, und <a href="http://de.wikipedia.org/wiki/Generische_Programmierung">generisches Programmieren</a> ist schon ziemlich <a href="http://www.logn.de/docs/hochgradig.pdf">hochgradig</a>.</p>
<p>Auf meiner Vormerkungsliste in der <a href="http://www.ubka.uni-karlsruhe.de/">Unibib</a> (und langfristig auf meiner Anschaffungsliste) steht dann natürlich auch noch <a href="http://www.awprofessional.com/bookstore/product.asp?isbn=0201729148&#038;rl=1">The Boost Graph Library: User Guide and Reference Manual</a>. Und ich hoffe ja, hier im Institut auch mal statt dem Java-Rumgemurkse was mit der BGL machen zu können &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/05/11/c-und-generisches-programmieren/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>DUKATH</title>
		<link>http://blog.tessarakt.de/archiv/2006/04/13/dukath/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/04/13/dukath/#comments</comments>
		<pubDate>Thu, 13 Apr 2006 11:02:03 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Technik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/04/13/dukath/</guid>
		<description><![CDATA[Endlich haben wir in der neuen WG Internet. Mein ipw2100 hatte mit der im Notebook integrierten Antenne zwar richtig viele Netz im Empfang, konnte sich aber zu keinem verbinden. Aber daß es mit einem richtigen Router, bei dem man ggf. &#8230; <a href="http://blog.tessarakt.de/archiv/2006/04/13/dukath/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Endlich haben wir in der neuen WG Internet.</p>
<p>Mein ipw2100 hatte mit der im Notebook integrierten Antenne zwar richtig viele Netz im Empfang, konnte sich aber zu keinem verbinden.</p>
<p>Aber daß es mit einem richtigen Router, bei dem man ggf. auch eine Außenantenne anschrauben kann, besser funktionieren würde, war eigentlich klar. Also wurde ein Linksys WRT 54 GL angeschafft, der sich im Client Mode zu einem Dukath-Accesspoint verbinden sollte.</p>
<p>Da die Original-Firmware keinen Client Mode unterstützt, haben wir <a href="http://www.openwrt.org/">OpenWRT</a> (RC5, White Russian) installiert. Der Router verbindet sich also mit dukath-stmb02, holt sich eine IP und macht NAT für das interne Netzwerk. Das interne Netz besteht übrigens aus einem WLAN, das von einem Netgear WG602 bereitgestellt wird; Hennings PC ist direkt per Kabel angeschlossen.  Ins Uninetz (das Netz, in dem der Router seine IP bekommt, ist nur ein Transitnetz mit sehr eingeschränkten Möglichkeiten) kommen die einzelnen Computer dann jeweils einzeln über einen VPN-Client (Cisco 3000 Access Concentrator, der vpnc funktioniert doch irgendwie einfacher als der Client von Cisco. Und für amd64 gibt es den vermutlich eh nicht &#8230;). vpnc auf dem Router würde eh keinen Sinn machen &#8211; der 300 MHz-Prozessor von Broadcom (MIPS-<acronym title=Instruction Set Architecture">ISA</acronym>) kriegt damit bei voller CPU-Auslastung wohl nur 30 kb/s hin.</p>
<p>A propos 30kb/s: Im Originalzustand war das so ungefähr das Maximum bei geschlossenem Fenster. Aber wofür Konservendosen doch gut sein können &#8230; Da bekommt die Dipol-Antenne gleich eine ausgeprägte Richtcharakteristik, und den 3<acronym title="Watt">W</acronym>-Antennenverstärker für 700 € (der eh nicht erlaubt wäre) kann man sich auch sparen &#8230;</p>
<p>Mal sehen, ob es heute abend noch besser läuft, wenn die zweite Antenne auch mit Konservendose ausgestattet ist &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/04/13/dukath/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Endlich fertig</title>
		<link>http://blog.tessarakt.de/archiv/2006/03/05/endlich-fertig-2/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/03/05/endlich-fertig-2/#comments</comments>
		<pubDate>Sun, 05 Mar 2006 17:49:17 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/03/05/endlich-fertig-2/</guid>
		<description><![CDATA[Endlich ist unser Minijava-Übersetzer fertig: Alle Beispielprogramme kompilieren, laufen fehlerfrei durch und geben etwas mehr oder weniger Sinnvolles aus. Jetzt noch ein paar Debug-Ausgaben wieder entfernen und dann, wenn Pascal aus dem Heimaturlaub zurück ist, vorführen &#8211; und damit sollte &#8230; <a href="http://blog.tessarakt.de/archiv/2006/03/05/endlich-fertig-2/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Endlich ist unser Minijava-Übersetzer fertig: Alle Beispielprogramme kompilieren, laufen fehlerfrei durch und geben etwas mehr oder weniger Sinnvolles aus.</p>
<p>Jetzt noch ein paar Debug-Ausgaben wieder entfernen und dann, wenn Pascal aus dem Heimaturlaub zurück ist, vorführen &#8211; und damit sollte das <a href="http://www.info.uni-karlsruhe.de/teaching.php/id=200509">Praktikum</a> dann abgeschlossen sein &#8230;</p>
<p>Insgesamt hab ich dabei doch sehr viel gelernt, auch wenn es ein Haufen Arbeit war und man sich häufig alleine ganz schön durchbeißen mußte &#8211; aber das wird im Berufsleben ja auch nicht anders.</p>
<p>Vermutlich hab ich so ziemlich alle Fehler gemacht, aus denen man bei diesem Praktikum was lernen kann <img src='http://blog.tessarakt.de/wp-includes/images/smilies/icon_wink.gif' alt=';-)' class='wp-smiley' /> </p>
<p><img src="http://www.tessarakt.de/stuff/alloc-tuple.png" alt="Beispiel-Firm-Graph" /></p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/03/05/endlich-fertig-2/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Durchheitstest</title>
		<link>http://blog.tessarakt.de/archiv/2006/02/28/durchheitstest/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/02/28/durchheitstest/#comments</comments>
		<pubDate>Tue, 28 Feb 2006 21:04:55 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Entdeckungen]]></category>
		<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Web]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/02/28/durchheitstest/</guid>
		<description><![CDATA[Ein Karlsruher Informatik-Student hat den ultimativen Test auf Durchheit erstellt. Mit hohen Ergebnissen sollten wohl nur informatik- und mathematikaffine Personen rechnen, aber Vergleichsergebnisse wären auch mal interessant &#8230; Also: Wie durch bist Du?]]></description>
			<content:encoded><![CDATA[<p>Ein Karlsruher Informatik-Student hat den ultimativen <a href="http://cathrax.com/page.php?id=5">Test auf Durchheit</a> erstellt. Mit hohen Ergebnissen sollten wohl nur informatik- und mathematikaffine Personen rechnen, aber Vergleichsergebnisse wären auch mal interessant &#8230;</p>
<p>Also: Wie durch bist Du?</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/02/28/durchheitstest/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Lokale Variablen</title>
		<link>http://blog.tessarakt.de/archiv/2006/02/03/lokale-variablen/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/02/03/lokale-variablen/#comments</comments>
		<pubDate>Fri, 03 Feb 2006 11:41:16 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/02/03/lokale-variablen/</guid>
		<description><![CDATA[Was mir gerade mal wieder bei meinem Hiwi-Job aufgefallen ist, als ich mit altem Code zu tun hatte: Viele Leute scheinen irgendwie davon auszugehen, daß lokale Variablen irgendwie teuer sind &#8230; Entsprechend steht dann sowas wie m.insert(obj.get(i), obj.get(i).value()); statt Typ &#8230; <a href="http://blog.tessarakt.de/archiv/2006/02/03/lokale-variablen/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>Was mir gerade mal wieder bei meinem Hiwi-Job aufgefallen ist, als ich mit altem Code zu tun hatte: Viele Leute scheinen irgendwie davon auszugehen, daß lokale Variablen irgendwie teuer sind &#8230;</p>
<p>Entsprechend steht dann sowas wie</p>
<blockquote><p><code>m.insert(obj.get(i), obj.get(i).value());</code></p></blockquote>
<p>statt</p>
<blockquote><p><code>Typ tmp = obj.get(i);<br />
m.insert(tmp, tmp.value());</code></p></blockquote>
<p>Lokale Variablen werden üblicherweise in Registern gehalten, nur wenn die nicht reichen, auf dem Stackframe. Zwischenergebnisse in Ausdrücken müssen ja auch irgendwo gespeichert werden, sind also im Prinzip das gleiche wie alias-freie lokale Variablen. Wenn man sich einen Datenflußgraphen anschaut, macht es daher auch überhaupt keinen Unterschied &#8211; normalerweise.</p>
<p>Im vorliegenden Fall liegt der Unterschied darin, daß im ersten Fall <code>get(i)</code> zweimal, im zweiten Fall dagegen nur einmal aufgerufen werden muß. Natürlich kann es semantische Unterschiede geben, wenn <code>get()</code> nicht seiteneffektfrei ist. Aber als Programmierer sollte man das wissen. Der Compiler dagegen weiß es nicht so ohne weiteres, und kann es außer in ganz trivialen Fällen auch nicht vernünftig feststellen, muß es also meist bei zwei Aufrufen belassen, die nicht durch <em>common subexpression elimination</em> beseitigt werden können.</p>
<p>Wir halten fest: Das zweite Beispiel ist besser lesbar und resultiert jedenfalls nicht in schlechterem Code als das erste.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/02/03/lokale-variablen/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>\n</title>
		<link>http://blog.tessarakt.de/archiv/2006/01/29/n/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/01/29/n/#comments</comments>
		<pubDate>Sun, 29 Jan 2006 18:43:13 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/01/29/n/</guid>
		<description><![CDATA[Merke: Wenn man in einem printf das &#8220;\n&#8221; am Ende vergißt, kommen die Ausgaben in nicht wirklich nachvollziehbarer Reihenfolge. Ärgerlich, wenn man das dann beim Debuggen nicht mitkriegt &#8230;]]></description>
			<content:encoded><![CDATA[<p>Merke: Wenn man in einem printf das &#8220;\n&#8221; am Ende vergißt, kommen die Ausgaben in nicht wirklich nachvollziehbarer Reihenfolge. Ärgerlich, wenn man das dann beim Debuggen nicht mitkriegt &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/01/29/n/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Do no evil</title>
		<link>http://blog.tessarakt.de/archiv/2006/01/28/do-no-evil/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/01/28/do-no-evil/#comments</comments>
		<pubDate>Sat, 28 Jan 2006 12:45:30 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Medien]]></category>
		<category><![CDATA[Politik]]></category>
		<category><![CDATA[Wirtschaft]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/01/28/do-no-evil/</guid>
		<description><![CDATA[Do no evil &#8211; das ist ja bekanntlich die (öffentlich vertretene) Philosophie von Google. Und dieses gute Unternehmen mit ethischen Prinzipien filtert nun in China politisch &#8220;heikle&#8221; Themen wie Taiwan oder Tibet. Da hat man sich mit dem Reformkommunismus chinesischer &#8230; <a href="http://blog.tessarakt.de/archiv/2006/01/28/do-no-evil/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p><em>Do no evil</em> &#8211; das ist ja bekanntlich die (öffentlich vertretene) <a href="http://www.google.com/corporate/tenthings.html">Philo</a><a href="http://www.google.com/search?hl=en&#038;lr=&#038;q=google+%22do+no+evil%22&#038;btnG=Search">sophie</a> von <a href="http://www.google.de/">Google</a>.</p>
<p>Und dieses gute Unternehmen mit ethischen Prinzipien <a href="http://www.heise.de/newsticker/meldung/68792">filtert</a> nun in China politisch &#8220;heikle&#8221; Themen wie Taiwan oder Tibet. Da hat man sich mit dem Reformkommunismus chinesischer Prägung (in normalem Deutsch: Staatskapitalismus) ja hervorragend arrangiert.</p>
<p>Immerhin <a href="http://www.heise.de/newsticker/meldung/68924">wird das nun</a> Thema einer Anhörung des US-amerikanischen Senats-<a href="http://wwwc.house.gov/international_relations/afhear.htm">Unterausschusses für weltweite Menschenrechte</a>.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/01/28/do-no-evil/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>gcj</title>
		<link>http://blog.tessarakt.de/archiv/2006/01/26/gcj/</link>
		<comments>http://blog.tessarakt.de/archiv/2006/01/26/gcj/#comments</comments>
		<pubDate>Thu, 26 Jan 2006 07:55:18 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2006/01/26/gcj/</guid>
		<description><![CDATA[Gerade wurde ich mal wieder an einen Bug in gcj, also dem GNU-Java-Compiler erinnert, weil mal wieder bestätigt wurde, daß er noch auftritt. Interessant zu sehen, wie sich sowas (nicht) entwickelt &#8230;]]></description>
			<content:encoded><![CDATA[<p>Gerade wurde ich mal wieder an einen <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10632">Bug</a> in gcj, also dem GNU-Java-Compiler erinnert, weil mal wieder bestätigt wurde, daß er noch auftritt. Interessant zu sehen, wie sich sowas (nicht) entwickelt &#8230;</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2006/01/26/gcj/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Softwareprozesse</title>
		<link>http://blog.tessarakt.de/archiv/2005/08/08/softwareprozesse/</link>
		<comments>http://blog.tessarakt.de/archiv/2005/08/08/softwareprozesse/#comments</comments>
		<pubDate>Mon, 08 Aug 2005 15:50:20 +0000</pubDate>
		<dc:creator>Jens</dc:creator>
				<category><![CDATA[Informatik]]></category>
		<category><![CDATA[Uni]]></category>

		<guid isPermaLink="false">http://blog.tessarakt.de/archiv/2005/08/08/softwareprozesse/</guid>
		<description><![CDATA[So langsam verstehe ich, was der Sinn von &#8220;Schnell funktionierenen Code erzeugen&#8221; und &#8220;Falls nötig, refaktorisieren&#8221; in Softwareprozessen wie XP ist. Erst, wenn man man mit einem (selbst geschriebenen) Grundgerüst eines Frameworks eine (funktionierende) Anwendung geschrieben hat, weiß man, was &#8230; <a href="http://blog.tessarakt.de/archiv/2005/08/08/softwareprozesse/">Weiterlesen <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<p>So langsam verstehe ich, was der Sinn von &#8220;Schnell funktionierenen Code erzeugen&#8221; und &#8220;Falls nötig, refaktorisieren&#8221; in Softwareprozessen wie <acronym title="eXtreme Programming">XP</acronym> ist. Erst, wenn man man mit einem (selbst geschriebenen) Grundgerüst eines Frameworks eine (funktionierende) Anwendung geschrieben hat, weiß man, was im Framework fehlt. Und zwar sieht man dies daran, wo der Code der Anwendung Redundanzen enthält, die man dadurch beseitigen kann, daß man im Framework geeignete Abstraktionen zur Verfügung stellt.</p>
<p>IMO kann man das auch nicht vorausplanen. Man weiß eben <em>nicht</em> vorher, welche Abstraktionen sinnvoll sind. Versucht man es dennoch, erhält man im Regelfall ein Framework, das entweder nicht zu durchschauen ist, weil es eine enorm komplexe Schnittstelle hat, so daß man eine weitere Schicht darüber braucht, um diese Komplexität zu handlen (beliebtes Anti-Pattern: <em>Add an extra layer of indirection</em>), oder es bietet nicht die richtigen Funktionen, so daß die Anwendung schließlich ein einziger Workaround ist (oder man wieder mal eine zusätzliche Schicht eingefügt hat).</p>
<p>Das Ganze formalisieren zu wollen, ist meines Erachtens zum Scheitern verurteilt. Um die nötigen Abstraktionen bestimmen zu können, muß erstmal etwas Konkretes da sein. Das nötige Fingerspitzengefühl, um zu wissen, <em>wieviel</em> Konkretes da sein muß, ist wohl ein wichtiger Schritt in der Entwicklung jedes Programmierers.</p>
<p>Unnötig zu sagen, daß man sowas in einer <em>Vorlesung</em> (Softwaretechnik) ganz sicher nicht lernt &#8211; die bis jetzt knapp 140 Stunden Programmier-Hiwi-Job haben da deutlich mehr gebracht.</p>
<p>Achja, das &#8220;Standard&#8221;-V-Modell mit Entwurfsphase und Programmierern, die stur nur das ihnen zugewiesene Modul betrachten, stelle ich mir doch arg langweilig vor. So möchte ich nicht arbeiten müssen.</p>
]]></content:encoded>
			<wfw:commentRss>http://blog.tessarakt.de/archiv/2005/08/08/softwareprozesse/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

