This page describes the Second European Tcl/Tk Users Meeting held June 7-8, 2001 in Hamburg, Germany.
The presentations of this meeting are available at the http://www.eurotcl.eu/preasteventations.html#eurotcl2001%|%EuroTcl site%|%.
----
''Here's a report posted by [Rolf Ade] on comp.lang.tcl:''
(Too sad, nobody has reported about what has happen at the 2. Tcl/TK
European User Meeting at Hamburg-Harburg at the 7th and 8th June
2001. Therefore a few notes at my own. Excuse the clumsy English.)
It was great to be there; thanks again to [Carsten Zerbst], for
organizing this meeting the second time.
At both days around 40 Tcl'ers met in the rooms of the Technische
Universität Hamburg-Harburg. It was truly an European meeting; about
half of the participants were Germans, the other half traveled
there from England, Italy, Switzerland, Netherlands, Finland and maybe
some other countries.
The major general themes of the talks and the private discussions
between the talks are not uncommon to the readers of c.l.t. To name a
few: Tcl is really, truly great for embedding, there is a pressure
need for a central extension repository or a least a batteries
included distribution, and what happened to Paul Duffins feather.
Undoubted, there is only a small tcl community. But this doesn't truly
reflect the wide spread usage of tcl within the industry. Everybody at
the meeting reported about some tcl embedded commercial
applications. Do you ever heard about a commercial package, that has
an embedded perl interpreter?
In his keynote, [Andreas Kupries] gave an overview of what has happen
in the tcl world in the last year and what is coming in the near
future (new alpha/first beta of tcl8.4). He pointed out, that the [Tcl Core Team] (beside the fact, that a lot, maybe most of the real core
development is done by [TCT] members) isn't the tcl core development
team, but more of a coordination and regulation instance. Everyone is
invited to involve ideas to make tcl a just more useful thing, writing
[TIP]s and implement the ideas in coordination with the TCT. The
closing "Oustervote" was about which extensions should be included
within a batteries included distribution.
[Andrej Vckovski], from the swiss [netcetera], held two
impressive talks, the first about Tcl as a strategic development
platform and the second about building web applications, especially
using the netcetera tool websh (available as Open Source). The
history of the at the moment 60 people company netcetera is a clear
tcl success story. They use tcl for building web applications, CORBA
Services, internal tools, process support, test automation, gluing
legacy application, products and embedding. It's unimpossible to
summerize in a few words all the good points Andrej made about themes
like "selling" tcl and packaging tcl applications. His talks showed
very clearly, that the folks at netcetera have deep experiences in
building large and complicated web applications. Therefore, if you are in
the same area, websh may really worth a try.
[Franco Violi] presented another impressing example of successful
commercial tcl usage. Beside the already last year presented TclCobol
(an interface between [Cobol] and Tcl/Tk) his talk was focused on his
[TclDirectory], a Tk Interface to [LDAP] Servers, and a new toolkit,
that is able to generate database GUI's out of a small, compact
description, which dramatically simplifies legacy application
development. A part of this is a set of "legacy widgets" for special
datatypes. Franco promised to publish the code of at least some
of his tools to sourceforge within the next weeks and months.
[Uwe Zdun]'s Introduction to the OO package [XOTcl] triggered probably the
most discussions of all talks. In some sense XOTcl is really different
from most other tcl OO extensions, including itcl. Uwe and his
co-author [Gustaf Neumann] are claiming their OO system is much more the
"tcl way" of doing OO development, than every other tcl OO
extension. XOTcl is a "slot based" OO system with a lot of
capabilities like introspection, dynamically changeable objects,
classes and superclasses, per-object mixin of classes into the
precedence order of an object in front of the precedence order implied
by the class hierarchy (used for object-specific extensions), and
special filter methods, that are automatically invoked, every time an
object receives a message. Some yelled "clearly wrong" about some of
the ideas, others where thrilled exactly from the same ideas. I'm at
least sure really a lot of the tcl european meeting participants will
take a closer look at XOTcl at home within the next weeks.
The second day started with a talk from [Stefan Finzel] about how to
write "proved" and certificateable tcl code. He found the Tcl/Tk
Engineering Manuals useful, but not specific enough, and defined
himself a set of around 200 additional coding rules. He also promoted
the use of code checker programs, like frink and
procheck. Additional, he has written code checking tools by himself,
especially for checking the usage of variables. Stefan promised to
publish his coding rules and his code checking tools at the tclers
wiki.
[Jochen Loewer] talked about what has happened with his [tDOM] package (for
easy and powerful [XML]/[DOM] processing with an extra focus on
expressiveness and performance) since his last year talk. How fast and
less memory hungry his tDOM package is showed a few test results
compared with the results of the lately published "Java XML
Representations Benchmark". Compared with the six most popular Java
XML/DOM Implementations, tDOM builds a DOM tree 5 to 15 times faster,
while using 3 to 4 times lesser memory. Since the last year, the C
coded Xpath implementation included in tDOM was quality
improved. Jochen added a [HTML] reader to the suite, to build DOM trees
from HTML files. A fast XML validator module was added to the package,
that allows to validate XML documents against their [DTD], while
building the DOM tree or using the SAX interface of the package. tDOM
is thread save now, and work is ongoing, to share DOM trees between
threads. Jochen has added a C coded [XSLT] engine to tDOM, that allows to
transform the in memory XML data. Although this is at the moment a
work in progress, it has started to be useful for simple XSLT
stylesheets and tasks. Although tDOM isn't very present in public
perception, there are a few commercial applications, that are using
it.
[Carsten Orthbrandt] presented a success story about using tcl in an
area you may never have minded: tcl as scripting language for
professional game development. Carstens company, SEK-Ost, uses tcl as
scripting engine within the game itself and also for workflow tools in
the production process. They use tcl only embedded and don't use Tcl
DLLs but link statically. They have done a couple of interesting
things with and to tcl. For example they added a "pre-processor", to
provide a different mechanism for comments, skipping the "not strictly
intuitive" way of tcl comments, and to be able to do some C-like
conditional inclusion of Tcl sources. They are using one tcl
interpreter per game object, that means hundreds or thousands of
interpreters at a time. Every created game object calls some class
scripts. To circumvent reloading and compiling of otherwise constant
scripts, they added a bytecode cache, that keeps all loaded scripts in
memory and returns the preprocessed and (if it was evaluated before)
compiled Tcl object on successive requests for the same tcl file. For
use within the game, they added over 600 custom commands to tcl. They
also had some big problems, Carsten said. Handling of C++ object
references in Tcl was one of the bigger challenges. A custom type for
smart object pointers didn't worked out, because of the limited
control over the lifetime of custom type internal representations. On
top of there tcl wishlist are a lightweight tcl (because they don't
use events, sockets or reg expressions) and the possibility of opaque
types. Indeed they are thinking about rewriting tcl for there needs,
Carsten told.
[Arjen Markus] talked about using tcl to generate test programs and
libraries written in some other procedural language, lets say Fortran
90 or Java. Basically, Markus tcl program (which he calls Testmake),
generates from some skeleton code and the user defined test input (in
a very simple "data-like" syntax) full working test programs.
Very promising sounded the talk of Mr. Vogler from the German federal
office for environment protection. They developed together with an
industry partner some kind of generic database access for tcl. To do
this, they defined an abstract layer above existing tcl interfaces for
several databases, including [Oracle], [MySQL], [PostgreSQL] and [ODBC]. Since
they only manage the abstract layer, they can only build "generic"
database commands for the "common denominator" of the functionalities
provided by the several underlaying database interfaces. They already
have the commitment of the federal office to make the package public
available as open source, after they finished. This is remarkable, as
they pointed out, because it truly isn't common for German federal
offices to do this. 80 to 90 percent of the code are already done,
they said. Await the package to be available anytime in august or
september.
The maybe most entertaining talk of the meeting was held by [Lindsay Marshall].
He reported about his experiences using tcl/tk on the [iPaq]
PDA. The first step, if you also want do this, is to replace the
standard Win CE (or whatever) OS of the iPaq with a linux
installation, which is, according to Lindsay, quite easy. After
crosscompiling and copying across, wish worked straight away, he
said. The major practical problem while using tk applications is more
or less obvious: the iPaq has, as any other PDA, a really small
screen, compared to a typical desktop system. After reducing the
default button text typeface (and also the width of the scrollbars)
Lindsay was able to use his IRC client Zircon at his iPaq. At top of
Lindsays wishlist for an "PDA tcl/tk" are anti-aliased fonts support
(crucial because of the needed small point sizes of the fonts) and a
more easy and centralized way of adjusting some defaults like the font
sizes.
[Kristoffer Lawson] talked about a high-level protocol, object system
and related libraries for controlling and building user interfaces to
work with a large variety of display platforms, without change to the
application. The major point of the hole system is to describe user
interfaces in terms of abstract objects forming a tree structure,
similar to what [LaTeX] and XML do in the field of documents. Out of
this description a display server is rendering the user interface. Tcl
comes into the story if you ask for code. Kristoffer and his
co-workers have already a Tcl/XOTcl client library to talk to a
display server, and, beside a HTML display server, a basic tk display
server.
Unfortunately, [David Welton] couldn't manage to come to the meeting, to
talk about his apache module [mod_dtcl].
----
[Andreas Kupries] also posted a valuable summary [http://groups.google.com/groups?ic=1&th=1e6a8deef5c83c91] to comp.lang.tcl.
<<categories>> Tcl Conferences | Community