Archéo-programmation et retour aux sources d'une ère héroïque

Le GW Basic est un des premiers langages de programmation. Il date du tout début des années 80, et était alors fourni gracieusement avec la toute première version de DOS. C'est une des nombreuses variantes du Basic.

GW signifie Graphics & Window et Basic signifie Beginners' All purpose Symbollc Computing.

Ce langage est très simple à appréhender. Les lignes sont numérotées (ce qui est assez déroutant par rapport aux langages plus modernes) et s'exécutent dans l'ordre, grâce à un interpréteur DOS.

Ce langage est dépassé, et ses possibilités sont vraiment limitées. Mais j'ai appris à programmer avec ce langage vers 12 ans, et du coup c'est un langage auquel je suis très attaché. Je trouve qu'il constitue un premier pas sympathique dans le monde de la programmation : on a très vite des résultats, et de manière très simple. Même s'il faut passer rapidement à autre chose, c'est un début assez amusant. En outre, même en cas de fausse manip, on est sûr de ne pas causer de dégâts à son système.

J'ai compilé ici les pages de mon vieux site web qui étaient dédiées au GW Basic. Elles s'adressent essentiellement à des débutants complets, ce qui explique que pas mal de manipulations sont détaillées. Les lecteurs avancés pourront passer une grande partie des chapitres. Voici le plan :

Généralités

Un langage interprété

Travailler avec l'éditeur

Les commandes

Exemples simples

Exemples avancés

Liens

Avant tout, si vous souhaitez essayer GW Basic, vous pouvez télécharger l'interpréteur GW2 Basic et quelques programmes de mon cru à cette adresse. (Il s'agit d'une archive ZIP.) Je vous propose ici la version 2 (donc GW2), qui date de 1984.

Le rétro-gaming est devenu à la mode. Peut-être qu'un jour le rétro-programming deviendra une activité ludique...

Généralités

Vu qu'il a été développé fin des années 70, début des années 80, il fonctionne en mode console et en 16 couleurs... 24 lignes, 80 colonnes. Oui, moi aussi sur mon écran 27' ça fait bizarre. Il n'est pas compatible avec les machines 64 bits, mais j'ai constaté qu'il fonctionnait très bien jusqu'à XP 32 bits.

Pour que vous voyez à quoi ça ressemble... voici la fenêtre MS-Dos (donc ouverte comme une fenêtre normale sous Windows) de l'éditeur, telle qu'elle apparait au lancement de GW2.EXE :

Le seul élément nécessaire est le programme GW2.EXE, que je vous ai proposé en téléchargement. Il n'y a aucune bibliothèque, pas d'installation nécessaire, rien. Inutile de dire qu'avec ses 60 Ko, on est loin des monstres actuels...

Un langage interprété

La quasi-totalité des langages de programmation actuels fonctionnent au moyen d’un compilateur : on écrit le programme dans un éditeur, puis on le compile. La compilation consiste à transformer le script en une suite d'instructions en langage assembleur, compréhensibles par le processeur. Ces instructions sont regroupées habituellement dans un fichier à l'extention *.exe sur les plate-formes Windows.

Les langages interprétés (PHP, Python,...) ne peuvent pas être mis sous la forme d'exécutables. Ils restent des scripts ne peuvant être exécutés que sur une machine possédant l'interpréteur approprié. C'est une limite forte à leur diffusion, surtout à l'ère d'internet et du "tout-en-un-clic". Au sens strict, on ne parle pas de programme, mais de script.

Vous l'avez deviné, GW Basic est un langage interprété et non pas compilé. Les scripts GW Basic (des fichiers textes avec une extension BAS) ont donc besoin d'un programme qui tourne à côté et qui lit le script ligne par ligne, en temps réel. Le script n'est pas transformé en exécutable, mais reste un fichier texte, "lu, compris et réalisé" par l'interpréteur.

Une bonne image serait une pile d’assiettes sales. Chaque assiette correspond à une ligne en GWB. Soit un quidam qui doit les laver (notre éditeur GWB). Il prend l’assiette du haut, la lave, l’essuie, la pose. Il a traité la première ligne de commandes. Il passe à la deuxième. Puis à la troisième. Et il ne pourra jamais s’intéresser à la n^ième  s’il n’a pas fait la n^-1ème avant. Admettons maintenant que la n^ième est cassée (soit une erreur dans le code). Il la prend, essaye de la laver, se coupe, il saigne. Il arrête de nettoyer les assiettes. Notre éditeur vient de planter. Mais il a exécuté correctement toutes les commandes avant, tout comme notre quidam a essuyé ses assiettes. Un compilateur aurait analysé tout le code d'une traite, et aurait immédiatement averti de l'erreur.

On pourrait croire que c'est un avantage, mais en réalité, c'est très handicapant et problématique pour déboguer un script. Ainsi, à l'heure actuelle, se servir de GWB pour un script de plus de 500 lignes revient à peu près à tondre sa pelouse avec un coupe-ongles. Mais c'est pourtant ce que j'ai fait... et vous en aurez la triste preuve si vous téléchargez mes scripts d'exemple...

Parenthèse : Philippe m'a écrit pour m'indiquer une méthode permettant de compiler un programe Basic, au moyen de l'utilitaire BASCOM. Il faut d'abord sauvegarder le programme source depuis GWbasic avec l'option A (save "toto.bas",A) pour indiquer que le format est ASCII. Ensuite, il faut quitter GW et compiler le source avec BASCOM option O (bascom/o, puis donner le nom du fichier toto) avant de lancer LINK en donnant le nom du fichier toto.obj qui est sorti de Bascom. Et on obtient un beau fichier .EXE !

Nous allons essayer maintenant de passer de notre pile d’assiettes à un code source GWB.

Pour cela, il faut savoir que GWB est rédigé au moyen de lignes. On va habituellement de 10 en 10. Cela permet, dans le cas d’une relecture ou d’une modification du programme, d’insérer des lignes entre celles existant. Chaque ligne vaut pour une assiette... Voici un exemple simple de code :

10 CLS
20 PRINT "GW2 Basic démarré"
30 PRINT "Programme d’essai"
40 INPUT A
50 PRINT A
60 END

Il se comprend ainsi :

10 commande pour effacer l’écran
20 écrire « GW2 Basic démarré »
30 écrire « Programme d’essai »
40 acquérir un chiffre et le ranger dans la variable A
50 écrire le contenu de la variable A
60 fin du programme

Si vous commettez une erreur à la ligne 50 (par exemple si vous tapez : 50 PTRINT A), l’ordinateur exécutera correctement les 4 premières lignes, puis vous enverra un message d’erreur... mais pas avant d’être arrivé à la ligne 50.

Avec des scripts un peu plus évolués, on peut arriver à ce genre de résultat :

... avec quelques sons DOS  de très mauvais goût en prime (des bips émis par le haut-parleur de la carte-mère...). C'est à peu près le maximum qu'on peut réaliser en mode texte. En mode graphique, on peut également tracer des lignes et des courbes.

Travailler avec l'éditeur

Présentation de l'éditeur

Après avoir lancé GW2.EXE apparaît la fenêtre présentée ci-dessus. En haut de l'écran on remarque : la version du programme (ici la version 3, ce qui est très logique pour GW2) ; le copyright Microsoft (on voit que cette version date de 1984) ; la mémoire allouée (en Ko !!) ; le résultat du lancement de GW2 ("Ok") et le prompt (curseur clignotant).

En bas de l'écran, on voit la liste des raccourcis claviers, correspondant aux touches F1 à F10 de votre clavier. Quand vous appuyez dessus, cela revient à écrire la commande indiquée ET à la valider par 'Entrée'. Les plus utiles sont LIST, RUN, LOAD, SAVE. (Explications utiles et nécessaires dans la partie dédiée de ce site.)

Le prompt

Au niveau du prompt, il est possible de réaliser trois choses :

- soit taper une commande DIRECTE, qui va s'exécuter immédiatement lorsqu'on appuiera sur Entrée. L'éditeur marque à la ligne du dessous le résultat, affiche Ok une ligne en-dessous, et renvoie le prompt.

Voici par exemple comment afficher le traditionnel "Hello world" :

print "Hello world"
Hello world
Ok
_

- soit taper une commande de GESTION. Par exemple ouvrir un fichier, enregistrer, éditer une ligne d'un script, exécuter un script, effacer l'écran dans la fenêtre DOS (CLS), etc. Ces commandes retournent soit "Ok" soit un message d'erreur (le plus souvent "Types incompatibles", notamment si on omet les guillemets). La commande RUN va exécuter le programme chargé en mémoire.

- soit écrire une LIGNE DE COMMANDE prenant place dans un programme : il s'agit d'une ou plusieurs commandes précédées d'un numéro de ligne. Cela revient à créer un nouveau script. Mais attention ! Il faut toujours effacer de la mémoire de GWB le script précédent avec la commande NEW, sinon les deux programmes vont se mélanger !

Rédiger un programme

Il est possible de rédiger ou de modifier un programme à partir de l'éditeur. Des commandes permettent de charger en mémoire, d'exécuter ou d'enregistrer un script.

Néanmoins, il est vivement recommandé de créer et d'éditer tous les scripts à partir du Bloc-Notes. Ou encore mieux, à partir d'un éditeur dédié à la programmation, et qui ne met pas en forme le texte, mais qui a une coloration syntaxique : Purple, SynTextEditor. Word est ainsi à proscrire !

Il faut alors enregistrer ses scripts avec une extension *.bas. On associera sous windows cette extension à notre éditeur. Dès lors on pourra :

- en double-cliquant sur le script, le modifier ;

- en faisant un cliquer-déplacer du script vers GW2.EXE, l'exécuter ;

- en lançant GW2.EXE et en tapant la commande LOAD "--------.bas", le charger en mémoire.

Il faut éviter de mettre des caractères spéciaux tels que : é è @ ë ô ã dans cette commande si on écrit à partir du bloc-notes, et ceci pour des raisons de codage des caractères. De même, un programme écrit à partir de l'interpréteur et enregistré en .bas ne pourra pas être lu à partir d'un éditeur de texte sous windows.

Gérer les scripts à partir de l'éditeur

Voici la liste des commandes qui permettent de s'en sortir avec l'éditeur (elles peuvent bien entendu être incluses dans le corps d'un programme) :

ALT+ENTREE

ce n'est pas une commande, mais un raccourci clavier qui permet de jongler entre le mode fenêtre et le mode plein-écran

SYSTEM

permet de quitter GW2 pour Windows

CLS

permet d'effacer l'écran (abbréviation de CLear the Screen)

KEY OFF

permet de supprimer la ligne de rappel des commandes en bas de la fenêtre

LIST (raccourci : F1)

permet d'afficher le contenu des lignes du programme (listing)

EDIT ***

(avec un nombre à la place de ***) permet d'éditer une ligne du programme actuellement chargé en mémoire. Cette commande renvoie la ligne ; il faut ensuite la modifier (ou non) et valider avec Entrée.

pour éditer une ligne, on peut aussi se contenter de taper le numéro et la commande associée. Quand on valide par Entrée, la ligne existante est remplacée par celle qu'on vient de saisir. Si on fait suivre le numéro de ligne d'un astérisque * et qu'on valide par Entrée, la ligne est supprimée.

NEW

efface le programme chargé en mémoire, ce qui permet d'en créer un nouveau

SAVE "--------"

avec -------- un nom de fichier (avec ou sans l'extension .bas)

permet de sauvegarder un programme dans le même répertoire que GW2.exe.

SCREEN ***

avec *** un nombre

permet de changer la configuration de l'écran. Elle redevient normale quand vous passez dans Windows ! SCREEN 0,0,0 correspond à un écran "normal".

RUN

permet d'éxecuter le programme actuellement chargé

LOAD "--------"

avec -------- un nom de fichier (avec ou sans l'extension .bas)

permet de charger un programme basic placé dans le même répertoire-racine que GW2.exe

RUN "--------"

avec -------- un nom de fichier (avec ou sans l'extension .bas)

permet d'éxécuter un programme basic

TRON (raccourci : F7)

active la commande TR qui permet, quand on éxécute un programme, d'afficher le numéro des ligne en même temps

TROFF (raccourci : F8)

désactive la commande TR

Les commandes

Ces commandes peuvent être saisies directement dans l'interpréteur ou faire partie d'un programme. La casse (majuscules ou minuscules) est sans importance.

Divers

Deux éléments peuvent être utiles : 

REM ***

cette commande permet d'insérer un commentaire. Tout ce qui suit REM sera ignoré par l'interpréteur.

:

le double-point permet de lier des commandes différentes sur une même ligne. Des exemples sont présentés ci-après.

Variables

En GW Basic, les variables n'ont pas besoin d'être déclarées. (Déclarer une variable, c'est écrire clairement que A est une variable, en disant si il s'agit d'une variable globale ou locale (s'appliquant à tout ou partie d'un programme) et en en définissant le type.) Certains noms de variable sont toutefois interdits.

Le premier type existant est les variables numériques : A, B, C, AK, ABZ, etc. Un nombre (réel ou entier) est alors affecté à la variable, et il est possible de réaliser des calculs avec elle.

Le second type est les variables de chaînes : A$, B$, CN$, ND(8)$, etc. Il s'agit de chaînes de caractères ASCII. Le contenu de ces variables doit être entouré de guillemets : A$="mqjlmj".

Enfin, il est possible de déclarer des listes de nombres : A(0), A(1), A(2), etc. ou des listes de chaînes de caractères : B$(0), B$(1), B$(2), etc. Si C est une variable contenant un nombre entier, alors il est possible d'appeler une liste A à son Cème index en écrivant : A(C). C'est tout l'intérêt des listes.

Voici les commandes qui s'appliquent directement aux variables :

LET A=5

change la valeur de la variable A.

on peut aussi écrire : LET A=5*B/C, etc. La commande LET peut être omise, mais il est conseillé de l'écrire.

LET A=RND

affecte une valeur aléatoire, comprise entre 0 et 1 (exclus), à 10 chiffres après la virgule, à A.

par exemple, la commande : LET A=INT(350*RND) affecte une valeur comprise entre 0 et 350 (exclus) à la variable A (INT permet de renvoyer la partie entière).

 Voici quelques opérateurs qui s'appliquent aux variables numériques :

+ : somme

- : soustraction

* : produit

/ : division

^ : exposant

INT : partie entière

RND : valeur aléatoire

. : symbole de la virgule

ABS : valeur absolue

FRAC : partie décimale d'un nombre (renvoi du type 0.185 et non 185)

> : supérieur à

< : inférieur à

= : égal à (fonctionne aussi pour des variables de chaînes)

<> : différent de (fonctionne aussi pour des variables de chaînes)

Commandes de saut

On rappelle que sous GW BASIC, toutes les lignes sont numérotées. Il est donc possible de se rendre à une ligne précise grâce à une commande :

GOTO x

l'interpréteur va à la ligne x

Cette commande n'existe pas dans les langages modernes (ou de manière très anecdotique, son utilisation n'étant pas recommandée).

Commandes d'affichage

Elles permettent à l'interpréteur de renvoyer des informations à l'utilisateur, via l'écran. A noter qu'il est aussi possible de gérer un port LPT1.

PRINT "ABC123"

afficher à l'écran le texte entre guillemets (ici : ABC123).

rappel : si on écrit à partir de windows dans un éditeur de texte, il faut éviter les caractères spéciaux (accents, etc.).

l'emploi de ; dans une commande PRINT permet d'afficher plusieurs éléments à la suite

PRINT A

afficher à l'écran la valeur de la variable numérique A

PRINT A$

affiche la variable A$ (chaîne de caractères)

PRINT (CHR$(13))

affiche le caractère ASCII correspondant au numéro mis entre parenthèse (le caractère 13 correspond à un retour à la ligne, dit retour chariot).

PRINT STRING$(80,CHR$(114))

écrire 80 fois le signe "r" (CHR$(114))

remarque : ALT+114 (ou autre nombre) : affiche un caractère spécifique à l'écran : ALT+13 = "ENTREE"

PLAY "A"

émettre un son grâce au haut-parleur de la carte mère. On doit indiquer entre parenthèses un paramètre de A à H, qui n'est pas une variable, mais une indication pour la tonalité du son.

LOCATE x, y

cette commande permet de déplacer le curseur à l'écran à une ligne x (de 1 à 24 lignes) et sur une colonne (de 1 à 80).

on peut se contenter d'écrire LOCATE x pour se déplacer à la ligne x, ou remplacer x et y par des variables.

COLOR x

écrire en couleur. Le chiffre de la couleur est compris entre 0 et 31. La fin des nombres correspond à des couleurs qui clignotent à l'écran. Exemples : 0=noir, 2=bleu, 5=mauve, 7=blanc-gris, etc.

tant qu'on n'entre pas une autre commande COLOR, la couleur sélectionnée reste active.

attention toutefois, les couleurs sont... flashy.

COLOR 2,5,14

écrire en couleur bleue (2) sur fond mauve (5) avec l'écran bordé de jaune (14).

cette commande est surtout utile suivie de CLS ; l'interpréteur affichera alors tout l'écran en mauve. Cela permet sinon d'écrire quelques éléments à l'écran sur fond coloré.

LINE (1,1)-(100,100)

fonctionne dans certains modes d'affichages seulement (SCREEN 9 par exemple : écran de 350 pixels par 640). Trace une ligne entre les points de coordonnées (1,1) et (100,100). Peut être associé à une couleur. Pour placer un point de coordonnées (50,70), on fera : LINE (50,70)-(50,70).

Commandes d'entrée

Les commandes d'entrée permettent à l'utilisateur d'interagir avec le programme. Ce qui est saisi par l'utilisateur est stocké dans une variable.

INPUT A

demander une variable numérique à l'utilisateur. Un "? " s'affiche à l'écran, et l'utilisateur entre un nombre. La valeur numérique entrée est affecté à la variable A.

INPUT A$

prendre en compte une entrée de l'utilisateur. Ici, le nom de la variable (A) est suivi de "$" : alors la commande affecte une chaîne de caractères à la variable A$. Si A$ est une chaîne numérique (par exemple A$="20457"), il est impossible d'effectuer des calculs avec. Elle sera stockée comme étant une chaîne de caractères ASCII.

A$=INKEY$

cette commande est très utile pour prendre en compte une frappe de l'utilisateur de manière transparente. Rien ne s'affiche à l'écran ; l'interpréteur enregistre une frappe sur le clavier (une et une seule).

Attention ! Contrairement à ce qu'on pourrait croire, le programme ne s'arrête pas sur cette ligne jusqu'à ce que l'utilisateur appuie sur une touche. Il regarde la valeur en tête du buffer clavier, et passe à la suite.

Il faut donc faire suivre sur la même ligne la commande INKEY$ par :IF A$="" THEN GOTO la ligne où l'on se trouve. Dans le cas contraire, l'interpréteur passe directement à la ligne suivante, sans attendre de valeur.

Tests logiques

Les tests logiques sont la base de la programmation, avec les boucles. Ce sont eux qui permettent de créer des programmes qui ne soient pas linéaires. Autrement dit, ils permettent au programme de réagir de différentes manières dans des cas différents.

IF A$="Paul" THEN GOTO 150 ELSE GOTO 120

si (IF) la variable A$ égale à "Paul" alors (THEN) aller à la ligne 150 (GOTO 150) sinon (ELSE) aller à la ligne 120 (GOTO 120).

le ELSE est facultatif. Si on l'omet, l'interpréteur passe à la ligne suivante.

IF A<>19 THEN PRINT A

si (IF) la variable A différente de 19 (A<>19) alors (THEN) afficher la valeur de A à l'écran (PRINT A)

 Il est possible de réaliser les tests suivants :

A<>19 ou A$<>"ABC" : A différent de 19, respectivement ABC

A=19 ou A$="ABC" : A égal à 19, respectivement ABC

A<19 : A inférieur à 19

A>19 : A supérieur à 19

A$<>"" : A$ différent d'une chaîne vide (A$ contient une valeur)

A$="" : A$ égal à une chaîne vide

Boucles 

Les boucles sont l'autre élément fondamental en programmation. Elles permettent de réaliser une série de commande un grand nombre de fois et d'automatiser une action, ou d'appliquer une série de commandes à une même plage de valeurs.

Ces boucles pourraient être réalisées grâce à un test logique, à une variable incrémentée et une commande GOTO, mais il existe un moyen plus simple sous GW Basic :

FOR A=1 TO 20000
(série de commandes à répéter)
NEXT A

dans cet exemple, la série de commande est réalisée pour A allant de jusqu'à 20000 : la ligne NEXT A renvoie à la première ligne, en augmentant la valeur de A de 1 à chaque passage (incrémentation), ce qui fait qu'au bout de 20000 passages entres ces deux lignes (en 1-2 secondes), l'ordinateur passera aux autre lignes du programme.

Si les deux commandes sont sur une même ligne, et séparées par un : alors la commende sert à temporiser (mettre au moins 100000 pour un délai sensible).

Pour sortir de la boucle, il faut insérer dedans un test IF/THEN qui renvoie vers une commande GOTO qui pointe sur la ligne suivant le NEXT.

Les programmes plus modernes permettent de réaliser des boucles plus élaborées, et simplifient la manière de sortir de la boucle.

Les fonctions sont un élément fondamental de la programmation moderne. Malheureusement, GW Basic ne permet pas de les réaliser.

Exemples simples

Ces quelques exemples simples s'adressent à un débutant. Ils précisent également comment se servir de l'éditeur.

Addition

Le programme ci-dessous permet d'additionner deux nombres :

10 cls:key off
20 locate 3,5:color 5:print "LOGICIEL DE CALCUL"
30 locate 7,5:print "Entrez le premier chiffre :"
40 input A
50 locate 9,5:print "Entrez le second chiffre :"
60 input B
70 locate 11,5:color 5,2: print "La somme est";A+B
80 end

Ce script sert à additionner deux chiffres... c'est un code très basique sans boucles ni tests !

Exercice : modifiez ce programme pour que, dès le départ, l'utilisateur ait le choix d'additionner, multiplier, soustraire ou diviser deux nombres.

Complément : avec la division, vous pouvez aborder sommairement le principe de la robustesse des programmes. Il faudra intégrer un test vérifiant qu'on ne demande pas à l'ordinateur de diviser par 0.

Age et nom
 

Une fois dans l'éditeur GW Basic, on tape KEY OFF : CLS pour effacer l'écran, et on saisit le listing suivant :

10 key off:cls
20 print "Quel est votre nom ?"
30 input A$
40 print "Quel est votre age ?"
50 input B
60 print "Vous vous appelez ";A$;" et avez ";B;" ans."
70 end
SAVE "Jedebute"
RUN

On peut modifier ce programme en posant d'autres questions, en ajoutant de la couleur, en ajoutant quelques tests (55 IF B<1 THEN PRINT "Saisie erronnee":GOTO 50)...

Il est aussi possible d'écrire les lignes 10 à 70 dans un fichier texte, et de changer le nom du fichier de Jedebute.txt en Jedebute.bas sous windows. On lance ensuite GW Basic, et on charge le programme grâce à LOAD "Jedebute". On l'exécute ensuite grâce à RUN.

Il est très utile d'associer l'extension *.bas à votre éditeur de texte. Il est ainsi possible de l'ouvrir directement dans l'éditeur de texte. Pour l'exécuter avec GW Basic, il est aussi possible de faire un cliquer-déplacer du script vers le programme.

Age et nom amélioré

Il est possible de réécrire ce programme en l'améliorant un peu :

10 key off:cls
20 print "Quel est votre age ?"
30 input A
40 if A<1 or A>120 then goto 60
50 goto 80
60 print "Saisie erronnee..."
70 goto 20
80 print "Merci."
90 print "Quel est votre nom ?"
100 input B$
110 print "Merci de patienter..."
120 for C=1 to 20000
130 next C
140 cls
150 print "Vous avez ";A;" ans et vous vous appelez ";B$;"."
160 end

Ce programme demande l'âge de l'utilisateur (lignes 10 20 30), vérifie s'il est cohérent, par des tests sommaires (lignes 40 50) et envoie un message, en cas contraire (lignes 60 70).

Il demande ensuite à l'utilisteur son nom (lignes 80 90 100), puis effectue une boucle pour temporiser (lignes 110 120 130).

L'ordinateur redonne ensuite les informations acquises (ligne 140 150) puis stoppe le programme (ligne 160).

L'intérêt de ce script est qu'il effectue des tests pour vérifier la cohérence des résultats et informations qu'on lui fournit. En outre, il renvoye à l'utilisateur des informations sur ce que lui-même fait et sur ce que l'utilisateur doit faire (attendre, donner son nom, etc.). Le retour de l'information vers l'utilisateur est une composante fondamentale de l'informatique actuelle. Ne négligez jamais cet aspect, de même que la robustesse de vos programmes.

Ce programme peut cependant encore être amélioré... par l'intégration d'autres tests, comme par exemple :

105 if B$="Ton nom" or B$="TON NOM" then print "Utilisateur reconnu"

eventuellement en rajoutant ELSE GOTO 170 avec :

170 print "Utilisateur non reconnu - fin programme"
180 end

On voit déjà ce qui peut suivre... La reconnaissance de l'utilisateur, et l'intégration de mot de passe... Ceci dit, le niveau de sécurité qu'on peut obtenir avec un programme GW Basic est ridiculement bas...

Exemples avancés

Dans l'archive ZIP que j'ai proposée en téléchargement, et qui contient le programme GW2.exe se trouvent également quelques programmes de mon cru :

- un programme basique de cryptographie, basé sur le chiffre de Vigenère. Inutile de dire qu'il n'est pas très commode à l'usage et d'une sécurité toute relative... Il y avait un mot de passe pour accéder au programme ; j'ai modifié le script pour que ce mot de passe s'affiche en clair (OVERAGE). Ceci dit, avec un load "Code.bas", il n'est pas très dur à retrouver...

- divers programmes autour des nombres premiers : ils permettent de définir si un nombre est premier ; ils génèrent la liste des nombres premiers, etc. ;

- un jeu de morpion, mais je ne suis pas l'auteur de l'algorithme d'IA ;

- plusieurs programmes "d'affichage", qui permettent de consulter la table de Mendeleïev et d'afficher des informations sur les éléments chimiques. Cette table est en trois fichiers et n'a pas été achevée. Elle comprend encore des bugs non résolus. Et pardonnez-moi les bi-bi-biii-bip aux changements de pages, j'étais jeune...

Ces programmes ne sont pas parfaits, mais ils donnent un aperçu de réalisations possibles en GW Basic. Le programme d'affichage de la table de Mendeleïev s'apparente quand même pas mal à une tentative de suicide, vu le nombre d'informations à saisir dans un code aussi abscons. (Je me rappelle encore l'avoir fait, alors que ça remonte à plus de dix ans...)

Par ailleurs, je débutais largement en programmation quand je les ai réalisés, et il y a pas mal d'erreurs dans les scripts (qui ne conduisent pas à des bugs, mais qui sont des lignes de codes non optimisées).

Liens

Le GW Basic est assez peu représenté sur internet. On trouve sur youtube quelques vidéos, par exemple ici, même si on constate que certains ont un peu de mal.

Le manuel officiel, en anglais, mérite également d'être consulté.