Presque inconnu, ce langage a connu son heure de gloire dans les années 80, certaines machines  ont été organisées directement avec lui en lieu et place du langage BASIC de l’époque.

C’est un langage qu’on peut trouver fascinant et un peu déroutant qui s’éloigne des langages informatiques conventionnels, il ne s’inscrit pas dans la philosophie des langages traditionnels qu’on connaît et qu’on utilise aujourd’hui.
Il demandera un effort certain  qui obligera à se battre pendant les premières heures de la confrontation  mais il n’y a là rien d’impossible tout au plus quelques difficultés à surmonter.

Un langage informatique n’est qu’un outil comme les autres, il se doit d’être facile à utiliser et à la portée de tous.
    - La syntaxe est simple et non contraignante
    - Définition de ses propres mnémoniques
    - Vitesse d’exécution d’un langage compilé
    - Facilité de développement d’un interpréteur
FORTH réuni ces qualités en étant un langage semi-compilé.

Tout le travail de programmation consiste à ajouter de nouveaux mots à un dictionnaire initial en n’utilisant dans chaque définition que des mots déjà connus de la machine.
 Les autres particularités importantes de ce langage sont sa rapidité et sa compacité, même si avec nos machines actuelles la vitesse d’exécution et la taille du programme ne sont plus des critères décisifs.
Il reste vingt fois plus rapide qu’un Basic, en gardant les avantages d’un langage interprété et peut être plus compact que l’Assembleur tout en n’ayant pas la lourdeur et la pénibilité de programmation de ce langage.

Forth repose sur l'utilisation intensive de piles c’est  une des importantes caractéristiques du langage, la pile de données fourni les arguments entre les mots.
La manipulation de la pile des données est d’une importance cruciale, c’est un élément déterminant qui régente l’essentiel de la programmation en Forth, le bon discernement de son fonctionnement est nécessaire quand à l’élaboration d’un logiciel.
Un programme Forth est constitué  d’une suite de mots, chacun de ces mots donnant lieu à une action précise.
Tout en Forth n’est que mots !
On peut comparer un mot à une procédure ou une fonction des autres langages.
Cet ensemble est englobé dans ce que l’on nomme un DICTIONNAIRE, la création et la définition de chacun de ces mots y sont contenus en séquence dans l’ordre de création de la définition.

Forth laisse une infinie liberté au développeur, qui explique même les mécanismes internes du langage, c’est au programmeur d’écrire ou non les sécurités afin d’inhiber les erreurs ou les abus.




GForth est le système Forth du projet GNU, il s'agit donc d'un logiciel libre. Il fonctionne sur de nombreuses plates-formes dont Linux. Il reste très compatible avec les normes établies «ANS-FORTH» ce qui rend le dialecte plus portable et donne accès à une documentation considérable (souvent en Anglais).
On le trouve dans la bibliothèque d’installation de beaucoup de distributions.

Parmi ses atouts, on peut souligner un grand respect de la norme ANSI et une vélocité tout à fait honnête.

Gedit propose la coloration syntaxique pour le langage forth, cela améliore notablement la lisibilité du code et facilite sensiblement la saisie.

Quelques mots développés en Gforth qui composent des cadres à l'écran pour enrichir un peu l'interface texte.

les arguments déposés préalablement sur la pile sont :
    - haut  = hauteur du cadre
    - long  = longueur du cadre
    - col   = coordonnée du point de départ du cadre X
    - ligne = coordonnée du point de départ du cadre Y

cadre1 : dessine un cadre simple trait
cadre2 : dessine un cadre double traits
cadre3 : dessine un cadre avec des caractères + - |
col_simple et col_double : dessine une colonnes
croise_simple et croise_double : dessine le caractère de croisement entre le cadre et la colonne

\\ ============================================
\\ Dessin de cadre avec recouvrement haut = nombre de lignes utilisables
\\ ============================================

\\ arguments :
\\ haut = nombre de lignes du cadre
\\ long = longueur utilisable dans le cadre
\\ col ligne = coordonnées x y du point de départ du cadre
\\ corient : orientation du croisement 1=gauche 2=droite 3=centre

variable ccol
variable clig
variable clong
variable chaut
variable corient

: cadre1 ( haut long col ligne --- )
    clig !     ccol ! clong ! chaut !
    ccol @ clig @ at-xy ." ┌" clong @ 0 do ." ─" loop ." ┐"
    chaut @ 0 do ccol @ clig @ 1+ i + at-xy ." │" clong @ spaces ." │" loop
    ccol @ clig @ chaut @ 1+ + at-xy ." └" clong @ 0 do ." ─" loop ." ┘"
;

: cadre2 ( haut long col ligne --- )
    clig !     ccol ! clong ! chaut !
    ccol @ clig @ at-xy ." ╔" clong @ 0 do ." ═" loop ." ╗"
    chaut @ 0 do ccol @ clig @ 1+ i + at-xy ." ║" clong @ spaces ." ║" loop
    ccol @ clig @ chaut @ 1+ + at-xy ." ╚" clong @ 0 do ." ═" loop ." ╝"
;

: cadre3 ( haut long col ligne --- )
    clig !     ccol ! clong ! chaut !
    ccol @ clig @ at-xy ." +" clong @ 0 do ." -" loop ." +"
    chaut @ 0 do ccol @ clig @ 1+ i + at-xy ." |" clong @ spaces ." |" loop
    ccol @ clig @ chaut @ 1+ + at-xy ." +" clong @ 0 do ." -" loop ." +"
;

: col_simple ( haut col ligne --- )
    clig ! ccol ! chaut !
    chaut @ 0 do ccol @ clig @ i + at-xy ." |" loop
;

: col_double ( haut col ligne --- )
    clig ! ccol ! chaut !
    chaut @ 0 do ccol @ clig @ i + at-xy ." ║" loop
;

: croise_simple ( orient col ligne --- )
    clig ! ccol ! corient !
    corient @ 1 = if ccol @ clig @ at-xy ." ├" then
    corient @ 2 = if ccol @ clig @ at-xy ." ┤" then
    corient @ 3 = if ccol @ clig @ at-xy ." ┬" then
;

: croise_double ( orient col ligne --- )
    clig ! ccol ! corient !
    corient @ 1 = if ccol @ clig @ at-xy ." ╠" then
    corient @ 2 = if ccol @ clig @ at-xy ." ╣" then
    corient @ 3 = if ccol @ clig @ at-xy ." ╦" then
;    

Les couleurs de l'écran texte peuvent être modifiées comme dans un script bash avec une séquence d'échappement, cette séquence n'est pas affichée mais modifie les attributs de l'écran ce qui va coloriser le texte ou certaine zone.

Il y a 8 codes et 2 mots
    couleur_fond
    couleur_texte
    coul_init                  : permet de réinitialiser avec les couleurs par défaut.
    coul_contraste_inv        : contraste inversé (inverse la couleur de fond et de texte)

\\ ====================================
\\ couleurs d'écran
\\ ====================================

\\ Il faut envoyer une séquence d'échappement :   ESC[code;code m
\\        ESC = 27
\\        [   = 91
\\        m    = 109
\\        ;    = 59

\\ =================================================
\\ code argument  : 1-noir 2-rouge 3-vert 4-brun 5-bleu 6-magenta 7-cyan 8-gris
\\ =================================================

: coul_texte ( code --- )
    27 pad c!
    91 pad 1+ c!
    51 pad 2 + c!
    109 pad 4 + c!
    dup 1 = if 48 pad 3 + c! then
    dup 2 = if 49 pad 3 + c! then
    dup 3 = if 50 pad 3 + c! then
    dup 4 = if 51 pad 3 + c! then
    dup 5 = if 52 pad 3 + c! then
    dup 6 = if 53 pad 3 + c! then
    dup 7 = if 54 pad 3 + c! then
    dup 8 = if 55 pad 3 + c! then
    drop
    pad 5 type
;

: coul_fond ( code --- )
    27 pad c!
    91 pad 1+ c!
    52 pad 2 + c!
    109 pad 4 + c!
    dup 1 = if 48 pad 3 + c! then
    dup 2 = if 49 pad 3 + c! then
    dup 3 = if 50 pad 3 + c! then
    dup 4 = if 51 pad 3 + c! then
    dup 5 = if 52 pad 3 + c! then
    dup 6 = if 53 pad 3 + c! then
    dup 7 = if 54 pad 3 + c! then
    dup 8 = if 55 pad 3 + c! then
    drop
    pad 5 type
;

: coul_init ( --- )
    27 pad c!
    91 pad 1+ c!
    48 pad 2 + c!
    109 pad 3 + c!
    pad 4 type
;

: coul_contraste_inv ( ---)
    27 pad c!
    91 pad 1+ c!
    55 pad 2 + c!
    109 pad 3 + c!
    pad 4 type
;

Un exemple pour créer un menu facilement

LAZARUS : l'environnement de développement sous Linux

Equivalent à Delphi sous Windows, Lazarus en est presque la copie conforme sous le système d'exploitation Linux la gratuité en plus.
Pour une formation à ce langage il est possible de puiser dans l'énorme documentation (cours et tutoriaux) de Delphi, à part quelques adaptations au niveau du codage, tous les préceptes concernant le langage sont identiques.

L'environnement de développement intégré est extrêmement riche en fonctionnalités et en outils. Il est en effet facile de créer un programme exécutable en quelques minutes, voire quelques secondes, simplement en choisissant des éléments pré-définis qu'il ne reste plus qu'à assembler et compiler.
L'environnement de développement intégré semblera familier aux programmeurs ayant déjà utilisé un EDI genre Visual Basic ou dBase Windows.

L'éditeur de code permet de travailler le code source, c'est un éditeur de texte très largement configurable et qui offre de grandes commodités d'édition, la coloration syntaxique etc..

La palette de composants contient les éléments les plus utilisés dans la conception des fiches. On trouve des composants supplémentaires sur internet qui peuvent compléter la liste déjà longue ou pour un usage plus spécifique, cela facilite grandement le travail. Ces paquets de type Fcl peuvent enrichir la palette et apporter des fonctionnalités additionnelles.

Un échantillon de l'apparence de quelques composants les plus habituels

L'inspecteur d'objets

Le langage de programmation employé pour la construction des procédures est le Pascal, éprouvé, puissant et très largement répandu, il offre une bibliothèque d'objets de très haut niveau et d'une remarquable qualité, accessible et modifiable dans ses moindre détails par qui le souhaiterait. Freepascal implémenté sous Lazarus permet de compiler les programmes et de créer un exécutable naturellement et confortablement.