The 2010 Tcl Conference was held in Oakbrook Terrace, IL.
Our invited guest was Georgios Petasis , a Natural
Language researcher and Tcl advocate from Greece. Initially, Georgios
wasn't sure he would have anything to say that would interest us. It
turned out that he has a lot to say, and all of it is interesting.
Georgios's main interests are Natural Language Processing, Machine
Learning and Tcl/Tk. He developed the Tk DragNDrop package, Tcl Agents,
the Tk Toolbar and more. He recently completed migrating a major
application from IncrTcl on Tcl8.5 to TclOO on Tcl8.6 and spoke at
length on the ease and hazards of such a migration.
The Tcl Community Association awarded two more Community Service Awards
for their work on extending Tcl's support for Object Oriented programming
with XOTcl and the new TclOO.
The final highlights to the conference were a couple of post-conference
events. The folks who stayed Friday night enjoyed a tour of
and a dinner and theater excursion to see
Seven Brides for Seven Brothers at the
Welcome and Keynote
Slides from Keynote Address:
- The shock of Tcl 8.6
- Porting existing code to TclOO
- Case study: the Ellogon NLP platform
- iTcl facilities in TclOO
- Organisation of classes in Ellogon
- Creating an Annotation Tool
- Concatenating Dialogs
WubTk is a new implementation of Tk that is layered on jQuery in a browser. It
allows development of web applications in Tcl using a familiar Tk-like API.
This paper describes the conversion of an existing biomedical visualization
program to WubTk, enabling it to be deployed in a browser. It also describes a
custom iOS App that provides a more native look and feel on devices like the
iPad and iPhone.
The paper also positions WubTk with respect to Tk (including enhancements
beyond the Tk API) and discusses planned new features.
ATWF a Tcl web framework is a work in progress, which started about 3 years ago
with a brain storming wiki page ToW Tcl on WebFreeWay. The ideas collected at
that page with a lot of feedback from the community were the base for further
investigation. Inspired from a payed work project using PHP's Zend framework I
decided to convert as a starting point the basic parts of that framework nearly
1:1 into Tcl. The very first pre alpha version is now handling the first
requests. It has some adaptions to Tcl constructs, but the rest is nearly
identical to the original version.
I have been working on a number of small projects that use TclOO in fairly
complex ways, and this paper will cover some of them. In particular, it will look
at its use for building more advanced APIs in the areas of interfacing to the
HTTP protocol for use with REST services, for mapping relational databases
into Tcl, and for supporting metadata on TclOO objects themselves.
Ozgur Ugurlu and Kevin Kenny
Tcl Assembly Language: what it is
- A way for scripts to include instructions at the
- Tcl virtual machine level
- A bookkeeping system for code generation
- A way for compilers (for instance little languages) to target the Tcl bytecode engine
- A rapid prototyping system for Tcl code generation
- A new backend connection for L?
Cookfs is an open source VFS for Tcl written in C and Tcl. It is designed to achieve better
compression ratio compared to Mk4 VFS and ZIP archives. It also offers configurable
compression algorithm currently zlib and bz2, with plans for lzma in the future.
It's also designed to be used in Tclkit-like applications. Cookit project shows how cookfs can
be used for this purpose.
Work In Progress Slides.
TkRibbon is a Windows-like Ribbon for Tcl/Tk.
A diagramming toolbox
Tcl (and the) Community
Google's Summer Of Code (short: GSoC) is a global
program funded and operated by Google that offers student
developers stipends to write code for various open source
software projects. The Tcl Community participated again
this year, for the third time in a row. As in previous years
this participation was managed by the Tcl Community As-
sociation (short: TCA) as the mentoring organization,
the same organization which runs the US Tcl Conferences.
The main entrypoint to the program for the community
itself can be found on the Tcler's Wiki.
Wize attempts to reduce complexity by offering a development environment that lets
programmers do more, with less, by providing:
- Code and data validation.
- Abstract GUI creation (layouts, scrollbars, tooltips, bindings, etc).
- Powerful widgets (TreeView, Tabset and shaped widgets).
- Hierarchical Tcl data (Tree).
- A common base of support components.
This paper describes the C and Tcl Hashtable Underpinnings for Language High-level Understanding, or CTHULHU.
CTHULHU is a series of tools to build C extensions for Tcl, from Tcl. It's focus is on computing problems
that require Tcl to have access to complex data structures that are themselves manipulated by existing C code.
These tools were originally developed to support the Test and Evaluation Solution's Integrated Recovery
Model, but would be applicable to any problem in which Tcl needs to interact with C data structures in real-
Software development on micro-controller based computing platforms is very challenging due to
minimal computing resources and I/O capabilities. These micro-controller platforms are deployed
widely in areas such as home automation, consumer electronics, automotive and medical devices.
This paper discusses a set of software tools, implemented in Tcl / Tk, that support software code
generation for small embedded micro-controller based systems. The core tool is a program called,
pycca, which is a domain specific language for specifying data structures, data relationships and
Finite state machine behavior. The focus of the paper is not on the functionality of pycca but rather
the underlying Tcl technology used to implement the tools. Although it is not possible to run a Tcl
interpreter on small micro-controller based systems, Tcl is a valuable tool used to support the de-
velopment and testing of this class of system. All the programs discussed are available as part of
an open source project.
Prashant Thakre and Tushar Gupta
This paper describes the
challenges involved in porting a
large scale enterprise
application from Tcl/Tk 8.4 to
Tcl/Tk 8.5, and lists down all
issues encountered during the
migration. The migration to
Tcl/Tk 8.5 required adjustments
in application code,
necessitated due to changes in
interface, or as a result of
behaviour. On some occasions it
was required to patch the
Tcl/Tk 8.5 distribution with fixes
which are now expected to be
included into standard Tcl/Tk
Steve Landers and David Roseman
This paper will describe the implementation of an augmented reality simulation
of a proposed wind farm, combining Google Earth (either standalone or via a
browser plugin) with animated turbine models to give realistic impressions of
the visual impact of a proposed offshore wind farm in Lake Michigan.
Several aspects of the simulation will be discussed, including the use of a
Tcl/Tk application for the generation and layout of KML (geographic data)
files, the use of Tcl CGI programs for generating dynamically sized images and
data, and a Tcl/Tk program to control Google Earth.
Mention will also be made of some of the non-programming issues
encountered, including visual perception issues such as Field of View and the
This paper is about TkDND, a Tcl/Tk extension that aims to add cross-application drag and
drop support to Tk, for popular operating systems, such as Microsoft Windows, Apple OS X
and GNU/Linux. Being in its second rewrite, TkDND 2.x has a stable implementation for
Windows and OS X, while support for Linux and the XDND protocol is still under
This paper is about the Ellogon language engineering platform, and the challenges faced in
modernising it, in order to better exploit contemporary hardware. Ellogon is an open-source
infrastructure, specialised in natural language processing. Following a data model that
closely resembles TIPSTER, Ellogon can be used either as an autonomous application,
offering a graphical user interface, or it can be embedded in a C/C++ application as a library.
Ellogon has been implemented in C/C++ and Tcl/Tk: in fact Ellogon is a vanilla Tcl interpreter,
with the Ellogon core loaded as a Tcl extension, and a set of Tcl/Tk scripts that implement
the GUI. The core component of Ellogon, being a Tcl extension, heavily relies on Tcl objects
to implement its data model, a decision made more than a decade ago, which poses
difficulties into making Ellogon a multi-threaded application.
Handling email has become a greater and greater burden on the aver-
age computer user. The user must be able to read mail safely, including
examining the non-obvious fake mail. There is a need to sort valid from
invalid, urgent and non-critical, or just sorting into mail from mailing lists,
friends, relatives, etc.
This problem is worse for the systems administrator who also has to
deal with the quantities of mail clogging the networks, filling the disks and
filling the administrator mailbox with failure notices.
There are many tools to mitigate these problems, ranging from using a
webmail service like Gmail, letting Microsoft solve your problems by using
Outlook, or using *ix tools like procmail, etc.
All of these tools are written in compiled languages. The speed is good,
but the ability to reconfigure and adapt is low.
Tools written in Tcl are as fast as the average user, and are more easily
adapted to the ever-changing email environment.
This paper provides an overview of a new image manipu-
lation and processing package for Tcl, the C Raster Image
Manipulation Package, or CRIMP for short. We will have
a quick look into its history, internal organization and im-
plementation, plus current and possible future features and
directions to work in.
Gaurav Bansal and Roshni Lalwani
Considering the huge designs required to be navigated and analyzed in the Electronic
Design Automation (EDA) applications, there is need to enhance the underlying Tcl/Tk
widgets to optimize both the performance and memory consumption.
This paper talks about enhancing the MtiHierarchy widget (part of the Mtiwidget
package) and Text widgets in a way that eliminates the performance overheads due to the
magnanimity of the data in the EDA applications and also providing various useful
A GUI application must enable and disable widgets as the state of the application changes.
Bryan Oakley's notion of "actions" aids this by associating widgets with user actions; widgets
associated with an action can be enabled and disabled as a group. This paper suggests a different
pattern in which widgets are associated instead with the conditions for which they are enabled,
thus greatly simplifying the problem of triggering widget state changes as the application state
This paper is about two Tile and Ttk themes, TileQt and TileGTK. Despite being two distinct
and very different extensions, the motivation for their development was common: making
Tk applications look as native as possible under the Linux operating system.
Madhur Bhatia, Saurabh Khaitan, and Tushar Gupta
Automating regression flow for any GUI
application always poses a lot of challenges. The
automation demands recording and replaying the
user interactions with the GUI often with timing
synchronization between operations. There are
some commercial and open-source solutions
available which provide interactive test capabilities
which can capture user sequences. Such testing
applications access the internal objects of the
application through the hooks provided via GUI
toolkit. For automating the GUI based tests for our
emulation product Veloce, an enterprise application
based on Tcl/TK, various testing solutions were
evaluated. Automation of GUI testing was
supplemented by other methods like tcl script
regressions, custom test applications and specific
logging wherever required. The paper presents a
case-study of various issues encountered in
developing good automated regression flow for
emulation GUI, and presents some coding and
development guidelines for Tcl/Tk applications in
general for suitability for development of automated
The support for displaying HTML and especially complex Web sites has always been
problematic in Tk. Several efforts have been made in order to alleviate this problem, and this
paper presents another (and still incomplete) one. This paper presents TkGecko, a Tcl/Tk
extension written in C++, which allows Gecko (the HTML processing and rendering engine
developed by the Mozilla Foundation) to be embedded as a widget in Tk. The current status
of the TkGecko extension is alpha quality, while the code is publically available under the
Eagle (Extensible Adaptable Generalized Logic Engine) is an
implementation of the Tcl scripting language for the Common Language
Runtime (CLR) .
The initial scope of the project was modest compared to 'real' Tcl; however,
it was ambitious considering the sixty day schedule for design,
implementation, and testing. Three years have passed since then.
This paper explains how Eagle has matured and evolved since it was
presented at the 15th Annual Tcl/Tk Conference .