Check out the new USENIX Web site.
7th USENIX Tcl/Tk Conference

Abstracts of the Refereed Papers to be Presented



Middleware

Rapid CORBA Server Development in Tcl: A Case Study

A large Swiss bank needed to collect, combine, process, and distribute financial market data from various 3rd party data sources to a large number of internal and external clients -- the typical integration task at which scripting languages excel. The bank uses an implementation of CORBA as their standard enterprise-wide middleware for distributed applications. We describe how we designed and built a Tcl/C++ transport framework which allowed us to develop the "kernel" of this server application entirely in Tcl, yet support CORBA as the primary interface to the server. We further describe how this framework allows a small development team to rapidly implement changes and enhancements to the server and its external interface, while automatically generating the corresponding changes that are needed for the CORBA interface. Additionally, we show how we were able to automatically generate code to create new tcl commands that make use of the same, generated, Tcl/C++ marshalling routines in order to develop a CORBA client in Tcl, which is used to regression test the server, when full end-to-end testing is needed.
AGNI: A Multi-threaded Middleware for Distributed Scripting
We present the design of a AGNI - a Tcl 8.1 based Middleware for building reactive, extensible, reconfigurable distributed systems, based upon an abstraction we call Mobile Streams. Using our system, a distributed, event-driven application can be scripted from a single point of control and dynamically extended and re-configured while it is in execution. Our system is suitable for building a wide variety of applications; for example, distributed test, conferencing and control-oriented applications. We illustrate the use of our system by presenting example applications.
Introducing QoS awareness in Tcl programming: QTcl
A number of distributed applications require communication services with Quality of Service (QoS) guarantees. Among the actions undertaken by the Internet Engineering Task Force (IETF) with regard to the end-to-end QoS provisioning issue in the Internet, the definition of the Integrated Services (IntServ) framework plays a major role. According to this model, applications need to interact with network routers by means of a signalling protocol, RSVP. Even though special-purpose APIs have been defined to let applications negotiate QoS parameters across RSVP-capable networks, the integration of QoS negotiation mechanisms in the applications still remains an open issue. In modern programming, the Tcl scripting language plays a significant role, as it enables fast system prototyping by gluing basic components to build complex applications. In this paper we present QTcl, an extension of Tcl-DP which provides programmers with a new set of primitives, fully compliant with the SCRAPI programming interface for RSVP. We also present how QTcl has been used in an advanced VoD application to setup reservations in an IntServ network.
CollabWiseTk: A Toolkit for Rendering Stand-alone Applications Collaborative
Traditionally, a stand-alone client application is rendered collaborative for members of a team either by sharing its view or by re-writing it as a collaborative client. However, it may not be possible to anticipate in advance all preferences for collaboration, hence such a client may appear confusing to some of the team members.

We propose a novel client/server architecture for tk-based applications: rendering any stand-alone client collaborative, without a code re-write. Participants themselves are allowed to dynamically re-configure the inter-client synchronization table to suit their changing preferences and needs. The CollabWiseTk toolkit, based on the proposed architecture, is an extension of the tk functionality to support collaboration. It re-defines the existing tk commands such that the entire tk widget set is rendered collaborative for use with multiple users.

We demonstrate the capabilities of the CollabWiseTk toolkit by readily rendering collaborative most of the Tk Widget Demonstrations, distributed with the core Tcl/Tk. The toolkit is implemented in pure tcl and it ports to all platforms.



Testing and Integration

GDBTk - Integrating Tcl/Tk into a recalcitrant command-line application
This paper will describe the some of the lessons we learned embedding Tcl/Tk into the Gnu Debugger (GDB). GDB is a command-line application, and there were a number of problems which this caused, particularly when using Tk within the application. We will describe a few of these problems, and the solutions we came up with. The paper will also give a brief overview of GDBTk itself.
Tcl/Tk: A Strong Basis for Complex Load Testing Systems
This paper describes a Tcl/Tk-based load testing environment which was developed for Deutsche Telekom, Europe's largest telco carrier and online service provider. Deutsche Telekom uses the system to ensure a high quality of service and availability. The paper explains the complex requirements of load testing and gives a detailed overview for the extensive use of Tcl/Tk within the system.
Using Tcl To Build A Buzzword* Compliant Environment That Glues Together Legacy Analysis Programs
The Siemens Integrated Design (SID) Environment is a system that allows engineers to link together many legacy computer programs. This capability provides significant reduction in effort for defining the conceptual design of electrical generators. The SID environment is a generic tool for running all types of analysis programs (methods) as well as managing their associated data. Methods are plugged into the environment in a simplified fashion by using a well-defined interface. Any features that are added to the environment immediately benefit all methods. Data can be shared between remote sites through an in-house developed, java based, replication server. This paper discusses how Tcl was used to develop the SID Environment and why it was the best choice for our application.


Web Technologies

Proxy Tk: A Java applet user interface toolkit for Tcl
Proxy Tk allows a Tcl program to provide a highly interactive web-browser user interface, without requiring the end user to download additional software. It uses a thin client design, where a server-side Tcl application communicates with a very small generic Java applet running in the browser, sending it commands to create and modify widgets, and receiving events from the user. A Tk-like layer encapsulates the communication protocols to provide a familiar programming paradigm, and allow easy porting of existing code.
The TclHttpd Web Server
This paper describes TclHttpd, a web server built entirely in Tcl. The web server can be used as a stand-alone server or it can be embedded into applications to web-enable them. TclHttpd provides a Tcl+HTML template facility that is useful for maintaining site-wide look and feel, and an application-direct URL that invokes a Tcl procedure in an application. This paper describes the architecture of the application and relates our experience using the system to host www.scriptics.com.
TkGecko: A Frill-Necked Lizard
The Mozilla Open Source project has made a full-featured, fast Web browser, Netscape's Navigator, available in source form to the Internet community. A major component of the project, and an early released package, is the NewLayout (a.k.a. Gecko) HTML/XML rendering engine. One feature of this module is that it is designed to be embeddable in any application. This characteristic is quite compatible with Tcl/Tk.

TkGecko is a project to create a Tk extension that allows the NewLayout rendering engine to be embedded in a Tk application as a Tk widget. Ideally, this new widget will be as completely configurable as all other Tk widgets, with all configuration options able to be queried and changed at run-time. The widget features methods and configuration options that allow the functions of the NewLayout rendering engine to be accessed and changed from a Tcl script.

Currently the TkGecko project is still in its infancy. This paper aims to define the goals of the project and expected milestones.

Scriptics Connect
Scriptics Connect is a commercial product from Scriptics Corporation that provides an XML-based platform for business-to-business applications. It takes advantage of XML as a standard mechanism for formatting structured data, and uses standard World Wide Web servers and Tcl to provide the infrastructure needed to support business-to-business applications. In addition, it uses Tcl to greatly simplify the task of writing XML-based business-to-business applications.


User Interface and Applications

Supporting Information Awareness Using Animated Widgets
This paper describes a Tcl/Tk widget set extension that supports three animated behaviors: fading, tickering, and rolling. This extension is targeted for use in information awareness applications that monitor and communicate constantly changing information. Described is the programming interface for the widgets as well as the design decisions made in creating them and programs that use them. Introduced in the description are two new techniques called automatic markups and history-based shadowing, highlighting techniques used to identify and communicate the nature of the changes.
Collaborative Client-Server Architectures in Tcl/Tk: A Class Project Experiment and Experience
This paper presents a class software project that was part of a recent experimental graduate course on Frontiers of Collaborative Computing on the Internet. We chose Tcl/Tk to facilitate rapid prototyping, testing, and demonstrating all phases of the project. The major milestones achieved during this course are:
Scripted Documents
Software used to be written as source code, which was then compiled and linked into a single machine-specific application program. With scripting languages, editable scripts are now executable without intermediate steps, but the dependency on lots of script files complicates robust deployment. A range of "wrapping" schemes are in use today to package scripts and extensions into a single file. The "Scripted Document" approach presented here goes further by offering a database-centric solution for packaging, installation, configuration, upgrades, as well as all application-specific data. An implementation for Tcl is described using MetaKit as embedded database with a summary of the experiences gathered so far.


Extending Core Tcl

The Tcl Extension Architecture (TEA)
This paper describes goals and current state of the Tcl Extension Architecture (TEA). The goal of TEA is to create a standard for Tcl extensions that makes it easier to build, install, and share Tcl extensions. In its current form, TEA specifies a standard compilation environment for Tcl and its extensions. The standard uses autoconf , configure and make on UNIX and Windows. A longer term goal is to create an infrastructure that supports network distribution and installation of Tcl extensions. A standard build environment is a necessary first step to support automated compilation and distribution of extensions. This paper describes the current state of TEA, but we expect to continue to refine the standard and add to it as we gain experience with it.
XOTCL - an Object-Oriented Scripting Language
This paper describes the object-oriented scripting language XOTCL (Extended OTCL), which is a value added replacement of OTCL. OTCL implements dynamic and introspective language support for object-orientation on top of TCL. XOTCL includes the functionality of OTCL but focuses on the construction, management, and adaptation of complex systems. In order to combine the benefits of scripting languages with advanced object-oriented techniques, we extended OTCL in various ways: We developed the filter as a powerful adapation technique and an intuitive means for the instantiation of large program structures. In order to enable objects to access several addition-classes we improved the flexibility of mixin methods by enhancing the object model with per-object mixins. We integrated the object system with the TCL namespace concept to provide nested classes and dynamic object aggregations. Moreover, we introduced assertions and meta-data to improve reliability and
A Multi-threaded Server for Shared Hash Table Access
This paper presents a multi-threaded socket server allowing access to shared hash tables. It is implemented using Tcl 8.1 multi-threading capabilities and runs multiple Tcl interpreters to service client requests. The application is designed as a pre-threaded server which allows a single working thread to handle many requests. The central shared data object is a hash table with structured values which allows access by all threads. Synchronization is based on a reader/writer lock implementation using the synchronization primitives available in Tcl, i.e., mutexes and condition variables. The application achieves insert rates that are significantly higher than what current commercial database management systems achieve. The usage of third-level language programming in C and application-specific scripting in Tcl allows a design based on a light-weight, robust kernel on the one hand and easily modifiable application-domain code on the other. The experiences with thread-safety and other threading features in Tcl 8.1 have been largely positive in this real-world application.
Feather: Teaching Tcl objects to fly
Feather is a set of extensions which enhances the capabilities and flexibility of Tcl objects, builds a framework around them to enable new data types to be easily added and also provides a rich set of new data types. This paper starts off by giving quite a detailed description of how Tcl objects work and then moves on to describe the features of Feather, how they work and what they can be used for.




?Need help? Use our Contacts page.
Last changed: 3 Feb. 2000 mc
Conference Index
Events Calendar
USENIX home