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
• Conclusions

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.

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

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- time.

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.

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 unexpected functional 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 release.

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 Moon Illusion.

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 development.

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.

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 features.

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 changes.

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.

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 regressions.

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 BSD license.

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 .