History of Tcl
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.
Ajuba
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 (now Tcl) 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 is now fueling a major growth spurt at Ajuba. by the end of 1999 we expect to have nearly 50 employees.
Tcl has also taken over from Sun the role of developing the Tcl core facilities, and it will continue to release them freely just like Sun did. In 1998 Tcl 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, Tcl 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.
In the future, Tcl will continue to develop both open source and commercial products. With this arrangement we hope to achieve the best of all worlds, with the open source core continuing to improve rapidly and Tcl products filling the gaps and providing the revenue to support both the free and product developments. The Tcl user community will continue to play an important role in the evolution of Tcl, as it always has.
ActiveState
This section added by Jeff Hobbs
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 software howevr, just the XML and server stuff. Jeff Hobbs, formerly the Tcl Ambassador at Scriptics/Tcl, moved to ActiveState (already known for their Perl products and development) to head their Tcl technologies group.
ActiveState now provides the full range of products and services related to Tcl development, in addition to being a very active participant in continuing the further development of the open source core.
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.
Vision for the future
Integration applications will continue to grow in importance as more and more businesses discover that their competitiveness depends on being able to make all of their computerized systems work together effectively. Tcl provides a uniquely great platform for building these integration applications. In the future, when CIOs are planning the future of their information infrastructure, I believe that the integration platform will have the same level of importance that the operating system platform and database platform have today. I hope that Tcl will be the premier integration platform, and Tcl the premier vendor of these platforms.
--------------------------------------------------------------------------------------
Tcl的历史
人们常常问我设计Tcl语言的目的是什么，为什么它会变得这么受欢迎。本文将重温一下当年产生设计Tcl和Tk的想法，回顾Tcl和Tk在过去十年间发展的过程，以及我从伯克利到sun到scriptics的人生经历。你将看到，起初Tcl是很简陋的；这个系统的成功令我很吃惊，其实我也是通过回顾它的历史才开始明白Tcl流行的原因是什么。
Tcl的诞生
Tcl脚本诞生于80年代初，我在加州大学伯克利分校的项目“集成电路设计工具”的研究。那时，我和我的学生已经写出了许多用于IC设计的交互工具，如Magic和Crystal。每个工具都需要一个命令语言（在那个年代，人们需要键入命令才能使用这些工具；图形用户界面还没有被广泛的使用）。不过我们的研究重点是工具而不是它们的命令语言，所以我们没有在命令语言上投入太多的精力，结果语言方面变得很薄弱。更糟的是，每个工具的语言之间是互不相通的。这样一来，经过一段时间后，就变得相当棘手。
1987年秋，在DEC的西部研究所的假期中，我有了设计一种嵌入式命令语言的想法。这个想法就是花费一些精力去创建一种优秀的解释型语言，然后进一步把它做成一个能够在许多不同的应用程序中重复利用的库包（library package），语言的解释器要提供一系列相对通用的工具，如变量，控制结构，过程。每个使用这个语言的程序都可以以扩展的形式把自己的功能加到语言中，达到用语言来控制程序的目的。Tcl的全称“工具命令语言”正说明了这一点。
可嵌入性是Tcl的特点之一，为了实现这个想法，我准备在以下三个方面进行着手：
★这个语言必须是可扩展的：它应该能够让每个应用程序可以很方便的把自己的功能加到语言的基本功能中，并且程序的特定功能必须使用起来非常自然，就好像一开始就是为这个语言设计的一样。
★这个语言必须非常的简单通用，能很方便的与许多不同的应用程序配合工作，而不会限制应用程序的功能。
★由于大部分出色的功能都来自于应用程序，所以这个语言的首要目的就是将扩展部件整合或“胶合”在一起，因此它必须要有很好的整合性能。
1988年初，假期一结束，我就开始着手设计Tcl的工作了。1988年春天的时候，我开始在一个图形化的文本编辑器中使用第一个版本的Tcl。在我停止IC设计工具的相关研究之前，Tcl的实验还大部分停留在理论阶段。当时我想除了我自己没有人会对这个嵌入式的语言感兴趣。
Tk的诞生
那时，我对图形用户界面也很感兴趣。80年代图形用户界面逐渐流行的时候，我注意到交互式软件的复杂性正在迅速的增长，最引人注目的发展趋势看起来好像是对巨额投资的庞大项目的需求在不断增加。作为一名教授，实验条件不是很充足，这使我开始担心像我们这样类似小团队的研究所是不是就不可能再做出交互式的系统了。
我得出的结论是，我们的唯一希望就是减少创建大型系统时除可重复利用的部件以外的部分对资源的需求，如果一个系统最复杂的地方是用部件来完成的，而且可以把部件从一个系统移植到另一个系统，也许我们就可以以小团队的规模来创建强大的系统，这要求花费一些精力来开发这些部件。不过如果有几个小组协同工作的话，完成它只是一个时间的问题。
我也在考虑这样一个问题，要想使基于组建的设计能够实现，需要有一个强大的有弹性的控件整合工具。这些想法在我一开始考虑做Tcl的时候就产生了，我觉得像Tcl这样的嵌入式命令语言作为脚本语言对整合部件会很有用。我决定创建一些作为Tcl扩展的GUI部件并且使用Tcl来把这些部件整合到图形用户界面中，借此实践一下这个理论。这个扩展就成为了Tk。
我1988年末开始做Tk。这只是一个兼职的项目，所以用了两年的时间才使Tk具有了一些实用的功能。
早期的集成套件
我已经记不清是什么时候开始让人们使用Tcl了，我记得我在伯克利“产学研大会”上作了一个关于Tcl的演讲，来自工业界的几百名与会者听了我们系的这个研究成果。我还被一些对此感兴趣的公司邀请去做演讲。在这几次演讲期间，一些人向我要Tcl的拷贝，于是在1989年，这一部分人最早接触到了Tcl。
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的用户从1990年初开始每年都在迅速增加。从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正是他们的需求所在，他们把它作为可嵌入式的脚本语言来使用，而常常不去使用Tk。由于Tcl能够满足他们的特殊目的，所以他们很喜欢Tcl，从某种意义上说，这两部分人都没错。
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接口及一些有用的编程功能。还有许多贡献者我已经记不太清了，在此我只能表示歉意。
社区中其他的论坛在这个时期也在发展。我起初为社区中的用户建立了一个邮件列表，但是短短几年里，这个列表变得相当冗长，以至于后来无法控制。在社区的帮助下，我们建立了comp.lang.tcl新闻组来代替原来的邮件列表，从此，它就成为了交换信息和讨论Tcl新功能的绝佳地点。
1993年Larry Rowe意识到社区中的人们需要面对面的交流。于是他在伯克利组织了第一届Tcl专题讨论会，大约有60人参加。由于这次大会开得非常成功，所以我们决定把它定为一年一届。1995年，USENIX协会开始对这个讨论会进行资助。从此，它就变为了一个有几百人参加的，发表大量论文、教程，开展众多活动的全方位的大会。Tcl大会也是世界上最大的参加者上身着装统一的大会之一，每年要分发5-10种不同设计图案的短袖衫来区别不同的扩展和活动。
在这段时间里，我大约每6到10个月发布一次Tcl/Tk的新版本。大部分新的功能都是采用的Tcl社区的建议。有时，使用者甚至直接给我提供新功能的源代码，然后，我再把它加到软件的核心代码中。通常，每次新版本发布前都有一个讨论的过程，我提供一份新功能的候选列表，然后在社区中由大家投票选出他们认为最重要的功能。我尽可能优先考虑得票最多的功能。
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脚本创建了一个二进制编译器，这使它的运行速度提升了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一直信守诺言。随着性能不断提升的新版本的出现，起初那些担心逐渐被开发新功能的热情所代替。
在那些年，Tcl的使用者继续不断增长。到1997年已经有了成千上万的Tcl开发者；sun公司的FTP站点的Tcl下载率由1995年底的2000人每星期上升到1998年初的超过10000人每星期。很明显，Tcl对我是一个巨大的商业机会。开放源代码的发展满足不了Tcl社区中的许多要求。比如，几乎没有开发Tcl的工具，像培训和技术支持这样的专业服务也仅仅是零散进行的。许多重要的扩展，如对ActiveX和CORBA的支持还没有编写出来。
Ajuba
1997年底，为了更好的发展Tcl，我决定离开sun创建一个完全关注于Tcl的公司。1998年1月，我和Sarah Daniels创建了Scriptics（即今天的 Tcl），由Sarah负责市场营销。一个月内，sun公司Tcl小组的约一半成员都跳槽加入了我们公司，我们开始开发TclPro，一套包括我们最初产品的开发工具。TclPro 1.0 于1998年9月完成。它在市场上的成功为Ajuba的出现提供了强有力的支持。1999年底我们准备再雇佣50名员工。
Tcl公司已经代替了sun公司在开发Tcl核心工具上的角色，并且它将继续像sun公司那样免费的发布它。1998年，Tcl公司为Tcl8.0做了一些改进，修复了一些错误并加进了一些小的功能，比如可以更好的支持[Incr Tcl]扩展。1999年4月，Tcl发布了第一个最重要的开放源码的版本，Tcl/Tk8.1，这个版本加进了对Unicode的支持（国际化），线性安全机制（用于多线程服务程序）和一个由Henry Spencer开发的全新的规则表达式包，还有一些类似对Unicode提供支持这样优秀的新功能。Tcl成为第一个满足企业中关键程序各方面要求的脚本语言。
今后，Tcl将会继续开发开放源代码的和进行商业赢利的两种产品，在这种理念下，我们会不断的提升开放源代码的核心部件的性能，改进产品的不足，为免费的和商品化的两种开发工具提供资金支持，我们要做就要做到最好。Tcl社区将一如既往的在Tcl的发展中扮演重要的角色。
ActiveState
这一部分的作者是Jeff Hobbs
Ajuba创建了基于Tcl的企业版的XML类服务应用程序，后来它被Interwoven于2000年10月收购。不过Interwoven对开放源码的软件不感兴趣，他们只关注XML和服务器的相关产品。Jeff Hobbs，前Tcl Scriptics/Tcl的代理人，跳槽到Active State（以发布Perl的产品和开发工具闻名）来领导他们的Tcl技术部。
ActiveState现在提供用于Tcl开发的一系列产品和服务，另外，它也是不断深入开发开放源代码内核的非常活跃的参与者。
Tcl：屡获大奖的软件
1998年春， 我听到了几个令人振奋的消息，Tcl获得了两项重要的奖项。一个是ACM软件系统大奖，奖给每年的“具有长远影响的软件系统”。以往这个奖项的获得者包括许多重要的系统如TCP/IP协议，第一个线性表，第一个关系数据库，因特网，Unix系统，PostScript，Smalltalk。另一个是USENIX软件工具用户组织（STUG）大奖，这个奖项奖给年度优秀的软件工具。
未来的版本
整合性的程序将会继续发展下去，因为越来越多的企业发现他们的竞争力取决于能否使他们的计算机系统有效的协同工作。Tcl为建立这些整合程序提供了非常强大的平台。今后，当那些首席技术官们在设计他们将来的信息系统结构的时候，我相信对整合性的平台的重视，就会像现在对操作系统平台和数据库平台的重视一样，会放在首要考虑的位置。我希望Tcl有一天能成为最重要的整合平台。