En attendant que l’un des constructeurs de calculatrices crée une application Sofus pour calculatrice, voici comment on peut programmer en Sofus sur une calculatrice programmable en Python :

• Sur Numworks, il suffit de se rendre sur cette page à l’aide du logiclel Chrome et là, une fois la Numworks connectée, de cliquer sur le bouton Envoyer sur ma calculatrice
• Sur Casio, brancher la calculatrice sur un ordinateur en mode USB (ceci fera apparaître un dossier sur l’ordinateur ; ce dossier n’est autre que la Casio) puis copier-coller le script Python ci-dessous dans le dossier Casio. Après avoir déconnecté la Casio, on peut la programmer en Sofus.
• Sur Ti, il est nécessaire de disposer de la dernière version du logiciel Ti-Connect pour être en mesure de charger un script Python sur la calculatrice Ti 83 Premium CE Python. Si on ne dispose que de la Ti 83 Premium CE, on peut, à l’aide du logiciel Ti-Connect, y transférer le fichier SOFUS.8xv ci-dessous

Si le fichier sofus.py ci-dessus pose problème parce qu’il a été « zippé », on peut aussi le télécharger, « dézippé » en cliquant sur le lien télécharger ci-dessous :

Voici le script à télécharger directement :

Le principe de la programmation objet est de faire accomplir les tâches non pas directement par la machine, mais par des objets auxquels on s’adresse par envoi de messages. Par exemple, si je veux savoir ce qu’il advient de la variable prix après une augmentation de 5 pourcents, je lui demande de s’augmenter elle-même de 5 pourcents ce qui s’écrit augmente_toi_de(5,pourcents). Mais pour que cette requête aie des chances d’aboutir, il faut que

• L’objet qui s’appelle prix soit capable de s’augmenter de 5 pourcents : On dit qu’il doit posséder une méthode (informatique) d’augmentation ;
• Je précise à qui je donne l’ordre d’augmenter (cela n’a en général pas le même effet sur moi, que l’on augmente mon pouvoir d’achat ou le coût de la vie !). Tant que j’écris augmente_toi_de(5,pourcents) aucun objet ne fera rien, faute de savoir à qui l’ordre est donné. En Python, on précède un ordre (qui est d’ailleurs le nom de la méthode) du nom du destinataire, séparés par un point. Comme dans prix.augmente_toi_de(5,pourcents) qui est à lire comme « Ohé prix, je m’adresse à toi : Augmente toi de 5 pourcents »

Le nom de Sofus vient d’une allusion à la théorie des groupes de Lie et à son créateur Sophus Lie qui ramenait les transformations à des compositions de transformations simples, dites infinitésimales. Les transformations qui peuvent s’appliquer à une variable Sofus sont en fait les méthodes que possède cette variable (puisque la variable est chargée de se transfomer elle-même, sur demande) et en voici la liste, spécifique du langage Sofus :

• augmente_toi_de() permet d’augmenter la variable d’une quantité à préciser (ou d’un pourcentage à préciser). Par exemple si la valeur actuelle d’une variable est 8, augmente_toi_de(5) la fera passer à 13 et augmente_toi_de(5,pourcents) la fera passer à 8,4
• diminue_toi_de() permet de diminuer la variable d’une quantité (ou d’un pourcentage) à préciser. Par exemple si la valeur actuelle d’une variable est 8, le message diminue_toi_de(5) la fera passer à 3 ;
• multiplie_toi_par() permet de faire agir un facteur (à préciser) sur la variable [1]. Par exemple si la valeur actuelle d’une variable est 8, le message multiplie_toi_par(5) va la transformer en 40 et le message multiplie_toi_par(5,pourcents) va la transformer en 0,4 (soit 40% de 8). Des variantes existent comme
  • double_toi() qui a le même effet que multiplie_toi_par(2)
  • triple_toi() qui a le même effet que multiplie_toi_par(3)
  • decuple_toi() qui a le même effet que multiplie_toi_par(10)
• divise_toi_par() permet de diviser une variable par un nombre (éventuellement donné en pourcents). Par exemple si la valeur actuelle d’une variable est 8, divise_toi_par(5) la transforme en 1,6 et divise_toi_par(5,pourcents) la transforme en 160.
• eleve_toi() éleve une variable à une puissance à fournir. Pour que Sofus reste proche de la langue française, l’exposant est donné sous la forme d’une fonction appelée a_la_puissance(). Par exemple si la valeur actuelle d’une variable est 8, le message eleve_toi(a_la_puissance(5)) aura pour effet de l’élever à la puissance 5 ce qui la transformera en 32768. Sofus propose aussi les abréviations suivantes :
  • eleve_toi(a_la_puissance(3)) s’abrège en eleve_toi(au_cube)
  • eleve_toi(a_la_puissance(2)) s’abrège en eleve_toi(au_carre)
  • eleve_toi(a_la_puissance(-1)) s’abrège en invese_toi() (avec des parenthèses vides parce que c’est la syntaxe des méthodes d’un objet)

Il y a d’autres méthodes de l’objet variable de Sofus que celles permettant de faire varier les variables :

__repr__ permet à l’objet d’avoir une représentation visible. En l’occurence, on demande que si une variable soit évaluée (par exemple dans la console) le résultat de l’évaluation soit la valeur de la variable.

__str__ est une méthode de conversion en chaîne de caractères. Elle permet que si v est une variable Sofus, print(v) n’affiche pas Variable object mais la valeur de la variable.

Enfin la méthode __init__ est particulière en ce qu’elle ne s’applique pas à l’objet mais à sa classe : Elle a pour effet de faire naître un objet de type Variable (en initialisant sa valeur, d’où le nom de cette méthode). Mais il n’est pas possible pour un objet non encore né, d’entendre le message lui disant de naître. Parce que tant qu’on n’est pas encore né, on n’entend rien. C’est donc à la classe Variable qu’est envoyé le message de naissance, ce qui a pour effet de faire naître un objet de cette classe (une variable Sofus) lequel, ensuite, pourra entendre les autres messages et varier selon les desiderata du programmeur et les messages que celui-ci enverra à la variable.

Pour créer une variable Sofus appelée prix et l’initialiser à la valeur 8, il faut donc écrire dans la console (ou dans un module, après avoir entré from sofus import *) le code

prix = Variable(8)

Une variable (informatique) est décrite comme « un symbole qui associe un nom et une valeur ». Une variable de Sofus doit donc posséder, outre ses méthodes, au moins un nom et une valeur. Cette notion est fondamentale dans le modèle de Dana Scott et Christopher Strachey pour qui un ordinateur (ou une calculatrice) est une machine à états fini, chaque état étant un ensemble de variables.

Dans Sofus, la valeur de la variable prix est notée prix.valeur ce qui est cohérent avec les notations de la programmation objet. Et la valeur de la variable courante (celle à qui on s’adresse) s’appelle, self.valeur ce qui peut se traduire par « ma valeur à moi »

Python aussi a ses variables, on y accède directement par leur nom. Et pour initialiser une variable on l’affecte ce qui se fait par un signe d’égalité. Voici une équivalence approximative entre Sofus et Python, concernant une variable v initialisée à 8 :

Comme on le voit, la syntaxe de Python est bien plus concise que celle de Sofus, mais aussi plus éloignée de la langue naturelle (qui prononce l’expression « fois-égale » dans la vie de tous les jours ?). Et le portage de Sofus en Python aboutit à cette solution mixte, avec des variables des deux types : Quand on écrit

prix = Variable(100)

on crée une variable de Python appelée prix, et dont la valeur est un objet de type « variable de Sofus » ayant la valeur initiale 100. Cette subtilité n’est pas importante pour qui veut juste programmer en Sofus sur la calculatrice.

La principale difficulté que présente la calculatrice pour la programmation, que ce soit en Python ou en Sofus, est l’usage du clavier, dont l’ergonomie ne vaut pas, et de loin, celle du clavier d’on ordinateur. Aussi, pour éviter le risque que l’utilisateur se cantonne à des noms de variables d’une seule lettre (sans parler des instructions dont le nom se doit d’être long si on veut qu’il soit explicite), les constructeurs de calculatrice ont opté depuis longtemps pour la navigation dans les menus. Avec par exemple ce bouton :

qui permet de naviguer dans les variables déjà définies dans la session. Du moins avec la Numworks et la Ti, parce que pour l’instant ce bouton est inopérant sur la Casio. Mais la programmation Python étant pour l’instant considérée plus comme « fonctionnelle » que comme « objet », les classes et leurs méthodes n’apparaissent pas dans ce menu. Les bricolages préconisés dépendent de la calculatrice :

• Pour La Ti et la Numworks, chaque méthode de l’objet Variable est une fonction ayant un homonyme vu comme variable globale. Par exemple
  1. def augmente_toi_de():
  2.      pass

  Télécharger

  Alors en entrant le nom d’une variable Sofus puis le point, il suffit de naviguer dans le menu des variables pour ajouter le texte .augmente_toi_de() dans lequel il suffit d’insérer l’incrément.

• Pour la Casio et la Numworks, on peut afficher le nom des variables et naviguer dans cet affichage puis faire du copier-coller pour rapidement avoir le texte dans la console Python.
• Pour entrer le texte pourcents ou a_la_puissance (ou au_carre ou au_cube), la Ti et la Numworks facilitent le travail, puisque ce sont des nomns de variables, auxquelles on accède par le bouton « var » ou « vars ».
• Pour la Casio, les textes pourcents etc sont affichés au lancement de Sofus et il faut naviguer dans cet affichage pour le copier-coller dans la console.
• Le texte Variable() permettant de facilement créer des variables dans Sofus, est affiché au lancement de Sofus, ce qui permet, sur Casio ou Numworks, de copier-coller ce texte dans la console [2].

Pour faire la comparaison entre les calculatrices, on va traiter un exemple simple : Un prix initialement fixé à 100 €, augmente puis diminue de 5 pourcents, et on souhaite connaître sa valeur finale.

L’incrément d’une variable est loin d’être spécifique de Sofus (même Scratch permet cela). Dans Sofus, le verbe incrémenter sous-entend que l’incrément est 1, mais dans χCAS, l’incrément est à donner entre parenthèses, après le nom de la variable. De même, des équivalents pour les 3 autres opérations ont été fournis, y compris sous la forme de néologismes :

L’avantage de χCAS sur Sofus est qu’il n’est pas nécessaire de passer par la programmation objet et les variables spécifiques de Sofus : Toute variable Python peut être incrémentée, décrémentée, multcrémentée ou divcrémentée en χCAS, ce qui permet de refaire les scripts sans pourcentages assez rapidement avec χCAS [3]. Par exemple :

• Nombres triangulaires :

• 24 dés

• puissances de 2

• factorielle

Outre le fait que χCAS ne permet pas d’augmenter, diminuer etc d’un pourcentage, il lui manque les mots doubler, inverser etc pour être aussi naturel que Sofus.

Par contre, avec Sofus en Python, si on veut faire aussi du calcul formel, il faut utiliser, en plus, le module SymPy.

Et χCAS permet aussi d’explorer un petit programme en mode pas-à-pas, ce qui est d’une grande aide à l’apprentissage de la programmation.

Enfin, il y a une autre syntaxe dans χCAS plus proche de la programmation objet de Sofus en Python ; par exemple au lieu de increment(v,3) on peut écrire v.increment(3) qui est très proche de la notation objet de Sofus en Python.