The central observation which led Ousterhout to create Tcl was the realization that many applications require the use of some sort of a special purpose, application specific, embedded “macro language”. Application programmers cobble these “tiny languages” into their codes in order to provide flexibility and some modicum of high level control. But the end result is frequently a quirky and fragile language. And each application has a different “tiny language” associated with it. The idea behind Tcl, then, was to create a single “core language” which could be easily embedded into a wide variety of applications. Further, it should be easily extensible so that individual applications can easily provide application specific capabilities available in the macro language itself, while still providing a robust, uniform syntax across a variety of applications. To say that Tcl satisfies these requirements would be a spectacular understatement.

The mechanics of using Tcl are very straightforward. Basically you just have to include the file tcl.h, issue some API calls to create a Tcl interpreter, and then evaluate a script file or perform other operations supported by the Tcl API. Then just link against libtcl.a and off you go.

Having done this, you have essentially created a shell. That is, your program can now execute shell scripts in the Tcl language. Tcl provides support for basic control flow, variable substitution file i/o and subroutines. In addition to the built in Tcl commands, you can define your own subroutines as Tcl procedures which effectively become new keywords.

But the real power of this approach is to add new commands to the interpreter which are realized by compiled C code in your application. Tcl provides a straightforward API call which allows you to register a function in your code to be called whenever the interpreter comes across a specific keyword of your choosing in the shell scripts it executes.

This facility allows you with tremendous ease, to endow your application with a powerful, robust and full featured macro language, trivially extend that macro language with new keywords which trigger execution of compiled application specific commands, and thereby raise the level of interaction with your code to one of essentially shell programming via script editing.

There are several important sources of info and code for Tcl. Definitely get the book mentioned above, and the source code for the Tcl and Tk toolkits can be downloaded from The Tcl developer Xchange.

Additionally there is a newsgroup, comp.lang.tcl which is well read, and an excellent place for people to get oriented, find help, etc. Highly recommended.

In any event, in order to use the Tk driver in PLplot, you will need Tcl-8.2 and Tk-8.2 (or higher versions). Additionally, in order to use the extended WISH paradigm (described below) you will need iTcl-3.1 (or a higher version).

However, you will quite likely find Tcl/Tk to be very addictive, and the great plethora of add-ons available at harbor will undoubtedly attract no small amount of your attention. It has been our experience that all of these extensions fit together very well. You will find that there are large sectors of the Tcl user community which create so-called “MegaWishes” which combine many of the available extensions into a single, heavily embellished, shell interpreter. The benefits of this approach will become apparent as you gain experience with Tcl and Tk.