Tcl and the Tk Toolkit, 2nd edition

I’m not sure what I was expecting, but the news that “my” book is finally out is cause for excitement, anxiety, and relief.

It’s not actually “my” book at all; it was originally written by Dr. John Ousterhout, who created the Tcl programming language, and the Tk toolkit. And Ken Jones is listed as the co author of the 2nd edition, because he’s the guy that pulled everything together and managed to actually bring the project to fruition.

However, I did play a part a part in the project. About 5 years ago, I was doing a lot with Tcl, and then, as now, I thought it was a shame that the language was not promoted as well as it could be. It’s not a perfect language, but at nearly 20 years old, it has stood the test of time, and it has a lot going for it. In any case, at the time, I had noticed that there was no good, publicly available tutorial. Tcl has always had an excellent set of man pages describing all of its various commands and subsystems, but did not ship with a tutorial that would help new users get started.

I thought that that would be a good problem to solve in order to make the language more attractive to newcomers. However, writing a tutorial from scratch is no simple task, so I started looking around for material that might be adapted. One thing that sprung to mind was the first edition of “Tcl and the Tk Toolkit”. At that point the book was nearly 10 years old, which in tech years is practically forever, and indeed, the material in the book, while good, was quite dated for some portions of Tcl. Figuring it couldn’t hurt, I emailed Dr. Ousterhout to see what he thought of open sourcing the book, or at least the first part of it, with the idea of updating and utilizing that as a tutorial. He was actually ok with that idea, but the copyright belonged to the publisher rather than him, so he gave me a contact with the publisher, who I then sent my idea to. They weren’t necessarily against the idea of releasing the material under an open license, but came back with another idea: why not update the book? That sounded like an interesting project in its own right.

I don’t recall all the details (this was in 2004), but the publisher ended up with Ken Jones as the guy to run the project, as he’d participated successfully in updating another popular Tcl book. In the end, there were several of us (Eric Foster-Johnson, Donal Fellows and Brian Griffin, in addition to Ken and myself), that worked on the project, divying things up by sections, with Ken coordinating. I am honored to have my name listed amongst such august company.

Which brings me back to being nervous: the idea of having something I wrote “set in stone” is a source of some anxiety for someone like me used to working with such a malleable world as that of software. Also; I wrote most of my contribution (I focused on the C API) several years ago, and I hope it’s still valid, and of course that there aren’t any huge and glaring errors.

For a while, the book seemed like it was in limbo – just when I thought it was dead, Ken would come back with an update. This was also a cause for concern, as I wanted the thing to either die a dignified death, and get on with my life, or appear in print.

As for the tutorial, I did manage to make that happen as well. Clif Flynt, who authored a Tcl/Tk book of his own, was kind enough to donate some material from a tutorial of his own, which several of us hacked at to get it into shape. It’s available here:

In any case, I sincerely hope that the material I wrote manages to do justice to the years and years of work that have gone into the language and its implementation, and hope you find the book valuable if you pick up a copy.

Tcl -= Ousterhout

It’s not really “news” that Dr. John Ousterhout is no longer the Tcl leader, that happened years ago, but it’s finally been formalized:

And people at large have taken notice, something that doesn’t happen with Tcl very often.

What I think is actually interesting about it is to consider the governance models for various programming languages. It seems that Tcl is something of an exception to the “benevolent dictator” model prevalent in the world of scripting languages. Python still uses this, with Guido van Rossum being the “BDFL”, or Benevolent Dictator For Life). Perl used to, with Larry Wall, although I’m not up to date on what they do now. Ruby has Yukihiro “Matz” Matsumoto.

The really big, established, popular languages like C, C++ and Java have committees that run them, although even there, the original development was often by small teams or individuals.

What about other languages, like Lua, Erlang, Scala, Clojure, Haskell, OCaml, and so on and so forth? Which governance model is in use? How does it help or hinder the language’s growth and adoption?

Dynamic Languages in Desktop Applications

Ted Leung talks about the lack of dynamic languages in desktop applications. There’s something ironic about that: Ted works for Sun Microsystems. Sun Microsystems, back in the day, was a big contributor to Tcl and Tk. Despite not being the “in thing”, Tcl and Tk are used a lot more than people think. Not so much in the latest and greatest things being built now, due to the (undeservedly) “uncool” reputation, but in lots of products that are still chugging along, earning money and serving their users well, if not noisily so. Interestingly enough, my biggest client here in the Innsbruck area is one of these. They have offices worldwide, make a good living at what they do, and their user interface is mostly in Tk.

New “Jim” Maintainer

Tcl is a fairly old language, nearly 20 years old this year. It’s also quite widespread, even if it’s not as popular as it once was. This means that a lot of things are fairly set in stone, and not likely to change short term. It also means that with time, it has grown quite a bit as a system, and has lots of pieces.

Several years ago, my friend Salvatore “antirez” Sanfilippo set out to create his own version of Tcl, something smaller and more flexible, and under his control so as to avoid being tied down with baggage from the past. The result was Jim, which, according to the web page:

… implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, First class arrays. All this with a binary size of about 85kb (that can be reduced further excluding some non-vital commands, and commands not available in Tcl itself).

which has made it popular with people who need a small scripting language for things like embedded systems.

Unfortunately, Salvatore hasn’t had as much time to work on it as he might like, being busy with money making web things (it’s tough to make money on programming languages), so it’s good to see that he has added

Tcl and Tk 8.5 out

Actually, they were out a few weeks ago, but I’ve been on vacation at the in-laws’ near Monselice, Italy. The release announcement is here:

It’s worth writing about, because it’s been a long time in the making, and contains a number of improvements. Particularly noteworthy in my opinion are ‘real’ hash tables (dicts), an even better sandbox model (Tcl and Java have the best sandboxes that I know of), and a theme engine for Tk that, in the right hands, significantly improves how it looks.

In the fickle world of language fads, Tcl doesn’t get the respect that it should these days. Like anything, it has problems, but what doesn’t, when examined up close? It’s ironic that for years it has gotten things right like Unicode support, and OS-level threading, that are currently being worked on in Ruby.

Hecl obviously owes a great deal to Tcl, but since it’s a new language (more or less necessitated by cell phone limitations), we’re free to take a stab at improving things that Tcl doesn’t get right.

In any case, Tcl is worth a look if you want to play with something that’s fundamentally different from a lot of popular languages, and the core team has put a lot of work into the latest release, so give it a whirl (perhaps using tkcon instead of the readline-less tclsh executable) with an open mind, and see if you don’t learn something new.