What is Tcl

Difference between version 268 and 272 - Previous - Next
!!!!!!
|[Contents%|%up: Contents]|[What is Tk%|%Next: What is Tk]|
!!!!!!

   ''Every shell attempts to expand until it becomes the system. Those shells that can not so expand are replaced by ones which can.'':   -- Adapted from [http://www.catb.org/jargon/html/Z/Zawinskis-Law.html%|%Zawinski's Law]

    ''The agility you get from having built a system that's fundamentally simple dominates all other kinds of agility ... We can make the same exact software we're making today, with dramatically simpler stuff.  Dramatically simpler languages, tools, techniques, approaches.  Like really radically simpler.'':   -- Rich Hickey, [https://www.youtube.com/watch?v=rI8tNMsozo0%|%Rails Conf 2012 Keynote: Simplicity Matters]

    ''You know - TCL/TK8.6 is insanely great.  I stopped using TCL/wish in about 2004 - this was a BIG mistake - I can now build GUIs in described by pure text.  *Nothing is hidden* it's all text - I just need emacs and make.  Why oh why did I ever even click on a button to start Xcode'':   -- [https://en.wikipedia.org/wiki/Joe_Armstrong_(programmer)%|%Joe Armstrong], [https://twitter.com/joeerl/status/1110126278953312256%|%2019-03-25]


'''What is Tcl?'''
[Tcl], or '''Tool Command Language''', originally by [John Ousterhout], is an 
[license%|%open-source]
 multi-purpose [Tcl C API%|%C library] which includes a 
powerful [dynamic language%|%dynamic] [scripting language%|%scripting 
language].  Together they
 provide ideal cross-platform development environment 
for any programming
 project.  It has served for decades as an essential system 
component in
 organizations ranging from [National Aeronautics and Space
Administration%|%NASA] to [Cisco Systems, Inc.%|%Cisco Systems], is a
 must-know 
language in the fields of [EDA], and powers companies such as
 [COMPANY: 
FlightAware%|%FlightAware] and [COMPANY: F5 Networks].

Tcl is fit for both the smallest and largest programming tasks, obviating the
need to decide whether it is overkill for a given job or whether a system
written in Tcl will scale up as needed.  Wherever a [shell] script might be
used Tcl is a better choice, and entire web ecosystems and mission-critical
control and testing systems have also been written in Tcl.  Tcl excels in all
these roles due to the minimal syntax of the language, the unique programming
paradigm exposed at the script level, and the careful engineering that has gone
into the design of the Tcl internals.

Tcl has all the features needed to rapidly create useful programs in any field
of application, on a wide variety of platforms, and supporting any character
set.  Whatever the platform, Tcl is probably already there.  



** The Library **

Tcl is also a cross-platform [C] library.  If you've been looking into
[http://developer.gnome.org/glib/%|%glib], [http://apr.apache.org/%|%APR],
[http://developer.mozilla.org/en-US/docs/NSPR%|%NSPR], or
[http://qt-project.org%|%qtcore], you might end up using Tcl not for its
scripting capability, but to provide the features you've been looking for in a
truly portable [C] library.

[Tk], the most popular Tcl extension, provides a cross-platform library for
creating [GUI%|%graphical user interfaces].  It has proven over decades to be
the most robust and simple-to-use GUI system, with an easy learning curve as
well.



** The Scripting Language **

The [scripting language%|%scripting language] is simple to learn and fun to
use.  It consists of only three basic elements: A [script] is composed of
[command%|%commands], and a command in turn is composed of [word%|%words].  The
syntax of Tcl is described in just a [Dodekalogue%|%dozen rules%|%].  There are
no reserved words and there is no built-in syntax for [control structure%|%control structures] or conditionals.  Built-in commands provide
facilities that are commonly included as syntactic elements in other languages.
This abstraction is simple enough to get to work with in just a few minutes,
even if one is new to programming, but rich enough to satisfy even the most
demanding software engineers.  No other language caters so adeptly to users at
both ends of the spectrum.  This makes it the ideal language both for learning
the art of programming and for actually getting things done.

Control and branching operations, like everything else in a Tcl program, are
implemented as commands.  For example, `[if]` is a command that in its simplest
form takes a expression and a block of code to be executed
if the condition is true.  A Tcl script could replace `[if]` with its own
implementation.  As with [Lisp], each program written in Tcl essentially
becomes a [domain-specific language] for performing the tasks at hand.  Tcl is
to scripting what [Forth] is to
[http://en.wikipedia.org/wiki/Stack_machine%|%stack machines]:  A
starkly-minimal language that unifies concepts wherever feasible, which
simplifies cognitive load and while achieving maximal flexibility.



** Features **

Tcl provides the wide range of features necessary to write any sort of program,
and in any programming style:

   '''Cross-platform scripting''':   Tcl provides a cross-platform API and handles the details under the hood, making it easy to write a program once and run it, without modification, on [Unix], [Mac OS X%|%OS X], [Android - An Open Handset Alliance Project%|%Android], or [Microsoft Windows%|%Windows] platforms.

   '''Cross-platform [C] [library%|%Tcl Portable Runtime Library]''':   In contrast with [Perl], Tcl's C library is intuitive and a pleasure to use.  Many programmers choose Tcl as their [scripting] language, but others choose it for its C library, which abstracts away the platform-specific details of '''synchronous''' and '''asynchronous I/O operations''', '''mutexes''', '''[ckalloc%|%memory allocation]''', '''[string] formatting''', '''[thread]ing''', '''[Unicode]''', '''[Tcl event loop%|%event loops]''' and '''queues''', '''[notifier%|%event notification]''', '''[DString%|%dynamic strings]''', '''arbitrary precision arithmetic''', '''[hash] tables''', shared object [load%|%loading], and '''[Regular Expressions%|%regular expression]'''.  [Tcl_Obj] object types provide automatic type conversion and are reference-counted for easy cleanup.  Tcl's C library can be particularly advantageous to those interested in learning C, providing a fantastic platform to ease into it, particularly when combined with on-the-fly integration libraries such as [Critcl].

   '''Cross-platform, event-driven, non-blocking I/O''':   [ECMAscript%|%node.js] has recently popularized this programming style, but this I/O model has been a fundamental component of [the Tcl core] for many years.

   '''Text-based computing''':   Tcl's [EIAS%|%everything-is-a-string] model offers a simple approach to programming.  Tcl recognizes that a script is already text and substrings in a script are used directly as values.  The [dodekalogue%|%syntactical rules] allow Tcl scripts to embrace [code is data%|%code as data] and assimilate the best traits of [shell] languages while scaling to larger projects much better.  As a superior alternative to both shell scripts and other general-purpose scripting languages, Tcl is the sole occupant of a certain sweet spot.  [Perl] tried, but came down with a morbid [http://en.wikipedia.org/wiki/Sigil_%28computer_programming%29%|%sigil]-lness.  [Python] didn't catch that disease, but it's too obese as an interacctive shell.  [Lisp] came close, but its [SEXP]'s are needlessly complex compared to Tcl [list%|%lists], its special operators are incongruous compared to Tcl's consistent command syntax, and [Lisp]'s syntactical provision for a list type departs from the text-based computing paradigm.

   '''Explicit [scope%|%Scoping]''':   A pleasant hybrid of dynamic and lexical scoping that maximizes the advantages of both scoping strategies while minimizing the downside.  [proc%|%Procedure] scope is entirely local, and variables in other scopes and namespace are explicitly linked in as needed, resulting in code that makes it clear what is being referenced. 

   '''Composability''':   Like other [functional programming%|%functional] programming languages, Tcl is highly composable.  Each command is a [list] and thus [code generation%|%can be manipulated] in the language itself.

   '''Dynamicity''':   Tcl is one of the most dynamic languages.  Don't want any conditionals in your language?  Just delete the `[if]`, `[for]` and `[while]` commands.  Want to [Playing newLISP%|%modify the body] of the current function mid-execution, or [upvar%|%modify variables] and [uplevel%|%run commands] in other stack frames?  Go right ahead. Using these features, you can easily add [new control structures%|%new control structure] to the language.  In [Python] it isn't possible to dynamically create variables in a local function scope, and the approach is ''don't do that''.  In Tcl it's easy to do, and the approach is, ''You're the expert. You know what you need to do.''
   '''Instrumentation''':   From `[trace]` to `[namespace unknown]`, Tcl provides a variety of built-in mechanisms to react to command execution and variable access.  Whether you're after powerful [debugging] or exotic control flow, you'll find the features you need. 

   '''[data structure%|%Data structures]''':   Tcl provides built-in data structures such as [list%|%lists], [array%|%arrays], and [dict%|%dictionaries], and other data structures are also available via extensions.  [tdom] stands out as an excellent implementation of the [DOM] that provides both [XML] and [JSON] parsers and formatters.  Uniquely, Tcl melds vai an [tcl_obj%|%internal design] which assures that value and structure are isomorphic, both for the purposes of efficiency and conceptual purity.  Thus performance '''[EIAS%|%stringiness]''' at the script level is not a performance issue.

   '''[control structure%|%Control structures]''':   Use built-in [control structure%|%control structures] such as `[if]`, `[while]`, and `[foreach]`, or [New Control Structures%|%write your own] if desired.

   '''TCP/IP [network programming%|%Network programming]''':   [socket], [http], [SSL], [TLS], [PKI], [CGI], and various other modules provide full [network programming%|%network programming] support.

   '''[thread%|%Threading]''':   Tcl's true native [thread%|%threading] module is recognized as [Tcl and threads%|%exceptionally-well-designed] and easy-to-use.  Contrast with [Perl] threads, which are [http://perldoc.perl.org/threads.html%|%officially documented] as "implemented in a way that makes them easy to misuse.  Few people know how to use them correctly or will be able to provide help".  Also contrast with [Python] which [https://docs.python.org/3/c-api/init.html%|%is not fully thread-safe], [Ruby] which is also [http://lucaguidi.com/2014/03/27/thread-safety-with-ruby.html%|%not particularly thread-safe], and [Lua] which [http://www.lua.org/manual/5.2/manual.html#2.1%|%makes no attempt] to expose operating-system threads. 

   '''[Regular expressions]''':   a hybrid DFA/NFA engine written by [Henry Spencer] that achieves better performance than the regular expression engines of [Perl], [Python], [PHP], etc.,

   '''[Unicode]''':   Support for Unicode has been fully-integrated into tcl, whether working with [string]s and [file]s, or matching [regular expressions].

   '''[Encoding] conversions''':   Easily transform text from one encoding to another.

   '''[Binary] data handling''':   [binary scan] and [binary format] make it easy to wrangle bits and work with binary [data format%|%data formats]. 

   '''Numerical computing''':   Tcl provides integers of arbitrary size and floating-point numbers of the C [double] type.

   '''Built-in event loop''':   Unlike [Python] and [Ruby] where facilities for event-driven programming are bolted on ([http://twistedmatrix.com%|%Twisted] and [http://rubyeventmachine.com/%|%EventMachine]) an event loop is built into Tcl, which is distributed with event-handling commands such as [after], [fileevent], [vwait], and [update]. 

   '''Bridge the Value/Reference Divide''':   Because there's no such thing as a reference at the script level, Tcl is free to manage values internally.  A [Copy-On-Write] strategy is built-in to the design of Tcl, so copying huge data structures at the script level is a memory-efficient operation. Tcl only makes real in-memory copies as necessary to ensure program data integrity in the case that one of the logical copies of the data structure is modified.

   '''Cycle-free garbage collection''':   In most languages, cycle-free garbage collection is not used because, despite its advantages, it doesn't play well with references.  In Tcl everything is a string and there are no explicit references at the script level so storage can be and is collected precisely when it becomes unused.

   '''[interp%|%multiple interpreters]''':   Within a single program multiple interpreters can be created, each with its own complete interpreter state.  With multiple interpreters programs can be composed as a set of cooperating programs, but within a single process.

   '''[interp%|%Safe interpreters]''':   Make it possible to create a sandbox where users of an application or web service can run untrusted code.

   '''[VFS%|%Virtual file system]''':   VFS functionality is fully integrated into Tcl's I/O subsystem.  This is a unique feature among programming languages, allowing virtually anything to be expressed in terms of the world's most ubiquitous [user interface]: the filesystem hierarchy.

   '''[reflected channel%|%Reflected channels]''':   Apply the API for working with file streams to just about anything.

   '''[stacked channel%|%Stacked channels]''':   Easily compose channels in order to [transform] content.
   '''Extensibility''':   In Tcl all control structures are implemented as commands and all commands can be replaced by user-defined procedures.  New commands can be written in C, [Fortran], or other languages, and [load%|%loaded] into a running interpreter. 

   '''[embedded%|%Embeddability]''':   Tcl was designed from the start as an embeddable language for use wherever scripting was needed.  It's one of the only mature languages that can be safely embedded in a [threads%|%multi-threaded] application.

   '''Inline C support''':   [critcl] makes it easy to rewrite performance-critical code segments in [C], providing unmatched integration between the two languages.

   '''[OO%|%object system]''':    [TclOO], a framework for composing object systems, and an object system in its own right, is built into Tcl.

   '''Built-in database''':   [SQLIte] was designed from the ground up as a Tcl extension and is distributed together with Tcl.  SQLite is renowned for its ease-of-use and robustness, and using it together with Tcl provides the experience envisioned by its creator. 
   '''[coroutine%|%Coroutines]''':   Each coroutine is a separate execution stack that can [yield%|%put itself into the background] until the active coroutine calls it back.  Coroutines are more powerful than other more limited coroutine implementations such as Python's generators.

   '''[Extensions for Tcl and Tk%|%Additional commands]''':   A large number of projects provide additional commands, including [tcllib], [Plotting data%|%graph plotting] packages, [TDBC%|%database access].


   '''[GUI] toolkit''':   [Tk] was designed for Tcl and works best with Tcl,  It has been adopted far and wide by other languages, but there's nothing like using directly with Tcl.  See [What is Tk].

   '''[tcltest%|%Unit testing]''':   A built-in package for unit testing makes it easy to practice [test-driven development].  It's minimal, flexible, easy to get started with.  It's also the foundation of the [https://core.tcl.tk/tcl/dir?ci=tip&name=tests%|%unit tests] that are distributed with Tcl itself, so there are plenty of examples of both simple and sophisticated use.

   '''Easy Deployment''':   [starkit%|%starkits] and [starpack%|%starpacks] make deploying a Tcl application as easy as downloading a single executable file. 


   '''Computer science in a box''':   Tcl source code is considered to be exemplary for those learning [C]. It provides illustrations of many fundamental and general computer science concepts.  It is meticulously written and the concepts come together in a way which is easy to experiment on from the scripting level and through the [Tcl C API%|%C API].  If you're hardcore, you'll probably get a kick out of Tcl.  If you're new to computer science, you couldn't choose a better platform on which to learn the ropes.



** Strengths **

   ''Domain-Specific Languages'':   What Tcl does better than any other is  provide the components and environment within which to can create a domain-specific language to match the problem at hand.  This will change the way you think about programming.  It isn't about lexing and parsing, but about creating little languages using the syntax of Tcl itself.  It may take some time for the ramifications of this strength to sink in, but the investment pays off.  This technique allows results in code that is more expressive, more readable, and more concise.  Tk is an example. The contrast between using it directly from Tcl and using it through a wrapper like [Tkinter] illustrates the ability to extend Tcl itself into any problem domain.

   ''Security'':   Tcl provides facilities to [interp limit%|%limit resource usage] and [interp create%|%constrain] functionality as needed.

   ''Rapid Development'':   Minimal syntax and powerful commands make it easy draft up working systems, and then later to improve performance by rewritting command in [C] to do the heavy lifting.

   ''Code Reuse'':   Tcl code can be organized into [package%|%packages] for reuse.

   ''Performance'':   Various components of Tcl have been recognized as being best-of-breed.  Two examples are [regular expressions] and Tcl's internal [hash] table.

   ''Multi-paradigm'':   Tcl comfortably integrates styles from various programming paradigms.  [TclOO] can be used for both [class]-based and [prototype pattern in Tcl%|%prototype]-based [object orientation%|%object-oriented] programming. Various other object systems are also available, including [stooop] [incr Tcl], [XOTcl], [snit].  Functional programmers will also find much to like in Tcl.  For an overview of the possibilities [http://wiki.tcl.tk/_/search?S=playing*&_charset_=UTF-8%|%search for `playing*`].

   ''Portable'':   Tcl runs on IBM mainframes and AS/400s, [Windows] NT, 95, 98, ME, XP, [Windows/CE], OS/2, Novell Netware, Cray supercomputers, Digital's VMS, Tandem Guardian, HP MPE/ix, Mac OS, and all flavours of Unix, as well as dozens of smaller operating systems like Acorn RISCOS, Amiga and Atari ST.

[Joe Mistachkin] 2006-06-08:  Based on my previous research (when I had access
to the actual hardware), modern versions of Tcl have not been ported to HP
MPE/ix.  Please correct me if this is inaccurate.

   ''Open Source'':   Anyone may, without charge, download and inspect the source code to Tcl.  Tcl itself is developed and maintained by programmers around the world.

   ''Internationalization and Localization support'':   All values are strings of [Unicode] characters so most existing writing systems can be processed. Converting Unicode from or to just about any encoding is also simple. See [i18n - writing for the world] or [Is Tcl Different!].

   ''Version invariance'':   This one is important, but hard to explain.  Tcl has been maintained in a way that promotes forward- and backward-compatibility at all levels.   The [Stubs%|%stubs] mechanism helps ensure that the compatible versions of a commands are made available, even when different versions of Tcl load the same file.  This turns out to be enormously beneficial daily work.



** Quotes **

   ''I stick with Tcl because it gets the job done faster and more maintainably than anything else I use... to quote Bryan Oakley, "I prefer to pick my tools by what they can do, not by how popular they are"'':   [Steve Landers], [Tcl Chatroom], 2014-05-09

   ''Tcl is not so much a programming language in the traditional sense. It is a set of primitives to pass data and control execution scope.'':   [John Roll]

   ''And these things are more than just convenience.  The simpler notation means that the task to be done isn't obscured by the mechanism of doing it.  Since our limit on what we can program is mostly the limit of what we can understand, with the simplicity comes power.  Abstraction wins.'':   [KBK%|%Kevin Kenny], [Tcl Chatroom], 2013-09-30

   ''Duck typing tends to make type errors less damaging, and a good dynamic language makes test-first development more practicable.'':   [KBK%|%Kevin Kenny], [Tcl Chatroom], 2013-09-30

   ''One aspect of [EIAS] that is worth consideration is how it has kept Tcl "pure" in some sense. Part of [EIAS] that is little mentioned is that Tcl's strings are ''immutable''. This means that Tcl's value space is purely [functional programming%|%functional], in the [Haskell] sense. All side-effects are confined to the shadow world of commands and variables and other second-class entities. What this means is that Tcl now possesses some very powerful purely functional data-structures that are somewhat better than those available in other languages. For instance, I cannot think of another popular language that supplies O(1) purely functional dictionaries and lists (arrays) out of the box (or even in the library). Not to mention efficient unicode and binary strings'':    [NEM], [EIAS] 2010-12-15



** [Who Uses Tcl] **

see [Who Uses Tcl]



** Testimonials **

   ''If this isn't a testimonial to Tcl's prowess, I don't know what is.'':   [myvzw.com and Tcl]

   ''IMHO the Tcl event loop is much easier to use than twisted, although the python twisted code has some really nice features (deferred values) and a good framework for writing specific things like network servers.'':   [Michael Schlenker], ''Tcl Event Loop and Threading'', [comp.lang.tcl], 2007-03-26


** Case Studies **


[Ulrich Albrecht]:  One more story, same implication: A couple of years ago I
was working at the technical university of Aachen (Germany) on a robot
simulation and path-planning system, including fast collision detection.  The
core functionality was included in a C++ class hierarchy describing robot parts
and kinematics, with a lot of C libraries from other sources mixed in. The code
was to perform on a real robot controller (a PPC-machine running vxworks), SGI
Irix (MIPS), Sun Solaris (SPARC), Linux (Intel) and eventually MS Windows
(Intel), so we could not include any platform specific stuff. With the
exception of vxworks though - where the real thing was moving - we thought we
should have a GUI with a virtualization and visualization of the robot and its
environment. Tcl/Tk looked good, because it was the only package that was as
portable, flexible and extensible as we needed. I wrote an OpenGL-widget for Tk
and a Tcl-to-C++ command-wrapper for every C++ class I needed to construct and
control at runtime, and ended up with a robotics-enabled wish I could feed all
kinds of scenarios and interact with. I can really say that 1. portability was
not a big issue, because the core C/C++-libraries were OS-independent and
Tcl/Tk as well as OpenGL were properly ported, 2. performance wasn't either,
because the critical parts were nice, dirty compiled C/C++, 3.  usability was
very good because of the robust interactive Tcl-interpreter we could use for
free, 4. the Tk-part performed and looked a lot better and more OS-consistent
than anything I've since seen in Java...

We even run this stuff in MS Internet Explorer (using the Tk-Plugin) for
demonstration purposes.

Nearly forgot: Porting the '''code''' to MS Windows was not the problem - it
was the '''makefiles''' that nearly drove us mad.


** [Tcl heritage%|%Heritage] **

See [Tcl heritage]

Tcl was originally developed as a reusable [command] language for experimental
computer-aided design ([CAD]) tools.  The [interpreter] was implemented as a
[C] library that could be linked into any application.  Because it is
'''very''' easy to add new functions to the Tcl interpreter, it is an ideal
embeddable scripting language.  (See [Tcl Chronology] for more history.)

Tcl could be roughly described as a cross-breed between the following:

   [LISP]/[Scheme]:   But with fewer kinship.
   [C]:   But not as low-level and numerocentric.
   [shell%|%shells]:   But designed to be more versatile and maintainable.


Tcl is a [homoiconic] language whose design was motiviated by the idea that
there would be as little core syntax as possible with as many other needed
facilities as possible implemented as commands.  Fundamentally, Tcl is nothing
but a script parser, a substitution engine, and a command dispatcher.

(See [Tcl heritage] for more ancestry.)



** About Tcl Scripts **

Tcl programs are sometimes called "[script%|%scripts]" because one design goal
of Tcl is to be used as [scripting language] within a larger system, but Tcl
includes features such as byte-compilation and extensibility, which make it
suitable for writing original systems in themselves.  Also, available
components such as [expect], [twapi], [Tclx], [tls], and others make Tcl a good
language for assembling larger systems from diverse pieces.



** Components and Subsystems **

   [Tcl event loop%|%event loop]:   

   [Tcl Core IO System%|%I/O]:   

   [NRE%|%non-recursive engine] (NRE):   Tcl is stackless since version 8.6



** Various Tcl Interpreters **

Many people are first introduced to Tcl as a component of another system.  Here are some examples:

   [Expect]:   A tool for automating interactive systems via their standard streams.
   
   [Cisco IOS]:   The shell provided in Cisco network equipment. 

   [tclsh]:   a stand-alone interpreter that's included with Tcl

   [wish]:   a Tcl interpreter with the Tk [extension] pre-loaded.   It is part of [Tk].

   [tclkit]:   an all-in-one-file combination of Tcl, Tk, [Metakit], [Itcl], [tclvfs] and a few other extensions. It is used for code in [starkit] format.

   [expect]:   a Tcl interpreter with the expect extension pre-loaded.  It is created when building expect.

   tcl and wishx:   commands that are included with [Tclx]

   itclsh:   tclsh that pre-loads [Itcl]

   tixwish:   included with [Tix]

   bltsh and bltwish:   included with [BLT]

   tcldomsh:   included with [TclDOM]

   ''xotclsh''' and '''xowish''':   included with [XOTcl]

As of Tcl 8.4, the only interpreters that you really need to think about are
'''tclsh''', '''tclkit''', and (on some platforms) '''wish''', as Tcl provides
the ability to dynamically load any of the other extensions during runtime.  In
fact, many of the extensions have been dropping the building and installing of
custom executables due to this.

Tcl is a weakly-typed [dynamic language].  In Tcl, [everything is a string],
but that fact just scratches the surface.

Tcl semantics allows code to be seen as data, as with [Lisp] (see [code is
data]).



** See Also **

   [Tcl]:   

   [How Tcl is special]:   

   [Is Tcl Different!]:    

   [How did you discover TCL/TK]:   

   [The Tcl Way]:   

   [The Tao of Tcl]:   

   [The Tcler's Wiki]:   

   [On What Platforms Does Tcl Run]?:    

   [Quality of source code]:   Anecdotes about the design, engineering, and organization of Tcl. 

   [How do you say 'Tcl'%|%How do you say "Tcl"]?:   

   [How much of Tcl is Fluff?]:   

   [Tcl advocacy]:   

   [Tcl and other languages]:   



** Further Reading **

   [http://lukeplant.me.uk/blog/posts/less-powerful-languages/%|%We need less powerful languages], [http://lukeplant.me.uk/%|%Luke Plant], 2015-11-14:   
   



** Discussion regarding this page **

*** Tcl and Just in Time (JIT) ? ***

[slebetman]: Does Tcl really do JIT? When was it/will it be introduced? 8.5?
8.6?

[NEM]: No. Certainly not JIT in the sense of compiling to native code. It
compiles to byte-code on-demand, which could be seen as "just in time", but JIT
usually means native.

[DKF]: We've talked (usually at [Tcl Conferences%|%conferences%|%] after a few
beers) about doing JIT, and the key problem is that it takes quite a lot of
development effort to do and would (potentially, depending on details) need to
be re-implemented for every architecture that Tcl supports. On the other hand,
doing just x86 would handle a very large fraction of what's actually
deployed...

[FB]: A plausible solution would be to use [LLVM] as an intermediary target
instead of the current bytecode format. Then LLVM would JIT-compile to the
native architecture using its available backends (it can also degrade
gracefully to interpreter mode). But it likely involves a lot of work.

[Sarnold]: Actually that's what [Jacl] does by compiling commands to Java bytecode
that the [JVM] can [JIT]-compile. A similar thing could be achieved using a [.NET]
implementation.

What are the advantages of LLVM over JVM/.NET ? (apart from giving more
performance and integration with C code, which are already known) Wouldn't it
be overkill to write a JIT-compiling Tcl from scratch for LLVM, since both Tcl
implementations exist for the JVM and .NET/Mono? 

[FB]: I thought that Jacl was only an interpreter, but you're right since it now
includes the [TJC compiler]. From what I know, the most interesting features of
LLVM are global and runtime optimizations, and a runtime compiler architecture
that can be used to provide [Critcl]-like features. Very interesting given the
glue nature of Tcl. Starting from TJC to build a LLVM-based compiler might give
a head start.

!!!!!!
|[Contents%|%up: Contents]|[What is Tk%|%Next: What is Tk]|
!!!!!!
<<categories>> Language | Documentation | TOC