Forth (langage)

Forth
Date de première version	1970
Développeur	Charles H. Moore
Influencé par	Lisp APL Burroughs large systems (en)
Site web	forth-standard.org
Extension de fichier	fth, fs, 4th, fb, f et forth

Forth est un langage de programmation à pile, inventé par Charles H. Moore dans les années 1960. Il a été standardisé par l'ANSI en 1994, puis adopté tel quel par l'ISO en 1997 et une nouvelle version, Forth 2012, a été publiée en 2014.

Historique

En 1958, un jeune informaticien nommé Charles Moore, chargé de calculer des trajectoires de satellites, entreprend, pour faciliter son travail quotidien, la construction d'une boîte à outils sous la forme d'un interpréteur de commandes. D'année en année, cet interpréteur est amélioré et rendu indépendant de la machine hôte. En 1968, il prend le nom de Forth, et en 1970, il est suffisamment mûr pour faire l'objet d'une première publication comme « Langage pour calcul interactif ».

1971 voit la première application d'envergure : Moore utilise Forth pour développer le logiciel de pilotage du radiotélescope de Kitt Peak (Arizona) sur deux mini-ordinateurs 16-bits. Il y est bientôt rejoint par Elizabeth Rather, qui devient le deuxième programmeur Forth. Par ses performances et sa souplesse d'emploi, l'application intéresse rapidement d'autres observatoires, et en 1976, Forth est adopté comme standard par l'Union internationale d'astronomie.

Après une première modernisation du logiciel de Kitt Peak en 1973, Moore et Rather fondent Forth, Inc., pour promouvoir le langage et ses applications. En 1976, une première version exécutable sur microprocesseurs 8-bits est disponible sous le nom de MicroFORTH.

En 1978 est créée une association, le Forth Interest Group (FIG), pour promouvoir une version « domaine public » du langage sur un maximum de processeurs, et publier la revue Forth Dimensions. Le FIG-FORTH, légèrement différent du MicroFORTH, contribuera grandement à la diffusion du langage.

Le besoin de standardisation d'un langage que chacun peut modifier à sa guise devient manifeste. Une première tentative (FORTH77) aboutit au premier standard largement diffusé, FORTH79. Ce standard évolue quatre ans plus tard en FORTH83, mais des incompatibilités entre les deux versions engendrent des problèmes de portabilité, et sont à l'origine d'un clivage dans la communauté des programmeurs FORTH.

Dénomination

Son nom est une contraction de l'anglais fourth, qui signifie « quatrième » : Moore le voyait comme un langage pour les ordinateurs de « quatrième génération ». À l'époque, la machine IBM utilisée, un IBM 1130, ne permettait que des noms de cinq lettres.

Principes

Forth repose sur l'utilisation explicite de piles — alors que les autres langages utilisent des piles invisibles au programmeur.

Pile de données

Une des importantes caractéristiques du langage est l'utilisation d'une pile de données pour passer des arguments entre les mots, qui sont les constituants d'un programme Forth.

Un simple exemple : l'expression 2+3*4 sera traduite par la suite 2 3 4 * +, dans la notation polonaise inversée.

Cette suite de mots agit sur la pile de données. Son effet est :

• d'empiler successivement les valeurs 2, 3, puis 4 ;
• de remplacer ensuite les deux nombres du sommet de la pile (3 et 4) par leur produit, 12 ;
• et enfin de remplacer les deux nombres en haut de pile (2 et 12) par leur somme, 14.

À partir des mots prédéfinis du langage, comme +, *, DUP (qui duplique l'élément en sommet de pile), SWAP (qui échange les deux éléments du sommet), etc., le programmeur construit le vocabulaire de son application en définissant ses propres mots, qu'il réutilise ensuite :

: CARRE DUP * ;      (définition de CARRE)
11 CARRE             (on obtient 121 au sommet de la pile)
: CUBE DUP CARRE * ; (usage de CARRE dans une définition)
2 CUBE               (on obtient 8 au sommet de la pile)

Une conséquence importante de l'utilisation d'une pile est la quasi-suppression des noms de variables locales, qui deviennent inutiles.

Pile de retour

Comme dans la quasi-totalité des langages, Forth utilise une pile pour stocker les adresses de retour des sous-programmes en cours d'exécution. L'originalité ici est de mettre cette pile à la disposition du programmeur, principalement pour un stockage temporaire de données, au moyen de deux opérateurs permettant les transferts pile de données – pile de retour.

Sous-programmes

Un mot Forth est l'équivalent des sous-programmes, fonctions ou procédures dans les autres langages. Cependant, Moore décrit les mots plus comme des abréviations que comme des fonctions à la C. Le mot d'ordre en Forth est la factorisation, c'est-à-dire le découpage de l'application en petits mots dont la définition tient sur une ligne ou deux.

Les « mots » de Forth sont « compilés », c'est-à-dire convertis en une forme exécutable et ajoutés au dictionnaire des mots. La forme exécutable diffère suivant le compilateur ou l'interpréteur utilisé : génération directe de code machine ou bytecode par exemple (il existe de nombreuses variantes intermédiaires).

Dans les autres langages, un sous-programme s'utilise avec une syntaxe différente des fonctions de base du langage : dans forth un sous-programme est un mot de plus, que l'on utilise de la même façon que les mots de base du langage : ce comportement identique des fonctions de base et des sous-programmes permet de redéfinir facilement une fonction de base pour améliorer un programme

Autres caractéristiques

Il n'y a pas d'instruction GOTO. La syntaxe particulière de l'instruction IF...ELSE...THEN permet de résoudre de façon élégante le problème des « n+1/2 itérations »^[Quoi ?] qui, en programmation structurée, aboutit à l'introduction d'une variable booléenne supplémentaire si l'on veut absolument éviter le GOTO.

Variables

Il n'y a pas d'opérateur d'affectation à deux opérandes (incarné par = dans de nombreux autres langages). Les variables sont toujours conçues comme des adresses dans la mémoire, et non comme la valeur stockée dans la mémoire. Le transfert des données se fait par les deux opérateurs @ (fetch) et ! (store), qui correspondent aux instructions LDA (Load Accumulator) et STA (Store Accumulator) d'un assembleur, la pile jouant ici le rôle de l'accumulateur.

VARIABLE toto 3 toto !  (déclare et initialise toto)
VARIABLE titi           (déclare titi)             
toto @ titi !           (recopie toto dans titi)

Sur la dernière ligne, l'invocation de toto pousse l'adresse toto sur la pile. @ remplace cette adresse par la valeur contenue à cet endroit de la mémoire, à savoir 3. À son tour, l'invocation de titi pousse l'adresse titi sur la pile. Celle-ci contient à ce moment la valeur 3 et l'adresse titi. Enfin, ! écrit 3 en mémoire à l'adresse titi, et laisse la pile vide.

Mise en œuvre

Le mélange interprétation/compilation, associé à des techniques de compilation efficaces et à la possibilité offerte par nombre de systèmes de définir aussi de nouvelles primitives en assembleur, fait de Forth l'un des langages interprétés les plus rapides et les plus compacts.

Très proche du matériel, le Forth est un langage que l'on peut qualifier de « bas niveau », mais qui dispose de ressources qui lui permettent de se rapprocher du « haut niveau ». Le langage est en effet basé sur un petit nombre de primitives suffisamment élémentaires pour être implémentées directement « dans le silicium » (c'est-à-dire être les instructions d'un processeur matériel ; les primitives de Forth sont donc bel et bien un « langage assembleur » pour ces processeurs. Il existe quelques exemples de processeurs Forth).

Dans le même temps, le langage permet de définir des mots qui ont une action sur la compilation ; on peut ainsi définir de nouvelles structures de contrôle (par exemple la structure switch/case peut s'écrire à partir de la structure if/then/else). Cette caractéristique fait de Forth un langage extensible.

C'est ainsi qu'à partir de quelques primitives écrites en langage machine, on peut construire un interpréteur en ligne de commande, un assembleur, un compilateur, un éditeur de source. La compacité est extrême : sur une machine 8 bits, 7 kilooctets suffisent pour avoir un interpréteur en ligne de commande, dont 700 octets seulement de code machine, le reste étant constitué de tables de pointeurs. En ajoutant environ 5 ko, on dispose de l'éditeur, d'un assembleur, et d'un système rudimentaire de stockage sur disquettes, le tout fonctionnant sans système d'exploitation avec quelques kilooctets de mémoire vive, et tenant sur une simple disquette (source intégrale incluse) ; autrement dit un micro-environnement de développement capable de s'autocompiler à partir de son propre source depuis une plateforme disposant de ressources modestes comme les applications embarquées.

Le langage Forth a fait l'objet d'une normalisation officielle, l'ANS-FORTH, fondée sur les standards officieux précédents Forth-79 et Forth-84. La plupart des Forth commerciaux suivent cette norme. Du fait de l'extrême facilité d'implémentation d'un interpréteur pour ce langage, il existe un très grand nombre de systèmes Forth de domaine public, qui sont soit alignés sur le standard ANS-Forth (comme gforth de GNU), soit sont des dialectes plus ou moins éloignés de Forth (notamment ColorForth de Charles Moore), et ce pour à peu près toutes les plateformes, de l'Intel 8051 à Windows, en passant par Linux.

Utilisation

Forth a été utilisé principalement dans des systèmes embarqués et des contrôleurs, en raison de leur caractère compact et de la facilité d'utiliser des mots définis en assembleur dans des programmes de plus haut niveau. Parmi les applications les plus prestigieuses, on relèvera sa présence sur quelques missions de la NASA.

Les ROM Open Firmware des produits d'Apple et de Sun, ainsi qu'une partie du boot de FreeBSD, étaient jusqu'à récemment écrites en Forth, permettant la portabilité du code de bas niveau entre les processeurs.

L'augmentation de performance des micro-contrôleurs permettant désormais la programmation des applications de ce type en langage C, désormais érigé en assembleur universel, l'utilisation de Forth régresse sur son terrain de prédilection. Plus généralement, la tendance étant à ce que le programmeur devienne une ressource interchangeable (ce qui permet déjà l'externalisation de certains développements) au détriment de l'expérience et de la compétence, l'utilisation de Forth ne peut que décliner.

Bien que la mort de Forth ait été annoncée maintes et maintes fois, et que d'aucuns le qualifieraient de moribond, de nouveaux programmeurs de divers horizons curieux et attirés par ses performances et ses conceptions remarquables s'y intéressent régulièrement et s'en inspirent ; la survie de quelques sociétés prestataires de services qui basent leur offre sur Forth et réalisent des développements pour des projets de pointe (gestion de trafic aérien par exemple), laissent à penser que Forth n'est pas une langue morte.

ASYST a été un logiciel d'automatisation de mesures par PC avec calcul en virgule flottante et un tas de possibilités très puissantes pour l'époque, tout en syntaxe forth (sur pc xt) ; souvent les utilisateurs de ce logiciel ne savaient pas que c'était du forth : il y avait quand même des différences par rapport au forth comme deux piles différentes pour les textes et les chiffres.

Le langage de programmation de contrats intelligents de Bitcoin, appelé script, utilise une syntaxe inspirée de Forth, avec notation polonaise inversée et des piles .

Voir aussi

Articles connexes

• Persistance : Forth a été au nombre des premiers langages persistants.
• PostScript : dans ses principes fondamentaux (pile, notation polonaise inversée, dictionnaire de mots…) le langage PostScript est très voisin de Forth ; il en diffère cependant dans la gestion dynamique de la portée des identificateurs (au moyen d'une pile de contexte contenant un nombre indéfini de dictionnaires, laquelle pile est aussi indépendante de la pile de données constamment utilisée pour l'exécution), et un contrôle complet des modes de fonctionnement entre interprétation, compilation et exécution, le langage permettant même de définir ses propres interprètes, compilateurs et exécuteurs, et la génération dynamique (pendant l'exécution du programme) de code exécutable par le programme lui-même.
• Joy : langage de pile fonctionnel inspiré de Forth
• Factor : langage de pile hérité de Forth
• Cat : un autre descendant de Forth
• RPL : le langage de programmation RPL inventé par Hewlett-Packard pour ses calculatrices a popularisé le concept de « pile de données ». Le RPL tient surtout du Forth, la concision de ce langage était bien adaptée aux calculatrices.
• WarpScript : Language de programmation et de requêtes de la base de données Open-source WARP10

Bibliographie

• (en) Kevin McCabe, FORTH fundamentals, Dilithium Press, 1983
• Kevin McCabe, Le FORTH, Paris, Belin, 1985, 290 p. (ISBN 2-7011-0587-0)
• (en) Leo Brodie, Starting Forth, Prentice Hall, juin 1987, 2^e éd., 346 p. (ISBN 0-13-843079-9, lire en ligne)
• (en) Leo Brodie, Thinking Forth, Forth Interest Group, juin 1994, 2^e éd., 316 p. (ISBN 0-935533-00-1, lire en ligne)
• (en) R.G. Loeliger, Threaded Interpretive Languages : Their Design and Implementation, Byte Books, janvier 1981, 1^re éd., 250 p. (ISBN 0-07-038360-X)
• E. D. Rather, C. H. Moore, FORTH - An application-oriented language - Programmer's Guide

Liens externes

• (en) Forth, Inc : le site officiel de la société fondée par Charles Moore et Elizabeth Rather, avec un historique détaillé du langage.
• (en) comp.lang.forth.repository
• (en) Forth Interest Group : le site, toujours actif, de feu le FIG, association qui fut très active pour la promotion du langage. Nombreux articles et sources, grosse bibliothèque de liens.
• (en) Euroforth : colloque annuel européen consacré à Forth.