Introduction à Smalltalk

Le Smalltalk est langage datant de 1972 pour sa première version. La version actuelle est le Smalltalk-80 (des années 80 :D). Contrairement à différents langages, il ne possède pas de point d'entrée spécifique. En effet, l'environnement correspond au point d'entrée directement. L'avantage d'une telle structure est que l'on peut exécuter une portion de code rapidement sans avoir à se soucier de la déclaration d'une fonction main, winmain…

Il faut préciser que le Smalltalk est un langage interprété, l'environnement de développement (sueak) dispose donc d'une machine virtuelle. Cela permet de « décompiler » le code rapidement et d'y naviguer plus facilement pour atteindre l'endroit qui a généré une exception. Ce qui s'avère très utile pour le « débogage ».

Bien que le Smalltalk soit surtout utilisé pour effectuer de la recherche , son objectif principal est d'écrire rapidement et clairement un algorithme. Il est utilisé dans de grands projets par des entreprises de renom telles que Thales, AMD… Le Smalltalk est un langage généraliste bien que Squeak soit très orienté multimédia. On peut évidemment faire des interfaces graphiques et des objets graphiques (par exemple les E-Toys), mais aussi de la synthèse vocale, du graphisme en 2D et 3D…

Le Smalltalk est langage simple à apprendre de par le peu d'éléments servant de syntaxe. De plus, peu de concepts sont nécessaires pour le maîtriser. Les règles fixes, de visibilité et de priorités, ainsi qu’uniformité des entités (tout est objet) ajoutent en simplicité au langage. Il s'agit aussi d'un langage puissant, car il est extensible et l'environnement correspondant permet d'effectuer des navigations et du débogage très facilement. De plus, le Smalltalk est un métalangage, car il se décrit lui-même et la notion d'image permet d'éviter les problèmes de fichiers et de chemins.
Le principal inconvénient du Smalltalk est le typage dynamique. En effet, cela peut dérouter le développeur débutant habitué à respecter le type d'une instance et à déclarer une variable en fonction de ce type. Le typage dynamique supprime cette déclaration et rend la tâche plus difficile en cas de maintenance.(ceci est un avis personnel :))

Les petits programmes suivants sont écrits en C. Leur objectif est de servir de fil conducteur pour mieux comprendre comment fonctionne le Smalltalk :

int main(int argc, char** argv)
{
    char *hello = "hello world\n";
    printf("%s", hello);    
}

int cinqAuQuintuple()
{
    int result=5, i;
    for (i=0; i<4;i++)
    {
        result *= 5;
    }
    return result;
}

int main(...)
{
    int notes[6], notessup10[6], i, j=0;
    
    // Ajouts des éléments au tableau
    notes[0] = 10; notes[1] = 5; notes[2] = 1; notes[3] = 7; notes[4] = 15; notes[5] = 19;
    
    // Affichage des notes
    for (i=0; i<6;i++)
    {
        printf("%d ", notes[i]);
    }
    
    // Récupération des notes strictement supérieures à 10
    for (i=0; i<6;i++)
    {
        if (notes[i] > 10)
        {
            notessup10[j] = notes[i];
            j++;
        }
    }
    
    // Affichage du nombre de notes strictement supérieures à 10
    printf("\nnbnotes > 10 = %d", j+1);
}

Voici la liste des éléments syntaxiques constituant le Smalltalk :

Maintenant que les éléments de syntaxes ont été présentés, les petits programmes 1 et 2 vont pouvoir être traduits en Smalltalk :

| hello |
hello := 'hello world'.
Transcript show:hello.

Comme vous pouvez le constatez la variable ''hello'' n'a pas de type à la déclaration. Son type est connu seulement à son affectation. De plus, aucune « console » n'est utilisée en Smalltalk. Son équivalent est le « Transcript » dont on verra comment l'afficher à la section V.

|v|
v := 5
(1 to:4) do:
    [ v := v*5.].
^v.

Dans cette fonction, trois notions ont été introduites : le bloc, la boucle for et le return. Un block connait son contexte et peut être comparé à des pointeurs sur fonctions en C. Il s'agit d'une entité qui contient du code à exécuter. Cette entité est soit passée en paramètre, soit exécutée ultérieurement. Le programme n° 2 donnera donc :

|v block|
block = [ v := v*5.]
v := 5.
(1 to:4) do:block.
^v.

Cela permet d'éviter de recopier plusieurs fois le même block.

III-B-1. Différents types de messages▲

III-B-2. Règles de priorités sur les messages▲

array at:1+3 put:4-5. 
" + et - sont des messages binaires, at:put: un message à mot-clés et pas de parenthèse 
     -> règle 1 -> array[4] = -1"
     
1+3/4-6. 
"que des messages binaires et pas de parenthèse
     -> règle 3 -> 4/4-6 -> 1-6 -> -5, cela renvoie donc -5"
     
(1+3)/(4-6)
" que des messages binaires, mais des parenthèses
     -> règle 2 -> 4/(-2) -> -2, cela renvoie donc -2 !!!!!"

Les collections permettent de regrouper et de faciliter l'accès aux données. Elles héritent de la classe Collection. Voici l'arbre d'héritage des collections :

IV-A-1. Collections ordonnées▲

IV-A-2. Collections non ordonnées▲

Pour présenter les messages, nous allons les diviser en trois catégories.

Commençons par les messages liés aux collections de taille variable (toutes sauf Array) :

• add: unObjet : permet d'ajouter unObjet à la collection ;
• addAll: autreCollection : permet d'ajouter tous les éléments de autreCollection à la collection ;
• remove: unObjet ifAbsent: [« traitements »] : permet de supprimer unObjet de la collection et exécute traitement si un objet est absent ;
• remove: unObjet : permet de supprimer unObjet de la collection et provoque une erreur si un objet est absent ;
• removeAll: autreCollection : permet de supprimer tous les éléments présents dans autreCollection de la collection.

Passons maintenant aux messages liés aux collections ordonnées :

• first : permet d'obtenir le premier élément de la collection ;
• last : permet d'obtenir le dernier élément de la collection ;
• at: indice : permet d'obtenir l'élément présent à l'indice indice ;
• at: indice put: unObjet : permet d'ajouter unObjet à l'indice indice de la collection.

Passons ensuite aux messages pour parcourir les collections :

• do: [:element| « traitements »] : chaque élément est traité, par traitement, grâce à la variable elementle représentant ;
• select: [:element| « expression booléenne »] : permet d'obtenir les éléments de la collection vérifiant l'expression booléenne ;
• reject: [:element| « expression booléenne » ] : permet d'obtenir les éléments de la collection ne vérifiant pas l'expression booléenne ;
• collect: [:element| « traitements »] : retourne une collection contenant les éléments dont on leur a appliqué le traitement ;
• detect: [:element | « expression booléenne »] ifNone: [« traitements alternatifs »] : retourne le premier élément vérifiant l'expression booléenne. Si aucun élément n'est trouvé, le traitement alternatif est exécuté ;
• detect: [:element | « expression booléenne »] : retourne le premier élément vérifiant l'expression booléenne. Si aucun élément n'est trouvé, une erreur est lancée.

Passons enfin aux messages spécifiques aux dictionnaires (classes héritant de Dictionary) :

• at: clé put: valeur : insère valeur à la case référencée par clé ;
• at: clé : permet d'obtenir la valeur de la case référencée par clé, mais provoque une erreur si clé est absente du dictionnaire ;
• at: clé ifAbsent: [« traitements »] : permet d'obtenir la valeur de la case référencée par clé et exécute traitements si clé est absente du dictionnaire ;
• removeKey: clé : retire la clé et la valeur référencée du dictionnaire ;
• keysAndValuesDo: [:clé :valeur| « traitements »] : exécute traitements pour chaque couple clé/valeur ;
• keysDo: [:clé | « traitements »] : exécute traitements pour chaque clé ;
• do: [:valeur| « traitements »] : exécute traitements pour chaque valeur ;
• collect: [:valeur| « traitements »] : retourne un ensemble (Set) contenant les valeurs traitées par traitements.

L'exemple qui suit correspond à la traduction du programme n° 3 en Smalltalk :

| notes notesup10 |
notes := OrderedCollection new.

" Ajout des notes au tableau "
notes add:10; add:5; add:1; add:7; add:15; add:19.

" Affichage des notes "
notes do:[:e| Transcript show:e; show:' '.].

" Récupération des notes strictement supérieures à 10 "
notesup10 := notes select:[ :e | e > 10].

" Affichage du nombre de notes strictement supérieures à 10 "
Transcript show: Character cr; show:'nb de notes > 10 = '; show:(notesup10 size).

Comme on peut le constater, la notion de collections présente moins de restrictions qu'un tableau classique : la taille n'est pas limitée et la taille est connue. De plus un des gros avantages, est que l'on accède directement à l'élément sans passer par une indexation ce qui empêche d'effectuer des débordements mémoire par exemple.
De plus, un des gros avantages du Smalltalk est mis en avant : la faible densité du code.