7th USENIX Tcl/Tk ConferenceFebruary 14-18, 2000
|
|
Our thanks to Clif Flynt for the summaries and the photographs. |
If the 6th Tcl/Tk Conference was Tcl's "coming of age" conference, then the 7th was "more of the same, but bigger." For example, at the last conference people described systems used to load-test and validate pilot-scale networks; this year, we learned about the design for a system that load-tests and validates equipment on the largest telephone network in Europe.
The papers presented were excellent, though the range was not as large as in previous years. Also, the attendee list seemed more skewed toward industry than academia. This may be another sign of Tcl's increasing acceptance in industry, or it may just reflect that moving the conference to the spring (midterms, instead of the previous summer-vacation date) made getting time to attend, as well as completing projects and writing papers before the submission deadlines, difficult
Along with the technical papers, this meeting featured a "Texas Shootout" Tcl coding contest, with some amazing coding examples; an after-dinner Tcl trivia game show (So, You Want to be a Tcl-Hacker); receptions sponsored by Scriptics, Vignette, and (I think) others; and of course, evening BoFs.
The Austin Marriott was an excellent hotel for this event. The function space was large and centrally located. The hotel snack bars and restaurants were convenient, and the lobby area had plenty of sitting and talking spaces. Folks with more time could take a short walk to view the Texas Capitol building or find some truly excellent restaurants.
As usual, the best parts of the conference for me were getting face time with folks that I've just exchanged mail with in the past, finding out what people are doing, and making plans for what we'll do next.
Tcl in AOL Digital City:
The Architecture of a Multithreaded High-Performance Web Site
Jim Davidson, America Online, Inc.
Jim Davidson described the AOL Digital city, a mammoth
database-driven Web site, and the AOLServer HTTP daemon that it extends.
Jim Davidson
AOLServer, derived from the NaviServer HTTP server, was purchased by AOL when the company moved from being a dial-up-based company to being an Internet-based company. The AOLServer server is now an open-source stem, available atOne of Davidson's first actions when he joined AOL was to integrate Tcl into the NaviServer/AOLServer. This provides a factor-of-100 speed-up over traditional CGI.
AOLServer supports both embedding code in HTML pages and embedding HTML generation in code modules.
The AOLServer is a multithreaded process, and Davidson discussed some of the pitfalls of multithreaded processes, including mutexes, locks, shared memory handling, resource allocation, and processing events. In early versions of the AOLServer, these problems were solved with patches and extensions to the Tcl code. AOL modified the Tcl slave interpreters to make copies of some data structures instead of having them shared. This created a working system but made migrating to more modern interpreters difficult.
Davidson described the architecture for AOLServer 3.0, which uses a cloning model to create new interpreters and use more of the features built into Tcl. Whereas migrating from Tcl 7.3 to 7.4 took a month of effort with AOLServer 2.1, migrating from 8.2.2 to 8.2.3 took 15 minutes with AOLServer 3.0.
AOLServer 3.0 implements locks and mutexes at the script level instead of the interpreter level. When AOLServer acquires pages, it caches them internally. This makes AOLServer resistant to the "Slashdot effect": If a page is being hit often, it remains in cache, instead of needing to be regenerated.
Despite all the nice features of AOLServer, it's still just an HTTP server. The useful and interesting content is created with the AOL Digital City modules. Digital City is a set of Tcl modules that hit multiple databases to generate custom dynamic HTML pages on the fly. One outcome of this is that pages are viewed as collections of text, instead of as a single entity.
Generating pages like this can be expensive because of the number of separate databases and tables that must be queried to build a page. Because of this overhead, much of the effort in the development of this package has been spent tuning the caching mechanisms. One problem is that as the number of combinations of dynamic information increased, it turned out that caching pages didn't work. Each page was likely to be unique, and so needed to be created from scratch.
The current solution is to put a high-speed front-end KSAM database between the Digital City modules and the complete (slow) relational DBMS. The pages are still built dynamically, but the most-used pieces of information are kept in the high-speed front-end database.
Davidson described some of AOLServer's many logging features. For example, the AOLServer maintains a count of how often commands are used. For example, the most commonly used commands in Digital City are if, set, and string. (This is not surprising in a site that is producing heavily customized text pages.)
One of the unexpected advantages Tcl brought to the Digital City
project is that the simplicity of Tcl makes it easy to bring people up to speed
quickly. More information on AOLServer is available at
<https://www.aolserver.com> and
<https://www.photo.net>.
The Middleware session papers demonstrated several different patterns for using Tcl to glue programs together. These patterns ranged from using Tcl with CORBA, to agent-style distributed applications, to techniques for converting standalone Tcl applications into collaborative-style distributed applications.
Rapid CORBA Server Development in Tcl: A Case Study
Jason Brazile and Andrej Vckovski, Netcetera AG
Brazile described a middleware data-distribution project that uses a
Tcl kernel to access multiple sources and combine and distribute that data
packaged in different
formats. This package acquires data in various proprietary binary
formats and converts it to Tcl data structures for internal use. It saves
processed data in an
internal cache and distributes the data formatted as XML documents, as CORBA
objects, or even as Tcl data structures.
Jason Brazile
The architecture they decided on for this project — mapping CORBA methods to Tcl procedures — provided the extra benefit of allowing the core functionality of the server to be developed and tested in Tcl without needing a CORBA development environment or network infrastructure.
Another fallout from this architecture is that CORBA stubs, skeletons, and Tcl/C++ conversion routines could be generated automatically from locally developed Tcl code-generation scripts according to a given IDL specification.
Advantages of using Tcl and scripting included:
AGNI: A Multi-threaded Middleware for Distributed
Scripting
M. Ranganathan, Mark Bednarek, Fernand Pors, and Doug Montgomery,
National Institute of Standards and Technology
M. Ranganathan described AGNI (AGents at NIst, and Sanskrit for fire), a package for scripting reconfigurable event-oriented distributed systems. This package allows clients and servers to migrate from site to site to balance load and access particular resources.
AGNI has the concept of mobile streams, which Ranganathan described as being like active mailboxes. This provides a single point of control that knows how to relay messages to the appropriate clients and servers.
To support the distributed nature of AGNI, Ranganathan and his associates built a reliable protocol on top of UDP. This was necessary to allow applications to migrate from machine to machine, since TCP doesn't like to have endpoints change during a session.
Ranganathan demonstrated how standalone applications can be merged into AGNI, and compared AGNI to other distributed systems such as Tcl-DB, AgentTCL, and SUMATRA. In brief, AGNI is more versatile and supports more models of distributed processing.
Introducing QoS Awareness in Tcl Programming: QTcl
Roberto Canonico, Maurizio D'Arienzo, Simon Pietro Romano, and
Giorgio Ventre, Università di Napoli
"Federico II"
Part of the future of the Internet is that applications will be able to reserve a certain bandwidth (Quality of Service) between client and server.
Canonico described a Tcl extension that allows scripts to use the RSVP protocol to request bandwidth in a manner that is compliant with the SCRAPI programming interface. This new facility is built on top of the Tcl-DP package. Having this package available allowed them to concentrate on the SCRAPI portion of their project, rather than also having to develop a distributed processing vehicle.
One of the requirements for a QoS-aware application is that it must be able to estimate its bandwidth requirements.
Canonico described the QTcl API, explained the rationale for using Tcl-DP, and showed experimental results that demonstrate how an application that has reserved a particular bandwidth can continue to function properly, even in the presence of other net traffic causing congestion in the network's routers. Of course, in order to obtain this behavior, special routers with QoS support and RSVP enabled need to be deployed within the network.
This package has been implemented and validated on a test network equipped with FreeBSD boxes acting as routers. The QoS support in these boxes was achieved by implementing a WFQ packet scheduler as an extension of the ALTQ package.
The QTcl package (for UNIX-based systems) is available at <https://www.grid.unina.it/qtcl>. The authors are currently implementing the QTcl interface for Windows-based systems.
CollabWiseTk: A Toolkit for Rendering Stand-alone Applications
Collaborative
Hemang Lavana and Franc Brglez, North Carolina State
University
Lavana proposed an architecture that allows standalone Tk applications to be transparently converted to distributed, collaborative applications. The keystone of this architecture is techniques that allow the distributed widgets to mediate synchronization and data.
Two users can interact with text widgets in several ways:
Lavana explained how the appropriate interaction model varies depending on the application. For example, group conferencing, shared whiteboard, shared editing, and chat each requires a different interaction model.=
The CollabWise architecture is to have a central group server attached to multiple application servers. Each application server may have multiple clients. The group server distributes the interaction models to the clients.
The interaction models are implemented by replacing the usual Tk widget bindings with an appropriate set of distributed bindings. This transparently converts an application written for a single platform into a distributed application.
More details about this project are available at <https://www.cbl.ncsu.edu/software>.
The three papers in this session demonstrated the wide range of applications for Tcl/Tk. Seeing what can be done when you embed a full scripting language into a debugger makes you wonder why all debuggers haven't been built like this for years, while the papers on load-testing a telephone network and gluing together legacy systems show how well Tcl/Tk can scale to world-scale problems.
GDBTk: Integrating Tcl/Tk into a Recalcitrant Command-line
Application
Jim Ingham, Cygnus Solutions
Jim Ingham described ways that an embedded interpreter can make a debugger more useful. The debugger he used as the example is GDBTk (now known as Insight), being used to debug a Tcl interpreter running a Tcl script.
Traversing a stack and listing the call parameters, including pointers, is an annoying and time-consuming part of debugging from a core dump. In particular, when debugging an interpreter and trying to determine what part of a script caused an error, you need not only to examine the C stack, but also to find the internal interpreter execution stack.
Traversing the call stack, dereferencing pointers, and displaying the interpreter stack is an application that can be easily automated. In fact, any set of repeated operations is a candidate for becoming a Tcl script.
Some advantages that Tcl has over the GDB macro language are the looping and test commands. These allow a programmer to automate such tasks as stepping through a linked list or array looking for a particular data pattern.
GDB events (breakpoints, touching variables, etc.) can be treated as Tcl events, invoking a Tcl proc to examine the program state and decide what to do from there.
The GDBTk/Insight package is available at <https://sourceware.cygnus.com/insight>.
Tcl/Tk: A Strong Basis for Complex Load Testing
Systems
Ahmet Can Keskin, Till Immanuel Patzschke, and Ernst von Voight,
Patzschke + Rasp Software AG
One of the environments in which Tcl/Tk has proven very useful is automated testing. Till Patzschke described using Tcl/Tk to performing load testing for Deutsche Telekom. The package they developed measures all the components of the network, from the user's connection, to the telephone network (via modem, ISDN, DSL, etc.), to the remote server. This system duplicates all the actions a user would perform: dialing out to the network, browsing, and so on.
Patzschke pointed out that one advantage to building a set of automated scripts over hiring a number of students to follow a written script is that the automated scripts provide much more reproducible results.
Another advantage is that a subset of the scripts can be run
continuously to provide early warning if the network perfor-mance should begin to
degrade.
Till Patzschke
The initial driving requirement for this system was to validate hardware and software installations. When acquiring new hardware, the contracts specified that problems found within 30 days would be fixed under the initial contract, but problems found later would be fixed for a fee.
This was a strong impetus to developing a reliable automated (fast) load-testing system.
After evaluating several OS and language choices, Patzschke and his associates settled on Tcl/Tk and Linux. He noted that these choices allow the developers to quickly adapt testing scripts as requirements change and to scale the system as necessary by adding more commodity hardware.
The system is operated from a single Tk application that controls the test stations. More than 60 systems are being controlled by the single Tk front end.
More information on the Automated-User package may be obtained from
<https://www.internetwork-ag.de>.
Using Tcl to Build a Buzzword-Compliant Environment that Glues
Together Legacy Analysis Programs
Carsten H. Lawrenz and Rajkumar C. Madhuram, Siemens Westinghouse
Power Corp.
Like many companies, over the years Siemens Westinghouse has accumulated a number of software tools for developing engineering designs. However, the paradigm for how tools should be built, both user-interface and data formats, changes over time, and these changes make it difficult to use tools from different generations together.
To continue being usable, the tools must either be rewritten (opening the gate for introducing new bugs), or the old applications must be glued together with wrappers to present a uniform interface to the users and translate between different data formats.
Rajkumar Madhuram described a project that created a Tcl-based set of wrappers to integrate the tools Siemens uses to design electrical generators into a unified tool that presents a single interface to the user.
The goals for this project included reducing the number of times data had to be translated from one format to another by hand (and the errors that can introduce) and reducing the time it takes to design a generator. Tcl was chosen for this application because of its runtime speed, ease of development, and rich set of GUI widgets.
Since some tools run on specific hardware, the Siemens Integrated Design (SID) package uses a client-server architecture, in which a thin client runs on the designer's local workstation, while the data and analysis tools exist on remote servers. The SID package generates user-input screens dynamically, using the Tk entry widget for keyboard input and allowing users to interact with canvas graphs to view and modify other data.
Proxy Tk: A Java Applet User Interface Toolkit for Tcl
Mark Roseman, TeamWave Software, Ltd.
Many computer users are most comfortable with browser-based user interfaces. While JavaScript and HTML are adequate for forms-based applications, they are inadequate for complex program interactions.
Larger applications can be written as applets running inside the browser. This allows a program to present a familiar interface to the user while providing the functionality developers require. Writing a large, complex application as a Java applet has other problems, including large download times and the slow development pace for low-level systems languages like Java and C++.
Once a developer has gotten used to the speed with which applications can be developed with a high-level language like Perl or Tcl/Tk, they are unwilling to move back to low-level languages like Java and C++ for the main program flow. Using the Tcl plug-in as the applet vehicle solves these problems, but many users and system administrators are resistant to adding new plug-ins to their environments.
Roseman described a solution to this dilemma: a thin Java client to generate GUIs that runs within a browser without requiring a plug-in download. The main program logic resides on the remote server, and only the GUI client runs within the browser.
The thin client includes a simple parser, wrappers around the AWT widgets to generate a GUI, and functionality for sending events back to the server. At the server end, traditional widget-interaction commands are replaced with procedures that support remote operation.
Roseman's group has found this to be a good compromise, allowing them to do their primary development and debugging in the traditional Tcl/Tk environment and to distribute the product with a small applet.
Roseman noted that not all Java runtime engines are created equal, and that Java applets can be described as "Write Once, Debug Everywhere." Having only the thin client in Java made the multiple-platform deployment much easier, since there was relatively little Java code in the product.
The TclHttpd Web Server
Brent Welch, Scriptics Corp.
Brent Welch described an HTTP server written entirely in Tcl. This server has been in use at Sun Microsystems for several years and is also the server for <https://www.scriptics.com>.
One of the unique features of this server is that it can be embedded into other Tcl applications, such as the TclPro license server, the Lyris MailShield, and NationsBank network-management applications.
The TclHttpd server supports dynamic content by:
Other internal functions include support for checking form data, and automatic mapping of attribute=value pairs into procedure arguments (using Tcl's introspective info command to determine what a procedure's arguments are).
Using Tcl scripts instead of CGI to handle form data removes the
need for forks, reduces the load on the hardware, and improves the performance of
the TclHttpd server.
Brent Welch
Welch showed some timing studies which demonstrated that the TclHttpd has decent performance. While the TclHttpd server is slower than the best server in each test, it is faster than the worst. The server can handle about 100 hits per second and has proved extremely stable.
This package is available at <https://dev.scriptics.com/software/tclhttpd/>.
TkGecko: A Frill-Necked Lizard
Steve Ball, Zveno Pty Ltd.
Steve Ball described his effort to embed the Mozilla NewLayout HTML/XML viewer inside a Tk widget. This effort is hampered by many features of the Mozilla code, including Mozilla's use of Gtk (which has its own event loop), the sheer size of the Mozilla package (compiling Mozilla requires 1 GB of disk space), the speed with which the Mozilla code base evolves, and the lack of current documentation.
Fortunately, the entire Mozilla package is not required for this effort. The NewLayout viewer module is a small subset of the browser code. Ball described the architecture of the NewLayout module, how it interacts with the Mozilla browser, and how these interfaces can be used to interact with the Tcl interpreter through the callbacks.
Ball demonstrated that the widget works. Future effort will be directed toward further integration of the NewLayout callbacks and the Tcl interpreter.
Scriptics Connect: An XML Integration Server Based on
Tcl
Eric Melski, Scott Stanton, and John Ousterhout, Scriptics
Corp.
Stanton described the application developed by Scriptics to facilitate creating XML-based business-to-business applications.
XML provides an easily extended, easily interpreted basis for information exchange. Having an easily parsed data-description language makes it easy for an expert programmer to generate a parser and create an application. It would be better if applications could be created by less skilled users.
Scott Stanton
The Scriptics Connect package allows a relatively untrained user to describe how the fields on a form should be treated with a Post-it Notes paradigm: fields in the displayed form can be marked and actions associated with the data in that field.
The Scriptics Author program displays a tree representation of the document skeleton. A user can attach scripts to the document elements without needing to navigate the document. After the user has selected form elements and described how values associated with those elements should be processed, a parser for this form is generated automatically.
Scriptics provides prebuilt data handlers for converting an XML form into the format appropriate for internal use.
More details about Scriptics Connect are available at <https://www.scriptics.com>.
Because the basic Tk GUI toolkit is rich and easy to extend, Tk has become one of the languages of choice for experimenting with user-interface designs. These papers introduce a novel way of displaying data with animations, experiments in collaborative computing, and a different way to view packaging scripts.
Supporting Information Awareness Using Animated
Widgets
D. Scott McCrickard and Q. Alex Zhao, Georgia Institute of
Technology
As has been noted, modern man is constantly bombarded by information. Scott McCrickard and his associates are investigating techniques for making information available on a CRT without distracting the user.
One of the techniques they are exploring is forms of animation: fading one datum into another and scrolling information horizontally (like a ticker tape) or vertically (like lines on a teletype). The goal is to modify the displayed information without jarring the user, while still notifying the user that new information is available.
As a research tool, they created several new Tk widgets that support images fading from one to the next, as well as scrolling text. These new widgets follow the standard Tk widget conventions, such as associating variables with widgets. For example, a -textvariable is associated with the ticker widgets, just as a -textvariable can be associated with a label. When new data is saved in the variable, the display automatically reflects the new values.
These animated widgets can be synchronized with one another. This lets a designer use a set of logos and scrolling text, with the logo providing context information while the scrolling data provides details.
D. Scott McCrickard
One problem with changing displays is that the important information may be, not the actual data, but the change from a previous value (for example, stock prices). When the user is alerted that data has changed, she may not recall the previous data. In order to retain history, old information can be displayed in a widget as shadows or background text. This lets a user see that something has changed and what the old value was.
McCrickard demonstrated several of these widgets, showing how the package can be used with applications ranging from a sports-score display to a grad-students employment listing.
The automated widget set is part of a package for designing agents
that is available at
<https://www.cc.gatech.edu/~mccricks/agentk>.
Collaborative Client-Server Architectures in Tcl/Tk: A Class
Project Experiment and Experience
Franc Brglez, Hemang Lavana, Zhi Fu, Debabrata Ghosh, Lorie I.
Moffitt, Steve Nelson, J. Marshall Smith, and Jun Zhou, North Carolina State
University
It's generally recognized that large projects should be used as part of the computer science curriculum. Franc Brglez described a large class project in which students worked together to develop an application that would allow them to jointly write a paper.
Franc Brglez
Brglez described the traditional approach to a number of people writing a paper — each student would have a login account on a central machine or would email their writings to the person collating the works. For this application, it was decided to use a client-server Web-based approach.
Tcl/Tk was chosen as the vehicle for this project because the power and simplicity of the Tcl channel architecture makes it easy to write client-server applications and because the language is easy to learn (an important requirement for a single-semester project).
The server for this application supports user validation, file ownership and protection, execution of system commands on the server, and file upload/download.
A student with prior Tcl experience wrote a universal server, and the students each created a GUI client to interact with the server. To validate the concepts, students used their clients to write and revise individual contributions to the paper.
The client-server architecture initiated in this class project continues to evolve a number of user-configurable collaborative environments.
More information about these collaborative computing projects is available at:
Scripted Documents
Jean-Claude Wippler, Equi4 Software
Writing multiplatform applications in Tcl/Tk is easy. Distribution is not always so simple.
Jean-Claude Wippler described the Metakit Tcl extension, which merges a small database into the Tcl interpreter and keeps application scripts and associated data within the database.
The advantages of this technique include:
Since the data and code are combined, there is no need to track installation and data paths.
Metakit has been in production use for a couple of years. One example of a Metakit-packed application is the Tcl'ers Wiki at <https://purl.org/thecliff/tcl/wiki/>.
More information on Metakit is available at <https://www.equi4.com/metakit/>.
The easy-to-extend and easy-to-read nature of Tcl makes the Tcl core a popular target for optimizations and experimentation. This constant activity has a lot to do with Tcl's application to a broad variety of problems.
Papers in this session discussed efforts at unifying some of the development, ways to make Tcl more object-oriented without copying C++/Java, and ways to make the Tcl core even more versatile.
The Tcl Extension Architecture
Brent Welch and Michael Thomas, Scriptics Corp.
Brent Welch described the problems involved with distributing the packages and extensions for Tcl.
Tcl scripts are easy to use in a multi-platform environment, but compiling Tcl extensions is not always so easy. The individual authors use their own conventions, and different platforms support different tools (VC++, AutoConf, Imake, etc.).
The TEA initiative is dedicated to developing a set of techniques and templates for developers to use when designing an extension and for creating configuration and installation scripts. The goal is to make Tcl extensions more consistent in form and easier to develop.
The current version of the TEA framework includes a set of M4 macros to simplify building an autoconf file that can be used on UNIX, or on Windows with the CygWin Tools.
Welch also discussed the stubs library, which was introduced in Tcl 8.1. The stubs library makes it possible for Tcl interpreters to load shared libraries at runtime, whether or not the underlying OS provides support for dynamic libraries. This is done via a stubs table, similar to the reference tables used to load .so files under Solaris or Linux.
Two byproducts of the stubs tables are that an extension can be compiled once and used with interpreters at different revision levels, and that the stubs tables define a "blessed" API into the Tcl interpreter that won't change.
As part of the TEA testing, Scriptics is now doing nightly automated builds of several extensions and packages, including BLT, Expect, Itcl, TclX, OraTcl, and TclODBC.
Some of the changes that fall out from using the new TEA configuration architecture (such as possibly removing TclConfig.sh) generated spirited discussion from the audience.
The TEA homepage is <https://www.scriptics.com/tea/>. A sample extension is available at <ftp://ftp.scriptics.com/pub/tcl/examples/tea>.
XOTcl — An Object-Oriented Scripting Language
Gustaf Neumann, Vienna University of Economics and BA, and Uwe Zdun,
University of Essen
Gustaf Neumann
Gustaf Neumann described XOTcl (pronounced exotickle), an object-oriented programming extension to Tcl that enhances Tcl's properties rather than imposing the C++/Java worldview on Tcl.
The Extended Object Tcl classes are designed to support introspection and extensibility, as well as protection and data-type checking.
The introspective nature of Tcl is one of the features that distinguishes it from other languages. For example, a running Tcl program can get a list of all the defined procedures and their bodies and arguments. On the other hand, most OO languages believe that the internal nature of an object should be hidden from all other objects. With XOTcl, the objects can be queried regarding their internal state, just as other Tcl and Tk objects can be queried.
Another way that Tcl differs from most OO languages is the ease with which program behavior can be modified at runtime. The behavior of most OO class methods is defined at compile time. Tcl takes advantage of its interpreted nature to allow new procedures to be added, or the class structure changed, as conditions dictate.
XOTcl objects can be extended at runtime via filters (at the class level) and mixing classes (at the object level). These methods provide sets of new procedures and interceptors for existing procedures for an object for behavior customization. These interceptors can be used for a wide range of situations, including debuggers and high-level OO constructs such as design patterns.
While adding features to support Tcl's strength, Extended Tcl also includes the common object-oriented language features of inheritance, abstract classes, and assertions.
XOTcl was developed from the MIT OTcl package and is available from <https://nestroy.wi-inf.uni-essen.de/xotcl>.
A Multi-Threaded Server for Shared Hash Table Access
Andrej Vckovski and Jason Brazile, Netcetera AG
Vckovski and Brazile are two of the developers of a multiple-feed, caching front end for a data server. This system required a high-speed but not complex database solution. The data needs to be cached until it is overwritten by fresh data and to be served to clients on demand.
The speed requirements made a traditional disk-based DBMS solution unacceptable. A requirement that the application be adaptable to changing data formats made an in-memory database supported by a compiled language like C or Java too inflexible. These two requirements led Vckovski and Brazile toward a scripted solution.
Vckovski described a solution in which multiple computers accept the data feeds and cache the data using the Tcl hash tables. These hash tables are shared across the multiple threads and systems so that clients can access the data transparently.
The system has been in production with data shared across four systems since summer 1999. In this configuration it handles several hundred updates per second.
Vckovski summarized that the Tcl thread safety is real and robust. He also observed that the Tcl hash algorithm is well optimized, and even with large tables (about 250,000 entries) the search distances are small.
Feather: Teaching Tcl Objects to Fly
Paul Duffin, IBM Hursley Laboratories, UK
One of Tcl's failings is the lack of complex data structures. Paul Duffin believes he has a solution to that problem (and perhaps all your problems, depending on what your problems are).
Tcl's internal data representation was changed in revision 8.0 from
simple NULL-terminated strings to an object with reference counts, and both textual and native form
representation.
Paul Duffin
Duffin described an extension to the Tcl object that allows multiple interfaces to objects.
With multiple views, it becomes possible to use objects in more ways than traditional Tcl supports.
Duffin described a large number of data constructs that he has built using the Feather extension, including generic collections, complex lists, maps, structures, opaque objects, and even the functional programming concepts of lambda and curried objects.
Duffin points out that the range of new data structures he created shows the versatility of this approach, making this extension a good option for others who need data structures that Tcl does not natively support.
D. Richard Hipp described his HTML display widget. This widget will display all HTML tags (including ugly nested tables) but does not support style sheets.
Steve Landis revisited the Software Tools paradigm and demonstrated a cross-platform, GUI-driven technique for linking programs with virtual pipes.
Glenn Thomas described a project using Tcl to automate a set of legacy programs. This packages executes the applications from a browser using the Tcl plug-in and Expect, and converts report output to HTML for easy viewing.
Dave Beasley described the latest changes to SWIG, a package that will convert a set of header files into a Tcl extension. The new changes create much smaller extensions.
Roy Terry showed a Tk application called hits that displays a file and searches for words that match a pattern. The application highlights the patterns and also builds a map showing where the hits are within the file.
Gil Benson described a user-friendly QDDB-based testing system that links to his organization's trouble-ticket system.
Leo Schubert described a set of wrappers for the native Tk widgets for Windows, Gtk, and KDE. Among other features, these wrappers allow new attributes to be added to widgets.
Devin Eyre uses Tcl/Tk and GIS information to create weather maps.
David Vice described how CPU uses Tcl as a data bus to merge multiple data sources and applications. They use XML as a standard for moving data between the objects.
Jeff Davis described his Tcl-based Web interface to a database for a fantasy-role-player baseball league.
Clif Flynt's laptop described a new method for creating multimedia applications in Tcl, while Flynt demonstrated that humans are not required for a presentation.
David Russell described several tools that he uses with Scotty to simplify systems administration.
Brad of Neosoft described a Tcl interface to LDAP. It's
available at <https://
www.openldap.org>.
Bill Krimmell described a Tcl interface to some National Scientific interface cards running under Linux.
Steve Ball showed TclXml working with the Xerxes C XML library, a set of code he debugged on the plane coming to the conference. This demonstrates that flying halfway around the world does have some benefits.
Mark Harris explained how Tcl is being used to generate dynamically constructed HTML pages in China.
Brian Griffin of Model Technology described a VHDL/Verilog simulator with a user interface written in Tcl driving a C code engine.
 Need help? Use our Contacts page.
Last changed: 16 October 2000 ah |
|
Conference index