Newsticker, Web-Blogs und andere Informationssysteme verwenden gerne das RSS-Format, um kurze Nachrichten in standardisierter Form an die Interessenten zu verteilen. Diese News-Schnipsel lassen sich bestens mit Tcl und der objektorientierten Erweiterung CZRSS verarbeiten.

Kleine orange Kästchen, die von den weißen Lettern XML oder RSS geziert werden, finden sich auf immer mehr Webseiten. Der Link dahinter führt zu einer Datei, die eine Zusammenfassung der jüngsten News enthält oder über Änderungen der Seite informiert. Mit Hilfe dieser Technik tauschen Portale untereinander Neuigkeiten aus, zum Beispiel zeigt Slashdot auch Freshmeat-Meldungen (Abbildung 1). Websites wie [rss-scout.de] oder [rss-verzeichnis.de] geben eine Übersicht über mehrere tausend Newsfeeds, von der Tagesschau bis zum örtlichen Turnverein. Ein RSS-Feed lässt sich sogar für fremde Sites nachrüsten – wie das geht, erklärt der “Perl-Snapshot” dieser Ausgabe.

RSS-Inhalte eignen sich bestens als Input für eigene Software. Ein Tcl-Programm kann die Informationen extrahieren und in die gewünschte Form wandeln oder in einer grafischen Oberfläche darstellen. Es gibt mehrere Tcl-Erweiterungen zum Lesen von RSS, sie basieren entweder auf einem XML-Parser oder sind wie das Redland-Framework[15] komplett in C geschrieben. Für diesen Artikel entstand ein weiteres Paket namens CZRSS[17] auf Basis von Jochen Loewers XML- Erweiterung TDOM[12], Code von Tcl-Guru David Gravereaux[16] und Objektorientierung mit Snit[9].

XML-Formatdschungel

Die Firma Userland verwendet seit 1997 einfache XML-Dateien für Nachrichtenzusammenfassungen[1]; ihren Standard nennt sie RSS (Rich Site Summary), Version 0.91. RSS-Files enthalten Informationen über eine Webseite: URL, Logo, Beschreibung sowie eine Reihe von Nachrichten. Jede einzelne Meldung besteht aus einem Titel, einer kurzen Beschreibung sowie einem Link auf die passende Webseite. Diese Dateien werden wie normales HTML vom Webserver verteilt. Der Mechanismus heißt irreführenderweise Newsfeed. Das suggeriert, dass die Dateien automatisch an interessierte Benutzer verteilt würden (Push-Technik). Der Client muss sie jedoch selbst abholen (Pull).

Die Weiterentwicklung des XML-Schemas wird von Userland kontrolliert. Deren Entscheidungen stießen aber nicht immer auf Zustimmung, ein unabhängiges Gremium definierte daher das RDF Site Summary[2] (Version 1.0). Userland ist inzwischen auch nicht untätig geblieben und stellte als Nachfolger von RSS 0.91 das Really Simple Syndication Scheme[3] vor (RSS 2.0). Um beliebige Newsfeeds zu lesen, muss ein Client daher mindestens diese drei XML-Schemata beherrschen. Neue Newsfeeds sollten RDF oder RSS 2.0 verwenden. Mit Atom[5] etabliert sich derzeit ein weiteres Schema für Zusammenfassungen, die Clients müssen daher künftig mit noch mehr Schemata umgehen.

Tcl-Hülle

Das neue RSS-Paket für Tcl soll all diese Details vor dem Programmierer verbergen und ihm die Informationen so bequem anbieten wie von Tk-Widgets gewohnt. Diese arbeiten objektorientiert:

% label .l -text "Hallo Welt"
% .l cget -text
Hallo Welt

Die bekannteste OO-Erweiterung ist sicherlich Incr Tcl, sie war Thema der ersten Folge der Federlesen-Reihe[8]. Incr Tcl bringt Tcl-Programmierern ein Objektmodell – wie von C++ oder Java bekannt – mit Vererbung, Zugriffsschutz und ähnlichen Mechanismen. Einen einfacheren Ansatz verfolgt Snit[9] von Will Duquette. Diese reine Tcl-Erweiterung ist inzwischen Bestandteil der Tcllib[10] und in aktuellen Linux-Systemen bereits enthalten (siehe auch Kasten “Das Neueste”).

Abbildung 1: Die Newsseite Slashdot blendet auch Meldungen von Freshmeat ein (rechts). Das Portal holt diese Informationen im standardisierten RSS-Format von der Freshmeat-Seite.

Objekte mit Snit

Listing 1 demonstriert Möglichkeiten für den Einsatz von Snit. Es definiert in den Zeilen 3 und 27 mit »snit::type Name« zwei Klassen, die unterschiedliche Variablen- und Methodentypen erhalten. In Klasse »a« finden sich die private Variable »privaterWert« und die statische Variable »PI« (Zeilen 4 und 5). Die private Variable steht nur ihrer Objektinstanz zur Verfügung, während »PI« von allen »a«-Instanzen geteilt wird.

01 package require snit
02 
03 snit::type a {
04   variable privaterWert
05   typevariable PI [expr {2*acos(0)}]
06 
07   constructor {w} {
08     set privaterWert $w
09   }
10 
11   method plus {var} {
12     incr privaterWert $var
13     return $privaterWert
14   }
15   method wert {} {
16     return $privaterWert
17   }
18   method aufruf {} {
19     return [$self wert]
20   }
21 
22   proc statisch {} {
23     return $PI
24   }
25 }
26 
27 snit::type b {
28   option -flag standard
29   option -überwacht 1
30 
31   onconfigure -überwacht {val} {
32     set options(-flag) $val
33     puts "setze -flag $val"
34   }
35   oncget -überwacht {
36     puts "lies $options(-flag)"
37     return $options(-flag)
38   }
39 
40   destructor {
41     puts "lösche $self"
42   }
43 }
44 
45 puts "n«A»n"
46 set iA [a create %AUTO% 42]
47 puts "iA $iA"
48 puts "wert [$iA wert]"
49 puts "plus [$iA plus 2]"
50 puts "wert [$iA wert]"
51 puts "aufruf [$iA aufruf]"
52 puts "statisch [a::statisch]"
53 
54 puts "n«B»n"
55 set iB [b create %AUTO%]
56 puts [$iB cget -flag]
57 $iB configure -flag 0
58 $iB cget -überwacht
59 $iB configure -überwacht 0
60 $iB cget -überwacht
61 $iB destroy

In Klasse »b« gibt es als dritten Variablentyp die »option« (Zeilen 28 und 29). Diese Optionen sind ähnlich wie bei Tk frei verfügbare Variablen, die ein Programm mit Hilfe der Methoden »cget« und »configure« lesen und schreiben kann. Normalerweise ist für Optionen kein weiterer Code notwendig, Snit speichert sie im internen Array »options«. Für die Option »-überwacht« implementiert das Beispiel per »oncget« (Zeile 35) und »onconfigure« (Zeile 31) jedoch eigene Methoden, die von Snit aufgerufen werden, wenn ein Programm die Option abfragt oder ändert.

Neben den Variablen enthält »a« einige Methoden (Zeilen 11 bis 20). Alle sind bei Snit frei verfügbar, private Methoden gibt es nicht. Die Instanzmethoden »plus«, »wert« und »aufruf« bearbeiten die Variable »privaterWert«. In der Methode »aufruf« ruft das Objekt eine Methode auf sich selbst auf. Statt des sonst üblichen »this« ist bei Snit dafür » zuständig.

Klassen ohne Erblast

Anders als andere OO-Erweiterungen kennt Snit keine Vererbung, stattdessen benutzt es eine Technik namens Delegation. Eine Klasse bindet dabei andere Klassen als Komponenten ein und delegiert Methodenaufrufe an die eingebetteten Klassen. Wer Näheres erfahren will, werfe einen Blick in die sehr gute FAQ und die ausführliche Manpage.

Während »snit::type Klasse« neue Klassen erzeugt, instantiiert » Klasse create Objekt Optionen« ein neues Objekt. Wenn der Name des Objekts nicht weiter wichtig ist, genügt die Angabe »%AUTO%« (Zeilen 46, 55). Das Create-Kommando gibt den Namen des neuen Objekts zurück. Die Ausgaben dieses Listings sind in Abbildung 2 zu sehen. Das Listing 2 zeigt einen Auszug aus dem Newsfeed der Tagesschau[6]. Es gilt wie für andere Nachrichtenquellen auch, dass man die Inhalte für kommerzielle Seiten nicht oder nur mit Genehmigung benutzen darf[7].

Abbildung 2: Das Skript in Listing 1 definiert zwei Snit-Klassen »a« und »b« und erzeugt daraus die Objekte »$iA« und »$iB«. Mit beiden Instanzen testet das Programm die Methoden und Optionen der Klassen.

Abbildung 3: Der einfache RSS-Newsreader (er ist noch in der Entwicklung) nutzt die vorgestellte CZRSS-Erweiterung von Tcl.

Channels und Items

RSS-Dateien bestehen aus zwei Teilen: Sie beginnen mit einer Beschreibung der Nachrichtenquelle im »channel«-Element (Zeile 4), danach folgt eine Serie von Nachrichten in »item«-Bereichen (Zeilen 9 und 14). Das Channel-Element nennt neben dem Namen und dem Link oft noch eine Beschreibung sowie einen Link zu einem Logo. Neben diesem Channel-Tag enthalten die Dateien bis zu 15 Nachrichten, die in je einem Item-Tag stecken. Jede Nachricht besteht aus einem Titel, einer Beschreibung und dem Link auf die Vollversion.

Der Aufbau der beiden anderen Schemata ist ähnlich, er unterscheidet sich vor allem durch die Verwendung von XML-Namespaces und die Lage der Item-Tags. Ein ausführlicher Vergleich findet sich in[4].

01 <?xml version="1.0" encoding="ISO-8859-1"?>
02 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
03  xmlns="http://my.netscape.com/rdf/simple/0.9/">
04   <channel>
05     <title>tagesschau.de - Die Nachrichten der ARD</title>
06     <link>http://www.tagesschau.de</link>
07     <description>tagesschau.de: Dieses Dokument enthält die [...]</description>
08   </channel>
09   <item>
10     <title>Knesset stimmt für Scharons Gaza-Abzugsplan</title>
11     <link>http://www.tagesschau.de/aktuell/meldungen/0,1185,OID3730326_REF1,00.html</link>
12     <description>Das israelische Parlament hat den umstrittenen Gaza-Abzugsplan [...] </description>
13   </item>
14   <item>
15     <title>Zitterpartie für Barroso und seine Kommissare</title>
16     <link>http://www.tagesschau.de/aktuell/meldungen/0,1185,OID3738140_REF1,00.html</link>
17     <description>Einen Tag vor der Abstimmung über die neue EU-Kommission ist unklar, [...] </description>
18   </item>
19 </rdf:RDF>

TDOM

RSS-Dateien folgen dem XML-Standard, zum Lesen ist daher ein XML-Parser nötig. Hier bietet sich die in einer früheren Federlesen-Folge vorgestellte Erweiterung TDOM[12] an. Ihr XML-Parser arbeitet sehr schnell und die DOM-Implementierung geht sparsam mit Speicher um. Die Erweiterung ist in Active Tcl[11] bereits enthalten. Wer sie selbst übersetzt, muss nur darauf achten, das Configure-Skript aus dem korrekten Verzeichnis heraus aufzurufen:

tar -xvzf tDOM-0.8.0.tar.gz
cd tDOM-0.8.0/unix/
../configure
make
make install

Neben Parser und DOM implementiert TDOM weitere XML-Techniken. Das CZRSS-Paket profitiert vor allem von den XPath-Querys, um XML-Elemente anhand ihrer Lage im Baum zu selektieren. Es könnte dank TDOM auch XML-Dokumente mit XSLT neu formatieren. Sowohl für XPath als auch XSLT finden sich Einführungen auf[13], die Spezifikation gibt es beim W3C[14].

CZRSS

Listing 3 zeigt die neu entwickelte Erweiterung zum Lesen der RSS-Dateien. Der Code in den Zeilen 3 bis 5 fordert zunächst weitere notwendige Pakete an: Snit gehört zur Tcllib, HTTP ist Bestandteil von Tcl. Die CZRSS-Erweiterung besteht aus den drei Snit-Klassen »doc« (ab Zeile 7), »channel« (ab Zeile 138) und »item« (Zeile 110). Die Doc-Klasse liest und analysiert die RSS-Dateien. Für die darin enthaltenen Informationen über die Nachrichtenquelle stehen die Objekte der Channel-Klasse bereit, für die Nachrichten selbst Item-Objekte. Um Kollisionen mit anderen RSS-Bibliotheken zu vermeiden, nutzen alle drei Klassen den Namensraum »cz«.

Das Laden der RSS-Datei erledigt die »load«-Methode (ab Zeile 20) der »doc«-Klasse. Sie holt das XML-File mit »http::geturl« (Zeile 24) und legt es in einer lokalen Datei ab. In Zeile 28 liest ein TDOM-Aufruf dieses File wieder. Der Umweg über die Datei wäre unnötig, wenn es nicht das leidige Encoding gäbe. TDOM kann auch direkt aus dem HTML-Stream lesen. Allerdings halten sich viele RSS-Dateien nicht an das Encoding, das sie selbst angegeben. Der XML-Parser verlässt sich dennoch auf die Angabe im Header und verstümmelt Umlaute und andere Sonderzeichen. Der Aufruf »tDOM::xmlOpenFile« umgeht dieses Problem und versteht das tatsächlich genutzt Encoding.

001 package provide czrss 0.1
002 
003 package require snit
004 package require tdom
005 package require http
006 
007 snit::type ::czrss::doc {
008   variable xpath
009   variable channel
010   variable items
011   variable url
012 
013   # Konstruktor für eine bestehende URI
014   constructor {uri} {
015     puts stdout "rss::doc $uri"
016     set url $uri
017     $self load
018   }
019 
020   method load {} {
021     # load xml to temporary file
022     set file "[clock seconds].xml"
023     set out [open $file w]
024     http::geturl $url -channel $out
025     close $out
026 
027     # load xml into dom from temporary file
028     set doc [dom parse -channel [tDOM::xmlOpenFile $file]]
029     set _root [$doc documentElement]
030     file delete $file
031 
032     set root [$doc documentElement]
033     switch [getRSSVersion $doc] {
034       0.91 - 0.92 - 0.93 - 2.0 {
035         set xpath(titleXpath)       {/rss/channel/title/text()}
036         set xpath(linkXpath)        {/rss/channel/link/text()}
037         set xpath(imgNodeXpath)     {/rss/channel/image/title}
038         set xpath(imgTitleXpath     {/rss/channel/image/title/text()}
039         set xpath(imgLinkXpath)     {/rss/channel/image/url/text()}
040         set xpath(imgWidthXpath)    {/rss/channel/image/width/text()}
041         set xpath(imgHeightXpath)   {/rss/channel/image/height/text()}
042         set xpath(storiesXpath)     {/rss/channel/item}
043         set xpath(itemTitleXpath)   {title/text()}
044         set xpath(itemLinkXpath)    {link/text()}
045         set xpath(itemPubDateXpath) {pubDate/text()}<c>046         set xpath(itemDescXpath)    {description/text()}
047       }
048       1.0 {
049         set xpath(titleXpath)       {/rdf:RDF/*[local-name()='channel']/*[local-name()='title']/text()}
[...]
061       }
062       default {
063         error "Unsupported schema [getRSSVersion $doc]"
064       }
065     }
066 
067     # Channel
068     set cN [$_root child 1 channel]
069     set channel [::czrss::channel create %AUTO% $self $cN]
070     puts $channel
071 
072     # Nachrichten
073     set items {}
074     set stories [$_root selectNodes $xpath(storiesXpath)]
075     foreach iN $stories {
076         lappend items [::czrss::item create %AUTO% $self $iN]
077     }
078   }
079 
080   method xpath {key} {
081       return $xpath($key)
082   }
[...]
089 
090   proc getRSSVersion {doc} {
091     set root [$doc documentElement]
092     switch [$root nodeName] {
093       rss {
094         if {[$root hasAttribute version]} {
095           return [$root getAttribute version]
096         }
097         # Best guess as most stuff is optional...
098         return 0.92
099       }
100       rdf:RDF {
101         return 1.0
102       }
103       default {
104         return 0
105       }
106     }
107   }
108 }
109 
110 snit::type ::czrss::item {
111   variable _node
112   variable _doc
113 
114   constructor {doc node} {
115     variable history
116     set _doc $doc
117     set _node $node
118   }
119 
120   method title {} {
121     set xpath [$_doc xpath itemTitleXpath]
122     return [::czrss::nodeTxt $_node $xpath]
123   }
124   method link {} {
125     set xpath [$_doc xpath itemLinkXpath]
126     return [::czrss::nodeUri $_node $xpath]
127   }
128   method description {} {
129     set xpath [$_doc xpath itemDescXpath]
130     return [::czrss::nodeTxt $_node $xpath]
131   }
132   method pubDate {} {
133     set xpath [$_doc xpath itemPubDateXpath]
134     return [::czrss::nodeTxt $_node $xpath]
135   }
136 }
137 
138 snit::type ::czrss::channel {
[...]
167 }
168 
169 namespace eval ::czrss {
170   proc encUri {uri} {
171     return [string map {& %26} $uri]
172   }
173   proc encTxt {txt} {
174     return [string map {& & < < > >} $txt]
175   }
176   proc nodeUri {node xpath} {
177     if {[$node selectNode $xpath] != ""} {
178       # Only if there is a lonely &, quote it back to an entity.
179       return [encUri [[$node selectNode $xpath] nodeValue]]
180     } else {
181       return ""
182     }
183   }
184   proc nodeTxt {node xpath} {
185     if {[$node selectNode $xpath] != ""} {
186       return [[$node selectNode $xpath] nodeValue]
187     } else {
188       return ""
189     }
190   }
191 }

Sprache erkannt

Das Switch-Kommando in Zeile 33 unterscheidet, ob es sich um eine RSS-Variante mit Namensräumen im XML-Code handelt oder nicht. Es ermittelt dazu die Versionsnummer – hierfür ist die statische Methode »getRSSVersion« zuständig (als Prozedur definiert ab Zeile 90). In dem Switch-Statement werden die XPath-Querys für die relevanten Elemente des RSS-File gesetzt. XPath-Suchstrings sind eine bequeme Technik, um Elemente im DOM anhand ihres Pfads zu finden.

Die in CZRSS verwendeten Abfragestrings sind – wie andere Teile auch – einem Programmbeispiel von David Gravereaux[16] entnommen, der damit die grundlegende Arbeit geleistet hat. Der Code speichert die Suchstrings in der Variablen »xpath«. Die ab Zeile 80 definierte Methode »xpath« gibt die passenden Querys zurück.

Ab Zeile 68 beziehungsweise 73 erzeugt die »load«-Methode noch Objekte für den Channel und die Nachrichten. Für die Objekte sind die Klassen »channel« und »item« zuständig, sie enthalten jeweils eine Referenz auf ihr Dokument und den DOM-Knoten. Alle Antworten dieser Klassen laufen gleich ab: Zuerst erfragen sie bei der übergeordneten »doc«-Instanz die richtige XPath-Query und lesen dann über eine Hilfsmethode den Wert aus dem DOM-Baum.

Mitarbeit möglich

An dieser einfachen Bibliothek ließe sich noch einiges verbessern. Sie könnte die Dateien selbstständig aktualisieren, mehrere Newsfeeds gleichzeitig unterstützen oder die Einträge nach Zeiten sortieren. Die Quellen sind wie immer auf dem FTP-Server des Linux-Magazins erhältlich[18] sowie im Tclers Wiki[17], in dem jeder Leser eigene Verbesserungen anbringen darf.

Anwendungsfälle

Ein einfacher Newsreader, der CZRSS nutzt, ist bereits in Arbeit, einen Vorgeschmack gibt die Abbildung 3. Die nächste Federlesen-Folge wird sich mit diesem Programm beschäftigen. Das Listing 4 zeigt, wie einfach es mit der RSS-Erweiterung ist, die HTML-Seite in Abbildung 4 aus den Daten eines Newsfeed zu erzeugen.

Abbildung 4: Das Tcl-Programm in Listing 4 verwandelt die Daten eines RSS-Newsfeed (Auszüge in Listing 2) in ein ansehnliches HTML-File.

Um die Aufrufparameter auszuwerten, nutzt das Skript die »tcl::OptProc«-Funktion aus dem Opt-Paket der Tcl-Distribution. Das Skript nimmt als Parameter »-file Ziel« den Namen der Ausgabedatei entgegen (Zeile 24). Defaultwert ist der leere String, in diesem Fall landet die Ausgabe auf Stdout (Zeile 33). Immer anzugeben ist die Quelladresse (URL), von der das Skript das RSS-Feed holt.

 01 source czrss.tcl
02 package require czrss
03 package require opt
04 package require html
05 
06 proc genhtml {doc} {
07   set channel [$doc channel]
08   ::html::init
09   set html [::html::head [$channel title]]
10   append html "<link rel='stylesheet' type='text/css' href='format.css'><style type='text/css'>"
11   append html [::html::openTag body]
12   append html [::html::h1 [$channel title]]
13   append html [::html::openTag dl]
14   foreach item [$doc items] {
15     append html "<dt><a href='http://[$item%20link]'>[$item title]</a></dt>n"
16     append html "<dd>[$item description]</dd>"
17   }
18   append html [::html::closeTag]
19   append html [::html::end]
20   return $html
21 }
22 
23 tcl::OptProc main {
24   {-file -string "" "zieldatei"}
25   {url "RSS-Feed, z.B. http://www.tagesschau.de/newsticker.rdf"}
26 } {
27   set doc [::czrss::doc create %AUTO% $url]
28   if {[string length $file] > 0} {
29     set fd [open $file w]
30     puts $fd [genhtml $doc]
31     close $fd
32   } else {
33     puts stdout [genhtml $doc]
34   }
35 }
36 
37 if {[catch {eval main $argv} res]} {
38   puts stderr $res
39 } else {
40   puts stdout $res
41 }

Aus RSS mach HTML

Die Prozedur »genhtml« (Zeile 6) erzeugt den HTML-Code. Sie nutzt das HTML-Paket der Tcllib, um etwas Arbeit beim korrekten Schreiben der Tags zu sparen, zum Beispiel setzt Zeile 9 den kompletten HTML-Header. Die Inhalte stammen aus dem CZRSS-Doc-Objekt. Die wichtigste Schleife findet sich ab Ziele 14: Sie geht alle Nachrichten-Items durch und erzeugt daraus die Definition-List-Elemente inklusive Hyperlink. Die Daten dazu sind per »[ link]« für die URL und »[ title]« für den Titel der Meldung schnell eingefügt.

Mit der hier beschriebenen Tcl-Erweiterung lassen sich sehr einfach RSS-Dateien auslesen und in eigenen Skripten nutzen. Die Skripte brauchen sich nicht selbst um die Details der diversen RSS-Dialekte kümmern. Programmierer und Anwender müssen lediglich die Urheberrechte der verwendeten Newsfeeds beachten. (fjl)

Das Neueste

Passend zum RSS-Reader haben Rolf Ade, Arjen Markus und Richard Suchenwirth auf dem Wiki [http://wiki.tcl.tk/12550] den XML-Browser Star DOM veröffentlicht. Er basiert auf TDOM[12] und gibt einen schnellen Überblick über die Struktur eines Dokuments. Besonders praktisch: Man kann auch große XML-Dokumente damit durchsuchen. Abbildung 5 zeigt Star DOM mit dem Newsfeed der Tagesschau aus Listing 2. Die Federlesen-Folge vom Februar 2002 (auch im Linux-Magazin-Sonderheft 4/04 “Skripting” zu finden) hat die Tcllib vorgestellt. Die neue Version 1.7 enthält zum Beispiel einen Parser für Bittorrent-Dateien, erkennt HTTP-Proxys automatisch und erzeugt eindeutige ID-Nummern. Auf dem französischen Tcl-Wiki [http://www.larochelle-innovatio.com/tcltk/726] ist mit “Bubbles” ein echter Zeitfresser gelandet (Abbildung 6): Die Spieler sollen die Blasen aus dem Spielfeld entfernen, dazu schießen sie neue Blasen zu per Mausklick markierten Punkten. Trifft die neue auf zwei oder mehr Bubbles der gleichen Farbe, lösen sich alle auf, andernfalls bleibt die neue Blase kleben. Abbildung 5: Der XML-Viewer Star DOM ist in Tcl, TDOM und BWidgets implementiert. Er zeigt hier das Newsfeed der Tagesschau aus Listing 2. Neue Release und künftige Entwicklung Der Tcl-Interpreter ist bei Version 8.4.7 angekommen, sie behebt vor allem Fehler unter Windows und verbessert den Code für Mac OS X. Auf der 11. Tcl-Konferenz (zu den Vorträgen: [http://wiki.tcl.tk/12649]) sprach Jeffrey Hobbs auch über die weitere Entwicklung von Tcl. Als wichtige Verbesserungen nannte er den GUI-Bereich (Aussehen, bessere Integration) sowie neue Datenstrukturen. Eine Roadmap zeigt [http://wiki.tcl.tk/12753], die Tcl-Version 8.5 ist demnach im Herbst 2005 zu erwarten. Genauere Zeitangaben (Tage statt Monate) sind hoffentlich von Pascal Scheffers Rechner zu erwarten: Mit ihm ermitteln Eltern den voraussichtlichen Geburtstermin ihrer Kinder: [http://wiki.tcl.tk/12708] Abbildung 6: Ein sehr einfaches Spiel, aber mit Sucht-Potenzial. Der Spieler muss neue Blasen zu gleichfarbigen schießen, um das Feld abzuräumen.