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.
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.
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].
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.
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.
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 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.
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."
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.
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.
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.
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.
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.
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.
Cyndy Lilagan, Mike Doyle, Steve Huntley, Steve Landers
Atsuhide Kobashi
Ruchir Agarwal, Prashant Thakre, Manu Goel, Maneesh Agarwal
Ron Wold
Arjen Markus
Wenny (Xiaohang) Wang, Richard J. Matus
Venkat Iyer
Colin McCormack
K. J. Nash and A. J. Simons
Steve Huntley, Steve Landers, Mike Doyle, Cyndy Lilagan
Joe Mistachkin
Donal Fellows
Sean Woods
Stefan Sobernig, Gustaf Neumann
Conference Committee
Brian Griffin
Mentor Graphics Facilities Coordination Clif Flynt
Noumena Corp General Chair, Website Admin Ron Fox
NSCL Michigan State University Program 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