Tool Command Language
Page d'aide sur l'homonymie Pour les articles homonymes, voir Tcl.
Tcl
Tcl.svg

Apparu en 1988
Auteur John Ousterhout
Développeurs Tcl Core Team et al.
Dernière version 8.5.11 (4 novembre 2011) [+/−]
Paradigmes Impératif, fonctionnel, objet, événementiel
Typage dynamique (tout est chaîne de caractères)
Influencé par C, Lisp, Shell, Awk, SCL
A influencé Python, PowerShell
Implémentations TCL, Jacl, Jim, Hecl
Système d'exploitation Multi-plateforme
Licence BSD
Site web http://www.tcl.tk/

Tool Command Language (abréviation : Tcl) est un langage de script initialement conçu en 1988 par John Ousterhout et son équipe à l'université de Berkeley. Il s'inspire principalement des langages C, Lisp, Shell et Awk. Ce langage à typage dynamique est multi-plateformes, extensible, facile à apprendre et repose sur douze règles syntaxiques. Tcl s'interface très aisément avec le langage C, ce qui lui permet de servir par exemple d'interprète embarqué dans des applications.

En 1990, John Ousterhout développe une extension pour Tcl appelée Tk qui est une bibliothèque pour créer des interfaces graphiques portables. Par la suite, le développement de Tk était suffisamment découplé de celui de Tcl pour être utilisé avec d'autres langages. Cependant la combinaison de Tcl et Tk reste connue comme langage sous le nom de Tcl-Tk ou Tcl/Tk.

Tcl-Tk fait partie des langages de programmation ayant la propriété d'homoiconicité comme pour le Lisp. Nombre d'informaticiens prononcent « Tiqueul » en parlant de Tcl, qui signifie chatouiller en anglais (tickle). Tk est prononcé « ticket ».

Sommaire

Caractéristiques

Réputé économe en mémoire vive[réf. souhaitée], Tcl est un langage interprété multi-plateforme.

L’un des mots d’ordre du langage est résumé sous la forme de tout est une chaîne de caractères (traduction littérale de everything is a string) : même le code définissant une procédure peut être manipulé comme une chaîne.

Par ailleurs, tout au sein du langage est une commande : même les instructions comme if ou while sont des commandes, et ne relèvent aucunement de la syntaxe du langage. Toutes les commandes, (y compris l'affectation de variables) peuvent être surchargées.

Les expressions mathématiques sont évaluées par une commande spéciale, avec une syntaxe inspirée du C.

Les listes imbriquées sont l'un des types de base du langage, et permettent une programmation fonctionnelle très concise. La syntaxe devient alors proche de la notation préfixée.

L'introspection de l'interprète permet d'accéder à toute la pile d'exécution, et d'exécuter des commandes à un niveau supérieur (dans la pile).

Il est possible de définir des actions à déclencher sur la lecture ou écriture d'une variable, ainsi que sur l'appel d'une procédure.

Le langage permet également de définir de nouvelles structures de contrôle (do .. until par exemple) en quelques lignes.

Les chaînes de caractères respectent la norme Unicode, et des commandes permettent de convertir des chaînes entre différents codages.

Les sockets multi-plateformes sont gérés, aussi bien côté client que côté serveur.

Tcl permet la recherche et substitution d'expressions rationnelles.

L’intégration aisée de code natif C, C++ et Java est possible.

Bien qu’aucune programmation orientée objet n’existe dans le cœur du langage, de nombreuses extensions permettent cette approche, même sans ajouter de code natif.

A noter que depuis TCL 8.6 (encore en Beta), une de ces extensions est implémentée au package de base, apportant ainsi une gestion de la POO en natif.

Description

Tcl est facile à apprendre, surtout pour un habitué du langage C ou quelqu'un qui connaît un shell. Bien que la syntaxe semble dans un premier abord assez similaire au C, en vérité elle est beaucoup plus simple. Le langage a également des aspects communs avec Lisp et Forth. Il permet de développer très rapidement des logiciels de petite ou moyenne taille. De plus, il est facile d'intégrer différents autres logiciels avec une IHM en Tcl/Tk.

Tcl est surtout connu pour son extension graphique Tk. Tcl/Tk permet de concevoir des applications fenêtrées indépendamment de la plateforme (UNIX / Mac OS / Windows) à la manière du langage Java.

Tcl étant un langage interprété, le développement d'un programme est rapide et peut s'effectuer par touches successives. Cette méthode de travail correspond à un cycle de développement en cascade.

Tcl facilite l'accès aux fonctions de son interprète, ce qui contribue à la puissance du langage et le place à mi-chemin entre un langage fonctionnel comme Lisp et un langage impératif comme BASIC.

Tcl est intégré ou embarqué avec de nombreuses applications grâce à sa syntaxe simple (par exemple, Oracle). L'une de ses forces est la réalisation aisée d'une suite de tests unitaires pour une application donnée. La réalisation aisée de tests de validation rend le développement incrémental très facile (à la manière de Forth).

Syntaxe et sémantique

La syntaxe suit le modèle d'un shell, avec quelques simplifications par rapport à des langages comme perl ou ksh. Un script de Tcl contient une ou plusieurs commandes. Une commande se compose de un ou plusieurs mots, qui sont séparés par des espaces.

mot0 mot1 mot2 mot3 ... motN
  • Les "" servent à grouper plusieurs mots, et ils seront considérés comme un seul mot (s'il y a des références parmi ces mots ils seront interprétés (substitués)).
  • Les {} peuvent jouer le même rôle (sans interprétation des variables) sauf dans certains cas.
  • Les [] délimitent des appels de fonctions dont on veut connaître le résultat.
  • Les () indiquent les indices des tableaux T(38) est l'équivalent de T[38] en langage C. Elles peuvent aussi permettre d'ordonner les calculs dans le cas d'expressions mathématiques.

Le premier mot est le nom de la commande. Les mots suivants sont les paramètres.

nomDeLaCommande par1 par2 par3 ...parN

Au lieu d'un paramètre, on peut mettre entre crochets [ ... ] une autre commande. Celle-ci est interprétée en premier et le résultat devient le paramètre de la commande supérieure. Entre accolades { ... } on peut mettre comme paramètre une séquence de mots qui n'est pas interprétée, mais utilisée directement. Les transferts de paramètres se font par valeur. La transmission par référence se fait sans mettre $ devant le nom de la variable, et par la commande upvar dans le corps de la procédure appelée. Les constantes ou chaînes de caractères sont indiquées telles quelles. Les commentaires s'écrivent après la commande # (qui est une commande comme les autres mais qui ne fait rien).

L'affectation se fait par l'instruction set, qui au passage retourne la valeur.

% set a 38
38

La valeur d'une variable s'obtient par [set a]. Remarquons que $a n'est qu'un raccourci d'écriture de [set a].

D'autres exemples de syntaxe :

% set s [Somme $a 38]; # a, transmis par valeur, ne peut être modifié
...
% MiseAjour listeA $x $y; # listeA, transmis par référence, est modifié par MiseAJour
...

La notation usuelle x=f(y) s'écrit en Tcl set x [f $y].

Type des variables

Généralités

Les variables ne sont pas typées explicitement. On peut néanmoins en définir cinq :

  • Les booléens : 0/false/no/n/off (faux) d'une part et 1/true/yes/y/on/ (vrai) ou un nombre différent de 0 d'autre part ;
  • les nombres : 1 0 3.14 1.e-10 ;
  • les chaînes de caractères : Bonjour, "Madame De Labas", 32 , {z 3.14} ;
  • les listes : de booléens, nombres, chaînes ou listes (on peut imbriquer les listes) ;
  • les tableaux associatifs : T(clef) M(2,3) qui peuvent contenir les 4 types précédents, même mélangés.

Les quatre premiers types sont dits types scalaires, ils peuvent donc être passés par valeur et retournés à l'appel d'une procédure. Ces types scalaires sont convertis automatiquement dans le type adéquat, par exemple, une chaîne de caractères peut devenir une liste :

% set fruits abricot
% puts $fruits
  abricot
% set fruits "pomme orange banane"
% puts [lindex $fruits end]
  banane

Une fonction peut retourner une chaîne ou une liste, mais pas un tableau qui n'est pas une variable scalaire. Ceux-ci peuvent toutefois être transmis par référence. Les dictionnaires (nouveauté de la version 8.5) sont un nouveau type scalaire, pouvant donc être fournis comme paramètre d'une procédure, et même retournés.

Booléens

% foreach bool [list 0 1 2 false true no yes n y] {if $bool {puts "$bool => true"} else {puts "$bool => false"}}
0 => false
1 => true
2 => true
false => false
true => true
no => false
yes => true
n => false
y => true

Nombres

Les nombres sont traités comme des chaînes de caractères sauf dans les expressions arithmétiques où ils sont d'abord convertis en binaire.

Tableaux associatifs

Les tableaux associatifs clé-valeur implémentent un type table de hachage sont très rapides et peuvent être très grands. Une clé, indice du tableau, peut être une chaîne de caractères ou une liste, sans limite de taille. On peut, par exemple, utiliser un texte de 10000 lignes comme clé.

Structures de contrôle

Contrairement à ce qui se passe pour d'autres langages, les mots qui servent aux structures de contrôles en Tcl ne sont pas des mots réservés avec une syntaxe spéciale. "for", "if", "while" sont des procédures qui obéissent à la syntaxe Tcl habituelle.

  while { uneExpressionLogique }   { 
      uneCommande
      uneCommande
      ....
  }
 
  if {$x<0} {
     set x 0
  } elseif { $x<5 } {
     set x 5
  } else {
     set x 10
  }
 
  for {set i 0} {$i<10} {incr i} { 
      puts $i 
  }
 
  foreach i [list "youpii" "aujourd'hui" "il fait beau" "bravo !" "bravo !"] {
      puts $i
  }
 
  foreach a $listeA  b $listeB  c $listeC {
      puts "$a $b $c"
  }
 
  foreach {x y} [list M Gaston Mlle Jeanne  M Robert Mme Raymonde] {
      puts "$x $y"
  }
 
  set couleur bleu
  switch $couleur {
    rouge { puts "FF0000" }
    bleu  { puts "0000FF" }
    vert  { puts "00FF00" }
    blanc { puts "FFFFFF" }
    noir  { puts "000000" }
    default { puts "inconnu" }
  }

Exemples

proc ! x {expr {$x<2? 1: $x*[! [incr x -1]]}}
  • Faire la somme d'une liste de nombres

Avec une boucle foreach parcourant la liste :

set nombres {10 9 8 7 6 5 4 3 2 1}
set somme 0
foreach i $nombres { 
   set somme [expr {$somme + $i}]
}

Ou en plus compact en utilisant la commande join :

set somme [expr [join $nombres +]]

Remarquons qu'un opérateur est un caractère comme un autre, il peut donc être stocké dans une variable :

foreach op {+ * - /} {
   set resultat [expr [join $nombres $op]]
   puts "Le résultat pour l'opérateur $op vaut $resultat"
}
  • Substituer des caractères selon une table de correspondance avec la commande string :
set sequence "ACGTATTACGGTCCATGAACGAATTGGGATATCGACCATGATGGAATTCTG"
puts [string map {GA R TC Y GT K AC M GC S AT W} $sequence]

Ensuite donner la fréquence d'apparition des lettres (A, C, T, G) dans la séquence en utilisant un tableau associatif (array), la commande split pour isoler chaque motif et la commande d'introspection (info) de l'interprète :

foreach nucleotide [split $sequence ""] {
   if ![info exists compte($nucleotide)] {
     set compte($nucleotide) 1
   } else {incr compte($nucleotide)}
}
 
foreach nucleotide [array names compte] {
   puts "$nucleotide -> $compte($nucleotide)"
}
  • Télécharger une page HTML
package require http
puts [http::data [http::geturl http://mini.net/tcl/540]]

Difficultés et pièges

Tcl est un langage extrêmement simple, et très puissant. C'est précisément ce qui lui permet d'exécuter du code qu'un compilateur, ou un autre interpréteur refuserait... et de donner un résultat bien différent de celui auquel le développeur s'attendait. Les sites consacrés au développement sous Tcl [réf. souhaitée] donnent des conseils aux développeurs débutants pour qu'ils prennent de bonnes habitudes.

Noms de variable et littéraux

Se souvenir qu'un nom de variable ne s'écrit pas différemment d'un littéral.

% puts x
  x
% set x a
  a
% puts "x $x"
  x a
% puts 0
  0
% set 0 1
  1
% puts $0
  1

Substitutions

Les substitutions peuvent donner des résultats surprenants.

% set x 1
  1
% set y x
  x
% set $y 2; #Equivaut à set x 2
  2
% puts $x
  2

Il n'y a pas de différence entre le code et les données, en ce sens qu'une chaîne de caractères quelconque peut devenir du code. Là encore, attention au jeu des substitutions.

set i 0;
set cond1 "$i<5"; #! Attention, cond1 est déjà égal à la chaîne "0<5" 
set cond2 {$i<5}; #! Ici, il n'y a pas de substitution, cond2 est égal à "$i<5"
set incre {set i [expr $i+1]; puts $i}
while $cond2 $incre; # Cette boucle s'exécute 5 fois.
set i 0;
while $cond1 $incre; # Cette boucle ne se termine jamais.

Déploiement et exécution

Classique

Sous Linux et les autres plateformes dérivées d'Unix, l'interprète Tcl-Tk est souvent installé par défaut. Si ce n'est pas le cas, il est nécessaire de compiler les codes sources à l'aide d'un compilateur C et ensuite de procéder à l'installation. L'exécution d'un code Tcl s'effectue en saisissant au prompt du shell:

tclsh fichier.tcl

Ou alors en lançant l'interprète via tclsh et ensuite en saisissant au prompt de l'interprète la ligne suivante:

source fichier.tcl

Cependant un script Tcl peut s'exécuter directement (un peu comme un script shell) en ajoutant la ligne suivante au début du code:

#!/usr/bin/env tclsh

Sous Windows, il est bien sûr possible de compiler les codes source mais la meilleure option demeure quand même l'installation de Tcl-Tk à partir d'un distribution précompilée. Pour exécuter un code Tcl, il suffira de double-cliquer sur celui-ci. À la différence d'Unix, il n'y a pas de console d'ouverte par défaut sous Windows. Autrement dit si vous exécutez un code Tcl en imprimant des résultats sur la sortie standard, rien ne s'affichera. Il faut ajouter au préalable la ligne suivante en début de code:

console show

On peut aussi utiliser l'interprète wish qui gère en plus le toolkit Tk.

Starkit

Starkit[1]est l'acronyme de "StandAlone Runtime called Tclkit". C'est un mécanisme qui consiste à regrouper dans un seul fichier tous les éléments qui composent une application Tcl-Tk (sources, images, bibliothèques, extensions, ...) avec la structure dans une sorte de système de fichier virtuel. Le fichier starkit obtenu, portant l'extension .kit, est exécuté par l'intermédiaire de Tclkit, un interprète Tcl-Tk est disponible pour toutes les plateformes cibles. En termes de déploiement cela signifie qu'il y a en tout et pour tout que deux fichiers à copier sur le disque: l'interprète Tclkit + le starkit. Nul besoin d'installer Tcl-Tk. Remarquons qu'un starkit peut être exécuté par un interprète classique (tclsh, wish).

Starpack

Le Starpack[2] est un exécutable dans lequel est incorporé les codes source d'une application sous la forme d'un starkit avec un interprète Tcl-Tk. En termes de déploiement cela signifie simplement qu'il n'y a qu'un seul fichier. Son installation consiste à le copier sur le disque et sa désinstallation consiste à le supprimer du disque. À la différence du starkit, le starpack est spécifique à la plateforme cible. Encore une fois, nul besoin d'installer Tcl-Tk.

Programmation orientée objet

Tcl ne dispose pas nativement de la programmation orientée objet. L'inclusion de la POO dans le noyau de Tcl est d'ailleurs un sujet de discussion récurrent au sein de la communauté des utilisateurs de ce langage. Les avis sont partagés principalement pour trois raisons:

  • la POO n'est pas le seul paradigme adaptable
  • une volonté de conserver un noyau compact
  • les diverses adaptations possibles des concepts objets

Pour cette dernière raison, Tcl a accès à plusieurs extensions objets.

Extension Mise en œuvre Description du modèle
XOTcl C Définition dynamique des classes, métaclasses et des méthodes avec instrospection. Héritage simple et multiple. Agrégation dynamique d'objets, classes imbriquées, mixins, filtre conditionnel, slots. Influencé par CLOS, Smalltalk et Self.
incr Tcl C Calqué sur le modèle objet du C++. Héritage multiple. Classes privées et publiques.
OTcl C Définition dynamique des classes, méta-classes et des méthodes avec instrospection. Héritage simple et multiple. Influencé par CLOS, Smalltalk et Self.
Snit Tcl Modèle basé sur la délégation au lieu de l'héritage
STOOP Tcl Proche du modèle objet du C++. Switch class.

Plateformes

Tcl est disponible pour la plupart des plateformes utilisées couramment. C'est-à-dire Windows CE/PocketPC/9x/NT/2000/XP/Vista/7, Mac OS 7/8/9/X ainsi que les plateformes dérivées d'UNIX telles que Linux, Android, BSD, AIX, HP-UX, IRIX, Solaris, OS/400, LynxOS et QNX.

De par son ancienneté, Tcl existe dans des versions antérieures plus rares pour des systèmes d'exploitation comme VMS, OS/2, Ultrix, SCO Openserver, OS-9, Unicos.

Distributions

L'installation de Tcl peut se faire en compilant les codes sources sur la plateforme cible. Cependant il existe des distributions binaires qui ont l'avantage de proposer en plus du langage des extensions pré-compilées.

ActiveTcl[3] 
ActiveTcl est la distribution la plus complète de Tcl/Tk. Elle est proposée par la société Activestate et livrée avec de nombreuses extensions précompilées et des bibliothèques. Il existe des versions pour Windows, Mac OS X, Linux, Solaris, AIX et HP-UX.
WinTclTk[4] 
WinTclTk est une distribution de Tcl-Tk uniquement pour Windows accompagnée d'extensions précompilées (dont certaines spécifiques à Windows), de bibliothèques et d'utilitaires.
eTcl[5] 
eTcl est une distribution française qui se présente sous la forme d'un seul exécutable. Elle est destinée en particulier aux PDA et aux appareils mobiles (Windows CE/Pocket PC/Windows Mobile/Android). Cependant, elle fonctionne aussi sur les plateformes Windows, Mac OS X et Linux. eTcl est très compact et comprend, en plus de Tcl-Tk, des extensions telles que SQLite ou un compilateur C autonome à la volée.
Wize[6] 
Wize (Wish Integrated Zip Executable) est une distribution se pilotant à partir d'un environnement de développement intégré et incorporant un système de fichier basé sur le format ZIP. Il dispose de SQLite, d'un compilateur de bytecode, de la gestion du son, des graphismes 3D et des fenêtres non-rectangulaires. Il existe des versions pour Windows et Linux.

La plupart des distributions Linux proposent par défaut une installation de base de Tcl-Tk, voire parfois les extensions qui vont avec. Pour se rendre compte de la présence de Tcl sous Linux, il suffit de saisir sur la ligne de commande: tclsh. Excepté dans le cas d'implémentations spécifiques Tcl est toujours distribué avec Tk, formant ainsi le langage Tcl-Tk.

Implémentations spécifiques

Jacl[7] 
Jacl est une implémentation de Tcl écrite entièrement en Java qui permet d'embarquer

un langage de script dans une application Java.

Jim[8] 
Jim est une implémentation de Tcl qui inclut un sous-ensemble des commandes de la version

officielle de Tcl plus des fonctionnalités spécifiques comme le dictionnaire, la clôture, les fonctions anonymes (lambda). Cet interprète tient dans seulement 85Ko.

Tcljs[9] 
Tcljs est une implémentation de Tcl écrite entièrement en JavaScript qui permet

d'embarquer Tcl dans un navigateur compatible.

Hecl[10] 
Hecl est un langage de script dont la syntaxe dérive de Tcl. Il est destiné aux téléphones

mobiles qui supportent une plateforme Java compatible J2ME.

NaTcl[11] 
NaTcl est une implémentation de Tcl permettant d'exécuter des scripts Tcl dans le navigateur Google Chrome ou dans des programmes compatibles avec la technologie Native Client (NaCl). Il permet de développer des applications Web avec Tcl et aussi d'accéder et de manipuler le contenu DOM de Chrome.

Bibliothèque standard

Tcl dispose d'une bibliothèque standard appelée Tcllib (le pendant pour Tk étant la Tklib) exclusivement écrite en Tcl. Elle contient 37 modules utilitaires couvrant une large gamme de domaines: protocoles de communication, cryptage, gestion de fichiers, structures de données, calcul numérique et mathématique, grammaire, terminaux, documentation automatique et utilitaires de texte.

Exemples:

# Opérateur somme
namespace import ::tcl::mathop::*
puts [+ 1 2 3 4 5 6 7 8 9 10]
 
# Maximum 
namespace import ::tcl::mathfunc::max
max 4 2 3 7 5 6 -42
 
# Cryptage RC4
namespace import ::tcl::rc4::*
set crypt [rc4 -key Secret "Hello, World!"]

Internet et réseaux

Tcl Plugin et les tclets

Le Tcl Plugin est un plugin qui permet d'exécuter des tclets (applets écrits en Tcl-Tk) dans un navigateur Web. Ce dernier interprète une application Tcl-Tk dans un environnement sécurisé appelé Safe-Tcl qui garantit l'intégrité de l'application hôte (le navigateur dans ce cas).

Serveurs web

Comme la plupart des langages de script Tcl a vocation à être exécuté à partir d'un serveur HTTP.

  • Tclhttpd

Tclhttpd est un serveur web léger écrit uniquement en Tcl. Il a l'avantage d'être extensible à souhait et multi-plateforme. Il peut servir de base à l'écriture d'un serveur d'application ou être embarqué pour gérer par exemple un système d'aide en ligne ou un moteur de recherche sur CD-ROM.

  • Apache, mod_tcl, Rivet et Websh

À partir du serveur HTTP Apache plusieurs options sont disponibles. Il y a tout d'abord le module mod_tcl qui se contente d'embarquer un interprète Tcl. Et ensuite les modules Rivet et Websh qui sont plus élaborés avec la prise en charge de la gestion des bases de données et des systèmes de templates.

  • AOLserver

AOLserver est un serveur web open source développé par la société AOL qui embarque un interprète Tcl. Il est multithread, extensible, utilisable à grande échelle et gère les pages web statiques et dynamiques. Il intègre un support complet des bases de données.

Système de gestion de contenu

Le système de gestion de contenu le plus connu basé sur Tcl est OpenACS (Open Architecture Community System). Il s'appuie sur le serveur web AOLserver et supporte les bases de données Oracle et PostgreSQL. OpenACS est utilisé pour concevoir de sites web collaboratifs, des sites de commerce en ligne, des PGI ou des systèmes d'apprentissage en ligne (e-learning) comme .LRN ou dotFolio.

Expect

Expect est un outil basé sur Tcl-Tk pour automatiser les applications interactives telles que telnet, ftp fsck, rlogin, rsh ou ssh, ou pour automatiser des tests. Il est utilisé par exemple pour l'administration système.

Organisation et aspects communautaires

Développement de Tcl-Tk

Le développement de Tcl-Tk est assuré par de nombreuses personnes qui apportent leurs contributions sous la forme de nouvelles fonctionnalités, de patches, de rapports de bogues ou de documentations. Pour fédérer cet effort de développement, a été créé en 2000 le TCT (Tcl Core Team). Le TCT est constitué d'un collège de 12 experts, dont John Ousterhout ne fait plus partie. Son activité est coordonnée par l'intermédiaire de TIPs (Tcl Improvement Proposals). Le TIP est un document qui décrit un projet d'amélioration de Tcl. N'importe qui peut écrire un TIP et le soumettre au TCT pour discussion et approbation lors d'un vote. Un site rassemble tous les TIPs et renseigne sur leur état d'avancement.

Pour ce qui est de la partie opérationnelle le développement collaboratif de Tcl-Tk est hébergé sur SourceForge.

Ressources communautaires

L'activité d'échange et de communication entre utilisateurs se concentre essentiellement sur le wiki et le groupe de discussion. Les wikis les plus actifs sont le wiki anglophone et francophone. Il en est de même pour les groupes de discussion sur Usenet avec comp.lang.tcl et fr.comp.lang.tcl. Un chat permanent est organisé en anglais.

A cela vient s'ajouter le site officiel de Tcl-Tk et les portails allemand, russe, chinois, coréen et japonais.

Une conférence annuelle a lieu aux États-Unis où sont présentés des cas d'utilisation de Tcl-Tk dans l'industrie par différents intervenants. C'est par ailleurs l'occasion de faire le point sur la feuille de route du langage. Dans la même année une conférence européenne (EuroTcl) se tient en Allemagne ou en France selon le même principe.

Des groupes d'utilisateurs existent aux États-Unis, Canada, Allemagne, Pays-Bas, Danemark, Angleterre et Corée.

Histoire de Tcl-Tk

L'idée du langage Tcl est venue au Docteur John K. Ousterhout de ses travaux sur les outils logiciels d'aide à la conception de circuits intégrés à l'Université de Berkeley en Californie au début des années 1980. John Ousterhout et ses étudiants avaient développé quelques outils interactifs. Ils étaient tous dotés d'un langage de commande différent ce qui finissait par rendre compliqué l'enchaînement des tâches.

En 1987, bénéficiant d'un congé sabbatique au Laboratoire de Recherche de Digital Equipment Corp., John Ousterhout se décida à harmoniser les différents langages de commande en créant un langage unique pour contrôler les applications. C'est ainsi que naquit Tcl (Tool Command Language) avec une syntaxe influencée par les langages C, Lisp, Shell et Awk. Les premiers tests furent effectués sur une station DEC 3100 et une station SUN-3/75. Tcl représentait alors 7000 lignes de code en C dont la moitié était des commentaires. Il ne fonctionnait que sur les systèmes UNIX.

Les objectifs primordiaux de ce langage interprété étaient les suivants:

  • Facile à apprendre et générique
  • Extensible
  • Pouvant être embarqué ou faire le lien avec des applications

Tcl commença à être distribué lors d'une conférence industrielle à l'Université de Berkeley en 1989. En mars 1990, John Ousterhout présenta un article sur Tcl à la Conférence USENIX. À la suite de nombreuses demandes, il mit à disposition librement les sources de Tcl2.1 sur le serveur FTP de l'université. Ceux-ci ne tardèrent pas à être copiés sur les autres serveurs FTP de par le monde. Parmi les personnes qui assistaient à cette conférence était présent un certain Don Libes du NIST (National Institute of Standards and Technology). Celui-ci étudiait une application pour automatiser des tâches sous UNIX et son travail n'avançait pas assez vite. Il comprit tout de suite que Tcl était une solution. À partir de Tcl, en 3 semaines, il écrivit Expect, un outil pour automatiser les applications interactives. Expect fut la première application écrite en Tcl à être largement distribuée, bénéficiant d'un grand crédit auprès des administrateurs systèmes.

Parallèlement, John Ousterhout commença à travailler sur Tk en tant qu'extension pour concevoir des interfaces graphiques avec Tcl à la fin de 1988. En janvier 1991, il présenta Tcl-Tk à la Conférence USENIX et à la Conférence X. Dès lors, la popularité de Tcl-Tk en tant que langage de script ne cessa de croître. Principalement pour deux raisons:

  • Sa capacité à être embarqué dans une application tout en créant ses propres commandes
  • La facilité avec laquelle on pouvait développer des interfaces graphiques (5 à 10 fois plus rapidement qu'avec Motif)

Ce second point intéressait beaucoup les industriels.

Une communauté se fédéra autour du langage et de nombreuses extensions commencèrent à voir le jour (dont TclX, incrTcl, BLT, Sybtcl, Oratcl, TclDP). La nécessité de communiquer davantage se fit sentir tant et si bien que John Ousterhout initia une liste de discussion. Mais le nombre d'utilisateurs croissant incita rapidement à la création du groupe de discussion comp.lang.tcl. En 1992 John Ousterhout co-fonda, avec Larry Rowe un collègue de l'Université de Berkeley, la société Perspecta Software dans le but de commercialiser Perspecta Presents, un logiciel de présentation sous Unix basé sur Tcl-Tk. En 1993 Larry Rowe organisa la première conférence annuelle Tcl-Tk à Berkeley. Par la suite ces conférences coïncidaient avec la sortie des nouvelles versions du langage. Un session était dédiée à la discussion sur l'adjonction de nouvelles fonctionnalités et la décision se faisait non sans humour par un vote approximatif à main levée connu sous le nom d'Ouster-vote.

En mai 1994, John Ousterhout quitta l'Université de Berkeley pour l'industrie à la suite d'une proposition de la société Sun Microsystems qui envisageait de faire de Tcl-Tk un langage de script universel pour Internet. Par cette réorientation professionnelle et la constitution d'une équipe (SunScript) au sein du Sun Microsystems Laboratories, John Ousterhout vit une opportunité d'assurer la pérennité du langage à long terme. Les clauses du contrat avec Sun Microsystems spécifiaient clairement que les codes sources de Tcl-Tk devaient rester librement accessibles. D'autres ne virent pas les choses de la même manière. Ainsi, le 23 septembre 1994, Richard Stallman posta sur comp.lang.tcl un message intitulé Why you should not use Tcl où il expliquait que Tcl n'était pas un vrai langage de programmation. De cette discussion enflammée naissait 1 mois plus tard le langage GUILE qui se voulait être une alternative à Tcl. Avec le recul, personne n'a encore bien compris quelles étaient les réelles motivations de Richard Stallman pour une telle attaque. Cet épisode est connu sous le nom de Tcl War.

Pendant ce temps là, au laboratoire de Sun Microsystems, Scott Stanton, Ray Johnson et Jacob Levy améliorèrent le système de gestion des entrées/sorties de Tcl-Tk, ajoutèrent le support des sockets, mais surtout, écrivirent une version pour Windows et Macinstosh. Ce qui fit de Tcl-Tk un langage de script généraliste et multi-plateforme en avril 1996 avec Tcl7.5/Tk4.1. S'ensuivirent d'autres améliorations dont: un compilateur de bytecode (qui augmenta la vitesse d'un facteur 10), le support des espaces de nom (namespace) et un plugin Tcl qui permettait d'exécuter des tclets (applets écrits en Tcl) dans un navigateur Web. Toutes ces innovations correspondaient à la version de Tcl-Tk 8.0 sortie en août 1997 où la décision fut prise d'aligner les numéros de version de Tk sur ceux de Tcl. Octobre 1997 vit la création du Tcl Consortium dont l'objectif était de promouvoir Tcl-Tk et d'accroître encore plus sa visibilité sur la marché de l'informatique. Ce consortium était financé par Sun Microsystems et avait à sa tête Peter H. Salus (ancien directeur exécutif de l'Association USENIX et du Sun User Group, mais aussi vice-président de la Free Software Fondation). Hormis John Ousterhout, le comité consultatif comptait parmi ses membres Brian W. Kernighan (co-créateur de Awk). Durant ces années, Tcl-Tk fut fortement impliquée dans la technologie des agents mobiles.

À la fin de l'année 1997, John Ousterhout quitta Sun Microsystems pour co-fonder la société Scriptics après que son employeur eut décidé d'annuler les projets de commercialisation d'outils de développement spécifiques au langage. Scriptics prit le relais en offrant des services autour de Tcl-Tk et en commercialisant notamment la suite d'outils TclPro. Le développement et la maintenance de Tcl-Tk furent alors transférés chez Scriptics avec une partie de l'équipe Tcl-Tk de Sun Microsystems. Les langages de script étaient alors en plein essor. Au printemps 1998, Tcl-Tk reçut deux prix. Tout d'abord le prix de l'ACM Software System qui récompense les logiciels qui ont eu une influence durable et ensuite le prix STUG (USENIX Software Tools User Group). En août 1998, lors d'une conférence sur l'opensource et les modèles économiques à San José en Californie, Richard Stallman monta à la tribune et prit le micro pour déclarer que John Ousterhout était un "parasite" du mouvement des logiciels libres ... En avril 1999 sortit la version Tcl-Tk 8.1. Elle intégrait un nouveau moteur d'expressions rationnelles (celui d'Henry Spencer) et le support d'Unicode. Sortie trop précipitamment, cette version s'avérait instable. Tant et si bien que la version 8.2 sortit 3 mois après pour corriger les imperfections.

En mai 2000, la société Scriptics prit le nom d'Ajuba Solutions s'orientant plus vers des solutions de serveurs basés sur Tcl et la technologie XML, en plein développement à cette période. En octobre 2000, elle fut rachetée par la société Interwoven. Peu intéressée par les logiciels libres, celle-ci autorisa le passage en opensource de la suite TclPro (dont la licence monoposte vallait 1000$). Le cas de la maintenance et du développement de Tcl-Tk avait déjà été anticipé avec la création en août 2000 du TCT (Tcl Core Team) un groupe constitué d'un collège d'experts indépendants de toute structure commerciale. C'est à cette époque que John Ousterhout (également membre du TCT) décida de ne plus assurer son rôle de "dictateur bénévole" et se tourna vers la gestion et la planification de projets informatiques. En février 2000 sortit la version de Tcl-Tk 8.3 qui avait déjà été élaborée chez Scriptics. La réelle efficacité du TCT ne put s'exprimer qu'avec la sortie de Tcl-Tk 8.4 en septembre 2002 avec entre autres un travail de fond sur les mécanismes internes du langage et l'adjonction d'un système de fichier virtuel. Après quatre années de développement, sort en décembre 2007 Tcl-Tk 8.5. Cette version apporte de nombreux changements à la fois pour Tcl et Tk.

Annexes

Historique des versions significatives

Version Date de sortie Principales nouveautés
8.5 20 décembre 2007
  • Fonctions anonymes (commande apply)
  • Expansion des arguments (commande {*})
  • Commande spécifique (chan) pour manipuler les canaux
  • Dictionnaire (commande dict)
  • Extension de la commande expr avec de nouveaux opérateurs mathématiques
  • Extension des commandes de gestion des listes
  • Refonte de la commande de gestion de la date et de l'heure
  • Amélioration de la vitesse d'exécution de 10 % par rapport à la version précédente

Plus de détails

8.4 10 septembre 2002
  • Système de fichier virtuel et Starkit
  • Amélioration de la prise en charge du port série (multi-plateforme)
  • Extension des commandes de gestion des listes
  • Statistique de distribution des données dans une table de hachage
  • Amélioration de la vitesse d'exécution de 25 % par rapport à la version précédente
8.3 10 février 2000
  • Extension de la commande des motifs globalisants (glob)
  • Extension des commandes de gestion des listes
8.2 17 août 1999
  • Nouvelles sous-commandes à la fonction string
  • Nouveau package http
  • Implémentation de la Tcl Extension Architecture (TEA)
8.1 29 avril 1999
  • Support d'Unicode
  • Extension du moteur d'expression régulière
  • Package DDE (Windows)
8.0 18 août 1997
  • Compilation du bytecode à la volée
  • Manipulation des données binaires
  • Copie des données d'un canal à un autre
  • Espaces de nom (namespace)
  • Packages http et registres (Windows)
7.5 21 avril 1996
  • Première version pour Windows et MacOS
  • Création de plusieurs interprètes dans une même application
  • Gestion des boucles d'évènement
  • Support des packages et chargement de bibliothèques extérieures
  • Support des sockets
  • Manipulation de la date et de l'heure
6.6 février 1993
  • Structure de contrôle elseif
2.1 3 mars 1990
  • Première version grand public
  • Mécanisme de communication inter-application

Mots réservés

after             error       lappend      platform           tcl_startOfNextWord
append            eval        lassign      platform::shell    tcl_startOfPreviousWord
apply             exec        lindex       proc               tcl_wordBreakAfter
array             exit        linsert      puts               tcl_wordBreakBefore
auto_execok       expr        list         pwd                tcltest
auto_import       fblocked    llength      re_syntax          tclvars
auto_load         fconfigure  load         read               tell
auto_mkindex      fcopy       lrange       reflectedchan      time
auto_mkindex_old  file        lrepeat      regexp             tm  
auto_qualify      fileevent   lreplace     registry *         trace
auto_reset        filename    lreverse     regsub             unknown  
bgerror           flush       lsearch      rename             unload
binary            for         lset         return             unset
break             foreach     lsort        Safe Base          update
catch             format      mathfunc     scan               uplevel
cd                gets        mathop       seek               upvar
chan              glob        memory       set                variable
clock             global      msgcat       socket             vwait
close             history     namespace    source             while
concat            http        open         split            
continue          if          package      string
dde *             incr        parray       subst
dict              info        pid          switch
encoding          interp      pkg::create  tcl_endOfWord
eof               join        pkg_mkIndex  tcl_findLibrary

(*): spécifique à la plateforme Windows

Extensions et bibliothèques les plus utilisées

Graphisme

Son

  • Snack (Boîte à outil de traitement sonore)
  • CSound (Instruments virtuels et traitement sonore)

Internet et réseaux

Système de gestion de base de données

Spécifique à Windows

Autres

Notes et références

  • John K. Ousterhout, Scripting: Higher Level Programming for the 21st Century, IEEE Computer magazine, March 1998 [1]
  • John K. Ousterhout, Tcl: An Embeddable Command Language, Proceedings of the USENIX Winter 1990 Technical Conference, pp133-146. [2]
  • John K. Ousterhout, The Tcl Programming Language, Dr. Dobb's Journal, vol. 19, Winter 1994.
  • John K. Ousterhout, Extensibility in Tcl, Dr. Dobb's Journal, 24(6), June 1999.
  • Robert S. Gray, Agent Tcl: A flexible and secure mobile-agent system, Dr. Dobbs Journal, 22(3):18-27, March 1997.
  • Peter Wayner, Net Programming For The Masses, BYTE, February 1996. [3]
  • Kathryn Edwards, The A-Z of Programming Languages: Tcl, Computerworld, May 2009. [4]
  • Salvatore Sanfilippo, Tcl the Misunderstood, March 2006 [5]
  • David Zolli, Découvrez Tclkit, les starkits et les starpacks, GNU Linux Magazine France n°60, avril 2004, pp66-69.

Livres

  • (fr) Bernard Desgraupes, Tcl/Tk - Apprentissage et Référence, 2è édition, Vuibert, ISBN 978-2-7117-4878-5, 2009.
  • (en) John K. Ousterhout, Tcl and the Tk Toolkit, Addison-Wesley, Reading, MA, USA, ISBN 0-201-63337-X, 1994. (Draft disponible en ligne)
  • (en) Brent B. Welch, Practical Programming in Tcl and Tk, Prentice Hall, Upper Saddle River, NJ, USA, ISBN 0-13-038560-3, 2003. (Plusieurs chapitres en ligne)
  • (en) J. Adrian Zimmer, Tcl/Tk for Programmers, IEEE Computer Society, distribué par John Wiley and Sons, ISBN 0-8186-8515-8, 1998. (Plusieurs chapitres en ligne)
  • (en) Cliff Flynt, Tcl/Tk for Real Programmers, Morgan Kaufman Publishers, ISBN 0-122-61205-1, 1998.
  • (en) Eric Foster-Johnson, Graphical applications with Tcl and Tk, M&T, ISBN 1-55851569-0, 1997.
  • (en) Mark Harrison et Michael McLennan, Effective Tcl/Tk Programming, Addison-Wesley, Reading, MA, États-Unis, ISBN 0-201-63474-0, 1998.
  • (en) Mark Harrison (ed), Tcl/Tk Tools, O'Reilly Media, ISBN 1-56592-218-2, 1997.
  • (en) David Maggiano, CGI Programming with Tcl, Addison Wesley, ISBN 0-201-60629-1, 2000.
  • (en) Raymond Blair, Arvind Durai et John Lautmann, Tcl Scripting for Cisco IOS (Networking Technology), Cisco Press, ISBN 1-58705-945-2, 2010.
  • (en) Wojciech Kocjan et Piotr Beltowski, Tcl 8.5 Network Programming, Packt Publishing, ISBN 1-84951-096-2, 2010.
  • (pt) Alexander Franca, Tcl/Tk: Programação Linux, Brasport, ISBN 978-8574522210, 2005.

Articles connexes

Liens externes


Wikimedia Foundation. 2010.

Contenu soumis à la licence CC-BY-SA. Source : Article Tool Command Language de Wikipédia en français (auteurs)

Regardez d'autres dictionnaires:

  • Tool command language — Tcl Skriptsprache mit Bytecode Interpreter Basisdaten Paradigmen: imperativ, funktional …   Deutsch Wikipedia

  • Tool Command Language — interpreted programming language used to develop prototype applications and CGI scripts, TCL (Computers) …   English contemporary dictionary

  • Tool Command Language —    Abbreviated Tcl, pronounced [tickle]. Developed by John Ousterhout while at the University of California at Berkeley, Tcl is a general purpose extensible scripting language supplied as a C library on Unix systems. Tcl is also available in… …   Dictionary of networking

  • language, philosophy of — Philosophical study of the nature and use of natural languages and the relations between language, language users, and the world. It encompasses the philosophical study of linguistic meaning (see semantics), the philosophical study of language… …   Universalium

  • Command Prompt — For other uses, see Command prompt (disambiguation). CMD redirects here. For other uses, see CMD (disambiguation). Command Prompt A component of Microsoft Windows …   Wikipedia

  • Command key — The Command key The Command key, also historically known as the Apple key, open Apple key or meta key is a modifier key present on Apple Keyboards. The Command key s purpose is to allow the user to enter keyboard shortcut commands to GUI… …   Wikipedia

  • language — /lang gwij/, n. 1. a body of words and the systems for their use common to a people who are of the same community or nation, the same geographical area, or the same cultural tradition: the two languages of Belgium; a Bantu language; the French… …   Universalium

  • Fourth-generation programming language — A fourth generation programming language (1970s 1990) (abbreviated 4GL) is a programming language or programming environment designed with a specific purpose in mind, such as the development of commercial business software.[1] In the history of… …   Wikipedia

  • Satellite Tool Kit — Infobox Software | name = STK caption = STK 8.0 being used to plan a lunar lagrange orbit. developer = Analytical Graphics, Inc. latest release version = 8.1.3 latest release date = March 13, 2008 operating system = Windows, Unix genre =… …   Wikipedia

  • Domain-specific language — Programming paradigms Agent oriented Automata based Component based Flow based Pipelined Concatenative Concurrent computing …   Wikipedia

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”