|
Unix Programming - Language Evaluations - Tcl
Tcl
Tcl (Tool Command Language) is a small language interpreter
designed to link with compiled
C libraries, providing
scripted control of C code (
extended
scripts
). Its original application was to
control libraries for electronic simulators (SPICE-like applications).
Tcl is also suitable for
embedded scripts
—that
is, scripts called from within C programs and returning values to
those programs. Tcl had its first general public release in
1990.
Some facilities built on top of Tcl have achieved wide use outside
the Tcl community itself. The two most important of these are:
-
The Tk toolkit, a kinder and gentler X interface that makes it
easy to rapidly build buttons, dialog boxes, menu trees, and
scrolling text widgets and collect input from them.
-
Expect, a language that makes it relatively easy to script
fully interactive programs with widely variable responses.
The Tk toolkit is so important that the language is often
referred to as Tcl/Tk. Tk is also frequently used with
Perl and
Python.
The main advantage of Tcl itself is that it is extremely
flexible and radically simple. The syntax is very odd (based on a
positional parser) but totally consistent. There are no reserved
words, and there is no syntactic distinction between a function call
and ‘built in’ syntax; thus the Tcl language interpreter
itself can be effectively redefined from within Tcl (which is what
makes projects like Expect
reasonable).
The main drawback of Tcl is that the pure language has only weak
facilities for namespace control and modularity, and two of them
(upvar and uplevel) are rather
dangerous if not used with great caution. Also, there are no data
structures other than association lists. Tcl therefore scales up very
poorly — it is difficult to organize and debug pure Tcl programs of
even moderate size (more than a few hundred lines) without tripping
over your own feet. In practice, almost all large Tcl programs use one
of several OO extensions to the language.
The oddities of the syntax can at first be a problem as well; the
distinction between string quotes and braces will probably give you
headaches for a while, and the rules for when things need to be quoted
or braced are a bit tricky.
Pure Tcl only provides access to a relatively small
and commonly used part of the Unix API (essentially just file handling,
process-spawning, and sockets). Indeed, Tcl has the flavor of an
experiment in seeing how small a scripting
language
can get and still be useful. Tcl extensions (similar to Perl modules)
provide a richer set of capabilities, but are (like CPAN modules) not
guaranteed to be installed everywhere.
The original Tcl reference is Tcl and the Tk
Toolkit [Ousterhout94], but that book has
been largely superseded by Practical Programming in Tcl and
Tk [Welch]. Brian Kernighan has written a
description of a real-world Tcl project [Kernighan95] that summarizes Tcl's strengths and weaknesses
as a rapid-prototyping and production tool; his contrast with
Microsoft Visual Basic is particularly balanced and
instructive.
The Tcl world doesn't have one central repository run by a core
group analogous to Perl's or Python's, but several excellent
websites both point to each other and cover most Tcl tool and
extension development. Look at the Tcl Developer Xchange first; among
other things, it offers Tcl sources of an interactive Tcl tutorial.
There is also a Tcl foundry at
SourceForge.
Tcl scripts have portability problems similar to those of shell
scripts; the language itself is highly portable, but the components it
calls may not be. Tcl implementations exist for the Microsoft family
of operating systems, MacOS, and many other platforms. Tcl/Tk scripts
will run on any platform with GUI capabilities.
Summing up: Tcl's best side is its spare,
compact design
and the
extensibility
of the Tcl interpreter. Its worst side is the odd positional parser
and the weakness of its data structures and namespace controls; the
latter defect makes it scale poorly for large projects.
TkMan is a browser for Unix man pages
and Texinfo documents. At roughly 1200 lines, it is quite large to be
written in pure Tcl, but the code is unusually well-modularized and
mature. It uses Tk to provide a GUI interface quite a bit nicer than
either the stock
man(1)
or
xman(1)
utilities support.
TkMan makes a good case study because it exhibits almost the
full gamut of Tcl techniques. Highlights include Tk integration,
scripted control of other Unix applications (such as the Glimpse
search engine), and the use of Tcl to parse Texinfo markup.
Any of the other languages would have made for a less direct
interface to the Tk GUI that constitutes most of this code.
A Web search for “TkMan” should turn up sources
and documentation.
Moodss: A Large Tcl Case Study
The Moodss system is a graphical monitoring application for
system administrators. It can watch logs and gather statistics for
MySQL, Linux, SNMP networks, and
Apache, and presents a
digested view of them through spreadsheet-like GUI panels called
‘dashboards’. Monitoring modules can be written in
Python or
Perl as well as
Tcl. The code is polished, mature, and considered an exemplar in the
Tcl community. There is a project website.
The Moodss core consists of about 18,000 lines of Tcl. It uses
several Tcl extensions including a custom object system; the Moodss author
admits that without these “writing such a big application would
not have been possible”.
Again, any of the other languages would have made for a less direct
interface to the Tk GUI that constitutes most of this code.
[an error occurred while processing this directive]
|
