Rétro Coding sur VICE

Ça fait déjà quelque fois que j’en parle, mais je suis un fan de rétro. Je pense que pour apprécier ce qu’on a aujourd’hui, il faut savoir apprécier ce qu’il y avait avant. Aujourd’hui, j’aimerais aller là ou je ne suis jamais allé, soit écrire du BASIC dans un Commodore 64 via l’émulateur VICE.

Mais pourquoi diantre?!

Pour exactement la même raison qu’un peintre va se limiter lui-même à une palette de couleurs précise pour faire une toile. On s’applique une ou plusieurs restrictions pour laisser notre cerveau arriver avec des solutions hors du commun. Donc, avant même de savoir comme ça fonctionne, je vais tenter de reproduire le classique « to do application ».

Préparation

Pour cet article, j’ai utilisé Ubuntu et j’ai installé Vice via apt. Si vous utilisez Windows, téléchargez ici.

Une fois vice et l’environnement du C64 est prêt, rouler :

Vous devriez voir soit un écran qui vous est familier, soit quelque chose d’effrayant et incompréhensible, tout dépendant l’âge que vous avez 😛

Quelles sont nos restrictions?

Vite comme ça, on voit qu’on a 38 911 octets de disponible pour notre code qui sera écrit en BASIC, mais je ne pense pas qu’on risque d’utiliser tout ça 😛 par contre, vous voyez l’éditeur? Pas de menu, pas de barre de défilement, pas de recherche… on écrit une ligne, on fait « enter », elle est traitée 😉

Ceci dit, mis à part les restriction de l’environnement, on peut ajouter à ça une restriction au niveau des fonctions BASIC disponibles. Un très bon exemple de ça, c’est qu’il n’existe pas d’instruction « else » pour le « if ».

J’ai parlé du fait qu’il faut mettre les numéros de ligne avant le code? Ouaip! on écrit 10 PRINT "HELLO WORLD!". Comme ça, si on se trompe, on peut écraser le code d’une ligne en remettant le même numéro de ligne. Il faut donc prévoir des « espaces » entre les numéros si on veut y ajouter du code plus tard. Par exemple :

Ce bout de code affichera HELLO WORLD!  en boucle (esc pour quitter), mais on pourrait ensuite taper :

Et la ligne serait alors insérée entre la 10 et la 20.

Oh! Et… dernier point. Vous vous souvenez de votre prof qui vous disait de ne JAMAIS utiliser de GOTO ? Ici c’est la norme.

Les commandes de base pour exécuter le code

Au démarrage, la RAM est vide. Commencez à taper du code et faites « enter » pour envoyer la ligne en mémoire.

Pour lister le contenu du code qui se trouve en mémoire, il faut exécuter LIST. Le C64 devrait vous répondre READY .

Pour exécuter le code en mémoire, tapez RUN. Le C64 devrait vous répondre READY .

Si vous voulez recommencer depuis le début, tapez NEW pour réinitialiser le programme. Le C64 devrait vous répondre READY .

Let’s GoOoOo!

L’objectif étant de recréer l’application de gestion de tâches à faire que j’ai l’habitude d’utiliser comme exemple lorsque je donne des formations. Dans cette application, on peut :

1.  créer une tâche à faire
2. marquer une tâche comme complétée
3. lister les tâches

Pour y arriver, gardons ça au plus simple pour commencer. La liste des tâches sera conservée dans un tableau de chaînes de caractères alors que l’indicateur pour vérifier si une tâche est complétée ou non sera stocké dans un deuxième tableau. Comme ça, on pourra retrouver l’information des deux propriétés en utilisant le même indice.

Initialisation

Cette section nous permettra d’initialiser les différentes variables qui seront utilisées et préparer l’écran pour l’affichage.

J’ai perdu qui là? Pas de panique, c’est du chinois, c’est normal 🙂 Ça fait partie de l’exercice.

PRINT CHR$(147)  permet simplement d’effacer le contenu affiché à l’écran. Pourquoi CHR$(147) ?

Du gros fun en vue 😛 CURRENT correspond à l’indice du prochain todo à ajouter, on se souvient, BASIC commence à 1 pas à 0 😛

Les lignes 20 et 25 déclarent les deux tableaux, le premier étant un tableau de chaînes de caractères à cause du suffixe $ au nom de la variable, et l’autre contient des entiers à cause du suffixe %. J’ai bien dit entier. Il n’existe pas de type booléen pour nos variables sur le C64, nous stockerons donc 0 (false) ou 1 (true)

Boucle principale

Lorsqu’on programme avec un langage procédurale, on doit avoir une boucle d’exécution qui va permettre à l’utilisateur de garder le programme ouvert tant qu’il ne désire pas quitter. Ça nous prend donc un point d’entrée pour boucler. Ici, on va simplement retenir le numéro de ligne et effacer le contenu à l’écran pour préparer l’affichage du menu :

Menu et liste

Affichons simplement un menu indiquant à l’utilisateur les différentes options possibles :

Pour faire simple, j’ai laissé la ligne 70 absente pour pouvoir insérer le IF CHOICE = 2 THEN GOTO ...  lorsque j’aurai une idée de ou sera la ligne du début du code pour le choix deux. La ligne qui contient PRINT "CHOIX";:INPUT CHOICE% permet de prendre l’entrée de l’utilisateur et de stocker cette valeur dans la variable CHOICE, puis on branche l’exécution avec un GOTO ou un END selon le choix, sinon on reboucle à l’initialisation du menu pour redemander son choix à l’utilisateur.

Créer un todo

Si l’utilisateur choisi l’option 1, demandons-lui simplement la description de tâche, puis ajoutons-là avec son indicateur aux deux tablaux, puis on retourne à l’écran principal :

Marquer un todo comme complété

Ici, on va afficher la liste des TODO avec leur indice, puis un indicateur à savoir si la tâche et faite ou non, puis la description. Pour finir, on demande à l’utilisateur de choisir le todo à compléter, en profitant du fait qu’on débute à l’indice 0 pour permettre à l’utilisateur d’annuler l’action :

Tester la solution

Pour lancer, simplement exécuter RUN.

Code complet

Conclusion

Bon. Aujourd’hui, j’espère que vous avez appris que les vielles technos peuvent aussi être cool. Ça nous force à penser autrement. Par exemple, si on voulait ajouter une autre propritété aux todos, comme par exemple la date de création, comment on aurait pu recréer le concept de l’objet pour le pas avoir 1 tableau par propriété? Faudrait s’y pencher un peu 😛

Si vous avez aimé, n’hésitez pas à partager dans vos réseaux!

Cheers!