Tcl

Tcl (originally from "Tool Command Language", but nonetheless conventionally rendered as "Tcl") is a scripting language created by John Ousterhout that is generally thought to be easy to learn, but powerful in the right hands. It is most commonly used for rapid prototyping, scripted applications, GUIs and testing. The name is commonly pronounced as "tickle". Tcl's features include:

Everything is a command, including language structures.
Everything can be dynamically redefined and overridden.
All data types can be manipulated as strings, including code.
Extremely simple syntactical rules, which everything follows.
Event-driven interface to sockets and files. Time based and user defined events are also possible.
Dynamic scope.
Ready extensibility (with C, C++, Java and Tcl)
Interpreted language, code can be created and modified dynamically.
Full Unicode support
Platform independent (Win32, UNIX, Mac, etc.)
Close integration with windowing (GUI) interface Tk
Easy maintenance of code. Tcl code is often more compact and readable than functionally equivalent code in other languages.

While Tcl itself does not provide an object oriented framework, the language itself can be extended to provide new features as required. Indeed, many C extensions have been written to provide OO functionality, including the XOTcl and incr Tcl packages. Other OO extensions, including Snit, are coded entirely in Tcl.

The most popular Tcl extension is the Tk toolkit, which allows one to write portable graphical user interfaces for a variety of operating systems.

A simple working example, demonstrating event-based handling of a socket, follows.

!/bin/sh
 next line restarts using tclsh in path \\
exec tclsh $0 ${1+"$@"}
 echo server that can handle multiple 
 simultaneous connections.
proc newConnection { sock addr port } {
    
    # client connections will be handled in
    # line-buffered, non-blocking mode
    fconfigure $sock -blocking no -buffering line
    # call handleData when socket is readable
    fileevent $sock readable [ list handleData $sock ]
}

proc handleData { sock } {
    puts $sock [ gets $sock ]
    if { [ eof $sock ] } {
       close $sock
    }
}
 handle all connections to port given
 as argument when server was invoked
 by calling newConnection
set port [ lindex $argv 0 ]
socket -server newConnection $port
 enter the event loop by waiting
 on a dummy variable that is otherwise
 unused.
vwait forever

Another example using Tk (from A simple A/D clock) and timer events, a digital clock in six lines of code:

proc every {ms body} {
    eval $body
    after $ms [list every $ms $body]
}
pack [label .clock -textvar time]
every 1000 {set ::time [clock format [clock sec] -format %H:%M:%S]} ;# RS

External links: