开源/自由项目 大历史

概述

Tcl 是一种简单易学但功能强大的语言。它的语法可以用仅仅一打规则就可以描述清楚，但它具备了在应用的几乎任何领域进行快速创建实用程序所有必须的特征，并且这些应用可以基于广泛使用的国际化平台。

Tk 是为Tcl 开发的一个图形工具包（graphical toolkit）。你可以使用它开发运行在Windwos，Linux，MacOSX和其它许多平台的图形应用程序。

无论你是出色的hacker、应用程序、系统管理员还是科研工作者，或者仅仅是学生，你都可以使用Tcl。

目前，应用Tcl比较成功的公司包括BitMover、TiVo Inc.、Motorala、IBM、Oracle等。具体可以参考：http://www.tcl.tk/about/audience.html

开源协议

I Have To Give Away My Tcl Programs?

Programs you write in Tcl are your intellectual property, and you may sell, license, or give them away as you want. Most Tcl programs are distributed in source-code form, but there are source filters and other tools to render your program unreadable by the casual pirate.

On the other hand, be certain that you check the license of any extensions, tools, or distributions that you use during development. Just because Tcl and Tk are free doesn't mean that everything in the community is free.

 

在网上没有找到Tcl/Tk具体遵循的协议，不过在这里（即上面的原文）也可以找到一些论述。Tcl/Tk是免费的，但不是说在该社区里什么都是免费的。你用Tcl编写的程序属于你的智力产品，你可以销、许可（license）或者放弃它们。许多Tcl程序是以开放源代码的形式发布的，但是存在源码过滤器和其它一些工具，在没有获得授权的情况下，它们可以令你的程序不可读。

 

Tcl/Tk发展史

John K. Ousterhout（Tcl/Tk的开创人）曾在网上写了一篇名为《HISTORY OF TCL》的文章，原文详见附件，全文如下：

 

人们常常问我这样的问题，设计Tcl的灵感是什么，为什么它会变得这么受欢迎。本文将重温一下当年产生设计Tcl和Tk的想法，回顾Tcl和Tk在过去十年间发展的过程，以及我从伯克利到sun到scriptics的人生经历。你将看到，起初Tcl是很简陋的；这个系统的成功令我很吃惊，其实我也是通过回顾它的历史才开始明白Tcl流行的原因是什么。

 Tcl的诞生

 Tcl脚本语言诞生于我的集成电路设计工具项目，当时我在加州大学伯克利分校，时间是80年代初。我和我的学生已经为IC设计写了几个交互工具，如Magic和Crystal。每个工具都需要一个命令语言（在那个年代，人们需要键入命令才能使用这些工具；图形用户界面还没有被广泛的使用）。不过，我们的兴趣重点是工具而不是它们的命令语言，所以我们没有在命令语言上投入太多的精力，结果最终语言方面变得很薄弱。更糟的是，每个工具的语言之间是互不相通的，以至于每个工具最终都伴随着一个糟糕的命令语言。一段时间后，情况变得更糟。

1987年秋，在DEC西部研究室的周期性休息日中，我有了设计一种嵌入式命令语言的想法。这个想法就是花费额外的精力去创建一种优秀的解释型语言，然后进一步把它做成一个能够在许多不同的应用程序中可重复利用的库包（library package）。语言的解释器要提供一系列相对通用的工具，如变量，控制结构，过程。每个使用这个语言的程序都可以以扩展的形式把自己的特性加到该语言中，达到用该语言控制程序的目的。Tcl（Tool Command Language）这个名字就源自这种需求。

可嵌入性是Tcl的特色之一，为了实现这个想法，我准备在以下三个方面进行着手：

l         这个语言必须是可扩展的：它应该能够让每个应用程序可以很方便的把自己的特色加到语言的基本功能中，并且这种具体的应用程序的特色要看起来非常自然，就好像一开始这些特色就被设计到了这个语言中。

l         这个语言必须非常的简单通用，能很方便的与许多不同的应用程序配合工作，并且不会限制应用程序所能提供的功能。

l         由于大部分出色的功能都来自于应用程序，所以这个语言的首要目的就是将扩展部件集成或“胶合”在一起。因此这种语言必须要有很好的集成特性。

1988年初，假期一结束，我开始研究Tcl，1988年春天的时候，我开始在一个图形化的文本编辑器中使用第一版的Tcl。那时我已经暂停了IC设计工具的研究工作，所以有关Tcl的实验大部分还在理论研究阶段：我当时认为除了我，没有人会对一种嵌入式命令语言感兴趣。

 Tk的诞生

 那时，我的另一个爱好就是图形用户界面。80年代图形用户界面逐渐流行的时候，我注意到交互式软件的复杂性正在迅速的增长。最有趣的是新的开发似乎需要巨额投资的大型工程项目的支持。作为一名只具有有限资源的教授，这令我担心：象我的研究小组一样的小团队是不是不再可能构建出创新型交互系统？

我得出的结论是，我们的唯一希望就是减少创建大型系统时除可重用组件以外的部分对资源的需求。如果一个系统的复杂性大部分在组件里，并且我们可以在系统间进行移植，也许我们就可以以小团队的规模来创建强大的系统。这要求花费很多精力去开发这些组件，但是，经过一段时间这项工作是可以逐渐完成的，或许几个小团队一起合作完成。

我同时深信，对集成这些组件而言，除非有一种强大并具有弹性的机制，否则，基于组件的设计不会成功。这些想法在我一开始考虑做Tcl的时候就产生了，我觉得像Tcl这样的嵌入式命令语言作为脚本语言对集成组件也会有用。我决定创建一个GUI组件集合作为对Tcl的扩展并且使用Tcl把这些组件集成到图形用户界面，从而来验证我的这个理论。这个扩展就成为了Tk。

我1988年末才开始做Tk，这只是一个兼职的项目，所以花费了大概两年的时间才使Tk具有了足够的实用功能。

 发布初期

 我已经记不清把Tcl介绍给大家的确切时间了。截止到1989年，我已经在几个工程中使用了Tcl，我记得我在伯克利工业联络会议（Berkeley Industrial Liaison Conference）期间做了一个关于Tcl的报告，那时，几百位来自工业界的人士来到伯克利听我们系的研究成果。，我又在对Tcl感兴趣的几家公司做了相关的Tcl报告来招待他们，在这几次报告中，一些人询问了他们是否可以得到Tcl的拷贝。无论如何，我在1989年把几份拷贝给了最早的好奇者。

1990年1月，我在USENIX会议上宣读了一篇关于Tcl的论文。参会的有几百人，并且他们对Tcl产生了浓厚的兴趣，许多人开始向我要Tcl的拷贝。大约在那个时候，我决定在伯克利的FTP站点上免费发放Tcl的源代码。从此，通过因特网，Tcl的用户开始与日俱增。

出席USENIX会议的其中一个人是国家标准和技术协会的Don Libes。一段时间以来Don想编写一个程序，这个程序能够自动的操作交互的UNIX应用程序，但这需要一种优秀的命令语言，而Don没有时间自己编写这样的一个语言，于是这个项目只能搁置在一边。听了我的演讲后，Don立即跑回家，下载了Tcl，编写了一个叫做Expect的非常优秀的程序，并且赶在下一次USENIX会议提交论文的最后期限之前完成了一篇关于它的论文。整个过程只用了三个星期。Don在1990年夏发表了他的论文之后，把Expect免费的提供给人们使用，于是在系统管理员界立即引起了一场不小的震动。Expect不仅是第一个广泛发布的Tcl应用程序，而且多年来一直也是最流行的。许多早期的Tcl用户都是通过使用Expect来学习Tcl。

在1990年末，可以使用Tk的基本功，1991年1月，我同时在USENIX会议和X大会上发表了一篇关于Tk的论文。这两次会议期间的几个星期中，我发布了Tk的第一个网络版本。Tk的第一版缺少许多重要的组件（比如，没有多行文本框组件），不过到了1992年夏天的时候，我就把文本框组件和一个强大的画布组件加了进去。这时Tk的用户开始迅速增长。

 开始流行

 Tcl/Tk的用户在90年代初每年都在迅速增加，从1989年的几个使用者到1993年的几万使用者。这种迅速增长的原因主要有两个方面。

Tcl/Tk使用者增加的第一个原因是：它提供了最简单的在UNIX（那时Tcl只能在UNIX系统下运行）下开发图形用户界面的方法。Tk的GUI工具既简单又强大；可以完全由Tcl而不用写一句C代码来编写感兴趣的应用程序。换成基于C的工具来开发比如Motif工具包则要变得复杂得多，而且功能也比较少。人们很快就认识到，用Tcl来开发GUI比用Motif可以少投入5到10倍的精力。这也证明了在工业界有许多人和我一样很关心开发交互式应用程序的高开支问题。

Tcl流行的第二个原因是它的可嵌入特性。在我开始做Tcl的时候，我猜想除了我没有人会关心可嵌入式的命令语言，但是我错了。包括Don Libes在内的许多人都想要编写脚本式的可扩展的应用程序，但却没有时间自己来创建这么一种语言。正因为可嵌入式的特性，Tcl为他们提供了一个完美的解决方案。因而，Tcl最终被广泛的用于股票交易，科学观测，生产自动化等许多领域。

在Tcl用户社区每一两年都会有对Tcl和Tk的使用的讨论。许多Tcl的使用者认为Tk是他们使用Tcl的唯一原因。他们中的一些甚至不喜欢Tcl语言，而希望Tk能够和其他的脚本语言结合。（实际上，已经有人这么做了，如Tkperl和Python）。而另一部分人认为Tcl正是他们的需求所在，他们把它作为可嵌入式的脚本语言来使用，并且正是因为能够达到这个目的才让他们喜欢上了这个语言的小道具（afreez注：指Tk）。从某种意义上说，这两部分人都没错。

 Tcl社区

 90年代初随着Tcl使用者的增加，人们在网上建立了一个关于这门语言的社区，目的是让大家发布功能强大的扩展和为新的用户提供帮助。Mark Diekhans和Karl Lehenbauer是早期开创者中的两位。他们编写了Tclx，最早免费可用的Tcl扩展之一。Tclx提供了对文件的访问，时间和日期控制，以及许多其它有用的功能。随着时间的推移，Tclx的功能被证明是非常重要的，以至于其中的许多功能已经被整合到了Tcl的基本功能中。

许多早期的Tcl倡导者编写了高质量的扩展并使这些扩展能够免费的使用。比如Michael Mclennan编写的[incr Tcl]，一种在Tcl内部提供面向对象编程的扩展。George Howlett编写的BLT，为Tk加进了几个重要的组件。Tom Poindexter编写的Sybtcl和Oratcl，提供了对主流数据库的访问。Brian Smith和Lary Rowe编写的TclDP，提供了Socket访问及一些分布式编程特性。还有许多贡献者我已经记不太清了，在此我只能表示歉意。

社区中其它的论坛在这个时期也在发展。我起初为社区中的用户建立了一个邮件列表，但是短短几年里，这个列表变得相当冗长，以至于后来无法控制。在Tcl社区的帮助下，我们建立了comp.lang.tcl新闻组来代替原来的邮件列表；从此，它就成为了信息交流和讨论Tcl新功能的绝佳论坛。

1993年Larry Rowe意识到社区中的人们需要面对面的交流，于是他在伯克利组织了第一届Tcl专题讨论会。大约有60人参加，由于这次大会开得非常成功，所以成为了年会。1995年，USENIX协会开始对这个讨论会进行资助；从此，它就变为了一个有几百人参加的，发表大量论文、教程，开展众多活动的全方位的大会。Tcl大会也是世界上最大的参加者上身着装统一的大会之一，每年要分发5-10种不同设计图案的T-shirt来区别不同的扩展和活动等。

在这段时间里，我大约每6到10个月发布一次Tcl/Tk的新版本。大部分新的功能都是采用的Tcl社区的建议；有时，使用者甚至直接给我提供新功能的原型代码（prototype code），然后，我再把它集成到核心软件中。典型的新版本发布流程是，开始大家开始讨论一段时间，同时我提供一份新功能的候选列表，然后在社区中由大家投票选出他们认为最重要的功能。我尽可能优先考虑得票最多的功能。

 Ouster-投票

 后来Tcl的发布周期就慢慢趋向于和Tcl大会保持一致。新版本发布的时间大概和大会的时间相当，大会上我会利用一个专门的议程去讨论下一个版本的新特征并取得反馈信息。我经常让与会者即兴的举手表决，统计一下听众对一些问题的想法，然后对举手的人数做个大概的统计（“10，20，30，…，看起来我大约得了35票”）。这些票数被大家称之为“ouster-投票”，得票数的正确性也常常被大家讨论的话题。一些爱说笑的人也含沙射影说我这个投票方法也不怎么太客观….

 在sun公司的日子

 1994年我决定离开伯克利投身工业界。过去我就一直想在工业界做兼职工作，在学术界干了14年，现在我看时机已经成熟了。在考虑了多方面的因素后，我决定接受sun公司的邀请。Eric Schmidt，sun公司的首席技术官，和Bert Sutherland，sun实验室的领导者，给我提供了一个机会，在sun实验室创立一个小组，将Tcl开发成因特网上通用的脚本语言。

我一直觉得Tcl最终需要进行商业赢利才能在长远的开发中生存下来，sun公司为Tcl向更高性能的发展提供了很好的机会。

我在1994年5月加入sun公司，然后组建了一个Tcl开发小组。在以后的3年里，sun的Tcl小组成员发展到了12人。以前基本上Tcl/tk的每一行代码都有我亲自来编写，但是从那以后，编写Tcl代码的工作就移交给Tcl小组的其他成员来完成了。

Sun公司提供的许多帮助使我们对Tcl/Tk的性能进行了大规模的提升。Scott Stanton 和Ray Johnson将Tcl/Tk移植到了Windows和Macintosh，于是Tcl就成了一个出色的跨平台的开发环境；当前，超过2/3下载Tcl的用户是用于Windows开发。Jacob Levy和Scott Stanton仔细测试了输入输出系统并加进了对Socket的支持，于是Tcl可以被广泛的用于网络应用程序。Brian Lewis为Tcl脚本创建了一个字节码（bytecode）编译器，这使它的运行速度提升了10倍。Jacob Levy开发了Safe-Tcl，一个强大的安全模型，使非信任的脚本能更安全的执行。Jacob Levy和Laurent Demailly创建了一个Tcl插件，使Tcl脚本可以在web浏览器中运行，我们创建了Jacl和TclBlend，使Tcl和Java可以紧密的工作在一起。我们还进行了一些小的改进，如动态加载，名称空间，时间和日期支持，二进制I/O，额外的文件操作命令，和一个改进的字体机制。

当我加盟sun后，许多人担心Tcl是否会变成一个私有的语言，当时在comp.lang.tcl上出现了许多热烈的讨论。幸运的是，sun公司同意在源代码论坛中继续发放Tcl/Tk的核心代码库，并且sun一直信守诺言。随着性能不断提升的新版本的出现，事实证明，Sun对Tcl的支持是不容质疑的，它使得比该语言的发展速度超过以前任何时候。起初那些担心逐渐被开发新功能的热情所代替。

这些年，Tcl的使用者继续地爆炸式增长。到1997年已经有了数十万的Tcl开发者；sun公司的FTP站点的Tcl下载率由1995年底的2000人每星期上升到1998年初的超过10000人每星期。很明显，Tcl对我是一个巨大的商业机会。Tcl开放源代码的发展满足不了Tcl社区中的许多要求。比如，几乎没有开发Tcl的工具，像培训和技术支持这样的专业服务也仅仅是零散进行的。许多重要的扩展，如对ActiveX和CORBA的支持还没有编写出来。

 Scriptics（afreez注：公司的名字）

 1997年底，为了更好的发展Tcl，我决定离开sun创建一个完全关注于Tcl的公司。1998年1月，我和Sarah Daniels创建了Scriptics（即今天的 Tcl），由Sarah负责市场和营销。一个月内，sun公司Tcl小组的约一半成员都跳槽加入了我们公司，我们开始开发TclPro，一套包括我们最初产品的开发工具。TclPro 1.0 于1998年9月完成。它在市场上的成功为公司的发展注入了强大的动力。

Scriptics已经取代了sun公司在开发Tcl核心工具上的角色，并且它将继续像sun公司那样免费的发布它。1998年，Scriptics为Tcl8.0做了一些改进，修复了一些错误并加进了一些小的功能，比如可以更好的支持[Incr Tcl]扩展。1999年4月，Tcl发布了第一个最重要的开放源码的版本，Tcl/Tk8.1。这个版本加进了对Unicode的支持（国际化），线性安全（用于多线程服务程序）和一个由Henry Spencer开发的全新的规则表达式包，该包包含了许多新的特性，也支持Unicode。Tcl成为第一个满足企业中关键程序各方面要求的脚本语言。

Tcl：获过大奖的软件

  1998年春， 我听到了令人振奋的消息，Tcl获得了两项大奖。一个是ACM软件系统大奖，奖给每年的“具有长远影响的软件系统”。以往这个奖项的获得者包括许多重要的系统如TCP/IP协议，第一个线性表，第一个电子制表软件，第一个关系数据库，万维网，Unix系统，PostScript，Smalltalk。另一个是USENIX软件工具用户组织（STUG）大奖，这个奖项奖给年度优秀的软件工具。

Tcl核心团队的成立

 这一部分由Jeff Hobbs和其他人添加

 Scriptics于2000年5月更名为Ajuba解决方案（Ajuba Solutions），反映了公司的发展重点放在了一系列的基于Tcl的XML技术。Ajuba创建了基于Tcl的企业版的XML类服务器软件，从这个方面来说，由于Tcl的成功，Ajuba也成为了牺牲品，之所以这么说是因为这个原因，后来它被Interwoven于2000年10月收购。不过Interwoven对开放源码的软件不感兴趣，他们只关注XML和服务器技术。

在2000年的七月到十月期间，核心开发的“所属权”发生了转变，它从一个单独的组织中脱离出来，属于了一个广泛的团队而不再属于任何一个单独的组织，并被广为传播。Tcl核心团队（Tcl Core Team）成立了，并建立了它的基本运行程序。

有关Tcl的教程也得益于包含它的许多公司。一个典型的例子就是，Jeff Hobbs，前Tcl Scriptics/Tcl的代理人，跳槽到ActiveState（以发布Perl的产品和开发闻名）来领导他们的Tcl技术部，他的工作不仅在开源Tcl核心上，而且也推进了许多由Scriptics开创的商业开发工具的发展。

  

最新动态

Tcl/Tk核心由Tcl核心团队（Tcl Core Team）和核心维护人（Core Maintainers）来管理。

具体的技术方面的动态，由于本人工作范围有限，未能做深入的研究，希望高手来完成这部分！

相关项目简介

下面是有关Tcl的一些项目连接，你也可以在SourceForge的主机上了看到它们：

 

 

项目发起人及管理简介

Tcl/Tk的开创人为John K. Ousterhout，具体的可以参考Tcl/Tk一节。

Tcl/Tk核心由Tcl核心团队（Tcl Core Team）和核心维护人（Core Maintainers）来管理。

 

参考文献

1．  http://wiki.tcl.tk/

作者简介

网名：afreez 曾用名：聂飞

嵌入式开发工程师 工作平台主要是Linux，OpenSource/Free Soft的迷恋者……

附录

附录一：HISTORY OF TCL

by John Ousterhout

People often ask me how I got the idea for Tcl and why it became so popular. In this page I've attempted to reconstruct the thought processes that led to Tcl and Tk and trace the evolution of Tcl and Tk over the last decade along with my path from Berkeley to Sun to Scriptics. As you will see, Tcl's beginnings were very modest; the success of the system was quite a surprise to me, and it's only in retrospect that I've begun to understand the reasons for Tcl's popularity.

The birth of Tcl

The Tcl scripting language grew out of my work on design tools for integrated circuits at the University of California at Berkeley in the early 1980's. My students and I had written several interactive tools for IC design, such as Magic and Crystal. Each tool needed to have a command language (in those days people tended to invoke tools by typing commands; graphical user interfaces weren't yet in widespread use). However, our primary interest was in the tools, not their command languages. Thus we didn't invest much effort in the command languages and the languages ended up being weak and quirky. Furthermore, the language for one tool couldn't be carried over to the next, so each tool ended up with a different bad command language. After a while this became rather embarrassing.

In the fall of 1987, while on sabbatical at DEC's Western Research Laboratory, I got the idea of building an embeddable command language. The idea was to spend extra effort to create a good interpreted language, and furthermore to build it as a library package that could be reused in many different applications. The language interpreter would provide a set of relatively generic facilities, such as variables, control structures, and procedures. Each application that used the language would add its own features into the language as extensions, so that the language could be used to control the application. The name Tcl (Tool Command Language) derived from this intended usage.

The notion of embeddability is one of the most unique aspects of Tcl, and it led me to the following three overall goals for the language:

• The language must be extensible: it must be very easy for each application to add its own features to the basic features of the language, and the application-specific features should appear natural, as if they had been designed into the language from the start.
• The language must be very simple and generic, so that it can work easily with many different applications and so that it doesn't restrict the features that applications can provide.
• Since most of the interesting functionality will come from the application, the primary purpose of the language is to integrate or "glue together" the extensions. Thus the language must have good facilities for integration.

I started work on Tcl when I returned from my sabbatical early in 1988, and I began using the first version of Tcl in a graphical text editor in the spring of 1988. By this time I had stopped working on IC design tools in my research, so the experiments with Tcl were mostly academic: I didn't think that anyone besides myself would be interested in an embeddable command language.

The birth of Tk

One of my other interests at that time was graphical user interfaces. As GUIs became more and more popular in the 1980s I had noticed that the complexity of interactive software was rising rapidly. The most interesting new developments seemed to require large projects with enormous investments. As a professor with modest resources, this worried me: would it become impossible for small teams like my research groups to build innovative interactive systems?

I concluded that the only hope for us was to reduce the resource requirements by building large systems out of reusable components. If most of the complexity of a system was in the components, and if we could carry the components forward from system to system, perhaps we could build large powerful systems with small teams. It would take quite a bit of work to develop the components, but this could be done gradually over time, perhaps by several smaller groups working together.

I also reasoned that component-based design would not work unless there was a powerful and flexible mechanism for integrating the components. These thoughts occurred shortly after I had begun thinking about Tcl, and it occurred to me that an embeddable command language such as Tcl might also be useful as a scripting language for integrating components. I decided to test this theory by creating a set of GUI components as a Tcl extension and using Tcl to assemble the components into graphical user interfaces. This extension became Tk.

I began work on Tk in late 1988, but it was a part-time project, so it took about two years before there was enough functionality for Tk to be useful.

Early distributions

I no longer remember exactly when I began giving Tcl away to other people. By 1989 I was using Tcl in a couple of projects, and I believe that I gave a talk on Tcl during the Berkeley Industrial Liaison Conference, where several hundred people from industry came to Berkeley to hear about research in our department. I believe that this led to invitations to give talks on Tcl at a few interested companies, and that some of the people at those talks asked if they could have copies of Tcl. In any case, I gave away a few copies of Tcl to early adopters in 1989.

In January of 1990 I presented a paper on Tcl at the USENIX Conference. The talk was attended by several hundred people and generated enough interest that many people began asking me for copies of Tcl. Around this time I decided to make the Tcl source code freely available on our FTP site at Berkeley. Once that happened, Tcl usage began to spread by word of mouth over the Internet.

One of the people at the USENIX presentation was Don Libes of the National Institute of Standards and Technology. Don had been wanting for some time to build a program to automate interactive Unix applications, but the project had stalled because it needed a good command language and Don didn't have the time to build one. After hearing my talk, Don rushed home, downloaded Tcl, built a wonderful application called Expect, and wrote a paper on it in time for the submission deadline for the next USENIX Conference. This whole process took just three weeks. Don made Expect freely available after presenting his paper in the summer of 1990, and it became an instant hit among system administrators. Expect was not only the first widely distributed Tcl application, but for many years it was the most popular. Many of the early Tcl users learned about it by using Expect.

The basic features of Tk became usable late in 1990, and I presented a paper on Tk at both the USENIX Conference and the X Conference in January 1991. Within a few weeks of these conferences I made the first Internet release of Tk. The first version of Tk lacked several important widgets (e.g., it had no multi-line text widget), but by the summer of 1992 I had added both a text widget and a powerful canvas widget. At this point usage of Tk began to increase dramatically.

Growing popularity

Usage of Tcl and Tk grew roughly an order of magnitude each year in the early 1990s, from a few users in 1989 to several tens of thousands in 1993. There were two primary reasons for this growth.

The first reason for the growth in Tcl/Tk usage was that it provided the easiest way to create graphical user interfaces under Unix (in those days Tcl only ran on Unix systems). Tk's GUI facilities were both very simple and very powerful; interesting applications could be written entirely in Tcl, without writing any C code at all. C-based alternatives such as the Motif toolkit were much more complicated, yet provided less functionality. It quickly became clear that GUIs could be created with 5-10x less effort in Tcl than Motif. It also turned out that many people in industry were just as concerned as I was about the high cost of developing interactive applications.

The second reason for the popularity of Tcl was its embeddable nature. When I started on Tcl I assumed that no-one besides myself would care about an embeddable command language, but I was wrong. Many people, including Don Libes and others, wanted to build applications that were scriptable and extensible but didn't have the time to build a language of their own. Because it was embeddable, Tcl provided a perfect solution for these people. As a result, Tcl ended up being used in applications ranging from stock trading to scientific visualization to manufacturing automation.

Out of this dichotomy in usage grew a discussion that reoccurs every year or two in the Tcl user community. Many Tcl users assert that Tk is the only reason they use Tcl. Some of them don't even like the Tcl language and wish that Tk could be mated with a different scripting language (in fact, this has happened several times, including TkPerl and Python). A different group argues that Tcl is all they care about; they use it as an embedded scripting language, often without Tk, and like the language's properties for this purpose. In a sense both groups are right.

The Tcl community

As Tcl usage grew in the early 1990s, a community formed around the language, contributing many powerful extensions and providing support for new users. Two of the earliest pioneers were Mark Diekhans and Karl Lehenbauer. They wrote TclX, which was one of the first freely available Tcl extensions. TclX provided file access, time and date manipulation, and many other useful facilities. Over time the features of TclX have proven so important that many of them have been incorporated into the base Tcl releases.

Many other Tcl pioneers wrote high-quality extensions and made them freely available. For example, Michael McLennan wrote [incr Tcl], an extension that provides object-oriented programming features in Tcl. George Howlett wrote BLT, which added several important widgets to Tk. Tom Poindexter wrote Sybtcl and Oratcl, which provided access to popular databases. Brian Smith and Larry Rowe wrote TclDP, which provided socket access and other distributed programming features. There are others as well; apologies to the many worthy contributors whom I have failed to recognize.

Other forms of community developed in this same period. I initially created a mailing list for communication among Tcl users, but within a few years it became so large as to be unwieldy. With help from the Tcl community the comp.lang.tcl newsgroup was created as a replacement for the mailing list; since then it has provided a wonderful forum for exchanging information and discussing new Tcl features.

In 1993 Larry Rowe recognized the need for people in the community to meet in person, so he organized the first Tcl Workshop at Berkeley that summer. About 60 people attended, and the workshop was so successful that it became an annual event. In 1995 the USENIX Association offered to help run the workshop; since then it has evolved into a full-fledged conference with several hundred attendees and a rich program of papers, tutorials, and other events. The Tcl Conference is also one of the world's premier events for upper body wear: each year there are 5-10 different T-shirt designs given away to recognize various extensions, events, etc.

During this period I made new releases of Tcl and Tk roughly every 6-12 months. Most of the new features were suggested by people in the Tcl community; in some cases users even supplied me with prototype code for the new features, which I then integrated into the core software. Typically each new release cycle would start off with a discussion period where I proposed a candidate list of new features and everyone in the community could vote for the ones they thought were most important. I tried to give priority to the features with the most votes.

Ouster-votes

Over time the Tcl release cycle tended to align with the Tcl Conference. A new release would typically come out around the time of the conference, and I would use one session of the conference to discuss new features for the next release and get feedback. I would often call for an impromptu show of hands to see how the audience felt about various issues, and then attempt to make a rough count of how many hands were raised ("ten, twenty, thirty, ... looks like about 35 hands to me"). These became known as "Ouster-votes" and their accuracy has often been a topic of discussion. Some wags have insinuated that my vote counting is less than totally objective....

The Sun years

In 1994 I decided to leave Berkeley for industry. I'd always wanted to spend part of my career in industry, and after 14 years in academia the time seemed right. After considering a variety of possibilities, I decided to accept an offer from Sun Microsystems. Eric Schmidt, Sun's Chief Technology Officer, and Bert Sutherland, Director of Sun Microsystems Laboratories, offered me the chance to build a team at Sun Labs and evolve Tcl into a universal scripting language for the Internet. I had always felt that Tcl would eventually need to have profitable businesses built around it in order to survive over the long term, and the Sun offer was a great opportunity to take Tcl to the next level.

I joined Sun in May of 1994 and began building a team of Tcl developers. Over the next three years the Sun Tcl team grew to a dozen members. Up until this point nearly every line of code in Tcl and Tk had been written by me personally, but over time more and more of the responsibility for Tcl code shifted to other members of the Sun Tcl team.

The additional resources provided by Sun allowed us to make major improvements to Tcl and Tk. Scott Stanton and Ray Johnson ported Tcl and Tk to Windows and the Macintosh, so that Tcl became an outstanding cross-platform development environment; today, more than two-thirds of Tcl downloads are for Windows. Jacob Levy and Scott Stanton overhauled the I/O system and added socket support, so that Tcl could easily be used for a variety of network applications. Brian Lewis built a bytecode compiler for Tcl scripts, which provided speedups of as much as a factor of 10x. Jacob Levy implemented Safe-Tcl, a powerful security model that allows untrusted scripts to be evaluated safely. Jacob Levy and Laurent Demailly built a Tcl plugin, so that Tcl scripts can be evaluated in a Web browser, and we created Jacl and TclBlend, which allow Tcl and Java to work closely together. We added many other smaller improvements, such as dynamic loading, namespaces, time and date support, binary I/O, additional file manipulation commands, and an improved font mechanism.

When I moved to Sun many people were worried that Tcl would become a proprietary language, and there were several "spirited discussions" on the comp.lang.tcl newsgroup. Fortunately, as part of my offer Sun had agreed that the core Tcl and Tk libraries would continue to be distributed freely in source form, and Sun honored this agreement faithfully. As new releases appeared with more and more improvements, it became clear that Sun's support for Tcl was a wonderful thing that allowed the language to evolve much more rapidly than it could have otherwise. The concerns were gradually replaced with enthusiasm for all the new features.

During these years Tcl usage continued to explode. By the end of 1997 there were hundreds of thousands of Tcl developers; the rate of Tcl downloads from the Sun FTP site increased from 2000 per week at the end of 1995 to more than 10000 per week by early 1998. It was clear to me that there were huge business opportunities around Tcl. It was also clear that the Tcl community had many needs that weren't being met by the open-source Tcl development. For example, there were almost no development tools for Tcl, and professional services such as training and support were only sporadically available. Many important extensions, such as ActiveX and CORBA support, still needed to be written.

Scriptics

In late 1997 I decided that the best thing for Tcl was to spin out of Sun and form a startup that could focus entirely on Tcl. In January 1998 I founded Scriptics with Sarah Daniels, who became VP of Marketing and Sales. Within a month about half of the Sun Tcl team had joined us and begun development of TclPro, a set of development tools that would comprise our first product. TclPro 1.0 shipped in September of 1998. Its success in the marketplace fueled a major growth spurt at the company.

Scriptics had also taken over from Sun the role of developing the Tcl core facilities, and it continued to release them freely just like Sun did. In 1998, Scriptics made several patch releases for Tcl 8.0 to fix bugs and add small new features, such as a better support for the [incr Tcl] extension. In April 1999, Scriptics made its first major open source release, Tcl/Tk 8.1. This release added Unicode support (for internationalization), thread safety (for multi-threaded server applications), and an all-new regular expression package by Henry Spencer that includes many new features as well as Unicode support. With the 8.1 release, Tcl became the first scripting language to have all the facilities needed for mission-critical enterprise applications.

Tcl: award-winning software

In the spring of 1998 I learned the wonderful news that Tcl had won two major awards. The first is the ACM Software System Award, awarded each year for "a software system that has had a lasting influence". Past winners of the award include such seminal systems as the TCP/IP protocols, the first spreadsheets, the first relational databases, the World-Wide Web, Unix, PostScript, and Smalltalk. The second award was the USENIX Software Tools User Group (STUG) Award, given each year in recognition of an outstanding software tool.

Formation of the Tcl Core Team

This section added by Jeff Hobbs and others

Scriptics was renamed Ajuba Solutions in May, 2000, reflecting the company's growing focus on a series of Tcl-based XML technologies. Ajuba became in part the victim of its own success in creating enterprise class XML server software based on Tcl, and was acquired by Interwoven in October, 2000. Interwoven was not interested in open source aspects of the company however, but rather the XML and server technologies.

During the period of July-October 2000, mechanisms were put in place to transition the "ownership" of core development, which was becoming increasingly widespread, away from a single organization, and towards a broader group not tied to any one particular organization. The Tcl Core Teamwas formed, and established its basic operating procedures.

Tcl of course still benefits from the involvement of many companies. As one prominent example, Jeff Hobbs, formerly the Tcl Ambassador at Scriptics/Ajuba, moved to ActiveState (already known for their Perl products and development) to head their Tcl technologies group, working both on the open source Tcl core, as well as advancing many of the commercial development tools that had been started at Scriptics.