Tcl HomeTcl Home hosted by
ActiveState

Google SiteSearch

Technical Session Abstracts

The use of Tcl/Tk in the AnatLab Virtual Anatomy Laboratory
Cyndy Lilagan, Mike Doyle, Steve Huntley, Steve Landers

The AnatLab system provides an interactive web environment for exploring human anatomy, including the locations, identities, relationships and extents of anatomical structures, as well as associated textual information.

An early version of AnatLab was demonstrated at Tcl2008, and this paper goes beyond that to describe a number of the Tcl-based technologies used to create AnatLab.

These include Ajax web services based on Tclhttpd, Flash-plugin interaction with Tcl services, a Metakit database (utilizing mk4too) for fast hashed access to anatomical structure information, a Tk-based graphical anatomical annotator, a Tcl-scripted annotation processor that handles I/O for TIF-based zmap structure databases and a Tcl anatomy nameserver that replaced a slower and more complex Java version.

Networked Digital Whiteboard with Handwritten-Symbol Interpreter and Dynamic-Display-Object Creator
Atsuhide Kobashi

We present a unique Tcl/Tk-based whiteboard system that facilitates discussions among multiple participants located at remote sites as well as in classroom or conference-room setups.

One of its uniquenesses is its capability to convert handwritten complex-structured math/scientific symbols to clean custom-font-based presentations. Another uniqueness is that it enables the user to easily create dynamic discussion tools incorporating various widgets instantly during a discussion, and send them to the whiteboard server for display and manipulation.

The above features can be easily augmented to fit various domains of discussion by adding more Tcl scripts and/or C modules. All of these unique capabilities are made possible by Tcl's easy mergeability with C and its superb scripting characteristics.

Using [incr Tcl] to improve stability of an Emulation debug GUI - A Case Study
Ruchir Agarwal, Prashant Thakre, Manu Goel, Maneesh Agarwal

This paper will discuss how an Emulation debug GUI, required to handle multiple datasets of different types at the same time and provide the user with design and debug information for all the datasets currently open, was having problems in switching between datasets, primarily due to pure Tcl code base. Then we will describe how the GUI was redesigned to take advantage of object oriented methodology provided by [incr Tcl]. This paper will describe how [incr Tcl] was used by ways of code examples. We will conclude the paper by mentioning the benefits achieved by this exercise and also give our recommendations on how to avoid the common pitfalls in using Tcl for large scale and complex software and how they can be easily avoided by using [incr Tcl].

Modelsim
Ron Wold

Over the past 10 years the Modelsim GUI, a software program written in Tcl/Tk, has grown from a simple user interface with three panes to an elaborate interface comprised of over 50 distinct windows. The Modelsim GUI architecture, while sufficient at the time of creation, began to crumble under the weight of so many windows. This paper will explore the issues that occurred as the window count grew, and describe some of the solutions that were chosen to address these issues.

Overview - Why so many windows?

Modelsim is an integrated development environment (IDE) used by electronic designers to develop, debug, simulate and test electronic designs. It supports several different hardware description languages (HDLs), each of which employs unique concepts that require unique user interfaces.

As HDL conceptual capabilities have grown over the years, the number of unique ModelSim windows has grown to keep pace with those capabilities. But as the number of windows within Modelsim increased, certain problem began to appear. Changes and enhancements became increasingly more difficult to implement. In many cases, code that was once simple and straightforward became complex and unwieldy.

A computational framework for flood risk assessment in the Netherlands
Arjen Markus

The safety of (river) dikes in the Netherlands, located in the delta of the rivers Rhine, Meuse and Scheldt, has been the subject of debate for more than ten years. Most methods to estimate the required dike height, as part of the risk assessment focus on the river only. If, however, a river dike breaks somewhere along the river, this influences the chance of dike breaches elsewhere: the water level downstream may be lowered, but the water can now reach the dikes around the flooded area from the inland side. This effect is known as river system behaviour.

To understand the importance of this effect and the possible consequences it has on the design methodology, we studied the hydrodynamics of a part of the Netherlands that is enclosed by the Rhine and Meuse. A major part of that study was to conduct several hundreds of simulations with different dike strength parameters and model flood wave to enable a statistical analysis of the risks in this area, vis-a-vis casualties and economic damage if a dike breaks.

This involved getting a set of otherwise independent programs to work together: the dike strength and flood parameters were selected via a Monte Carlo method, this led to input for a detailed hydrodynamic model of the rivers and the surrounding area and results from that model were analysed to estimate casualties and economic damage.

As these programs ran on different types of computers in different locations, Tcl programs were developed to automate the transfer of the input and output, the scheduling of the programs on the Linux cluster and local PCs and the checking of the computations. Furthermore, Tcl programs facilitated in collecting the results in a condensed form, useful for the subsequent statistical analysis.

While the framework as such was set up in an ad hoc manner, there is an elegant underlying formal model: the tuplespace that describes this framework very well. The file system of the Linux cluster served as the database system and Tcl's abilities to interact with the OS and the file system (both on Linux and PC) were instrumental in managing the actual computations.

A Tcl/Tk Add-on Script for Large Meshing Software
Wenny (Xiaohang) Wang, Richard J. Matus

Gridgen is meshing software used by many engineers and scientists worldwide since 1984 to reliably generate high quality grids for engineering analysis. Glyph, which is Gridgen?s Tcl-based scripting language, provides full access to the functionalities available interactively in Gridgen. It allows users to extend Gridgen?s functions as well as develop specialized meshing applications. This paper shows how a new Gridgen capability, automated block topology change, is developed through a script using Glyph, Tcl and Tk. This feature changes grid topologies in a matter of seconds while interactively changing grid topologies can require hours of a user?s time.

Comit's CVXT tool
Venkat Iyer

Comit has a tool called CVXT, which integrates the ability to write Tcl Tests with industry standard verilog simulators. As EDA tools have moved more and more towards Tcl, this now involves running multiple Tcl Versions in the same process space. CVXT has kept abreast of Tcl developments and is now on 8.6b1, but integrates into simulators that use Tcl 8.3. The talk is about:

1. how to make multiple separate tcl interpreters run in one process space.

2. How coroutines have helped this event driven, user programmable testing.

Wub, Coro, Dicts and Objects
Colin McCormack

This talk will discuss Wub's co-evolution with the new facilities of Tcl 8.6 (dicts, coros and objs.) This discussion should make obvious the opportunities of coroutines, dicts and objects for the author of network programs. Side-excursions to Coronet and the coro-based HTTP client.

Wub's architecture and functionality will then be dissected in exquisite detail, giving all assembled an insight into its design, a working knowledge of its utility, and several good reasons to use it."

Tools for Developing, Distributing and Using Tcl/Tk Applications over the World Wide Web
K. J. Nash and A. J. Simons

Tcl/Tk safe interpreters provide a secure environment for running arbitrary untrusted code. We have developed Web clients in Tcl/Tk that are optimized for running Tcl/Tk applications. We have also developed server-side tools that permit collaborative development of Tcl/Tk code in a Wiki-like environment, but optimized for code rather than text. We combine the advantages of the browser plugin and the Wiki, with added features such as an enhanced security policy, local caching, and remote storage of personal files. The clients can be compared with Adobe Air or Microsoft Silverlight, but are better oriented to sharing code because by default the client receives the full Tcl/Tk source code.

An overview of two key Stargus technologies - secure authentication and shared storage
Steve Huntley, Steve Landers, Mike Doyle, Cyndy Lilagan

Stargus is an ongoing project to develop a highly compact and portable virtual computing environment, based on the Tcl/Tk platform. It was first introduced at the Tcl2005 conference in Portland and several Stargus sub-projects have been sponsored, including Cryptkit, Tequila 2, Vlerq, Tkhtml3 and Critcl 2.

This paper introduces two key Stargus technologies - secure authentication via BetterID and shared storage via Mockingbird.

In an attempt to go OpenID one better, the Stargus security sub-system (tentatively named BetterID) will use overlapping up-to-date security concepts such as transient public-key cryptographic keypairs, restricted-domain browser cookie access and shared secrets to create a truly secure authentication protocol - essential for cloud computing. For ease of implementation, BetterID transactions will be stateless interactions between a service provider and a dynamic-language-enabled client, thus eliminating the need for an identity server (aside from static key storage). The dynamic language component will be Tcl- based, either in custom Tcl clients, or in browsers adapted to run Tcl directly, or Javascript-enabled browsers with ported Tcl code via tools like Google Web Toolkit.

The Mockingbird shared storage system is based on the concepts in Tequila (shared, persistent arrays), but extended so it can work over Cloud Computing. Llike BetterID, it doesn't require a dedicated server - Mockingbird state resides in message queues, and a server is only needed for transaction logging and bringing a client up-to-date on connection. Mockingbird builds on the authentication and security provided by BetterID to provide granular access control. By leveraging the Tequila model Tcl developers can work with a familiar paradigm and existing Tcl applications can be moved to a secure Cloud Computing environment with minimal changes.

Tcl In the CLR
Joe Mistachkin

Eagle (Extensible Adaptable Generalized Logic Engine) is an implementation of the Tcl scripting language for the Common Language Runtime (CLR). It is designed to be a universal scripting solution for any CLR based language.

In addition to being an implementation of the Tcl language, Eagle has the ability to function as a bidirectional bridge between "real" Tcl and the CLR.

This paper explains the details of how Eagle integrates Tcl with managed code and the CLR. It then describes the specifics of how to dynamically load, use, manage state for, respond to events generated by, and unload the Tcl library.

TclOO: Past, Present and Future
Donal Fellows

This paper will look at the history of development of Tcl's object system, its current usage within the community, and prospects for future development. The complexity of this project was such that it holds a number of key insights and lessons for Tcl developers, and yet it is now being used in the community for production code (libraries, applications and other object systems). As a result of this community usage, it is become clearer what features will be wanted in the future (in future releases of Tcl) and this paper will outline some of these future directions. OO Best Practices and Frameworks
Sean Woods

TclOO is a vibrant new applications platform. With it's inclusion in the core, it will soon be a vital tool in every programmer's toolbox. What we lack as a community is experience using it. This paper will outline the Author's proposed framework of methods and design elements that capture his vision of the 'Tcl Way' of doing things in the OO world. These designs are based on his own experience using Itcl and Tao to build web engines, complex UIs, and Agent Based simulations. Towards XOTcl 2.0 -- A Ten-Year Retrospective and Outlook
Stefan Sobernig, Gustaf Neumann

The Extended Object Tcl (XOTcl) language has diffused across the various Tcl/Tk communities for nearly ten years. In this time frame, it has been successfully adopted as a development platform for a variety of commercial, as well as academic applications and application frameworks. Likewise, it was subjected to research on language and application engineering. As it stands today, XOTcl belongs to the most flexible object-oriented languages available. While research was initially focused on extending the expressiveness in order to empower the developer, recent work was geared towards the orthogonality, the ease of use, the productiveness, and the tailorability of the language. This range of requirements led towards the development of an innovative OO-language framework which serves as a common environment for a family of object-oriented Tcl/Tk dialects. This paper presents the most interesting aspects of these developments and outlines the infrastructure of the forthcoming XOTcl 2.0 framework.

In this paper, we review the continued development of the XOTcl language and programming framework. We demonstrate major feature additions and enhancements since the initial XOTcl presentation in early 2000. Against this background, we shall build up an overview of future directions in the ongoing development of a revised XOTcl 2.0 infrastructure which, among other objectives, targets language-oriented programming. First, however, we shall briefly recall this project's history by highlighting important milestones.

Conference Committee

Brian Griffin   Mentor GraphicsFacilities Coordination
Clif Flynt   Noumena CorpGeneral Chair, Website Admin
Ron Fox   NSCL Michigan State UniversityProgram Chair
Arjen Markus   WL Delft Hydraulics
Cyndy Lilagan   Iomas Corp
Mike Doyle   Iomas Corp
Gerald Lester   KnG Consulting, LLC
Donal Fellows   University of Manchester
Jeffrey Hobbs   ActiveState Corp
Steve Landers   Digital Smarties
Joe Mistachkin   Mistachkin Systems
Kevin Kenny   GE Global Research Center
Ken Jones   Avia Training
Larry Virden   Tcl FAQ Maintainer
Andreas Kupries   ActiveState Corp

Contact Information

fox@nscl.msu.edu

Top of page
Developer Home | Getting Started | Tcl Advocacy | Software Resources | Documents | Community | Links
Site Map | Feedback | webmaster@-SPAM-.tcl.tk
Increase page width

Last modified: September 07, 2009