Tuteur pour le langage SMALLTALK

L'analyse des sources des programmes a mis en évidence des "écueils conceptuels" tels que la duplication de code et le saucissonnage de code. La duplication de code survient lorsque pour des actions similaires (comme trier un tableau de fournisseurs et trier un tableau de clients), on écrit à peu près les mêmes instructions, à quelques modifications près. Le développement se fait d'ailleurs de façon asynchrone : on écrit par exemple le sous-programme de tri du tableau des clients, on le teste, on le met au point puis on le recopie en changeant de nom et on effectue les quelques modifications nécessaires pour qu'il trie le tableau des fournisseurs. Le saucissonnage de code intervient au contraire lorsqu'on garde un seul sous-programmme pour tout gérer : on passe alors sans arret d'un paquet d'instructions communes à des structures de cas multiples en pagaille. Le saucissonnage intervient aussi lorsqu'on qu'on doit gérer de nombreux paramètres.

De plus, la programmation classique des interfaces utilisateurs oblige à un code important car les fenêtres d'applications pour les environnements graphiques utilisent de nombreuses sous-fenetres similaires avec des composants standards comme les boutons, les menus. Chaque fenêtre a son jeu de paramètres multiples comme la taille, la largeur, la hauteur de la fenêtre, le nom de la police de caractère, la taille de la police, les attributs logiques de passage en gras, en souligné, etc. ce qui entraine des listes des paramètres monstrueuses.

Face à ces problèmes de taille de code et face donc à l'arrivée des interfaces utilisateurs graphiques, il a fallu repenser le schéma de développement d'une application : au lieu de développer des programmes qui traitent des données, c'est à dire au lieu d'accorder la priorité aux programmes, on a décidé de gérer des objets (données) qui comportent des méthodes (programmes) et donc de se focaliser sur les données. Structurer un programme en sous-programmes était une obligation. Quant aux données, elles pouvaient ne pas être structurées du tout ou être structurées de facon incohérente sans qu'on n'y puisse rien.

La programmation objets a donc imposé de gérer les données, en organisant des modèles de données, nommées classes d'objets qui comportent des variables ou "champs" et des sous-programmes nommés "méthodes" dans la terminologie objets.

Des actions similaires se voient alors donner le même nom, c'est ce qu'on appelle le polymorphisme. Un comportement défini pour un modèle est automatiquement détecté et repris par un sous-modèle : on dit qu'il y a héritage des actions. De plus, les modèles peuvent avoir des valeurs par défaut. Au lieu de donner tous les paramètres par exemple pour une fenêtre utilisateur, on peut se contenter de ne donner que les valeurs différentes des valeurs par défaut d'où un code plus court.

La plupart des langages existant dans les années 90 (comme C et Pascal) ne pouvaient pas implémenter ces concepts directement et on a donc "bricolé" ces langages pour qu'ils puissent gérer les objets. Par exemple, le langage pascal est devenu le langage pascal orienté objets (comme dans Turbo Pascal pour Windows) : un objet est simplement défini comme un type particulier qui permet de coiffer les autres déclarations... Signalons qu'avec l'arrivée des développements visuels (on compose à l'écran les fenêtres d'application et la machine écrit le code correspondant) les objets fondamentaux comme les listes déroulantes, les barres d'outils etc. sont passés dans le standard des objets élémentaires et les langages ont encore effectué une évolution. Ainsi Turbo Pascal pour Windows est devenu Delphi qui est à la fois un langage et un environnement de développement basé sur le langage pascal.

SmallTalk lui, a utilisé une approche radicalement différente : conçu dés le départ pour gérer des objets (il s'agissait initialement de gérer de "vrais" objets réels comme des imprimantes, des photocpieuses) avec une interface ergonomique, il a tout de suite mis en place les concepts d'un langage objet "pur" : on commence par les objets, on finit par les programmes. Cela oblige les programmeurs classiques à changer leur mode d'écriture mais cela donne un langage très cohérent doublé d'un environnement adapté à l'écriture de classes et de méthodes...

Un tel environnement n'a rien à envier aux EDI (environnement de développement intégré) des années 2000, sauf pour les interfaces visuelles, ce qu'on peut aisément lui pardonner vu son grand age... De plus elle fonctionne encore très bien après l'an 2000, ce qui la rend sympathique !

Lorsqu'on lance SmallTalk, une fenêtre d'interaction apparait, nommée Transcript. On peut y écrire des commentaires entre des guillemets, écrire des instructions que SmallTalk viendra exécuter.

Par exemple si on écrit dans la fenêtre de Transcript le texte 'bonjour' size et si on sélectionne ce texte à la souris, un clic sur le bouton droit permet d'éxécuter l'instruction avec "Show it". SmallTalk écrit alors 7 ce qui signifie que la longueur de la chaine 'bonjour' est 7.

La différence entre le mode "Do it" et le mode "Show it" est importante : "Do it" exécute l'instruction mais ne dit rien par défaut, "Show it" affiche la derniere expression renvoyée par l'instruction. Si par exemple on trie une liste et qu'on met le résultat dans un fichier, "Do it" pourra se contenter de tout effectuer sans affichage intempestif alors que "Show it" viendra éventuellement afficher toute la liste triée, ce qui peut encombrer la fenêtre de Transcript.

On n'écrit pas de "programme" en SmallTalk mais des sous-programmes (on dit en fait une méthode plutot que sous-programme) relatifs à une classe d'objets choisis. Pour cela, après avoir réfléchi à la classe d'objets à utiliser, on utilise le gestionnaire de classe qu'on apppelle par le menu File / Browse Classes.

Une nouvelle fenêtre apparait, composée de 4 panneaux (pane en anglais). Les 3 panneaux du haut permettent de choisir les classes et les méthodes, celui du bas à écrire le texte de la méthode.

Soit la classe existe déjà (comme par exemple pour les nombres) soit on l'invente à l'aide de la commande Classes / Add Subclass.

Toutes les classes (il y en a en gros 170) ne sont pas affichées (on s'en rend compte à cause des symboles ... en fin de nom de classe). Un double-clic sur le nom de la classe affiche les sous-classes. Si on ne sait pas où est une sous-classe (par exemple pour un(e) débutant(e) il n'est pas du tout évident que la classe des nombres "Number" est une sous-classe de la classe "Magnitude"), on peut utiliser la commande Class / Find Class ou consulter une liste papier ou une page web comme celle du professeur Naugler pour avoir toute la hiérarchie des classes.

Pour écrire une méthode, donc, une fois la classe choisie, on rend actif le panneau inférieur du gestionnaire de classe (qui est une fenêtre d'édition) à l'aide de la commande Methods / New Method si la méthode n'existe pas. Si la méthode existe, cliquer sur son nom affiche le texte de la méthode. SmallTalk sait se positionner sur la première méthode dont l'initiale est tapée au clavier (comme pour les Explorateurs Windows des années 2000) : ainsi, pour trouver la première méthode dont le nom commence par m on tape m dans la liste de méthodes.

La copie écran ci-dessous montre par exemple l'édition de la méthode moyenne dans la classe "Collection".

Lorsqu'on enregistre la méthode par un clic-droit et la commande Save, le nom de la méthode apparait dans le panneau supérieur gauche du gestionnaire de classes : le sous-programme fait alors partie de SmallTalk au meme titre que les autres méthodes de SmallTalk.

On notera que le texte des toutes les autres méthodes de SmallTalk (sauf quelques méthode dites "primitives") s'affiche dès qu'on clique sur son nom dans le panneau supérieur droit du gestionnaire de classes : on a donc accès au code-source de tout le langage, ce qui est un avantage énorme pour un développeur professionnel puisqu'on a la possibilité de modifier tout le langage.

Pour quitter SmalTalk, on clique sur l'icone de SmallTalk dans la fenêtre de Transcript au-dessus du menu File (et oui, la CUA avec le menu Fichier / Quitter n'existait pas à l'époque) et on choisit Exit SmallTalk. Il reste alors à valider nos modifications en faisant un "backup" de l'image de l'environnement ou à les ignorer et le tour est joué.

Attention : SmallTalk garde une trace de TOUT ce qui a été fait dans le fichier change.log qui ne doit en aucun cas etre modifié (mais c'est un texte lisible qu'on peut recopier et dont on peut modifier la copie). En particulier si on édite en modifiant 5 fois une méthode, on trouvera les 5 versions de la méthode dans change.log ; cela peut-etre pratique pour revenir a une version antérieure, pour archiver les changements (afin de les commenter ultérieurement). Il existe bien sur des instructions pour compresser le log afin qu'il n'ait pas une taille monstrueuse...

une phrase = un sujet, un verbe (et des compléments éventuels)

Dans la terminologie SmallTalk, cela devient

une instruction = un objet, une méthode (et des paramètres éventuels)

Le couple méthode et paramètres éventuels est nommé message transmis à l'objet. Le résultat est appelé réponse de l'objet au message.

Ainsi en programmation traditionnelle, on pouvait écrire

RendVisiteA(Pierre,Paul) ;

avec un sous-programme RendVisiteA et deux paramètres Pierre et Paul. En SmallTalk cela devient

Pierre RendVisiteA: Paul

où Pierre est l'objet qui reçoit le message RendVisiteA: Paul. Le calcul 2 + 3 qui n'est pas une instruction dans un langage classique devient une instruction en SmallTalk où le message + 3 est envoyé à l'objet 2, message composé de la méthode + et du paramètre 3.

La lisibilité est accrue par la règle "on met le symbole : si la méthode requiert des paramètres". On est donc censé comprendre la syntaxe à utiliser pour une méthode donnée. L'affectation est la seul exception : les concepteurs de SmallTalk ont laissé le traditionnel := du Pascal au lieu d'un (joli) =:

Ainsi pour affecter à n la longueur (size en anglais) de l'objet x, on écrit n := (x size) qui doit donc s'interpréter comme l'envoi du message := (x size) à l'objet n.

Pour un programmeur classique, il faut donc apprendre à "inverser" les appels classiques de sous programmes. Voici quelques exemples :

     f(x)                     x f

     f(x,y)                   x f: y

     f(x,y,z)                 x f: y with: z

     f(x,g(y))                x f: (y g)

     f(x,g(y,z))              x f: (y g: z)

     f(x,g(y,z,k)             x f: (y g: z and: k)

SmallTalk étant un langage "pur", toute instruction doit passer par le modèle cité. Les test devienent donc des messages passés à la condition, les boucles des messages passés aux bornes de boucle. On doit par exemple traduire le test

     si condition alors

        instructions

     finsi

     condition ifTrue: [

       instructions

     ].

     pour i de1a n

        instructions

     finpour

     (1 to: n) do: [ :i |

        instructions

     ].

On notera que le symbole point (.) sert à indiquer la fin de l'instruction.

Deux difficultés se présentent alors pour apprendre SmallTalk : découvrir les 2000 et quelques méthodes déjà présentes, utiliser au mieux les classes déjà présentes. Par exemple on peut réinventer la fonction puissance dans la classe Float des nombres réels sans savoir qu'elle existe déjà (elle se nomme raisedTo:) dans la classe Number. Ou on peut triturer un tableau dans la classe Array pour avoir des valeurs uniques alors que la classes Set est conçue pour.

Voici à titre d'exemples quelques instructions SmallTalk standards à connaitre

                               Objet        Message

pour afficher l'heure          Date         today

pour extraire la sous-chaine   p            copyFrom: 5 to: 9
des caractères 5 à 9 dans p

pour avoir la valeur numéro i  t            at: i
du tableau t

pour affecter la valeur y      (t at: i)    put: y
en t[i]

pour savoir si x est compris   x            between: a and: b
entre a et b

pour savoir si on est a la     fic          atEnd
fin du fichier nommé fic

pour forcer l'affichage de     x            printString
l'objet x en mode texte

Prompter prompt: question default: valeur.

 carre
 ^self*self

On notera qu'il n'est pas possible de définir la méthode carre: donc avec le symbole "deux points" car SmallTalk exigerait alors un argument pour la méthode.

Avec un peu plus de lisibilité, on peut détailler en

 carre
   " calcul du carré du nombre récepteur "
   | leNombre sonCarre |
   leNombre := self .
   sonCarre := leNombre * leNombre .
 ^sonCarre

Renvoyons maintenant un nombre cadré sur plusieurs positions avec un caractère variable de remplissage. Toujours dans la classe Number, on écrit donc la méthode format: avec: soit le texte

 format: longueur avec: carRemp
   " cadre sur le nb de caractères demandés : on rajoute "
   " devant le nb autant de fois que nécessaire le caractère"
   " nommé carRemp "
 | s |
 s := self printString.
 [ (s size) > longueur ] whileFalse: [
    s := carRemp , s .
 ]. " fin de tant que "
 ^s

On peut alors demander à SmallTalk d'évaluer

  3.2 format: 10 avec: '*'

 '********3.2'

 initialeMajuscule
 ^((self at: 1)asUpperCase),(self copyFrom: 2 to: (self size))

 initialeMajuscule
    | answer size index aCharacter |
    size := self size.
    answer := String new: size.
    index := 1.
    [index <= size]
        whileTrue: [
            aCharacter := self at: index.
             (index=1)
               ifTrue: [
                  aCharacter :=  aCharacter asUpperCase]
               ifFalse:[
                  aCharacter :=  aCharacter asLowerCase
               ]. " fin de si "
            answer at: index put: aCharacter.
            index := index + 1].
    ^answer

Enfin, pour terminer nos exemples élémentaires, voici le comptage du nombre de lignes dans un fichier texte : dans la classe Stream, nous écrivons la méthode nombreDeLignes soit le texte

nombredeLignes

| nbl |

nbl := 0.
[self atEnd] whileFalse: [
  nbl := nbl + 1 .
  self nextLine .
]. " fin tant que non fin de fichier "

^nbl

Une fois le nom validé par "Ok" la classe apparait dans le panneau le plus à gauche qui donne la liste des classes :

Avant la création		Après la création

On peut alors créer une nouvelle méthode pour cette classe avec le menu Methods / New Method et y écrire notre programme, soit le texte

 bonjour

 " Exemple de commentaire, lire, écrire et affectation "

  | pren |

  Cursor offset: 140 @ 150.

  pren := Prompter  prompt: ' Bonjour. Quel est ton prénom ? '
                    default: ' euh ?'.

  pren := ' Merci. Au revoir ' ,
          (pren asUpperCase), ' ' ,
          (Date today) printString.

  Cursor offset: 140 @ 300.

  Menu message: pren.

Pour exécuter notre méthode bonjour, il nous faut un objet de classe Demo. On peut en créer un local et lui envoyer le message bonjour avec les instructions

puis le message de fin envoyé par Menu

Une meilleure solution pour exécuter notre méthode bonjour est de créer une variable globale. Pour cela, il faut que son nom commence par une majuscule. De plus, il faut valider la création de la variable lorsque SmallTalk pose la question de la création. Par exemple, nous créons ici la variable globale Mademo :

et pour utiliser bonjour, il suffit d'évaleur avec "Do it" l'expression Mademo bonjour.

table
 | fenetre |
 " table de multiplication "
 fenetre := TextWindow  windowLabeled: 'Table de Multiplication '
     frame: ( 210 @ 30 extent: 400 @(Display extent //2)y ).
 fenetre  cr ;
     nextPutAll: ' Table de ' ;
     nextPutAll: (self printString) ;
     cr ;
     cr .
 1 to: 10 do:   [ :ifois |
     fenetre
           nextPutAll:(ifois printString);
           nextPutAll: ' fois ' ;
           nextPutAll: (self printString) ;
           nextPutAll: ' = ' ;
           nextPutAll:((ifois * self) printString);
          cr. ] .
 Menu message: 'Cliquez en gauche ici pour terminer'.
 fenetre close.
^nil

 tabmult  " Table de multiplication "
 | n  |
 n := Prompter prompt: 'Donner un entier de 1 à 10 ' default: '3'.
 ( n asInteger) table.

format: unNombre
 " cadre sur le nb de caractères demandés"
 | s |
 s := self printString.
  [ (s size) > unNombre ] whileFalse: [
    s := ' ', s .
  ]. " fin de tant que "
 ^s

           nextPutAll:(ifois printString);

           nextPutAll:((ifois * self) printSting);

           nextPutAll:(ifois format:  5);

           nextPutAll:((ifois * self) format: 5);

puis le message de fin à l'écran

On appréciera le fait de pouvoir tester séparément les méthodes, par exemple en essayant successivement dans le Transcript les expressions

   5   format: 2

   5   table:

   Dgh tabmult