La programmation en première année basée sur …pvr/Micromondes_2.pdf · 2007-08-16 · Nous souhaitons remercier : Notre promoteur, le professeur Peter Van Roy pour son enthousiasme,

UNIVERSITE CATHOLIQUE DE LOUVAIN

FACULTE DES SCIENCES APPLIQUEES

DEPARTEMENT D’INGENIERIE INFORMATIQUE

La programmation en premiere anneebasee sur l’enrichissement progressif

de micromondes multi-agents(Partie II)

Promoteur : Peter Van Roy

Memoire presente en vue

de l’obtention du grade

de Licencie en Informatique

par Gregory de le Vingne

Maxime Romain

et Cecile Toint

Louvain-la-Neuve16 aout 2007

Nous souhaitons remercier :

Notre promoteur, le professeur Peter Van Roy pour son enthousiasme, samotivation et son soutien.

Nos lecteurs, Manuel Kolp et Kim Mens.Les assistants-chercheurs de l’equipe de Peter Van Roy, tout

particulierement Boris Mejias, pour avoir supporte avec le sourire nosincursions reguliere dans son bureau.

Monsieur Vanneck pour nous avoir permis de disposer des sallesinformatique.

Les etudiants qui ont participe a nos seances de cours, pour leur toleranceet leurs conseils avises.

Le professeur Philippe Toint pour ses relectures et ses remarquesconstructives sans lesquelles nous n’aurions pu optimiser ce memoire.

Christoph Bastin pour sa relecture orthographique.Nos amis et proches : Adeline, Audrey, Elley, Jade, Jonathan, Manu,

Muriel, Rose-Marie, Sarah, le kotmanga 2006-2007, ansi que beaucoupd’autres qui se reconnaıtront, pour leur presence.Elephant pour le transfert incessant de donnees.

Finalement, nos parents pour leur soutien continu tout au long de nosetudes.

1

Table des matieres

Introduction 12

1 Choix de l’Approche Employee 161.1 Les approches classiques . . . . . . . . . . . . . . . . . . . . . 17

1.1.1 La programmation orientee objet . . . . . . . . . . . . 171.1.2 La programmation fonctionnelle . . . . . . . . . . . . . 191.1.3 La programmation orientee agent . . . . . . . . . . . . 19

1.2 L’approche par agents dans des micromondes . . . . . . . . . . 21

2 Approche Par Enrichissement de Micromondes 242.1 Presentation globale . . . . . . . . . . . . . . . . . . . . . . . 242.2 Succession des micromondes . . . . . . . . . . . . . . . . . . . 252.3 Premier micromonde : First Steps . . . . . . . . . . . . . . . . 28

2.3.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 282.3.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 282.3.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 292.3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.4 Deuxieme micromonde : Procedures and Recursion . . . . . . 322.4.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 322.4.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 322.4.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 332.4.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 35

2.5 Troisieme micromonde : Multi Agents . . . . . . . . . . . . . . 382.5.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 382.5.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 382.5.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 382.5.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 42

2.6 Quatrieme micromonde : Time . . . . . . . . . . . . . . . . . . 422.6.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 422.6.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 422.6.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 43

2

2.6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 442.7 Cinquieme micromonde : New Agents . . . . . . . . . . . . . . 45

2.7.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 452.7.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 452.7.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 452.7.4 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . 502.7.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.8 Sixieme micromonde : Logoz Agent . . . . . . . . . . . . . . . 532.8.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 532.8.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 532.8.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 532.8.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 54

2.9 Septieme micromonde : Network . . . . . . . . . . . . . . . . . 552.9.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . 552.9.2 Concepts abordes . . . . . . . . . . . . . . . . . . . . . 562.9.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 562.9.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 57

3 Environnement de Programmation : LogOz 2.0 593.1 Architecture du logiciel . . . . . . . . . . . . . . . . . . . . . . 603.2 Implementation des agents . . . . . . . . . . . . . . . . . . . . 613.3 LogOz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623.4 L’interface graphique . . . . . . . . . . . . . . . . . . . . . . . 63

3.4.1 Le choix du micromonde . . . . . . . . . . . . . . . . . 633.4.2 Le bloc notes (ou notepad) . . . . . . . . . . . . . . . . 653.4.3 Le browser . . . . . . . . . . . . . . . . . . . . . . . . . 673.4.4 La feuille de dessin ou canvas . . . . . . . . . . . . . . 703.4.5 Les menus . . . . . . . . . . . . . . . . . . . . . . . . . 713.4.6 Les boutons . . . . . . . . . . . . . . . . . . . . . . . . 803.4.7 Le compilateur et l’environnement . . . . . . . . . . . . 81

3.5 Ameliorations du programme et resolution des problemes . . . 84

4 Enseignement et Pedagogie 894.1 Demarches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 894.2 Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 914.3 Seances de cours . . . . . . . . . . . . . . . . . . . . . . . . . 92

4.3.1 Premiere seance . . . . . . . . . . . . . . . . . . . . . . 924.3.2 Deuxieme seance . . . . . . . . . . . . . . . . . . . . . 944.3.3 Troisieme seance . . . . . . . . . . . . . . . . . . . . . 974.3.4 Quatrieme seance . . . . . . . . . . . . . . . . . . . . . 994.3.5 Cinquieme seance . . . . . . . . . . . . . . . . . . . . . 100

3

4.3.6 Sixieme seance . . . . . . . . . . . . . . . . . . . . . . 1034.3.7 Septieme seance . . . . . . . . . . . . . . . . . . . . . . 1064.3.8 Huitieme seance . . . . . . . . . . . . . . . . . . . . . . 1094.3.9 Neuvieme seance . . . . . . . . . . . . . . . . . . . . . 1114.3.10 Dixieme seance . . . . . . . . . . . . . . . . . . . . . . 1124.3.11 Onzieme, douzieme et treizieme seances . . . . . . . . . 1154.3.12 Quatorzieme seance . . . . . . . . . . . . . . . . . . . . 1244.3.13 Quinzieme seance . . . . . . . . . . . . . . . . . . . . . 127

4.4 Seances de cours supplementaires . . . . . . . . . . . . . . . . 1384.4.1 Reseau . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

5 Resultats de la Phase de Test 1395.1 Remarques et modifications diverses . . . . . . . . . . . . . . . 1395.2 Avertissement a destination de l’enseignant . . . . . . . . . . . 142

6 Evaluation 1456.1 Test de mi-parcours . . . . . . . . . . . . . . . . . . . . . . . . 145

6.1.1 Definitions theoriques des concepts . . . . . . . . . . . 1466.1.2 Application des principes basiques de la programmation1476.1.3 Application du principe de recursion . . . . . . . . . . 1476.1.4 Concurrence et creation d’agents . . . . . . . . . . . . 1486.1.5 Identification et reparation d’erreurs de compilation et

d’execution . . . . . . . . . . . . . . . . . . . . . . . . 1486.2 Exercices supplementaires . . . . . . . . . . . . . . . . . . . . 149

6.2.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . 1496.2.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . 149

6.3 Projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1506.3.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . 1506.3.2 Modalites pratiques . . . . . . . . . . . . . . . . . . . . 1516.3.3 Enonce . . . . . . . . . . . . . . . . . . . . . . . . . . . 1536.3.4 Philosophie d’evaluation . . . . . . . . . . . . . . . . . 154

6.4 Examen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1566.4.1 Cotation . . . . . . . . . . . . . . . . . . . . . . . . . . 1566.4.2 Question remplacant le test . . . . . . . . . . . . . . . 1586.4.3 Questions theoriques . . . . . . . . . . . . . . . . . . . 1586.4.4 Question pratique . . . . . . . . . . . . . . . . . . . . . 158

7 Critiques et Pistes 1607.1 Une approche ludique . . . . . . . . . . . . . . . . . . . . . . . 161

7.1.1 Le role du jeu video dans cette approche . . . . . . . . 161

4

7.1.2 Do computer games have a role in the classroom : unresume . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

7.1.3 Confrontation avec notre approche . . . . . . . . . . . 1647.2 Etude comparative . . . . . . . . . . . . . . . . . . . . . . . . 166

7.2.1 Squeak . . . . . . . . . . . . . . . . . . . . . . . . . . . 1677.2.2 ObjectKarel . . . . . . . . . . . . . . . . . . . . . . . . 1687.2.3 Remarques generales . . . . . . . . . . . . . . . . . . . 169

7.3 Pistes pour le futur . . . . . . . . . . . . . . . . . . . . . . . . 1697.3.1 Ameliorations du programme . . . . . . . . . . . . . . 1707.3.2 Cours supplementaires . . . . . . . . . . . . . . . . . . 172

A Cours 181A.1 Premier Cours : Les debutants avec le logiciel - Micromonde 1 181

A.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 181A.1.2 Les agents . . . . . . . . . . . . . . . . . . . . . . . . . 182A.1.3 L’interface . . . . . . . . . . . . . . . . . . . . . . . . . 184A.1.4 Les instructions . . . . . . . . . . . . . . . . . . . . . . 189A.1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 190

A.2 Deuxieme Cours : Procedures - Micromonde 2 . . . . . . . . . 191A.2.1 Les procedures . . . . . . . . . . . . . . . . . . . . . . 191A.2.2 Les arguments . . . . . . . . . . . . . . . . . . . . . . . 191A.2.3 Procedures et arguments . . . . . . . . . . . . . . . . . 192A.2.4 Dessins procedurals . . . . . . . . . . . . . . . . . . . . 194A.2.5 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . 197

A.3 Troisieme Cours : Operateurs et expressions conditionnelles -Micromonde 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 199A.3.1 Les operateurs . . . . . . . . . . . . . . . . . . . . . . . 199A.3.2 Les expressions conditionnelles . . . . . . . . . . . . . . 200A.3.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 204

A.4 Quatrieme Cours : Nouvelle structure de donnees : Les Listes- Micromonde 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 205A.4.1 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . 205A.4.2 Operations sur les listes . . . . . . . . . . . . . . . . . 206A.4.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 208

A.5 Cinquieme Cours : La Recursion - Micromonde 2 . . . . . . . 209A.5.1 Theorie . . . . . . . . . . . . . . . . . . . . . . . . . . 209A.5.2 Premiere Approche . . . . . . . . . . . . . . . . . . . . 212A.5.3 Seconde Approche . . . . . . . . . . . . . . . . . . . . 216A.5.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 217

A.6 Sixieme Cours : Multi-Turtles - Micromonde 3 . . . . . . . . . 219A.6.1 Agent : Rappel de le definition . . . . . . . . . . . . . . 219

5

A.6.2 Etat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219A.6.3 Cerveau . . . . . . . . . . . . . . . . . . . . . . . . . . 221A.6.4 Creation d’un nouvel agent tortue . . . . . . . . . . . . 221A.6.5 Concurrence . . . . . . . . . . . . . . . . . . . . . . . . 223A.6.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 224

A.7 Septieme Cours : Le Temps - Micromonde 4 . . . . . . . . . . 226A.7.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . 226A.7.2 L’Agent Metronome . . . . . . . . . . . . . . . . . . . 226A.7.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . 228A.7.4 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . 228A.7.5 Exercices de revision . . . . . . . . . . . . . . . . . . . 228

A.8 Huitieme Cours : Les Agents - Micromonde 5 . . . . . . . . . 229A.8.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . 229A.8.2 Creation d’un nouvel agent . . . . . . . . . . . . . . . . 229A.8.3 Exercice : une horloge . . . . . . . . . . . . . . . . . . 231A.8.4 Autres exercices . . . . . . . . . . . . . . . . . . . . . . 232

A.9 Neuvieme Cours : Test de mi-parcours et explication du projet 234A.9.1 Test (20 points) . . . . . . . . . . . . . . . . . . . . . . 234A.9.2 Projet : Pong . . . . . . . . . . . . . . . . . . . . . . . 237

A.10 Dixieme Cours : Introduction aux diagrammes . . . . . . . . . 239A.10.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . 239A.10.2 Diagrammes de sequence[18] . . . . . . . . . . . . . . . 239A.10.3 Diagramme d’etat . . . . . . . . . . . . . . . . . . . . . 241A.10.4 Un exemple . . . . . . . . . . . . . . . . . . . . . . . . 242A.10.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 244

A.11 Onzieme, Douzieme et Treizieme Cours : Projet “Space Inva-ders” - Micromonde 5 . . . . . . . . . . . . . . . . . . . . . . 246A.11.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 246A.11.2 Modelisation . . . . . . . . . . . . . . . . . . . . . . . 247A.11.3 Implementation . . . . . . . . . . . . . . . . . . . . . . 249

A.12 Quatorzieme Cours : Les threads - Micromonde 5 . . . . . . . 249A.12.1 Concurrence . . . . . . . . . . . . . . . . . . . . . . . . 249

A.13 Quinzieme Cours : Composition d’agents - Micromonde 5 . . . 256A.13.1 Un exemple : Le distributeur de boissons . . . . . . . . 256

A.14 Cours Supplementaire sur le Reseau - Micromonde 7 . . . . . 258A.14.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 258A.14.2 Les Turtles en reseau dans Logoz . . . . . . . . . . . . 258A.14.3 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . 259A.14.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . 260

6

B Examen 261B.1 PREMIERE PARTIE . . . . . . . . . . . . . . . . . . . . . . . 261B.2 SECONDE PARTIE . . . . . . . . . . . . . . . . . . . . . . . 262

B.2.1 Theorie . . . . . . . . . . . . . . . . . . . . . . . . . . 262B.2.2 Pratique . . . . . . . . . . . . . . . . . . . . . . . . . . 264

C Le projet Ping-pong 269C.1 Notre vision du jeu de ping-pong . . . . . . . . . . . . . . . . 269C.2 Les etats des agents . . . . . . . . . . . . . . . . . . . . . . . . 271C.3 Fonctions et procedures donnees . . . . . . . . . . . . . . . . . 271

C.3.1 Fonctions de dessin . . . . . . . . . . . . . . . . . . . . 271C.3.2 Procedure pour deplacer une image . . . . . . . . . . . 271C.3.3 Deplacement des palettes . . . . . . . . . . . . . . . . . 272C.3.4 Fonction Random . . . . . . . . . . . . . . . . . . . . . 272C.3.5 Fonctions sinus, cosinus et conversion nombre entier

nombre a virgule . . . . . . . . . . . . . . . . . . . . . 272C.3.6 Exemple de fonction de transition . . . . . . . . . . . . 273

D Questionnaire d’Evaluation 276

7

Table des figures

2.1 Diagramme de l’Etat de la tortue . . . . . . . . . . . . . . . . 302.2 Tortue a son initialisation . . . . . . . . . . . . . . . . . . . . 312.3 Procedure Triangle . . . . . . . . . . . . . . . . . . . . . . . . 332.4 Procedure Repeat . . . . . . . . . . . . . . . . . . . . . . . . . 342.5 Procedure illustrant la fonction Repeat . . . . . . . . . . . . . 342.6 Autre procedure illustrant la fonction Repeat . . . . . . . . . 342.7 Arbre recursif . . . . . . . . . . . . . . . . . . . . . . . . . . . 362.8 Dessin d’une fractale . . . . . . . . . . . . . . . . . . . . . . . 372.9 Fractale utilisant la notion de fonction . . . . . . . . . . . . . 392.10 Un dessin“collaboratif” . . . . . . . . . . . . . . . . . . . . . 412.11 Diagramme d’etat de l’agent Metronome . . . . . . . . . . . . 442.12 Interaction entre un agent Metronome et deux tortues . . . . 442.13 Prototype d’une fonction de transition . . . . . . . . . . . . . 462.14 Diagramme d’Etat de l’horloge . . . . . . . . . . . . . . . . . 512.15 L’interface “horloge” . . . . . . . . . . . . . . . . . . . . . . . 512.16 L’interface Pong . . . . . . . . . . . . . . . . . . . . . . . . . 522.17 L’interface Space Invaders . . . . . . . . . . . . . . . . . . . . 522.18 Representation des tortues en reseau . . . . . . . . . . . . . . 58

3.1 Architecture Logique du Logiciel . . . . . . . . . . . . . . . . 603.2 Implementation du port object . . . . . . . . . . . . . . . . . 623.3 Le logiciel LogOz sous Windows XP . . . . . . . . . . . . . . 643.4 La fenetre d’accueil de LogOz . . . . . . . . . . . . . . . . . . 653.5 Le Bloc notes et sa fonction de colorisation . . . . . . . . . . . 673.6 Le browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683.7 Le code du browser dans User.oz . . . . . . . . . . . . . . . . 693.8 Le code du browser dans LogozGraphics.oz . . . . . . . . . . . 703.9 La monde de la tortue : un tore . . . . . . . . . . . . . . . . . 713.10 Menu File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723.11 Sauvegarde de fichier . . . . . . . . . . . . . . . . . . . . . . . 733.12 Ouverture de fichier . . . . . . . . . . . . . . . . . . . . . . . . 74

8

3.13 Fermeture de l’application . . . . . . . . . . . . . . . . . . . . 743.14 Exemple de l’utilisation de la fonction ’Load Agent’. . . . . . . 763.15 Le menu Edit . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.16 Le menu Kill . . . . . . . . . . . . . . . . . . . . . . . . . . . 793.17 Le menu Help . . . . . . . . . . . . . . . . . . . . . . . . . . . 803.18 Les Boutons Run et Clear World . . . . . . . . . . . . . . . . 80

4.1 Procedure Carre avec argument . . . . . . . . . . . . . . . . 954.2 Dessin d’un oeil de maniere procedurale . . . . . . . . . . . . 964.3 Dessin d’un donut de maniere procedurale . . . . . . . . . . . 974.4 Expression if... else... end en Oz . . . . . . . . . . . . . . . . . 984.5 Pattern Matching en Oz . . . . . . . . . . . . . . . . . . . . . 984.6 Procedure executant plusieurs forward utilisant la recursion . 1014.7 Procedure Recursive dessinant une spirale . . . . . . . . . . . 1024.8 Algorithme recursif de construction d’un arbre . . . . . . . . 1024.9 Dessin recursif d’un arbre . . . . . . . . . . . . . . . . . . . . 1034.10 Deux tortues evoluant dans le meme micromonde . . . . . . . 1064.11 Code d’un carre implemente de maniere concurencielle . . . . 1074.12 Dessin de carre de maniere concurrentielle . . . . . . . . . . . 1074.13 L’Horloge dans LogOz . . . . . . . . . . . . . . . . . . . . . . 1114.14 Diagramme de sequence . . . . . . . . . . . . . . . . . . . . . 1134.15 Diagramme d’etat d’une porte . . . . . . . . . . . . . . . . . 1144.16 Un diagramme de sequence simplifie du Space Invaders . . . . 1174.17 Representation d’un programme sequentiel . . . . . . . . . . . 1264.18 Representation d’un programme concurrent . . . . . . . . . . 1264.19 Communication entre un thread producteur et un thread consom-

mateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1264.20 Communication entre un thread producteur, un thread consom-

mateur et un thread traducteur . . . . . . . . . . . . . . . . . 127

5.1 Explication du deroulement de l’exercice de l’arbre . . . . . . 141

7.1 L’interface de programme Squeak . . . . . . . . . . . . . . . . 1687.2 Deux tortues a la recherche de salades . . . . . . . . . . . . . 174

A.1 Diagramme de sequence . . . . . . . . . . . . . . . . . . . . . 240A.2 Diagramme d’etat d’une porte . . . . . . . . . . . . . . . . . 241A.3 Diagramme de sequence de l’horloge . . . . . . . . . . . . . . 243A.4 Diagramme de sequence de l’horloge . . . . . . . . . . . . . . 244

B.1 Exemple d’arbre binaire recursif . . . . . . . . . . . . . . . . 262

9

C.1 Jeu de Ping-Pong . . . . . . . . . . . . . . . . . . . . . . . . 270

10

Liste des tableaux

2.1 Messages compris par la Tortue . . . . . . . . . . . . . . . . . 302.2 Messages compris par l’agent Metronome . . . . . . . . . . . 432.3 Messages compris par l’agent LogOz . . . . . . . . . . . . . . 552.4 Message compris par l’agent Groupe (reseau) . . . . . . . . . 57

3.1 Outils ajoutes a l’environnement du compilateur . . . . . . . 823.2 Outils ajoutes a l’environnement du compilateur (suite) . . . 83

4.1 Tableau de correspondance entre micromondes et cours . . . . 924.2 Messages compris par l’agent Metronome . . . . . . . . . . . 108

A.1 Messages compris par la Tortue . . . . . . . . . . . . . . . . . 183A.2 Operateurs Binaires . . . . . . . . . . . . . . . . . . . . . . . 199A.3 Operateurs binaires (suite) . . . . . . . . . . . . . . . . . . . 200

D.1 Rapport d’Evaluation des cours . . . . . . . . . . . . . . . . . 277D.2 Rapport d’Evaluation des exercices . . . . . . . . . . . . . . . 278D.3 Rapport d’Evaluation des differentes evaluations . . . . . . . . 278

11

Introduction

Dans ce monde en perpetuel mouvement, la discipline qui est la notre, l’in-formatique, est peut-etre le domaine dans lequel nous observons l’evolutionla plus reguliere. Ce processus qui ne semble pas voue a s’arreter de si peuapporte sans cesse des nouvelles technologies et des nouvelles techniques pourmaıtriser celles-ci. L’adaptation des methodes d’education a ces innovationsest une priorite pour le monde universitaire. Englobe dans cet elan novateur,celui-ci ne peut eviter de renover ses formules.

Deja il y a une dizaine d’annees nous avions eu l’occasion de voir l’en-seignement des modeles orientes objet concurrencer, voire parfois remplacer,l’enseignement des langages imperatifs. Aujourd’hui, il semble utile de seposer des questions sur l’adequation de ces pratiques avec les exigences dumonde informatique actuel.

Ce memoire s’inscrit dans un vaste projet de renovation des methodes del’enseignement de l’informatique, et plus precisement de la programmation.L’objectif de cette etude est de proposer un programme de cours qui s’etalesur plusieurs annees. Cette alternative pourra etre proposee aux facultes,specialisees en l’informatique ou non, qui desirent enseigner la programma-tion.

En tant que futurs licencies, realiser ce travail pedagogique traduit toutd’abord l’ambition de compter dans le monde de la recherche educative enapportant une modeste pierre a l’edifice. Cela demontre aussi l’envie de tirerle meilleur parti de notre proximite avec le cote Etudiant de l’enseignementafin de creer une methode qui soit pratique, ambitieuse, et adaptee aux be-soins de tous.

Ce projet d’evolution des techniques educatives a entame sa premierephase avec le memoire realise par Isabelle Cambron et Mathieu Cuvelier[1]sous la direction du Professeur Peter Van Roy. Ce travail proposait les premie-

12

res sessions d’un cours de premiere annee et presentait un logiciel de supportpedagogique adapte a cet enseignement.

Le present memoire s’appuie sur cette premiere pierre et propose un enri-chissement du travail effectue. Il resulte en un cours d’un semestre complet.Ce cours est abouti, teste dans sa grande majorite et realise de maniere apouvoir etre applique immediatement.

Dans un souci de continuite, nous nous devons ici de preserver l’ideologiesuivie par nos predecesseurs : l’enrichissement de micromondes multi agent,l’approche ludique du cours ou encore une totale transparence dans les con-cepts vus . Leur methode nous a servi de base, une base que nous avonsutilisee pour avancer dans notre propre direction. Nous desirions continueret approfondir ici leur projet afin d’en faire non plus une piste de methoded’enseignement mais un cours a part entiere. En parallele, nous developponsl’outil pedagogique ainsi que le materiel necessaire aux cours theoriques.

Contenu

Ce memoire propose un cours a dispenser durant un semestre a desetudiants debutant en informatique. Il est compose de 14 seances de deuxheures, d’un projet, d’un test a mi-parcours et d’un examen. Il propose enplus des pistes, plus ou moins abouties, qui permettront soit a l’enseignantd’enrichir son cours en y ajoutant de nouveaux modules, soit a nos succes-seurs de constituer la base d’un second cours qui pourra etre dispense endeuxieme annee, ou au second quadrimestre de la premiere annee.

Public cible

Ce memoire presente une methode d’enseignement des techniques debase de la programmation. Cette methode a ete elaboree dans le but d’etreintegree, a terme, au programme de premiere annee de baccalaureat en in-formatique. Cependant, le public cible est beaucoup plus large.

Le monde universitaire

Ce memoire s’adresse a tous ceux qui, par le monde, participent a ce grandchantier. Dans un premier temps il est destine a servir de base a l’elaborationde cette entreprise. Le cours qui y est presente et le programme LogOz 2.0sur lequel il s’appuie sont destines a l’enseignement d’une premiere annee de

13

cours. Ils sont a etoffer dans le but d’atteindre l’objectif final d’un programmecoherent d’enseignement sur plusieurs annees.

Les enseignants interesses

Ce memoire est construit de maniere a ce que les seances creees puissentetre dispensees sans plus tarder, independamment du projet a long termedont il fait partie. Dans l’objectif de transmettre notre philosophie d’ensei-gnement a un plus grand nombre, la logique de chaque cours et de chaquemicromonde est expliquee clairement. Ceci afin que chacun puisse en saisirles tenants et aboutissants et puisse a son tour enseigner la programmation.Ce memoire s’adresse donc aux professeurs d’informatique qui desirent ex-plorer d’autres voies ou modifier leurs methodes d’enseignement, mais aussi atout enseignant qui desire ajouter a son programme un cours d’informatiqueconcret, facilement dispensable et motivant pour les etudiants.

Les etudiants autodidactes

Ce travail se destine aussi a quiconque decide de s’initier a l’informatiqueen general ou qui ressent l’envie de structurer ses connaissances sur based’un cours de niveau universitaire. L’etudiant autodidacte trouvera dans leprogramme LogOz une maniere facile et concrete de faire ses premiers pasdans le monde de la programmation. Il decouvrira aussi dans les cours pro-poses un chemin rapide et efficace vers la comprehension des techniques deprogrammation orientees agent. Ce cours presente un premier voyage dansle monde de l’informatique et preparera l’etudiant a l’apprentissage d’autreslangages.

Structure du document

Le present travail est organise en 7 parties. De maniere a ce qu’il puisseetre apprehende sans lectures preablables, il reprend certaines parties dumemoire d’Isabelle Cambron et Mathieu Cuvelier. Le lecteur averti ne s’eton-nera donc pas de retrouver des elements communs entre les deux travaux.

Nous presenterons tout d’abord une justification de l’approche employee.Nous expliquerons notre philosophie en exposant trois approches d’enseigne-ment de la programmation : orientee objet, fonctionnelle, orientee agent.Nous expliquerons ensuite la raison du choix du modele oriente agent pour letype d’enseignement que nous avons choisi : les micromondes. La seconde par-tie de ce chapitre sera consacree a la presentation du caractere videoludique

14

de notre approche. Nous verrons que cette caracteristique, autant louee quecritiquee par les chercheurs, se presente ici sous un aspect positif et profitablea l’etudiant.

Le deuxieme chapitre propose une explication du principe d’enrichis-sement des micromondes sur lequel se base notre methode, ainsi qu’unepresentation exhaustive des micromondes utilises. Il met l’accent sur l’im-portance de l’ordonnancement de ceux-ci dans le cadre de ce premier coursde programmation.

Le lecteur decouvrira dans ce troisieme chapitre un expose precis desfonctionnalites et du fonctionnement du logiciel d’aide a l’enseignement Lo-gOz 2.0. L’architecture du logiciel ainsi que ses differents composants serontpresentes dans le but de permettre a l’enseignant ou a l’etudiant autodidactede maıtriser l’outil. Il ne s’agit donc pas principalement d’une explication ducode ou des choix d’implementation.

Le quatrieme chapitre, intitule Enseignement et Pedagogie, retrace lesdifferentes demarches qui ont ete necessaires a l’organisation de la phase detest du cours. Il presente ensuite les principaux objectifs de chaque seancede cours ainsi que les notions enseignees par ceux-ci.

Le cinquieme chapitre est consacre a l’explication de la philosophie d’evalu-ation qui a ete pensee pour ce cours de programmation. Celle-ci comprendquatre phases (Test de mi-parcours, exercices supplementaires, projet et Exa-men). Chacune d’entre elles est explicitee dans le but de pouvoir transmettrecette philosophie aux enseignants ainsi qu’a nos eventuels successeurs.

Le sixieme chapitre reporte les enseignements tires de la phase de testdu cours. Il justifiera les principales modifications apportees a la methodeen fonction des remarques des etudiants, et mettre les futurs enseignants engarde contre certains points auxquels il sera necessaire d’apporter une atten-tion particuliere .

Le septieme et dernier chapitre proposera une critique de la methoded’enseignement par enrichissement de micromondes multi agents. Une courteetude comparative presentera d’autres approches et tentera d’evaluer lesavantages et inconvenients de notre methode. Ce chapitre proposera aussiles pistes a suivre pour l’enrichissement de ce cours ou pour l’elaborationd’un cours destine aux deuxiemes annees.

15

Chapitre 1

Choix de l’Approche Employee

L’apprentissage de l’informatique aux etudiants de premiere annee de bac-calaureat peut se reveler un tache delicate tant leurs niveaux respectifs deconnaissances en programmation s’echelonnent dans une fourchette parfoisetonnamment large. Certains maıtrisent deja les principes de base alors qued’autres ignorent jusqu’a la signification du terme “instruction”. La grandedifficulte reside alors dans la creation d’un cours qui conviendra aussi bienaux debutants qu’aux etudiants plus experimentes. Le devoir de l’enseignantd’un premier cours de programmation est de fournir des outils permettanta chacun d’atteindre le niveau necessaire pour suivre, a terme, des cours deprogrammation plus avances sans presenter de lacunes handicapantes. Cetobjectif implique d’une part l’education des novices aux principes introduc-tifs qui regissent le monde de la programmation et d’autre part la restruc-turation des connaissances des inities dans un modele adapte a la suite del’enseignement universitaire. Face a ce public a deux vitesses, le defi de l’en-seignant est de proposer une methode pedagogique qui, tout en revisitant lesbases de la programmation, permette aux etudiants les plus entreprenantsde remettre en cause leurs techniques de programmation et de tester leurspropres limites grace a des objectifs plus avances.

Dans le present chapitre nous nous efforcerons de justifier le choix d’unapprentissage par enrichissement de micromonde par rapport a d’autres tech-niques bien plus utilisees et parfaitement rodees. Ce choix, strategique etmurement reflechi, met a disposition de l’etudiant les outils destines a l’aidera comprendre au maximum des concepts qui lui sont presentes dans un envi-ronnement restreint (micromonde). Les restrictions imposees seront levees aufur et a mesure que les etudiants acquerront une maıtrise de ces micromondes.

Pour expliquer cette demarche, nous presenterons ci-apres les techniques

16

dites ”classiques”. Ces presentations succinctes de trois modes de program-mation seront suivies de l’explication concrete de notre methode et de lajustification de son adequation aux exigences de l’enseignement de premiereannee de baccalaureat en informatique.

1.1 Les approches classiques

1.1.1 La programmation orientee objet

De nos jours, le type de programmation le plus enseigne pour s’initier ala programmation est le modele objet. Nous observons cette popularite dansl’apprentissage du langage JAVA1 dispense depuis une dizaine d’annees auxpremieres annees des filieres de licence en informatique, d’ingenierie civile eninformatique et depuis 3 ans aux baccalaureats en informatique. Ce modede programmation avait alors deja longuement prouve ses vertus, le premierlangage objet, Simula I2[3], ayant ete developpe en 1964, et l’enseignementdu modele objet etant d’application depuis lors.

Afin de definir l’oriente objet, il peut etre utile de reprendre les termes deDavid Chappel[4] : “La modelisation objet consiste a creer une representationinformatique des elements du monde reel auxquels on s’interesse, sans sepreoccuper de l’implementation, ce qui signifie independamment d’un langagede programmation. Il s’agit donc de determiner les objets presents et d’isolerleurs donnees et les fonctions qui les utilisent.”

Au travers de cette definition nous pouvons retenir deux elements impor-tants qui caracterisent les objets : leur etat ainsi que leur comportement.Chaque objet se voit alors defini par :

– Un identifiant : qui permet de definir une reference unique vers un objetindependamment de ses methodes ou attributs.

– Ses attributs : qui contiennent les donnees qui caracterisent l’etat del’objet.

– Ses methodes : representent les actions possibles pour l’objet, son com-portement.

Il est important de noter que d’autres idees sont directement liees a la

1JAVA est un langage de programmation informatique oriente objet cree par JamesGosling et Patrick Naughton employes de Sun Microsystems et presente officiellement le23 mai 1995[2]

2La version la plus connue de Simula est Simula-67, developpee, comme son nom l’in-dique, en 1967 par Ole-Johan Dalh et Kristen Nygaard

17

programmation oriente objet, dont voici une liste d’exemples qui bien sur estloin d’etre exhaustive :

1. Le concept de classe : Une classe a pour but de declarer les proprietesparticulieres a un ensemble d’objets en leur definissant des methodeset des attributs communs. C’est le principe phare de la programma-tion orientee objet, ou chaque objet est defini par une classe. Il existeplusieurs types de classes (abstraites, interface,...) mais il n’est pas per-tinent d’en faire une analyse ici.

2. Le concept d’heritage : L’heritage entre classes permet de reemployerdes fonctions deja definies prealablement dans une autre classe sans de-voir les reecrire. Il suffit de specifier qu’une classe herite des methodesd’une autre pour permettre cette reutilisation.

3. Le concept de polymorphisme : “Le polymorphisme correspond a lapossibilite pour un operateur ou une fonction d’etre utilisable dansdes contextes differents (differenciable par le nombre et le type de pa-rametres) et d’avoir un comportement adapte a ces parametres”[5]. Ils’agit egalement d’un principe lie a la programmation objet tres sou-vent applique.

Les interets de travailler avec ce type de langage sont multiples : la mo-dularite est un avantage indeniable. Illustre par le principe de classe, il peutetre utilise dans le cadre de l’apprentissage pour developper individuellementdes sous-programmes (par exemple, un etudiant peut s’occuper de l’interfacegraphique alors qu’un autre se charge l’application proprement dite). Gracea l’heritage il est egalement possible de reutiliser du code ayant servi dans unautre cadre, ce qui permet a l’etudiant d’envisager son code dans un contexteplus global et lui apprend a reutiliser le code d’autres. Il est enfin tres utilede pouvoir modeliser un programme en se basant sur une representation in-formatique d’objets du monde reel. Cet avantage, tres intuitif, constitueraaussi le succes de la technique de orientee agent.

Cette approche n’est cependant pas ideale si l’on desire une comprehensionparfaite et globale. En effet, la modularite qui fait sa force est aussi sa fai-blesse car l’enseignant est souvent tente d’abstraire une partie des conceptsderriere des modules preprogrammes et de les fournir aux etudiants sans lamoindre explication, laissant ceux-ci penser qu’il s’agit en fait de modulesnatifs du langage qu’ils apprennent.

18

1.1.2 La programmation fonctionnelle

La programmation fonctionnelle se base principalement sur le conceptde machine a etat3. Chaque instruction modifie donc un etat. Afin de nepas compliquer la vie du programmeur outre mesure (celui-ci doit pouvoirconnaıtre l’etat a chaque moment) la programmation fonctionnelle utilisesouvent quelques regles de “simplification”. Par exemple, une variable nepeut etre assignee plusieurs fois. La recursion occupe une place importantedans ce type de programmation.

Cette regle implique directement une autre particularite de beaucoupde ces langages : le determinisme. Concretement, cela implique que chaqueexecution, avec les memes valeurs en entree, donne toujours le meme resultat.Il n’y a donc pas d’effet de bords4. Les langages fonctionnels les plus re-nommes sont : Lisp, Haskell, Oz, Scheme.

Certains langages fonctionnels se sont bien sur affranchis de ces contraintes.Il est alors possible, dans quelques uns d’entre eux, de specifier que certainesvariables sont reassignables, ce qui permet localement des effets de bords (parexemple : la structure de donnee Cell dans Oz ).

Cette approche presente, du point de vue pedagogique, des avantages nonnegligeables. Tout d’abord les concepts de fonction et procedure sont mis enavant des le debut de l’enseignement et sont donc immediatement integrespar l’etudiant. De plus, la syntaxe est generalement facile a maıtriser et lelangage est plutot intuitif.

Cependant, sa grande faiblesse - et le pourquoi du manque de succes dansl’enseignement de ces langages - est le manque d’utilisation en entreprise dela programmation fonctionnelle. Ce type de programmation reste mal connudu secteur industriel et n’y rivalise pas avec des langages tels que Java ouPython5.

1.1.3 La programmation orientee agent

Le paradigme de programmation oriente agent a ete introduit des 1990par les travaux du professeur Yoav Shoham. Shoham propose qu’un pro-

3Une machine a etat est une application possedant un etat initial et qui tend a joindreun etat final en modifiant son etat interne en fonction des evenements.[6]

4C’est une traduction mot-a-mot de l’expression anglaise side effect qui signifie effetsecondaire[7]

5Langage cree au debut des annees 1990 par Guido van Rossen au Pays-Bas en tantque successeur du langage ABC[8]

19

gramme oriente agent soit consitute de trois composantes :

– un systeme logique pour definir l’etat mental des agents– un langage de programmation interprete pour la programmation des

agents– un processus d’“agentification” pour compiler les programmes agents

en des systemes executables de bas niveau.[9]

La programmation oriente agent a, au cours des annees evoluee pour, al’heure actuelle, trouve son essence dans deux concepts majeurs : Les agentset les messages. Les agents sont, a l’instar des objets, une modelisationd’elements du monde reel. Un tel type d’application s’articule autour dedifferents agents qui s’echangent des messages. Chaque agent reagit aux mes-sages qu’il recoit. Son comportement est donc dicte par son environnement(utilisateur,...) et par les autres agents presents dans le systeme capables decommuniquer avec lui. Ces agents contiennent un etat et une fonction detransition qui modifie cet etat. En fonction du message recu, elle effectue desactions et envoie eventuellement des messages a d’autres agents.

Etonnamment, cette methode de programmation est rarement enseigneedans le milieu universitaire. La notion d’agent est bel et bien introduitedans des cours de projets informatiques de plus grande ampleur, mais demaniere succincte. On y apprend comment representer le reel par differentsdiagrammes. Ceux-ci servent uniquement a definir plus precisement le com-portement de l’application, car elle est finalement implementee dans un lan-gage oriente objet dans la majorite des cas.

Cependant, dans plusieurs universites, quelques pionniers tentent une in-troduction a la programmation directement orientee agent, notamment dansle but d’enseigner ensuite des methodes avancees de realisation d’applicationsreparties ou d’applications internet.

Les avantages de cette methode de programmation sont divers. D’unepart, comme pour l’oriente objet, la possibilite de modeliser des elementsdu reel est importante. Une fois cette realite transformee en diagrammesrepresentant les agents et les echanges de messages, il est tres facile d’imple-menter des applications de taille importante.

D’autre part, l’adequation du modele oriente agent aux applications reseauest impressionnante. En effet, une fois que les agents sont implementes, et lesmessages definis, il suffit de faire transiter ceux-ci par le reseau pour joindredes agents a distance. De ce fait, rien ne change dans la programmation desagents.

20

Il s’agit aussi d’une methode de programmation tres modulaire. Les agentspeuvent se programmer independamment et surtout, s’executer independam-ment.

Toutefois, ces avantages entraınent quelques inconvenients. Tout d’abord,si l’implementation de l’application est tres facile une fois le diagrammed’agents realises, il faut reconnaıtre que cette modelisation de la realite en“discussions entre agents” est parfois moins intuitive que pour la program-mation orientee objet.

D’autre part, le fait que les agents puissent s’executer independammentimplique que certains messages peuvent etre envoyes a des agents qui ne sontpas en train de s’executer, voire qui n’existent pas. Cela peut engendrer despannes si l’etudiant n’est pas initie aux techniques utilisees pour les prevenir.

Ensuite, le programmeur doit absolument maıtriser l’ordre dans lequel lesmessages sont envoyes et recus, s’il veut assurer le comportement coherentde son application.

Enfin, comme dans le cas d’un langage oriente objet, l’enseignant peutetre tente d’abstraire le fonctionnement de certains agents, et de proposeruniquement a l’etudiant la possibilite d’y envoyer des messages et d’en rece-voir. Le risque pour l’etudiant d’envisager les agents preprogrammes commeelement du systeme est moindre que pour l’oriente objet. En effet, meme sile fonctionnement de l’agent est cache, l’etudiant realise tout de meme qu’ilenvoie un message a un agent.

1.2 L’approche par agents dans des micro-

mondes

Ce memoire se voulant en partie pedagogique, une des questions impor-tantes etait le choix d’un mode d’enseignement. Puisque nous desirions testerune nouvelle maniere d’enseigner, nous avons choisi d’aborder la programma-tion par la notion d’agent. Les principes de celle-ci sont en effet bases sur desconcepts assez simples et intuitifs. Ils sont donc facilement comprehensiblespour un debutant en informatique.

Une fois le choix de travailler avec des agents pose, la deuxieme preoccupa-tion dans le cycle de la creation d’un cours est de trouver le moyen d’intro-duire les concepts de maniere graduelle. A l’instar du travail qui a servide preambule a ce memoire, notre methode d’enseignement se basera surl’approche par enrichissement de micromondes. Celle-ci a pour principale ca-

21

racteristique de permettre la limitation des concepts dans un environnementadapte au niveau de l’etudiant : le micromonde dans lequel il travaille. Unefois la limite de celui-ci atteinte (les agents connus et compris), il est possiblede passer au micromonde suivant, qui est une extension du precedent. Chaquemonde peut donc etre compris dans son ensemble et il ne reste pas d’elements“a definir plus tard” (reproche souvent formule a l’approche objet).

Ainsi les nouveaux concepts sont progressivement integres par l’etudiantqui ne se noie pas dans un ensemble trop vague et mal compris, mal defini.Cela permet a l’enseignant d’elargir autant de fois que necessaire l’universdes etudiants tout en gardant une logique d’apprentissage et un fil conduc-teur.

Bien sur l’ordre dans lequel nous abordons chacune des nouvelles notionsest tres important pour la comprehension. En effet, celui-ci doit etre fonc-tion des connaissances precedentes mais doit aussi permettre a l’etudiantd’avancer de maniere ludique dans son apprentissage. Il est important pourl’etudiant de sentir qu’il progresse dans la matiere, qu’il peut “creer” de nou-velles choses. Le chapitre suivant traitera des micromondes qui ont ete misen place ainsi que de la logique de leur ordonnancement. Mais il est d’ores etdeja important de noter que leur chronologie est un element primordial.

Cette approche par micromondes ne peut se construire sans le pilier cen-tral qu’est la concurrence. Chaque monde se compose de plusieurs agents quicommuniquent etre eux et interagissent. Des lors, cette notion de concur-rence doit intervenir le plus tot possible dans le processus d’apprentissage.L’etudiant doit comprendre ce qui se passe quand deux agents echangent desmessages, pouvoir se rendre compte que lui-meme, par l’intermediaire despremieres instructions, envoie un message a ces agents.

Nous ne sommes pas les premiers a trouver de nombreux avantages a cetteapproche, il existe quelques logiciels reposant egalement sur les micromondes :

– Logo6[10]– Squeak[5]

Tous deux furent a la base developpes dans le but d’apprendre la pro-grammation aux jeunes debutants, mais Logo (dont il existe plus de 130versions differentes) s’est emancipe de ce cadre pour avoir a l’heure actuelledes applications bien plus complexes. Le point commun entre ces logiciels et

6Plus d’explications sur ce logiciel seront donne dans un chapitre ulterieur

22

celui qui est presente ici est le cote ludique ainsi que la syntaxe minimaliste.L’environnement de ce style de logiciel est toujours “user-friendly” afin d’ac-centuer ce cote divertissant. Nous essaierons par la de donner aux debutantsl’impression de jouer plus que de programmer.

23

Chapitre 2

Approche Par Enrichissementde Micromondes

2.1 Presentation globale

Le chapitre precedent argumentait l’importance des micromondes dans lecadre d’un premier contact avec la programmation, ainsi que l’interet porteaux agents pour appliquer cette technique d’enseignement. Nous ne saurionsaborder un tel ouvrage sans mettre en valeur l’importance de la juste succes-sion des micromondes et de l’ordre d’introduction des differents agents qui lespeuplent. Chaque monde etant une extension de celui qui le precede il va desoi que les fonctionnalites et les agents sont egalement directement reportesd’un micromonde a l’autre, rendant indispensable une reflexion completeconcernant l’ordre dans lequel placer les mondes successifs.

Avant de poursuivre notre reflexion plus avant, il est indispensable dedefinir exactement ce qu’est un micromonde :Un Micromonde est un univers informatique specifique et limite dans lequelun nombre reduit de concepts sont presents et utilisables.Cette limitation est volontaire et a pour but de permettre a l’utilisateur demaıtriser entierement le micromonde.

Le modele des micromondes prend actuellement de l’ampleur surtout dansle cadre de la pedagogie active. Cette forme d’apprentissage a pour objectifde faire participer les etudiants de maniere concrete (active) a leur propreapprentissage. L’approche par enrichissement de micromonde permet doncce type d’enseignement. La popularite de cette branche de la pedagogie1 etles nombreuses etudes qu’elle suscite en font une base naturelle sur laquelle

1Squeak et ObjectKarel en sont des illustrations qui seront explique plus loin

24

inscrire notre methode. Il est tout aussi naturel que nous ne soyons pas lespremiers a nous y interesser. Une section ulterieure donnera au lecteur l’oc-casion de comparer la presente methode a d’autres applications actuelles del’apprentissage par micromonde.

La methode presentee dans ce memoire ne s’arrete cependant pas a cettesimple vision d’utilisation des micromondes, puisqu’elle se base principale-ment sur leur enrichissement et sur leur enchaınement. Le premier mondepropose est tres simpliste de maniere a ce que chaque etudiant puisse encomprendre les principes. Des que cet univers limite decouvre ses contraintes,l’etudiant est invite a passer au micromonde suivant comportant quelques res-trictions en moins et quelques concepts supplementaires. L’evolution de mi-cromonde en micromonde decouvre rapidement un univers nettement moinslimite et beaucoup plus proche des enjeux de la programmation en situa-tion reelle. Chaque monde intermediaire permet d’introduire de nouveauxconcepts-cle de la programmation et donc de construire petit a petit un uni-vers complet et complexe.Bien que cette approche se veuille independante de tout langage, il est im-possible d’enseigner des principes de bases de la programmation sans aborderle cote syntaxique. C’est pourquoi la decision a ete prise, en coherence avecle travail de nos predecesseurs, d’appuyer ces cours sur le langage de pro-grammation Oz. Celui-ci possede une syntaxe claire et intuitive et disposed’une etonnante adequation aux principes de construction d’agents et de leurcommunication.

En raison de leur implication directe dans l’environnement de program-mation LogOz 2.0, et de l’utilisation de la langue anglaise qui y est faite,les micromondes ont ete nommes a l’aide de termes anglais. Ceux ci serontpresentes dans la troisieme section de ce chapitre.

La prochaine section presente au lecteur les differents micromondes, lajustification de leur enchaınement et les raisons de leur existence.

2.2 Succession des micromondes

Comme explique precedemment, ce cours sera base sur le principe d’enri-chissement de micromondes, chacun d’entre eux etant l’extension du precedent.Chaque monde permettra d’introduire des concepts-cle de la programmationet donc il est important de reflechir a l’ordre dans lequel ils seront presentesaux etudiants.

25

Un petit tour d’horizon des decisions prises nous semble des lors interessant.Les premiers micromondes sont directement inspires du travail d’IsabelleCambron et Mathieu Cuvelier[1]. Nous nous contenterons donc de les resumer,et presenterons les micromondes supplementaires plus precisement.

Premier micromonde

Le tout premier micromonde est identique a celui qui composait l’envi-ronnement Turtle Graphics du logiciel Logo. Outre les explications relativesaux agents Browser et Turtle propres a l’environnement et necessaires a laprise en main du logiciel, le premier micromonde introduit les themes de basede la programmation. L’etudiant entre en contact avec les concepts d’agents,de variables et d’instructions dans un style ludique. Ce micromonde, bienqu’apparemment excessivement simple, se revele indispensable a l’acquisi-tion des bases et a la comprehension de la suite du cours. L’etudiant, a quil’on cache l’immensite de l’univers de la programmation, peut se focaliser surles quelques points qui lui sont enseignes. Fort de cette maıtrise, il pourraaffronter les micromondes suivants sans risque de s’y perdre. L’aspect ludiquede l’environnement LogOz permet toutefois aux elements plus avances de nepas se desinteresser du programme d’apprentissage.

Deuxieme micromonde

Dans le second micromonde, les etudiants decouvrent une serie de conceptsplus complexes bases sur les instructions et les variables introduites au prece-dent micromonde. Ces nouveaux themes sont principalement les procedureset la recursion. Les etudiants peuvent se familiariser avec ces nouveauxelements grace a plusieurs exercices exigeant l’utilisation des differentes fonc-tionnalites disponibles a ce stade. Ce monde se montre resolument plus vasteque le premier, les possibilites sont multiples, et les exercices pourraient oc-cuper les etudiants des heures durant. Une nouvelle limite est neanmoinsrapidement atteinte et de nouveaux concepts sont necessaires pour pouvoirevoluer.

Troisieme micromonde

Le troisieme micromonde pousse une premiere porte vers le modele orienteagent en introduisant principalement le concept de multi agents et donc deconcurrence. Bien que les agents soient presents des la premiere couche, cen’est que dans ce troisieme monde que l’on donne aux etudiants la possibilitede saisir pleinement leur mode de fonctionnement et leur composition.

26

Quatrieme micromonde

Base sur le concept de multi agents, le quatrieme micromonde ajouteun concept un peu particulier, a savoir le temps. Celui-ci illustre a l’aided’un agent, representant le temps qui s’ecoule, la concurrence entre differentsagents. C’est ici aussi qu’est introduit le principe de la communication entreles differents agents.

Cinquieme micromonde

Jusqu’ici l’etudiant s’etait contente d’interagir avec des agents qui luietaient fournis. Cela a permis la maıtrise du principe d’envoi de messagessans se soucier de la maniere dont la reception de ceux-ci etait traitee. Lecinquieme micromonde se base sur la connaissance des mondes precedents etoffre la possibilite a l’etudiant de programmer lui meme le comportement d’unagent. Les etudiants apprennent donc a creer eux-memes leurs propres agentsen definissant leurs reactions aux messages recus : la fonction de transition. Illeur est egalement donne quelques explications concernant certains elementsd’interface graphique ainsi que leur utilisation. Les etudiants decouvrent aussila possibilite de sauvegarder des agents qu’ils auraient crees. A ce stade il estpossible de changer d’interface pour parvenir a celle du ping-pong ou a celledu space invaders.

Sixieme micromonde

Dans ce sixieme micromonde nous etendons encore la notion d’agent,deja bien installee grace aux precedents micromondes, en mettant l’accentsur les imbrications d’agents. Certains gros agents sont eux meme composesde plus petits agents. Afin d’illustrer ce principe, nous revelons a l’etudiantque le logiciel LogOz est lui-meme un agent independant, compose de plu-sieurs agents tels que le Browser, a qui l’on peut envoyer des messagesindependamment. En creant des agents LogOz supplementaires et en les fai-sant interagir, l’etudiant renforce sa comprehension de la communicationentre agents et de la structure de logiciels plus importants.

Septieme micromonde

Le septieme micromonde porte un titre fort attractif : le reseau. Le butde cet apprentissage est de permettre a l’etudiant de profiter de la facilite desprincipes de reseau inherents au modele oriente agent qu’il est sense maıtrisergrace aux 6 premiers mondes sans pour autant lui imposer les principes tech-niques des connexions. L’apprentissage a pour but d’expliquer que tout ce

27

qui a ete vu auparavant est portable dans un modele en reseau ou les agentsse trouvent sur des machines differentes et ou les messages envoyes transitentsans peine d’un poste a l’autre.

Huitieme micromonde

Les agents concurrents, le reseau et les agents imbriques sont des conceptsqui, meme s’ils ont ete enseignes de maniere a etre assimiles simplement,n’en restent pas moins complexes. Une telle complexite mene inexorablementaux problemes qu’implique tout logiciel important : les pannes. Un huitiememicromonde pourrait etre interessant a developper, permettant a l’etudiantd’apprendre la gestion des pannes. Plusieurs pistes sont a envisager et serontpresentees de maniere plus precise par la suite.

2.3 Premier micromonde : First Steps

2.3.1 Presentation

Nous avons pris comme base pour creer ce premier micromonde sur TurtleGraphics de Logo[11]. Puisqu’il s’agit du premier monde nous l’avons voulutres simple, avec tres peu de possibilites pour l’utilisateur afin de permettrea celui-ci de se familiariser avec l’environnement et de comprendre l’entieretedes concepts presents dans ce monde sans devoir s’appuyer sur d’autresconnaissances.Comme de juste, notre premier cours se base donc entierement sur ce micro-monde.

2.3.2 Concepts abordes

– Les Agents : Nous permettons ici d’envisager une premiere definitiond’agent et ce grace a la presentation des deux agents presents dans cemicromonde :

1. L’agent Browser : C’est l’agent qui nous permet de visualiser lesinformations du monde, cet afficheur est integre au logiciel.

2. L’agent Turtle : Il s’agit de la tortue qui se deplace dans le mi-cromonde et se positionne au centre de celui-ci par defaut. C’estavec cet agent que l’etudiant interagira pour commencer.

– Les Variables

28

– Les Instructions : La definition des instructions va permettre a l’etudiantde “tester” le micromonde. Ici ne sont envisagees que les instructionsde base permettant de faire bouger la tortue et de la faire dessiner.

2.3.3 Implementation

L’agent “Browser”

Il a pour seule mission l’affichage. L’utilisateur peut y avoir acces vial’instruction suivante :

{Send Browser Msg}2

Le Browser affiche donc le message Msg passe en parametre a la procedureSend dans la fenetre de l’interface prevue pour.

L’agent “Turtle”

L’agent Turtle, quant a lui, se represente par une tortue au milieu dela feuille de dessin. L’utilisateur peut interagir avec elle en lui envoyant desmessages predefinis. Chacun des messages modifie l’etat interne de la tortue,que ce soit sa position en (X,Y), sa couleur, la position de son crayon (quilui permet d’ecrire), son angle, . . .La liste des messages compris par la tortue a ce stade se trouve dans letableau 2.1.

Si l’agent recoit un message qu’il ne comprend pas, il envoie un messageau Browser qui affichera un message d’erreur.

Notons que l’utilisateur ne fait pas appel a un sous-langage pour les ins-tructions, il s’agit bel et bien du langage Oz. L’entierete des instructions detous les micromondes seront donc ecrites en Oz.

Diagramme d’etat de l’agent “Turtle”

La figure 2.1 represente le diagramme d’etat de l’agent Turtle

Caracteristiques de la tortue

Dans l’univers de LogOz, la tortue represente a la fois le crayon quinous permet de dessiner ainsi qu’une maniere de se deplacer dans le micro-monde. Ces deplacements se font a l’aide des instructions precisees ci-dessus

2Bien que la commande {Browse Msg} soit aussi utilisable mais ne represente aucuninteret pedagogique

29

{Send Turtle forward(X)} demande a la tortue d’avancer de Xpixel(s)

{Send Turtle penUp} demande a la tortue de lever le crayon{Send Turtle penDown} demande a la tortue de baisser son

crayon{Send Turtle left(X)} demande a la tortue de tourner vers

la gauche d’un angle de X degres{Send Turtle right(X)} demande a la tortue de tourner vers

la droite d’un angle de X degres{send Turtle color(C)} demande a la tortue de changer la

couleur de son crayon (C = green, red,blue, yellow, black, purple ou

pink){Send Turtle name(N)} change le nom de la tortue en N{Send Turtle show} affiche dans le browser l’etat de la tortue

{Send Turtle giveYourState(X)} lie la variable X a l’etat de la tortue{Send Turtle kill} detruit la tortue. L’agent, donc le thread

n’existe plus.{Send Turtle center} Replace la tortue a la position

initiale

Tab. 2.1 – Messages compris par la Tortue

Fig. 2.1 – Diagramme de l’Etat de la tortue

30

Fig. 2.2 – Tortue a son initialisation

et dependent de la position de la tortue au moment ou elle recoit le message.Plusieurs parametres sont en effet a prendre en compte :

– les coordonnees en (X,Y) de la tortue au moment ou elle recoit le mes-sage. Nous signalons ici que le canevas (la fenetre de dessin definie parun carre de X∗X pixels) est un tore, c’est-a-dire que lorsque l’agentdepasse une des limites de l’espace de dessin, il reapparaıt de l’autrecote.

– la position de son crayon (en ecriture ou non).– l’angle de positionnement de la tortue qui determine ou est l’avant,

l’arriere,. . .pour elle.

Afin d’illustrer les angles,la figure 2.2 represente un dessin de la tortue a soninitialisation : Notons donc que la tortue peut tourner vers la droite ou versla gauche d’un angle compris entre 0 et 360 degres (un angle superieur estaccepte mais inutile).

Les angles tout comme les deplacements se calculent sur les axes (X,Y).Le point (0,0) se situe en haut a gauche du monde.

Exemple

X = 100

{Send Turtle penDown}{Send Turtle forward(X)}{Send Turtle left(120)}{Send Turtle forward(X)}{Send Turtle left(120)}{Send Turtle forward(X)}{Send Turtle left(120)}

31

2.3.4 Conclusion

Nous pouvons terminer la presentation de ce premier micromonde enrappelant le cote simple voire simpliste de celui-ci. L’utilisateur peut doncrapidement le maıtriser et se familiariser avec LogOz et les instructions debase. Cependant une telle simplicite implique forcement un univers tres li-mite, nous devrons donc rapidement passer au micromonde suivant.

2.4 Deuxieme micromonde : Procedures and

Recursion

2.4.1 Presentation

Comme le veut la logique d’enrichissement des micromondes, le deuxiememonde est donc une extension du premier (conservant ainsi les concepts etapplications du premier). L’enrichissement se fait principalement au niveaudes procedures et de la recursion.

C’est cette notion d’evolution qui fait la grande difference avec Logo clas-sique. En effet, l’utilisateur de Logo, une fois son univers decouvert, se retrou-vait dans l’incapacite d’avancer. Ici nous misons sur l’evolution en permettantde passer au micromonde suivant et donc d’envisager de nouveaux concepts.


– Procedures et Variables– Portee des Variables– Integer et Float– Operateurs Arithmetiques– Operateurs de Comparaisons– Expressions Conditionnelles– Les Listes– La Recursion

Nous avons choisi de passer quatre cours sur ce micromonde puisqu’ildefinit des concepts qui ne sont pas evident au premier abord comme le pat-tern matching, la recursion,...

32

proc{Triangle X}{Send Turtle forward(X)}{Send Turtle left(120)}{Send Turtle forward(X)}{Send Turtle left(120)}{Send Turtle forward(X)}{Send Turtle left(120)}

end

{Send Turtle penDown}{Triangle 50}{Triangle 100}{Triangle 150}

Fig. 2.3 – Procedure Triangle


Procedure

Nous choisissons ici de ne presenter que les specificites du micromonde,les seances de cours seront expliquees dans un futur chapitre.

Afin de faire comprendre la notion de procedure, il est donc possibledans ce monde de creer des procedures avec ou sans arguments selon lasyntaxe de Oz. Cette possibilite est illustree a la figure 2.3

Notion de repetition

Afin de rester syntaxiquement correcte dans le langage Oz, nous don-nons aux etudiant une procedure Repeat N P qui prend comme argumentsle nombre de fois a repeter, et la procedure qu’il faut executee. Elle a eteajoutee au micromonde deux, elle est donc directement utilisable. Cette no-tion est introduite a ce stade puisqu’elle nous semble interessante a jumeleravec la notion de procedure et de permettre ainsi de creer des dessins pluscomplexes et syntaxiquement plus faciles.

Deux exemples d’utilisation de la procedure Repeat sont donnes aux fi-gures 2.5 et 2.6.

33

proc{Repeat N P}

try

if N==0 then skip

else

{P}

{Repeat N-1 P}

end

catch _ then

{Browse ’error in Repeat’}

skip

end

end

Fig. 2.4 – Procedure Repeat

proc{Cercle}{Send Turtle forward(1)}{Send Turtle left(1)}

end

{Send Turtle penDown}{Repeat 360 Cercle}

Fig. 2.5 – Procedure illustrant la fonction Repeat

{Send Turtle penDown}{Repeat 360 proc{$}}

{Send Turtle forward(1)}{Send Turtle left(1)}

end

Fig. 2.6 – Autre procedure illustrant la fonction Repeat

Portee des variables

Dans ce micromonde, puisque les procedures sont integrees, il est possibled’avoir des portees de variables globales ou procedurales.

34

Float et integer, operateurs arithmetiques et operateurs de com-paraison

Afin de creer des procedures un peu plus complexes il devient utile dedefinir les elements ci-dessus ; La difference entre float et integer est indis-pensable pour comprendre les operateurs arithmetiques ainsi que ceux decomparaison.

Expressions conditionnelles

Etape logique une fois que les operateurs de comparaison sont connus. Lesexpressions conditionnelles permettent d’enrichir grandement les procedures,permettent la notion de condition dans ce deuxieme micromonde.

Recursion et listes

Un autre pilier de ce micromonde est sans conteste l’apprentissage de larecursion. En effet, une fois les expressions conditionnelles bien compriseset en particulier le pattern matching, il devient interessant des pouvoir lesillustrer dans un cadre plus global.La structure de donnees qui illustre le mieux le principe de recursion n’estautre que la liste, c’est pourquoi elle est introduite a ce niveau.

Exemple

Dans ce micromonde il est donc possible de cumuler les differentes notionsvues et d’arriver a dessiner un arbre sur base de recursion comme representea la figure 2.7

2.4.4 Conclusion

Ce deuxieme micromonde est particulierement riche de nouveaux conceptsclefs pour la programmation. Que ce soit la recursion, les expressions condi-tionnelles,... ils sont presents dans de nombreux langages et sont indispen-sables pour comprendre le fonctionnement d’un programme.La logique d’extension du premier micromonde est bien present puisque lesinstructions utilisees sont celles apprises dans celui-ci. A ce stade les pos-sibilites sont deja tres grandes pour realiser des dessins de complexite tres

35

procTree Size

if(Size < 4) then

skip

else

Send Turtle forward(Size)

Send Turtle left(20)

Tree (Size div 2)

Send Turtle right(40)

Tree (Size div 2)





end

end


Send Turtle penDown

Tree 200

Fig. 2.7 – Arbre recursif

variable... Il est donc logique de prendre un peu plus de temps sur ce micro-monde et d’assimiler l’ensemble des nouveaux elements.

Dessiner une fractale

L’exemple 2.8 reprend a peu pres tous les concepts vus jusqu’a present,mais surtout les procedures et la recursion.

proc{Triangle N}

if(N<4) then

skip

else

{Repeat 3 proc{$}

{Send Turtle forward(N)}

{Send Turtle right(120)} end}

{Triangle (N div 2)}

{Send Turtle penUp}

{Send Turtle forward(N div 2)}

36

{Send Turtle penDown}


{Send Turtle penUp}

{Send Turtle right(120)}


{Send Turtle left(120)}



{Send Turtle penUp}





end

end

{Send Turtle left(45)} {Send Turtle penDown} {Triangle 384}

Fig. 2.8 – Dessin d’une fractale

37

2.5 Troisieme micromonde : Multi Agents

2.5.1 Presentation

L’evolution suivante de nos micromondes est le multi agents a un niveaude base. Ce micromonde etend donc le deuxieme en offrant la possibilite decreer plusieurs tortues dans le meme monde.


– Fonction– Etat d’un agent– Tuple– Variable liee et non liee– Fonction de transition– Concurrence


Les fonctions

La definition de fonction va s’appuyer sur la definition de procedure vuedans le micromonde precedent. Elle sera donc definie comme une procedurerenvoyant un resultat qu’elle peut lier a une variable. Une fois de plus nousnous appuyons sur la syntaxe de Oz pour la definition de fonction :

fun{RandomColor}

Rand = {Random} mod 9 in

if(Rand == 0) then black

elseif(Rand == 1) then blue

elseif(Rand == 2) then green

elseif(Rand == 3) then red

elseif(Rand == 4) then pink

elseif(Rand == 5) then purple

elseif(Rand == 6) then orange

elseif(Rand == 7) then brown

else yellow end

end

Une illustration est presentee a la figure 2.9 de la notion de fonction.Celle-ci demontre egalement la continuite entre les micromondes.

38

Fig. 2.9 – Fractale utilisant la notion de fonction

L’etat d’un agent et les tuples

Puisqu’ici nous considerons l’agent Tortue nous allons nous concentrersur son etat a elle.Elle possede donc un etat qui est mis a jour a chaque reception de message(une sorte de memoire interne). Celui-ci peut-etre recupere par l’etudiant encliquant sur la tortue dans le micromonde, il recevra alors dans le browserun message de type :

state(Name X Y Direction PenDown Color)

– Name : correspond au nom de l’agent ;– X et Y : donne les coordonnees (X,Y) dans le micromonde (nous rap-

pelons que le point (0,0) se situe en haut a gauche) ;– Direction : correspond a la direction (angle trigonometrique) vers la-

quelle la tortue est orientee ;– PenDown : un booleen qui a true exprime le fait que la tortue ecrit

(son crayon est vers le bas) et a false qu’elle n’ecrit pas (son crayon estvers le haut) ;

– Color : Determine la couleur du trait de la tortue lorsque celle-ci ecrit.L’etat d’un agent est donc represente par un tuple avec chaque champ

correspondant a une caracteristique de son etat. Des lors nous devons intro-duire la notion de Tuple dans ce micromonde pour permettre aux etudiantsde comprendre ce qu’ils utilisent.

39

Variable liee et non liee

Puisqu’il peut etre utile d’utiliser l’etat de la tortue a d’autres fins quejuste le connaıtre, il devient pertinent pour l’etudiant de comprendre les no-tions de variables liees et non liees afin de pouvoir recuperer cet etat (desexemples sont donnes dans le sixieme cours en Annexe A.

Cerveau et fonction de transition

La fonction de transition de la tortue telle que definie dans LogOz luipermet de comprendre une serie de messages deja decrit ci-dessus. A chaquereception de message la tortue verifie qu’elle peut le comprendre, si c’est lecas elle modifie son etat en fonction du message recu, si ce n’est pas le caselle avertit l’utilisateur par l’envoi d’un message au Browser.

Creation de nouvelles tortues

Puisque tous les elements ont ete mis en place pour permettre a l’etudiantde creer ses propres tortues et leur envoyer des messages, il faut a presentconcretiser cette possibilite.

L’agent tortue est implemente comme un port object [12] qui utilise latechnique de message passing. Un port object est une combinaison de un ouplusieurs ports et un stream object. La tortue est implementee comme unthread qui lit les messages qui lui parviennent via le stream object. Toutecommunication avec la tortue se fera donc via ce stream object. Chaquemessage valide recu par la tortue entraınera une action qui est determinee al’avance.

Cette implementation est bien sur cachee aux etudiants a ce niveau, ilfaudra attendre que leur connaissance se developpe pour pouvoir leur expli-quer cette partie du monde.Il utilisera alors la fonction

MyTurtle = {NewTurtle state(Name X Y Direction PenDown Color)}

qui est ajoutee a l’environnement dans ce troisieme micromonde.Puisque la fonction de transition n’est pas accessible aux etudiants les com-portements des differentes tortues sont donc identiques.La creation de nouvelles tortues permet a l’etudiant de faire des dessins col-laboratifs, la figure 2.10 nous l’illustre et dont voici le code.

40

T1 = {NewTurtle state(’t1’ 440 340 270 true black)}

T2 = NewTurtle state(’t2’ 440 440 180 true black)}

T3 = {NewTurtle state(’t3’ 340 440 90 true black)}


proc{Carre T X}

if(X =< 0) then

{Send T penUp}

{Send T forward(200)}

skip

else

{Send T forward(X)}

{Send T right(91)}

{Carre T X-3}

end

end

{Carre Turtle 100} {Carre T1 100} {Carre T2 100}

{Carre T3 100}

Fig. 2.10 – Un dessin“collaboratif”

La concurrence

Le troisieme micromonde est enrichi, comme mentionne precedemment,par une nouvelle couche multi agents. Comme son nom l’indique, cette coucheva permettre a l’utilisateur de programmer avec plusieurs agents. Les differentsagents peuvent soit etre totalement independants, soit interagir entre eux.

41

Dans ce micromonde, l’etudiant pourra seulement creer des agents de typeTurtle. Chaque agent aura son propre nom ainsi que son propre identifiant,et pourra effectuer ses propres actions. Cette evolution apporte un tout nou-veau concept clef : la concurrence.

La concurrence apparaıt lorsque deux ou plusieurs activites independantespeuvent etre executees simultanement. Il ne devrait y avoir aucune interferenceentre ces activites, a moins que le programmeur ne decide qu’il est necessairequ’elles communiquent entre elles[12]. Plusieurs agents pourront donc effec-tuer differentes actions en meme temps. La concurrence ne deviendra sourcede problemes ou de conflits qu’a partir du moment ou les agents devrontutiliser des ressources partagees.

2.5.4 Conclusion

Dans ce micromonde l’accent est mis sur la comprehension du fonctionne-ment d’un agent. Bien sur il ne s’agit ici que d’une version simplifiee puisquetous les agents ont le meme comportement mais cela nous permet de faireaisement la transition entre cet univers et les suivants qui permettra de creerdes agents differents. Cette etape nous semble indispensable pour s’assurerque les bases sont bien comprises. L’etudiant possede maintenant assez deconnaissance pour comprendre et creer des agents plus complexes.

2.6 Quatrieme micromonde : Time

2.6.1 Presentation

Le quatrieme micromonde est, comme le veut la logique posee des ledepart, une extension du troisieme avec la notion de temps en plus. Jusqu’icile temps n’etait pas pris en compte dans la collaboration des agents, cenouveau concept va permettre a l’etudiant d’approfondir ses connaissancesen se servant de celui-ci.


– Le Temps– Un nouvel agent : le Metronome

Le concept de temps est aborde grace a un nouvel agent introduit dansce micromonde : le Metronome. Celui-ci a pour but d’emettre un message

42

toutes les secondes. Ce message peut etre envoye au browser ou a un autreagent suivant le desir du programmeur. Il peut egalement definir le contenude ce message et doit donc assumer que celui-ci soit comprehensible pour lesautres agents.


L’agent metronome

L’arrivee de ce nouvel agent ne peut se faire sans une maniere pourl’etudiant d’y faire appel. Tout comme pour l’agent tortue nous cachonsl’implementation exacte a l’etudiant qui, a ce stade, n’est pas encore capablede la comprendre, et avons donc ajoute une nouvelle fonction :

MyClock = {NewMetronome state([ListOfAgents] MsgToSend)}

avec ListOfAgents representant une liste contenant l’ensemble des agents aqui il faut envoyer le message (identique pour tous) et le MsgToSend, lemessage a envoyer (l’utilisation d’une liste comme premier argument nouspermet de revoir le concept de liste qui reste complexe).

Puisqu’il s’agit d’un agent lui-meme, le metronome est egalement capablede comprendre une serie de message ; le tableau 2.2 nous en fournit la liste.

start demarre le Metronomestop arrete le Metronome

register(Agent) Ajoute un agent a la liste des agentsauxquels un message est envoye chaque seconde

message(Msg) definit le message Msg a envoyer aux agentsclear reinitialise l’etat du Metronome a sstate(nil, nil)

La liste des agents est vide ainsi que le message a envoyer

Tab. 2.2 – Messages compris par l’agent Metronome

Afin de permettre aux lecteurs de bien saisir le fonctionnement du Metronome,nous fournissons a la figure A.4 le diagramme d’etat du l’agent Metronome.

Cela permet d’illustrer la notion de concurrence puisque les differentsagents, recevant le message a la meme seconde, agiront chacun en memetemps (du moins donneront cette illusion pour l’utilisateur).Il est important de souligner au niveau du micromonde que cela ne pose pasde probleme dans le cas envisage puisque les agents ne travaillent pas sur desressources partagees.

43

Fig. 2.11 – Diagramme d’etat de l’agent Metronome

L’exemple de la figure 2.12 illustre simplement ce concept. Le metronomeMyClock cree par l’utilisateur envoie un message toutes les secondes conte-nant forward(100) aux deux tortues creees.

{Send Turtle kill} % supprime l’agent

Turtle T1 = {NewTurtle state(’t1’ 440 340 270 true green)}T2 = {NewTurtle state(’t2’ 100 200 0 false blue)}MyClock = {NewMetronome state(nil nil)}{Send MyClock register(T1)}{Send MyClock register(T2)}{Send MyClock message(forward(100))}{Send MyClock start}

Fig. 2.12 – Interaction entre un agent Metronome et deux tortues

2.6.4 Conclusion

Ce quatrieme micromonde, bien que plus “petit” que les precedents, per-met d’accentuer la comprehension des agents et de leur concurrence grace auprincipe de temps. L’introduction de l’agent Metronome nous permet aussid’ouvrir l’etudiant a d’autres types d’agents, de comprendre qu’il existe desagents avec des buts differents et de se detacher de la tortue sans l’abandon-ner.

44

Ce niveau nous permet aussi un rappel sur la creation des agents qui seraprimordial pour les micromondes a venir.

2.7 Cinquieme micromonde : New Agents

2.7.1 Presentation

Le cinquieme micromonde, le dernier envisage par nos predecesseurs, en-richit le quatrieme micromonde mais surtout le troisieme par l’evolution duprincipe de multi agents. En effet, dans cet univers il sera possible non seule-ment de creer de nouvelles tortues mais egalement d’en definir un nouvelagent avec sa fonction de transition et son etat initial.Il sera aussi donne quelques aides pour les interfaces graphiques de manierea travailler de maniere plus ludique.


– Creation d’Agents– Etat et fonction de transition– Elements basiques d’interface graphique


Creation d’un agent

Puisque l’enrichissement principal de ce nouveau micromonde est la pos-sibilite de creer des agents, il faut ajouter a l’environnement une fonction quipermet de les creer :

MyAgent = {NewAgent Fun State}

Les connaissances de l’etudiant ne sont toujours pas assez completes pourcomprendre les ports objects. Cependant, il lui est maintenant possible d’imple-menter lui-meme la fonction de transition (ce qui fait la difference avec lemicromonde trois). Le but est donc atteint : l’etudiant peut definir le com-portement de l’agent qu’il cree.

Etat et fonction de transition

Il est important de souligner que la fonction de transition tout commel’etat sont en fait deja connus par l’etudiant puisque l’implementation deceux-ci n’est pas differente de ce qu’ils ont vu auparavant.

45

Un etat est defini par un tuple, comme pour l’agent tortue vu ci-dessus, oubien de maniere encore plus simple par un entier (ce sera le cas notammentpour le premier exercice envisage qui sera un compteur).Une fonction de transition n’est rien d’autre qu’une fonction qui prend en pa-rametre un message et un etat. La figure 2.13 nous en donne une illustrationtypique.

fun{FonctionTransition Msg State}{case Msg}of ... then

....

%renvoie le nouvel etat

[] ... then

...


else

...


end

end

Fig. 2.13 – Prototype d’une fonction de transition

Elements basiques d’interface graphique

Afin de rendre la visualisation des agents plus performante et de pouvoircontinuer l’apprentissage de maniere ludique, nous introduisons dans ce mi-cromonde de notions d’interfaces graphiques. Il va de soi que nous n’allonspas demander a l’etudiant d’apprendre QTk3, c’est pourquoi nous avons in-troduit quelques nouvelles fonctions permettant de faire appel a ces fonctionsgraphiques :

– DrawLine dont la commande est Tag = {DrawLine Size DirectionColor}, cette fonction prend donc trois parametres :

1. Size qui definit la taille en pixel de la ligne que l’on desire ecrire

2. Direction qui definit l’oritentation de la ligne a dessiner (suivantles angles trigonometriques)

3Graphical User interface Design for Oz[13]

46

3. Color qui determine la couleur dans laquelle la ligne sera dessinee.

il s’agit bien d’une fonction puisqu’elle renvoie un Tag qui est un iden-tifiant pour le dessin.

– DeleteTag {DeleteTag Tag} est une procedure qui efface simplementle dessin correspondant au Tag passe en parametre.

– DrawBall TagBall = {DrawBall X Y } dessine une balle a la position(X,Y) donnee en parametre et est identifiee par son Tag (tout commela ligne).

– DrawPaddle TagPaddle = {DrawPaddle X Y } est fort semblable ala precedente puisqu’elle dessine une palette a la position (X,Y) donneeen parametre. Cette palette est de taille fixe : 100 pixels et est aussiidentifiee par son Tag.

– DrawEnnemy Tag = {DrawEnnemy (X Y)} dessine une chauve-sourisa la position (X Y) donnee en parametre et est identifiee par son Tag.

– DrawDefender Tag = {DrawDefender (X Y)} dessine un vaisseauspatial a la position (X Y) donnee en parametre et est identifiee parson Tag.

– DrawBomb Tag = {DrawBomb (X Y)} dessine une bombe a la posi-tion (X Y) donnee en parametre et est identifiee par son Tag.

– DrawDefeat Tag = {DrawDefeat} dessine une image game over aucentre de l’ecran ;

– Defeat Tag = {Defeat} dessine une image Defeat au centre de l’ecran ;

– DrawMeteore Tag = {DrawMeteore (X Y Level)} dessine un meteorede la taille Level (cinq niveaux possibles) a la position (X Y) donneeen parametre et est identifiee par son Tag.

– MoveTag {MoveTag Tag X Y }. Cette procedure deplace le dessinidentifie par le tag de sa position horizontale actuelle posX vers posX+ X et de sa position verticale actuelle posY vers posY + Y.

47

Exemple d’application

Pour illustrer l’ensemble des principes vu ci-dessus nous avons choisid’implementer une horloge comme exemple de programme multi agents. L’hor-loge est composee de 3 agents : l’agent Seconde, l’agent Minute et l’agentHeure. Une fois arrive a 60, l’agent Seconde enverra un message a l’agentMinute, qui une fois arrive a 60 enverra un message a l’agent Heure.La figure 2.14 presente le diagramme de sequence de cette horloge, il permetde voir les interactions entre les differents agents. Vient ensuite l’implemen-tation de cette horloge et pour finir, la figure 2.15 presente le resultat.

%%% Fonction de transition de l’agent Seconde

fun{BrainSecond Msg state(Memory X)}

case Msg

of tick then

{DeleteTag X}

if(Memory > 0) then

if(Memory == 90) then

% si l’angle de l’aiguille est a 90 degres

% (soit dirigee vers le haut)

{Send Minute minute} end

NewX = {DrawLine 150 Memory-6 red} in

state(Memory-6 NewX)

% L’angle de 6 degre represente un soixantieme

% du cadran

else

NewX={DrawLine 150 Memory+360-6 red} in

state(Memory+360-6 NewX)

end

[] init(D) then

X = {DrawLine 150 D red}

state(D X)

end

end

48

%%% Fonction de transition de l’agent Minute

fun{BrainMinute Msg state(Memory X)}

case Msg

of minute then

{DeleteTag X}

if(Memory > 0) then

if(Memory mod 24 == 0) then

{Send Heure heure} end

NewX = {DrawLine 140 Memory-6 black} in


else

NewX = {DrawLine 140 Memory+360-6 black} in


end

[] init(D) then

X = {DrawLine 140 D black}

state(D X)

end

end

%\%\% Fonction de transition de l’agent Heure

fun{BrainHour Msg state(Memory X)}

case Msg

of heure then

{DeleteTag X}

if(Memory > 0) then

NewX = {DrawLine 130 Memory-6 black} in


else

NewX = {DrawLine 130 Memory+360-6 black} in


end

[] init(D) then

X = {DrawLine 130 D black}

state(D X)

end

end

49

\%\%\% Creation des agent Seconde = {NewAgent BrainSecond state(78

_)} Minute = {NewAgent BrainMinute state(96 _)} Heure = {NewAgent

BrainHour state(6 _)}

{Send Seconde init(78)} {Send Minute init(96)} {Send Heure

init(6)} Clock = {NewMetronome state([Seconde] tick)} \ \% seul

l’agent Seconde recevra un TIC a chaque seconde. \% L’agent Minute

reagira aux messages envoy´es par l’agent Seconde. \% L’agent

Heure reagira aux messages envoy´es par l’agent Minute.

{Send Clock start}

2.7.4 Interfaces

Dans ce cinquieme micromonde il est dorenavant possible de changer l’in-terface de la feuille de dessin. Quatre possibilites s’offrent alors a l’utilisateur,qui lui sont presentes lors des differents cours :

1. L’interface Turtle (cfr figure 2.9)

2. L’interface Horloge (cfr figure 2.15)

3. L’interface Pong (cfr figure 2.16)

4. L’interface Space Invaders (cfr figure 2.17)

2.7.5 Conclusion

Ce cinquieme micromonde avec la possibilite de creer des agents, de lessauver, de definir leur comportement est un enorme pas pour l’etudiant quipeut ainsi a loisir creer de nouvelles applications en les complexifiant petit apetit.Notons tout de meme que les outils graphiques restent dans ce micromondeassez limites.

50

Fig. 2.14 – Diagramme d’Etat de l’horloge

Fig. 2.15 – L’interface “horloge”

51

Fig. 2.16 – L’interface Pong

Fig. 2.17 – L’interface Space Invaders

52

2.8 Sixieme micromonde : Logoz Agent

2.8.1 Presentation

Puisqu’il est deja possible dans le micromonde precedent de creer sespropres agents, avec leurs comportements propres, nous pourrions croire quenous avons atteint les limites de l’enrichissement par micromonde. Mais iln’en est rien. Dans ce sixieme micromonde nous allons pousser la logique desagents encore plus loin pour permettre a l’etudiant de se rendre compteque tout peut etre un agent. Nous allons en effet definir l’agent LogOzrepresentant tout l’univers dans lequel nous avons travaille jusqu’a presentcomme un unique agent duplicable.


– Le multi Agents– Communication


Puisque nous avons choisi de faire de LogOz un agent, il nous a fallupas mal remanier le code de nos predecesseurs de maniere a rendre cela pos-sible. La structure interne du code a ete entierement revue. Dans la versionprecedente de LogOz 1.0, l’ensemble du code n’etait qu’une unique procedure.Nous avons maintenant separe en procedures distinctes les differents elementspour finalement obtenir deux procedures principales.

– BuildChoice qui construit la fenetre de selection du micromonde. Apresselection du micromonde par l’utilisateur, la seconde procedure estlancee.

– BuildMain elle construit la fenetre principale de LogOz avec toutes lesprocedures et fonctions qui lui sont attachees.

Bien sur, une serie de procedures outils sont egalement implementees apart, comme le calcul de l’image representant la tortue en fonction de sonangle, ou encore une fonction permettant de traduire les degres en radians,. . .

Les details de l’implementation seront donnes dans le chapitre “Environ-nement de Programmation : LogOz 2.0” ci-apres.

53

Un nouvel agent LogOz est cree par la procedure NewLogozAgent quirenvoie une reference (un port) vers le nouvel agent cree, reference qui serautilisee pour envoyer des messages a cet agent. Celui-ci se trouvera dans lememe micromonde que son parent (avec resolution egale).

Donc chaque agent Logoz possede des references vers lui-meme (via lavariable Self) et vers son parent s’il y en a un (via la variable Parent).

Etant donne que chaque agent Logoz possede un id unique, il est desormaispossible d’afficher sur le Browser de n’importe quel agent Logoz un messagea partir de n’importe quel autre grace aux deux nouvelles procedures :

– BrowseAll(Msg) affiche le message Msg sur tous les Browsers des agentsLogoz actifs.

– BrowseID(Msg Id) affiche le message Msg sur le Browser de l’agentdont l’identifiant est Id.

Comme tout nouvel agent, il faut definir les messages que celui-ci estcapable de comprendre ainsi que son comportement face a ces derniers. Ceux-ci sont repris dans le tableau 2.3 pour plus de clarte.

2.8.4 Conclusion

Le but principal de ce micromonde etait de permettre aux etudiants derealiser que tout element d’un programme, jusqu’a ce programme lui-meme,peut etre un agent independant auquel on peut envoyer des messages. Ceconcept, bien qu’implemente dans le sixieme micromonde de LogOz, n’est pasencore exploite dans sa totalite. Il reste en effet de nombreuses ameliorationsa y apporter en etendant, notamment, les possibilites d’interagir directementavec les differents composants de l’agent LogOz. De meme, aucun cours dumodule supplementaire relatif a ce micromonde n’a ete ecrit. Nous invitonsnos successeurs a se baser sur le travail realise sur ce micromonde afin de creerun module de cours qui mette en avant la possibilite de considerer toute chosecomme un agent et qui enseigne le principe d’imbrication de petits agentsdans des plus gros.

54

appendText(”VOTRE TEXTE”) affiche ”VOTRE TEXTE” dans le browsersetText”VOTRE TEXTE”) replace le texte existant dans le browser par

“VOTRE TEXTE”run Permet de compiler a partir du code

Utile pour communiquer entre agents LogOzrun(Cmd) Permet de compiler Cmd en plus

des instructions deja presentesclear agis comme le bouton “ClearWorld”

colorise Colorise les mots clefsnew Remet LogOz dans son etat initial

Browse(Msg) Affiche sur le Browser de l’agentle message Msg

quit permet de quitter le LogOz a qui le messageest envoye

changeDelay(Delay) Change le delai entre les executionsdes instructions. Delay est un integerrepresentant le temps en milliseconde

KillAll permet de detruire tous les agentsGetId(Id) Lie l’id de l’agent a qui est

adresse le message a IdchangeWorldInterface(Interface) Permet de changer l’interface de LogOz

Interface peut prendre les formes suivantes :turtle, pong, time, space

Tab. 2.3 – Messages compris par l’agent LogOz

2.9 Septieme micromonde : Network

2.9.1 Presentation

Ce septieme micromonde, comme son nom l’indique, est dedie a la creationd’un reseau. L’interet de creer un reseau dans le logiciel LogOz 2.0 est depermettre aux etudiants de se rendre compte de la simplicite de passer desagents en reseau. Il est evident que ceux-ci ne sont pas encore en mesure dele creer de leurs propres mains, c’est pourquoi ce micromonde propose unemaniere simplifiee d’y avoir acces.

La demarche de creation d’un reseau dans LogOz passe par la creationd’un “Groupe” qui peut etre considere comme un serveur. Une fois ce groupecree, chaque utilisateur desirant rejoindre le reseau doit se connecter a cegroupe.

55

Nous avons choisi de garder la logique d’agent dans la conception dureseau, et c’est pourquoi la creation et la connexion au groupe est traite parun agent. Celui-ci garde en memoire les utilisateurs connectes, les differentsagents ajoutes sur le reseau qu’il rend disponibles a tous, ainsi que la connec-tion et la diffusion des tortues de chaque client. Par la suite nous parleronsde l’etat de cet agent comme etant le reseau.


– Generalisation des agents au reseau– Principe de base de reseau


Puisque notre reseau repose sur le fonctionnement d’un agent, il nousfaut donc definir l’ensemble des messages que celui-ci peut recevoir et com-prendre. Ceux-ci sont repris dans le tableau 2.4.

Afin de permettre aux utilisateurs de se connecter a l’agent reseau, il fautsuivre les etapes suivantes :

– Creation du groupe :Groupe = {CreateGroup UserName AdresseDuGroupe}

– Connecter une tortue au reseau (et voir les autres tortues connectees) :{Send Groupe turtleWorld(nomT Turtle UserName)}

– Connecter un agent au reseau{Send Groupe add(AgentName AgentPort)}

La figure 2.18 nous montre une application reseau. Afin de faire la dis-tinction entre les tortues du reseau et les autres, un systeme de couleurs a etemis en place : les tortues des autres utilisateurs reseau sont donc dessineesen mauve, alors que les tortues de l’utilisateur restent vertes.

Divers exemples d’applications sont envisageables, cependant, puisque cemicromonde ne rentrait pas dans le cadre de notre cours, nous n’avons pasd’exemple precis a propose dans cette section. Une illustration sera tout dememe introduite dans le dernier chapitre.

56

register(UserName UserPort ?B) Ajoute l’utilisateur userName et son portUserPort a l’etat de l’agent, si celui-ci

existe deja B est lie a already

sinon il est lie a ok.add(AgentName AgentPort) Ajoute au groupe l’agent nomme

AgentName avec le port AgentPort.remove(AgentName) Supprime l’agent nomme AgentName

du reseauget(AgentName ?Agent) Lie Agent au port designe par

AgentName.getAll( ?AgentRec) Lie AgentRec a l’enregistrement

de tous les agents disponibles sur le reseau.listAgent(LogozPort) Liste l’ensemble des agents disponibles

sur le Browser de Logoz identifiepar LogozPort.

Show Affiche l’etat complet du reseauDisconnect(UserName) Supprime Username de la liste

des utilisateurs connectesturtleWorld(TurtleName Turtle UserPort) Ajoute la tortue sur el reseau et affiche

toutes les tortues deja connectees au reseau.

Tab. 2.4 – Message compris par l’agent Groupe (reseau)

2.9.4 Conclusion

La realisation de ce micromonde permet a l’etudiant de se rendre comptede la facilite avec laquelle les agents peuvent se mettre en reseau. En effetune fois les messages definis et la fonction de transition implementee, le faitde passer par un reseau ne modifie en rien le comportement des agents.Cette revelation permet aussi de comprendre un des avantages indeniablesdu modele oriente agent sur lequel repose ce cours et de voir des perspectivesd’utilisation dans le monde professionnel.

57

Fig. 2.18 – Representation des tortues en reseau

58

Chapitre 3

Environnement deProgrammation : LogOz 2.0

Ce chapitre presente les particularites de l’application utilisee par lesetudiants tout au long de leur apprentissage. Ce logiciel est une ameliorationdu programme LogOz cree par Isabelle Cambron et Mathieu Cuvelier dansle cadre de leur memoire.Ces ameliorations peuvent etre reparties selon deux grands groupes. Une ma-jorite d’entre elles ont ete induites directement par l’elargissement des mi-cromondes. Elles implementent les nouvelles possibilites offertes par les courssupplementaires ou modifient le fonctionnement general de LogOz 1.0 dans lebut de le rendre plus facile a modifier a l’avenir. Comme la programmationde ces fonctionnalites est invisible et que leurs applications sont detailleesdans la partie consacree a l’enseignement et dans les cours en annexe, nousn’y ferons que tres peu reference dans ce chapitre.Le second groupe de modifications contient toutes les fonctionnalites ajouteesdans le but d’ameliorer le confort et la facilite d’utilisation du logiciel parles etudiants. Ces ameliorations, bien que parfois peu visibles, rendent LogOz2.0 beaucoup plus convivial que son predecesseur.

Afin de ne pas desorienter le lecteur qui n’aurait pas eu connaissance decette precedente version, nous fournissons une documentation complete com-prenant une explication precise des elements de LogOz 1.0 qui ont subsisteainsi que des nouveautes apportees par LogOz 2.0.

59

Fig. 3.1 – Architecture Logique du Logiciel

3.1 Architecture du logiciel

Le code de l’application LogOz est divisee en quatre parties, chacunecorrespondant a une unite de compilation independante des autres parties(functors). Chacun de ces foncteurs peut etre considere comme un compo-sant :

1. LogozGraphics.oz : Foncteur principal de l’application. Il contienttoute l’interface graphique ainsi qu’une serie d’outils utiles au bon fonc-tionnement des differents micromondes. Cela comprend :

– les differents micromondes et les definitions des fonctionnalites qui ysont accessibles ;

– le bloc note et son processus de colorisation dynamique des motscles ;

– le Browser embarque ;– les menus et les procedures qui implementent leur comportement ;– tous les elements en rapport avec le compilateur et l’environnement ;– toutes les procedures de gestion des agents de type Turtle ;– les procedures necessaires a l’utilisation du protocole reseau ;– les procedures indispensables au fonctionnement des mondes Pong et

Space invaders utiles aux projets ;– les procedures et fonctions de l’implementation du jeu en reseau “les

tortues et les salades”.

60

Ce foncteur, qui s’appelait TurtleGraphics.oz dans la premiere versionde LogOz, a ete renomme des lors qu’il ne concernait plus uniquementla gestion de l’agent Tortue.

2. Metronome.oz : Ce foncteur contient tous les elements necessairesau fonctionnement et a l’utilisation des agents de type Metronome. Ildefinit donc leurs procedures et fonctions de creation et d’utilisation.

3. User.oz : Ce foncteur contient des fonctions destinees a l’utilisateur.Il s’agit par exemple des fonctions mathematiques (cosinus, sinus,...)et des fonctions de creation d’agents. Ce foncteur definit egalementl’agent Browser qui permet l’affichage, ainsi que l’integration de lafenetre Browser a l’interface graphique.

4. ClasslinkedList : Ce foncteur contient une classe qui implemente uneliste chaınee. Cette liste chaınee sert a garder une reference vers lesagents crees par l’utilisateur afin de pouvoir les detruire ulterieurement.

3.2 Implementation des agents

Les agents tels que Turtle, Metronome ainsi que les agents crees par l’uti-lisateur sont implementes a l’aide de port objects qui utilisent la technique dumessage passing. L’implementation du port object est basee sur la descrip-tion donnee dans “Concepts, Techniques, and Models of Computer Program-ming”[12]. Celle-ci a toutefois subi quelques modifications afin de permettrel’arret du thread de ces port objects a tout instant. La figure 3.2 montrel’implementation du port object utilise dans l’implementation de LogOz.

La procedure Kill permet de tuer un thread de maniere brutale. Cetteprocedure est executee lorsque l’agent recoit le message kill. Ceci entraınel’autodestruction de l’agent. Cependant, cette solution ne permet pas d’arreterun agent lorsque celui-ci entre dans une boucle infinie. Le message Kill s’ajou-terait alors simplement a la file des messages en attente et ne serait traitequ’apres ceux qui s’y trouvaient avant lui selon le principe de la pile FIFO1.Si l’utilisateur se trompe dans son programme et que l’agent entre dans uneboucle infinie, le message kill ne sera donc jamais traite. Une modeste solu-tion a ce probleme est trouvee dans l’ajout de la fonction kill all Turtles dans

1First In First Out : Le premier element ajoute a la pile est le premier a en etre retire

61

Fig. 3.2 – Implementation du port object

les menus presentes par la suite2.

3.3 LogOz

L’environnement de programmation a ete implemente dans le langage Oz(version 1.3.2). Pour cette raison, et pour la ressemblance de son premier mi-cromonde avec le logiciel didactique ludique Logo, il a ete baptise LogOz. Leprogramme a ete prevu pour pouvoir etre execute sur une machine Linux. Ilfonctionne egalement sur un PC equipe de Windows ou sur un Mac tournantsous Mac OSX3, bien que certaines erreurs d’affichage minimes persistent.

LogOz est un environnement permettant d’apprendre la programmationet ses concepts d’une maniere relativement simple et ludique. L’environne-ment de programmation se base sur l’enchaınement et l’enrichissement dedifferents micromondes au fur et a mesure du parcours de l’etudiant. Laforce de la methode se trouve dans le fait que l’etudiant utilise des le debut

2Les menus sont presentes au point 3.4.53Ceci vaut pour Mac OSX version 10.4, les versions anterieures n’ayant pu etre testees

62

un langage de programmation reel : Oz. L’interface se veut aussi convivialeet interactive que possible. Celle-ci, appelee LogOz Graphics est une sorted’IDE (Integreted Development Environment) pour les etudiants debutantsen programmation. Elle est tres simple a utiliser bien que tres complete.

La langue choisie pour l’environnement de programmation est tout natu-rellement l’anglais. Ce choix semblait plutot evident compte tenu de son largeemploi dans le monde de l’informatique et de son utilisation dans le langageOz lui-meme. Le vocabulaire utilise n’est neanmoins pas tres complique, desorte que tout etudiant ayant une connaissance au moins basique de l’anglaispuisse se servir du logiciel sans probleme.

3.4 L’interface graphique

L’interface graphique de l’environnement LogOz a ete realisee avec QTk4

selon les possibilites offertes par les librairies graphiques disponibles pour lelangage Oz. Cette interface est composee de plusieurs grandes parties quisont detaillees dans cette section :

1. le choix du micromonde ;

2. le bloc notes ;

3. le browser ;

4. la feuille de dessin ou canvas ;

5. les menus ;

6. les boutons.

La figure 3.3 donne une vue generale de l’environnement de programma-tion LogOz.

3.4.1 Le choix du micromonde

La figure 3.4 represente la fenetre qui s’ouvre lorsque l’utilisateur lancele logiciel. Celle-ci permet de choisir le micromonde que l’on souhaite lancer.Chaque micromonde est en rapport avec une ou plusieurs seances de cours5.La fenetre d’accueil permet aussi de choisir une resolution preferee. Selon

4QTk regroupe les librairies servant a la programmation d’interface graphique en lan-gage Oz.

5Le lien entre les seances de cours et les micromondes est expose dans les annexesconsacrees aux seances de cours (Annexe A)

63

Fig. 3.3 – Le logiciel LogOz sous Windows XP

ce choix, la taille de l’interface de LogOz s’adaptera a la taille de l’ecran del’etudiant. La feuille de dessin elle aussi modifiera sa taille afin d’occuper uneplace optimale dans l’application. Une fois un micromonde et une resolutionselectionnes, l’environnement de programmation s’ouvre. Le numero du mi-cromonde choisi, ainsi que son titre, s’affichent au dessus du canvas. Seulesles fonctionnalites propres au micromonde choisi ainsi que celles des micro-mondes precedents sont utilisables dans l’environnement. C’est le principememe prone par la methode d’enrichissement micromondes.

Afin d’ameliorer le confort d’utilisation de l’application, la fenetre dechoix du micromonde est accessible a n’importe quel moment via le menuFile6. Dans ce cas, le contenu du notepad n’est pas perdu mais est directementreporte dans le bloc notes du nouveau micromonde selectionne. Cette fonc-tion a ete implementee en reponse aux problemes rencontres par les etudiantsqui, apres s’etre trompes de micromonde, se voyaient obliges de relancer leurapplication. De meme, lorsque les concepts d’un micromonde sont epuises etqu’il est temps de passer au suivant, il est utile de pouvoir le faire le plusnaturellement possible.

6Voir explication sur les menus au point 3.4.5

64

Fig. 3.4 – La fenetre d’accueil de LogOz

Des reflexions ont porte sur la necessite d’empecher les etudiants d’accederau(x) micromonde(s) superieur(s) (ceci serait possible, par exemple, grace aune principe de mot de passe) sans en avoir recu l’autorisation de la part del’enseignant. Cette fonctionnalite, bien qu’ayant un interet pedagogique, neconviendrait pas a l’utilisation du programme par un etudiant autodidacte.Ce cours devant satisfaire un public le plus large possible nous avons choiside ne pas implementer cette fonctionnalite.

3.4.2 Le bloc notes (ou notepad)

La figure 3.5 represente le bloc notes. C’est dans ce bloc notes (aussirefere sous le terme de notepad) que l’etudiant doit ecrire le code destine aetre compile et execute. Il prend l’apparence d’un simple fichier texte afin d’ensimplifier l’utilisation. Il est possible de sauvegarder le code ecrit dans le blocnotes dans un fichier. Il est aussi possible d’y charger du code prealablementecrit. L’extension du fichier peut etre determinee par l’utilisateur au momentde la sauvegarde mais le format conseille est celui attribue aux fichiers decode OZ : monFichier.oz. Cette double fonctionnalite de sauvegarde et dechargement a deux avantages. Tout d’abord elle permet a l’etudiant de pou-

65

voir conserver ses resolutions d’exercices, soit pour les terminer a domicile,soit pour en profiter lors de travaux ulterieurs. D’autre part, cela permetaussi a l’etudiant confronte a de grandes applications et se sentant a l’etroitdans le notepad de programmer son code dans un autre editeur de texte plusadapte (Emacs, gedit, notepad++, . . .7) et ensuite d’importer son travailpour le compiler et l’executer dans LogOz.

Le bloc notes dispose en plus d’un label indiquant le numero de la ligneet le numero de la colonne auxquels le curseur se trouve. Cette fonction qui,a premiere vue pourrait sembler peu utile, se revele en fait indispensableau moment de reperer les erreurs signalees par le compilateur et renseigneesdans le Browser par le numero de la ligne concernee.

La derniere fonctionnalite apportee au bloc notes est la colorisation au-tomatique des mots-cles8. Cette colorisation, bien que n’atteignant pas leniveau d’un systeme tel que celui propose par l’environnement de program-mation Mozart[14], colorise correctement les mots-cles. Nous separons cettetechnique en deux cas distincts :

– La colorisation a l’ecriture : Dans ce cas, le sous-program-me de colori-sation verifie a chaque pression d’une touche qui imprime un caracteresi le mot auquel elle appartient fait partie du groupe de mots-cle acoloriser.

– La colorisation au chargement d’un fichier : Dans ce cas le sous-program-me de colorisation parcourt tout le texte, mot par mot, a la recherchedes mots-cles. Il colorise ensuite chaque mot cle identifie.

L’implementation d’une telle fonction de colorisation n’a pas ete sansmal. Plusieurs versions differentes ont ete mises au point avant d’arriver a unsysteme performant. Des fonctions de base permettant de positionner le cur-seur a des endroits cle (debut d’un mot, fin d’un mot, fin d’une phrase) ont duetre reimplementees vu que certains bugs persistaient dans QTk.9. La fonc-tion de colorisation s’appuie des lors sur une serie de fonctions implementeesspecialement pour l’occasion.

La prochaine etape dans l’implementation de la gestion du texte par le

7Emacs : www.gnu.org/software/emacs/, gedit : www.gnome.org/projects/gedit/, No-tepad++ : http ://notepad-plus.sourceforge.net/fr/site.htm

8Les mots-cles comprennent aussi les symboles propres au langage Oz9Des bugs subsistent pour placer le curseur au debut ou a la fin d’un mot ou d’une

ligne selon des coordonnees fournies.

66

Fig. 3.5 – Le Bloc notes et sa fonction de colorisation

bloc notes concerne son indentation. Il est indeniable qu’un tel outil aurait unimpact direct sur la facilite des etudiants a reperer leurs erreurs et a program-mer correctement. Toutefois, les seances de test de cours ont montre que lesetudiants prenaient systematiquement l’habitude d’indenter leur code eux-memes. L’indentation automatique s’inscrirait donc dans la recherche d’unconfort d’utilisation accru, mais n’est pas une fonctionnalite indispensable.De plus, les methodes specifiques liees au widget Text dans QTk ne sont pasnecessairement prevues pour realiser ce genre d’outil.

3.4.3 Le browser

La figure 3.6 represente le Browser. Il s’agit d’une integration du “OzBrowser” dans l’interface LogOz (embedded Browser). Celui-ci peut etre uti-lise comme le simple Browser Oz grace a la commande Browse messageaAfficherou bien en tant qu’agent Browser grace a l’envoi de message Send BrowsermessageaAfficher. Il permet egalement l’affichage des erreurs de compilation.Lorsque le compilateur decouvre une erreur, il l’indique dans le Browser.Celui-ci permet donc a l’utilisateur d’afficher des donnees, mais egalementde s’informer du comportement de l’application.

Le Browser sert egalement d’interface entre un agent et l’utilisateur. Parexemple, il permet a l’utilisateur de connaıtre certaines informations a pro-pos de la tortue. En effet, lorsque l’on clique sur la tortue dans le canvas,celle-ci affiche son etat dans le browser (position, penUp/penDown, couleurdu trait, etc.).

67

Fig. 3.6 – Le browser

Une petite astuce a ete necessaire afin de pouvoir integrer le Browser al’interface graphique (figure 3.7). Il n’existe en effet pas de “TK frame” enQTk. Il a donc ete necessaire de creer un BrowserObject similaire au browserpredefini et de l’integrer dans un “label”. Comme il etait cependant impos-sible de modifier sa taille, un scrollframe a ete ajoute afin que le browser neprenne pas trop de place dans l’interface graphique. Toutes les fonctionnalitesdu “Oz Browser” sont bien entendu conservees.

Le micromonde 6 propose l’utilisation de LogOz comme agent independant.Il est alors possible de creer plusieurs agents LogOz, et l’application doit pou-voir gerer plusieurs browsers. Desormais, on ne peut pas utiliser un Browse-rObject commun a toutes les instances10 de LogOz.

Pour resoudre ce probleme, nous avons quelque peu modifie la facon dontle browser est integre a l’interface (comme le montre la figure ??).

Il s’agit maintenant d’une procedure a laquelle on passe deux variablesnon liees :

{NewBrowser ?BrowseDesc ?BrowserObject}

La procedure va ensuite lier ces variables lors de son execution :– BrowseDesc : definition du widget a integrer tel quel dans l’interface.– BrowserObject : L’objet Browser proprement dit.

10Nous nous referons ici aux instantiations de LogOz creees par la fonction NewLogo-zAgent, pas a l’execution du fichier LogozGraphics.oza

68

Fig. 3.7 – Le code du browser dans User.oz

La fonction Browse a aussi subi quelques modifications afin de pouvoirs’adapter a ce nouveau micromonde. En effet, comme il peut desormais yavoir autant de BrowserObject qu’il y a d’instances de LogOz, il est necessairede le passer en argument a la procedure.

Afin de prendre en compte cette nouveaute et de pouvoir referencer leBrowser propre a chaque instance de LogOz, il a ete necessaire d’integrer unsysteme de numero d’identification qui reference chacune des instances.

Nous utilisons donc la procedure {NewBrowser} a partir de LogOz afinde recuperer les BrowserObject qui seront stockes dans une structure dedonnees11 globale, dont les champs sont les ID des instances de LogOz cor-respondantes12.

Chaque instance de LogOz possede donc un ID unique qui permet del’identifier mais egalement d’atteindre le Browser qui y est lie. A ce stade,c’est-a-dire a partir du micromonde 6, il existe trois manieres differentesd’afficher un message dans un Browser :

– {Browse Msg}, qui envoie le message Msg dans le browser de l’instanceduquel on a execute la commande ;

– {BrowseAll(Msg)}, qui affiche le message Msg sur chacun des Browsersde chaque agent LogOz actif.

– {BrowseID(Msg Id)}, qui affiche le message Msg sur le Browser del’agent dont l’identifiant est Id.

Les details d’implementation du Browser sont montres a la figure 3.8.

11La structure de donnee utilisee est le record12Dans un record, les differents elements sont accessibles via les noms des champs, aussi

connu comme ’feature’

69

Fig. 3.8 – Le code du browser dans LogozGraphics.oz

3.4.4 La feuille de dessin ou canvas

La figure 3.9 presente le monde dans lequel la tortue evolue. Ce monderepresente une feuille de dessin. Le bouton “Clear World” permet de nettoyerla feuille de dessin. Depuis la version 2.0, le bouton “Clear World” permetaussi de se debarrasser de tous les agents en cours d’execution (en supposantque ceux-ci ne bouclent pas indefiniment). En effet, dans la precedente ver-sion du programme, certains agents continuaient a s’executer en arriere plan,ce qui, a la longue, avait tendance a ralentir significativement l’application.

Pour l’implementation de la feuille de dessin, nos predecesseurs avaientopte pour le choix d’un systeme de tore13. Ce choix permet a la tortue quifranchit une des limites de la feuille de poursuivre son deplacement du coteoppose au bord franchi. Cette technique permet astucieusement de ne pasdevoir tenir compte de la taille du canvas pour ecrire ses applications. Latortue peut, grace a cette astuce, se deplacer indefiniment dans tous les senssans jamais rencontrer de limites. Une feuille de dessin finie aurait proposeune contrainte de programmation supplementaire qui aurait eventuellementpu trouver justification dans la realisation de certains exercices. Cependant,nous avons choisi de conserver l’idee originale, et de ne pas modifier cette

13Le tore est la surface engendree par la revolution d’un cercle autour d’une droite deson plan. Dans le cas present, la feuille de dessin est une mise a plat de cette surface, desorte que un bord du canvas communique avec son oppose.

70

Fig. 3.9 – La monde de la tortue : un tore

particularite dans la version 2.0.

3.4.5 Les menus

La barre de menus comprend les quatre elements suivants :

1. File

2. Edit

3. Kill

4. Help

File

La figure 3.10 represente le menu File.Ce menu comporte quelques fonctionnalites assez semblables a celles qui

se trouvent dans beaucoup d’autres logiciels. Tous ces elements du menu sontdisponibles des le premier micromonde :

– New : L’environnement en memoire ainsi que l’interface graphique sontremis a zero. Tout ce qui avait ete ajoute a l’environnement est retire.

71

Fig. 3.10 – Menu File

Le notepad et le browser sont vides de leur contenu. Le micromonde encours est reinitialise. Si l’interface choisie est le monde de la tortue, unnouvel agent Turtle est place au centre de la feuille de dessin. Si l’inter-face est autre que le monde de la tortue (Time, Pong, Space invaders),LogOz conserve le choix de cette interface.

– Save : Permet de sauver dans un fichier le contenu du notepad quipourra etre reutilise plus tard. Comme explique precedemment, le logi-ciel laisse libre choix de l’extension de ce fichier a l’utilisateur, mais lesformats conseilles sont .oz ou .txt. Il est aussi possible de ne pas definirde format pour les fichiers sauvegardes sans que LogOz n’eprouve dedifficulte a les reconnaıtre. (Fig. 3.11)

– Open : Permet de charger un fichier de texte (peu importe son format)dans le notepad (Fig. 3.12)

– Quit : Quitte l’application apres avoir demande confirmation a l’utili-sateur. (Fig. 3.13)

Les trois autres fonctions du menu File sont particulieres a l’environne-ment LogOz et representent toutes trois des fonctionnalites apportees par laversion LogOz 2.0.

– Change MicroWorld : Permet a tout moment de changer de micro-monde. Ce choix renvoie directement a la fenetre d’accueil, ou l’utili-sateur peut choisir son micromonde et sa definition. Le code ecrit dansle notepad est conserve. Cependant, les agents en cours d’execution nesurvivent pas.

72

Fig. 3.11 – Sauvegarde de fichier

73

Fig. 3.12 – Ouverture de fichier

Fig. 3.13 – Fermeture de l’application

74

– Load Agent : Cette fonction permet de charger directement dans l’en-vironnement la definition d’un agent qui aurait ete sauvegardee aupa-ravant a l’aide de la fonction Save. Lorsqu’un agent est charge, le nomdu fichier dans lequel il se trouvait est affiche en dessous du bloc notes.Il est alors utilisable comme si sa fonction de transition avait ete ecritedans le notepad (voir la figure 3.14).

Plus precisement, cette fonction charge le contenu du fichier dans unevariable qui sera ajoutee automatiquement a l’environnement du com-pilateur. Theoriquement, cette fonction ne devait servir qu’a chargerdes agents. Cependant, tant qu’une fonction correcte de sauvegarded’agents n’est pas implementee, on peut trouver une autre utilite a cettefonction. En effet cette fonction a simplement le meme effet qu’auraitune copie du code charge dans le notepad si celui-ci etait cache a l’utili-sateur. Ainsi, un professeur peut faire utiliser a l’etudiant des fonctionsqu’il aurait creees au prealable, tout en evitant d’encombrer le codede l’application de l’etudiant. Cela peut aussi, en partie, servir a encacher les details d’implementation. Cela supposerait alors d’adapterles permissions du fichier pour qu’il puisse etre ouvert par la fonctionLoadAgent mais qu’il ne puisse pas etre lu par l’etudiant. On pourraitencore l’utiliser pour precharger du code utile sans encombrer inutile-ment le bloc notes.Ces agents charges restent utilisables jusqu’a ce que l’utilisateur decidede les retirer de l’environnement en activant la fonction {Unload AllAgents}, c’est a dire que leur definition n’est pas effacee par la fonctionClear World.Cette fonctionnalite de chargement d’agents devrait s’accompagner d’unetechnique de sauvegarde d’agents plus performante que celle qui est pro-posee ici. Cette technique de sauvegarde devrait permettre, a terme,de sauvegarder et de charger dynamiquement des agents (c’est a dire,d’avoir des procedures Save Agent et Load Agent).

– Unload All Agents : Cette fonction permet de retirer de l’environnementles agents qui ont ete charges par la fonction Load Agents.

Edit

La figure 3.15 montre l’apparence du menu EditCe menu permet de modifier les parametres suivants :

75

Fig. 3.14 – Exemple de l’utilisation de la fonction ’Load Agent’.

76

Fig. 3.15 – Le menu Edit

– Delay : Cet element du menu, disponible des le premier micromonde,determine le temps d’attente de la tortue entre chacune des instructionsqu’elle doit executer. Ce parametre est modifiable a tout instant, memependant que la tortue est en cours d’execution. Ce delay a ete introduitafin de permettre a l’utilisateur une meilleure visualisation des mouve-ments de la tortue. Il a ete effectivement demontre que les etudiantsdesiraient observer le cheminement de la tortue lors de l’execution desfigures qu’ils avaient programmees. Cette observation, outre son as-pect ludique, permet d’augmenter la comprehension du deroulementde l’execution d’un programme. Le delai applicable afin d’observer auralenti est pratiquement indispensable a la comprehension des principesde recursion, qui ont parfois du mal a etre saisis sur base uniquementd’explications theoriques. Dans le cas ou l’etudiant desirerait unique-ment obtenir le resultat final, le delai peut etre diminue jusqu’a 1 ms.Le delai de 0ms etait precedemment disponible mais il s’est avere alorsque l’execution etait tellement rapide que la tortue disparaissait et queles etudiants se trouvaient desorientes. Cela entraınait aussi parfois despannes du logiciel. Les differents Delay disponibles dans LogOz 2.0 sont1 - 5 - 10 - 50 - 100 - 500 ms. Ces valeurs ont ete determinees en fonctiondes exigences des etudiants ayant teste le logiciel.

– Change World Interface : Cette fonctionnalite, disponible a partir ducinquieme micromonde, permet a l’utilisateur de migrer vers un uni-vers different de celui qu’il a connu jusqu’alors, qui contient l’agenttortue. Trois nouveaux univers sont proposes. Le premier d’entre euxest le monde de l’horloge, destine a inviter l’etudiant a implementer

77

une horloge geante en relation avec l’agent metronome. Les chiffres desheures sont deja inscrits a l’ecran, et il suffit aux etudiants d’ajouter lesaiguilles ainsi que les procedures qui les feront bouger. La seconde inter-face est l’interface Pong. Celle-ci servira de decor au projet a realiser engroupe par les etudiants. Ce projet est bien entendu d’implementer unjeu de ping pong dans la tradition des premiers jeux video. Le terrainse situe en arriere plan et les etudiants auront a ajouter les palettes etla balle afin de pouvoir jouer. Le troisieme monde est celui de SpaceInvaders. Il servira de contexte au projet realise au cours. Ce projetconsiste lui aussi a la creation d’un jeu video14. Les etudiants devront,sous la direction de l’enseignant, programmer les differents agents dujeu qui viendront s’ajouter sur le fond noir cense representer l’espace.

– Clear Text : Cet element du menu est disponible des le premier micro-monde. Il permet d’effacer le contenu du bloc notes. Les donnees nonsauvegardees sont perdues, mais les agents charges subsistent.

– Clear Environment : Cette fonctionnalite, disponible a partir du pre-mier micromonde, permet d’effacer de la memoire toutes les variablesdeclarees par l’utilisateur, c’est-a-dire celles qui ont ete ajoutees a l’en-vironnement en memoire. Les agents charges, eux, ne sont pas effaces.L’environnement initial du micromonde est donc retabli, a l’exceptiondes agents pre-charges. Si par exemple une variable X a ete declaree,celle-ci disparaıt des que l’utilisateur clique sur la fonction de menuClear Environment.

– Start Copy, End Copy, Paste : Ces fonctionnalites sont une implementa-tion sous forme de menu du principe de copie implementee dans LogOz1.0 et qui fonctionnait a l’aide de raccourcis clavier. Les etudiants lesmoins affranchis avaient effectivement eprouve de grandes difficulte autiliser les fonctions CTRL+X, CTRL+C, CTRL+V alors qu’ils sonthabitues a effectuer l’action coller en selectionnant du test et en utili-sant le menu contextuel ou le menu Edit dans la plupart des applica-tions grand public. Les utilisateur d’ordinateurs Macintosh eprouvaienteux aussi des difficultes a devoir utiliser la touche CTRL la ou ils uti-lisent habituellement la touche Commande/Pomme. Ces fonctions demenus s’utilisent de la meme maniere que les raccourcis. Start Copyest a activer lorsque le curseur se trouve au debut de la zone de textea copier, End Copy est a activer lorsque le curseur se trouve a la fin de

14L’enonce de ce projet se trouve dans le chapitre Enseignement et Pedagogie

78

Fig. 3.16 – Le menu Kill

la zone de texte a copier, et Paste est a selectionner lorsque le curseurse trouve a l’endroit ou l’utilisateur desire coller son texte.

Kill

La figure 3.16 illustre le menu Kill.Le menu kill permet d’arreter n’importe quel agent de maniere brutale. Il

utilise la fonction Kill ajoutee aux ports objects qui implementent les agents.Il est compose de trois elements :

– All Turtles : Cet element du menu est disponible a partir du secondmicromonde. Il entraıne l’arret immediat de l’agent Turtle. Cette fonc-tion est tres utile lorsqu’on se rend compte de l’existence d’une erreurdans le code qui vient d’etre lance, ou lorsque la tortue entre dans uneboucle infinie. Kill allTurtles permet d’eviter d’avoir a attendre jusqu’ala fin de l’execution (qui n’arrivera peut etre jamais) avant de continuera travailler.

– All Metronomes : Cet element du menu est disponible a partir du qua-trieme micromonde, qui introduit le concept de metronome. L’arretdu Metronome peut s’averer utile lorsque plusieurs agents dependentdu message emis par le Metronome pour effectuer differentes actions.L’utilisateur peut mettre fin aux messages envoyes par le Metronomeet donc aux actions qui s’ensuivent. Il ne s’agit en fait qu’un raccourcide l’instruction Send MyClock stop.

– All other Agents : Cet element du menu est disponible a partir ducinquieme micromonde, qui introduit le concept de creation d’agents.Cette fonction est utile pour arreter un agent cree par {NewAgent} quicomporterait des erreurs ou rentrerait dans une boucle infinie.

79

Fig. 3.17 – Le menu Help

Fig. 3.18 – Les Boutons Run et Clear World

Help

La figure 3.17 illustre le menu Help.Ce menu est compose de deux elements :

– Instructions : Affiche une fenetre qui reprend les differentes commandesdisponibles. La fenetre d’instruction propose une barre de menu quisepare les instructions en differents groupes. Les raccourcis claviers sontsuivis des fonctions mathematiques. Viennent ensuite toutes les com-mandes relatives aux cours, separees en fonction des micromondes danslesquels elles sont introduites. Lors de la selection d’un element dans lemenu, les instructions relatives s’affichent dans la zone d’affichage dela fenetre.

– About : Affiche une fenetre qui contient des informations concernantles deux versions de LogOz et leurs auteurs.

3.4.6 Les boutons

La figure 3.18 presente les boutons Run et ClearWorld :– Run : compile et execute le code qui se trouve dans le bloc notes. S’il

y a une erreur a la compilation, celle-ci sera affichee dans le Browser.– Clear World : Reinitialise le monde actuel (Turtle World, Time World,

Pong World ou Space Invaders World). Tout ce qui se trouvait dans lemonde de l’interface est efface. La version LogOz 2.0 perfectionne cettefonction en s’assurant que tous les agents, ainsi que leur representation

80

graphique, disparaisse de l’environnement et de la feuille de dessin.Effectivement, la premiere version du logiciel presentait quelques insta-bilites a ce niveau, et la suppression, notamment des palettes de Ponget de la balle, ne se faisait qu’en apparence.

3.4.7 Le compilateur et l’environnement

Dans LogOz 1.0des outils ont ete ajoutes au compilateur afin de permettreune utilisation plus facile et plus intuitive de LogOz. Nous avons continueleur voie en ajoutant a notre tour des outils pour simplifier l’utilisation desnouveaux micromondes. Ces outils se comportent comme des mots-cles dulangage, il ne faut donc pas les declarer pour les utiliser. Ces outils ne sontdisponibles qu’a partir de certains micromondes qui en necessitent l’usage.La plupart ne sont pas disponibles dans les premiers micromondes.

Les outils ajoutes a l’environnement du compilateur

Le tableau 3.1 montre tous les outils qui ont ete ajoutes a l’environnementdu compilateur.

81

Age

nt/

fonct

ion

Des

crip

tion

Apar

tir

du

mic

rom

onde

Turt

leag

ent

tort

ue

exis

tant

des

ledep

art

dan

sl’en

vir

onnem

ent.

De

cett

em

anie

reil

n’e

stpas

nec

essa

ire

de

dec

lare

r1

une

tort

ue

pou

rco

mm

ence

ra

uti

lise

rle

logi

ciel

Bro

wse

rag

ent

Bro

wse

rquiper

met

d’a

ffich

erdes

info

rmat

ions

dan

sla

fenet

red’a

ffich

age

1B

row

sebro

wse

rcl

assi

que

de

Oz

quies

tre

dir

ige

vers

leB

row

ser

embar

que

1Sin

efo

nct

ion

quire

nvo

iele

sinus

d’u

nan

gle

endeg

res

1C

osin

efo

nct

ion

quire

nvo

iele

cosi

nus

d’u

nan

gle

endeg

res

1Tan

gent

fonct

ion

quire

nvo

iela

tange

nte

d’u

nan

gle

endeg

res

1R

epea

tpro

cedure

quiper

met

de

repet

erN

fois

une

pro

cedure

P2

Ran

dom

fonct

ion

quire

nvo

ieun

nom

bre

alea

toir

e2

New

Turt

lefo

nct

ion

quiper

met

de

cree

run

nou

velag

ent

tort

ue

dan

sle

mon

de

3N

ewM

etro

nom

efo

nct

ion

per

met

tant

de

cree

run

nou

velag

ent

Met

ronom

e4

New

Age

nt

fonct

ion

quiper

met

de

cree

run

nou

velag

ent

5D

raw

Lin

efo

nct

ion

quiper

met

de

des

siner

une

lign

edan

sle

mon

de

5D

raw

Pad

dle

fonct

ion

quiper

met

de

des

siner

une

pal

ette

dan

sle

mon

de

5D

elet

eTag

pro

cedure

quiper

met

d’e

ffac

erun

Tag

du

mon

de

5M

oveT

agpro

cedure

quiper

met

de

dep

lace

run

Tag

dan

sle

mon

de

5D

raw

Bal

lfo

nct

ion

quiper

met

de

des

siner

une

bal

ledan

sle

mon

de

5G

etW

indow

Siz

efo

nct

ion

quire

nvo

iela

taille

(en

floa

t)de

lafe

net

rede

des

sin

5D

raw

Def

ender

fonct

ion

quiper

met

de

des

siner

un

vais

seau

spat

ialdan

sle

mon

de

5D

raw

Ennem

yfo

nct

ion

quiper

met

de

des

siner

une

chau

ve-s

ouri

sdan

sle

mon

de

5D

raw

Met

eore

fonct

ion

quiper

met

de

des

siner

un

met

eore

dan

sle

mon

de

5D

raw

Bom

bfo

nct

ion

quiper

met

de

des

siner

un

mis

sile

dan

sle

mon

de

5D

raw

Vic

tory

fonct

ion

quiper

met

de

des

siner

lelo

gode

vic

toir

eau

centr

edu

mon

de

5D

raw

Def

eat

fonct

ion

quiper

met

de

des

siner

lelo

goga

meo

ver

auce

ntr

edu

mon

de

5

Tab.3.

1–

Outi

lsajo

ute

sa

l’en

viron

nem

ent

du

com

pilat

eur

82

Age

nt/

fonct

ion

Des

crip

tion

Apar

tir

du

mic

rom

onde

New

Log

ozA

gent

fonct

ion

quiper

met

de

cree

rune

nou

velle

inst

ance

de

Log

Oz

6Sel

fag

ent

Log

Oz

coura

nt

6B

row

seA

llpro

cedure

quiper

met

d’a

ffich

erdes

info

rmat

ions

dan

sle

sB

row

sers

de

toute

sle

sin

stan

ces

Log

Oz

6B

row

seID

pro

cedure

quiper

met

d’a

ffich

erdes

info

rmat

ions

dan

sle

Bro

wse

rd’u

ne

inst

ance

Log

Oz

des

ignee

par

son

ID6

Par

ent

agen

tLog

Oz

quia

cree

l’in

stan

ceco

ura

nte

de

Log

Oz

(s’ily

ena

un)

6C

reat

eGro

up

fonct

ion

quiper

met

de

cree

run

grou

pe

rese

au7

Con

nec

tToG

roup

fonct

ion

quiper

met

de

seco

nnec

ter

aun

grou

pe

rese

aupre

alab

lem

ent

cree

7D

raw

Sal

adfo

nct

ion

quiper

met

de

des

siner

une

sala

de

dan

sle

mon

de

7C

reat

eSer

ver

pro

cedure

quicr

eeun

serv

eur

pou

rle

jeu

des

tort

ues

etdes

sala

des

7C

onnec

tfo

nct

ion

quiper

met

de

seco

nnec

ter

aun

serv

eur

du

jeu

des

tort

ues

etdes

sala

des

pre

alab

lem

ent

cree

7

Tab.3.

2–

Outi

lsajo

ute

sa

l’en

viron

nem

ent

du

com

pilat

eur

(suit

e)

83

Remarque : Le mot-cle declare est ajoute lors de la compilation demaniere a ne pas devoir l’ecrire a chaque fois afin de simplifier la prise enmain du langage au debut. Des que l’on pousse sur le bouton run, ce mot-cleest ajoute de la maniere suivante :

{E enqueue(feedVirtualString("declare "#{TextHandle get($)}))}

Le projet du jeu des tortues et salades, qui n’a pas ete integre a ce cours,sera presente dans le chapitre 7 consacre aux pistes.

3.5 Ameliorations du programme et resolution

des problemes

Cette section presente au lecteur interesse par les differences significativesentre les deux versions de LogOz les apports concrets de la version 2.0.

Colorisation automatique des mots-cles, des symboles et des com-mentaires

A chaque evenement15 sur le bloc notes, le systeme verifie que le mot en-tier forme par l’ajout de la nouvelle lettre forme un mot cle. Si tel est le cas,alors ce mot est colorise. Si un caractere supplementaire est ajoute au mot,il sera remis en couleur normale, sauf si ce caractere est un symbole special.Une autre fonction de colorisation a aussi ete implementee afin de faire uneverification sur un texte entier ajoute d’un coup au bloc notes lors de l’ou-verture d’un fichier ou du collage de texte. Dans ce cas, il faut parcourir toutle contenu du bloc notes a la recherche de mots-cles, symboles proteges etcommentaires.

Transformation de LogOz en agent geant : micromonde 6

Afin de convertir LogOz en agent geant, il a ete indispensable de rema-nier l’ensemble de l’implementation du programme. Nous avons separe lecode en deux grosses parties. La premiere concerne la fenetre de selectionde la resolution et des micromondes, la seconde reprend la fenetre LogOz ettoutes les fonctionnalites qui s’y rapportent. Nous avons ensuite implementeune fonction permettant de creer un agent independant a partir de l’agentLogOz courant. La fonction de transition de cet agent accepte des messages

15Un evenement est caracterise par la pression d’une touche du clavier ou d’un boutonde la souris.

84

effectuant les memes fonctions que la plupart des boutons et menus dispo-nibles dans la fenetre LogOz. Etant donne que cette nouvelle fonction renvoiele port de l’agent nouvellement cree, il est possible de faire interagir les agentsentre eux et donc d’envoyer des messages vers une instance dupliquee de Lo-gOz a partir d’une autre. Tous les messages compris par l’agent LogOz sontrepris au tableau 2.3.

Implementation de la partie reseau : micromonde 7

Pour la partie reseau, nous avons implemente plusieurs fonctions specifi-ques. Il y a ainsi deux groupes de fonctions utiles. La premiere partie concernele principe de creation d’un groupe. Ce groupe est en fait represente par unagent qui est mis a disposition par la fonction CreateGroup qui prend commeargument un chemin (reseau) pour le partage de l’espace virtuel de l’agent. Decette maniere, les autres utilisateurs peuvent acceder a cet agent reseau gracea la fonction ConnectToGroup a laquelle il faut egalement specifier le chemind’acces. Apres avoir ainsi recupere l’agent reseau, il est possible d’ajouterdes agents supplementaires a la liste des agents disponibles en reseau. Cettefonctionnalite permet alors d’une utilisation a distance de ces agents quis’executent sur le LogOz a partir duquel l’agent en question a ete envoye surle reseau. Le cas d’utilisation ideal consiste a utiliser des agents qui repondenten liant les variables non liees des messages envoyes.

Il est egalement possible de connecter sa tortue au reseau et afficher sursa propre feuille de dessin toutes les tortues connectees des autres utilisa-teurs. Seule sa propre tortue est utilisable et celles des autres sont afficheesdans une autre couleur et mises a jour a chaque deplacement effectue par unutilisateur reseau. Ceci permet de realiser des dessins a plusieurs en reseau.Pour arriver a ce resultat, nous avons du ajouter a la fonction de transitionde l’agent LogOz des messages specifiques a la feuille de dessin et la fonctionde transition de la tortue a du etre amelioree (voir plus loin :”Ameliorationde la fonction de transition de la tortue”).

Ajout du choix de la resolution d’affichage

Dans un souci de confort d’utilisation et a la demande des etudiants,nous avons implemente la possibilite de changer la resolution d’affichage duLogOz. Les resolutions d’ecran pouvant varier fortement d’un ordinateur al’autre, il etait necessaire d’adapter la fenetre de LogOz. De cette maniere,

85

un etudiant utilisant une resolution d’ecran de 800x600 n’aura pas la moitiede sa feuille de dessin qui sort de l’ecran. De meme, celui qui utilise uneresolution plus grande aura plus de place pour ses dessins.

Retour a la fenetre de choix de micromonde et de resolution depuisune session en cours

Dans LogOz 2.0, il etait impossible de changer de micromonde a partird’une session ouverte. Il fallait fermer le programme et l’ouvrir a nouveau afinde changer le niveau du micromonde. Par consequent, nous avons implementecette fonctionnalite manquante. Elle est disponible sous le menu File au nomde ”Change Microworld”. Lorsque l’on change de micromonde, une nouvelleinstance de LogOz est lancee. Nous nous retrouvons donc dans un LogOzreinitialise. Cependant le texte qui etait present dans le bloc notes sera tou-jours present apres le changement.

Ajout d’une interface pour le jeu ”Space invaders”

Dans le cadre du projet ”Space Invaders”, nous avons rajoute une nouvelleinterface qui est disponible dans la fonction ”Change World Interface” sousle menu ”Edit”.

Implementation d’une fonction permettant de recuperer la taillede la fenetre de dessin a partir de LogOz

Comme il est maintenant possible de choisir des resolutions d’affichagedifferentes, il fallait une fonction permettant de recuperer la taille de lafenetre de dessin afin de realiser certains dessins ou encore dans le cadredes projets ”Pong” et ”Space Invaders”.

Amelioration de l’implementation du metronome

L’implementation de l’agent Metronome n’etait pas parfaite. En effet, leprogramme LogOz se fermait souvent suite a une erreur lorsque l’on voulait lereinitialiser sans avoir envoye un message ’start’ au metronome. Cette lacuneest maintenant comblee.

Ajout des identifiants pour les instances de LogOz

Afin de pouvoir differencier les instances de LogOz ouvertes, nous avonsajoute un systeme d’identification par numero. Celui-ci est affichee dans le

86

titre de la fenetre a partir du micromonde 6. Ce numero d’identification per-met d’afficher des messages sur le browser de n’importe quelle instance gracea la fonction BrowseID qui prend comme argument le message et l’identifiantdu LogOz cible. Il est egalement possible d’afficher un meme message sur lesbrowsers de toutes les instances par la fonction BrowseAll. Afin de parvenira realiser ces fonctions, chaque fois qu’un LogOz est ouvert, son objet ’brow-ser’ est enregistre dans une variable globale avec comme champ de selectionson identifiant. Les identifiants sont attribues de maniere incrementale etla fermeture d’un agent permet de replacer son identifiant dans la liste desidentifiants attribuables.

Ajout de raccourcis clavier

En plus des raccourcis deja existant pour le copier/coller et la sauvegardedu contenu d’un fichier, nous en avons ajoute quelques-uns :

– “CTRL + n” : reinitialise le bloc notes et l’environnement (“File”→“New”)

– “CTRL + o” : ouvre un fichier dans le bloc notes (“File” → “Open”)– “CTRL + r” : compile le contenu du bloc notes (bouton “Run”)

Rappel des raccourcis existant :– “CTRL + x” : debut de selection de la copie (“Edit” → “Start Copy”)– “CTRL + c” : fin de selection de la copie (“Edit” → “End Copy”)– “CTRL + v” : colle la selection a la position courante du curseur

(“Edit” → “Paste”)– “CTRL +s” : sauvegarde le contenu du bloc notes dans un fichier (“Fi-

le” → “Save”)

Implementation de procedures de dessin

De nouvelles procedures de dessin specifiques au projet “Space Invaders”ont ete implementees. On y retrouve notamment le dessin d’un vaisseau spa-tial, d’une chauve-souris, d’un meteore ou encore le logo de victoire.

Amelioration de la fonction de transition de la tortue

Quelques erreurs frequentes faites par les etudiants amenaient a la ferme-ture premature du programme LogOz. Ces erreurs consistaient entre autresa l’utilisation d’arguments incorrects dans les messages envoyes a l’agentTurtle. Nous avons donc ajoute des verifications sur le type des argumentsenvoyes, ainsi que des reponses adequates en cas d’utilisation incorrecte. Il

87

est desormais possible de passer des Float en argument aux messages for-ward, left et right. De meme, si on envoie un atome comme argument, latortue repondra simplement qu’elle ne peut utiliser ce type de variable.

Deux nouveaux messages sont maintenant acceptes par la tortue. Il s’agitpremierement du message center qui replace la tortue au centre de la feuillede dessin. On retrouve ensuite un message specifique au monde reseau destortues. Il s’agit du message register qui ajoute a la liste reseau16 de unepaire NomDeTortue#UserPort qui represente le nom de la tortue mise enreseau par le LogOz dont le port de l’agent est UserPort. Ainsi, les messagesde deplacement de la tortue ont ete remanies de sorte que sa representationsoit coherente sur chacune des feuilles de dessin des utilisateurs connectes augroupe reseau.

Amelioration de la fonction ”Clear World”

Dans la precedente version de LogOz, cette fonction souffrait d’une ef-ficacite inegale. Nous l’avons donc remaniee de maniere a ce que la rendrefiable. Il arrivait que certains agents soient toujours actifs apres execution dela procedure ClearWorld. Cette erreur survenait notamment lors de creationde nouveaux agents comme les aiguilles de l’horloge dans l’exemple sur letemps ou de la balle dans le projet “Pong” qui continuaient a exister apresreinitialisation. La nouvelle fonction supprime desormais ce genre d’erreur.

Amelioration de la mise a jour des informations du bloc notes

Les informations du bloc notes regrouppent le numero de ligne et decolonne de la position du curseur, des informations sur l’ouverture ou sauve-garde des fichiers et des informations sur les agents precharges. Concernant lenumero de ligne et de colonne, la mise a jour se fait a chaque evenement. Cecipresente un traitement plus efficace que l’ancienne technique, qui consistaita mettre a jour ce champ quatre fois par seconde.

16On entend par liste reseau une liste maintenue a jour dans l’etat de la tortue quicontient des informations relatives au reseau

88

Chapitre 4

Enseignement et Pedagogie

4.1 Demarches

Meme si comme nous l’avons explique precedemment ce memoire s’adressea un public large, son but premier est la creation d’un cours de programma-tion pour une premiere annee de baccalaureat en informatique. Il est sense depenser qu’un cours est bien plus qu’un syllabus cree par quelques etudiantssur base d’un ideal pedagogique. Un cours, et a fortiori un cours d’informa-tique, est une idee en mouvement qui evolue en fonction des reactions dupublic, qui s’adapte aux exigences et aux difficultes des etudiants. Une phasede test etait donc necessaire avant d’arreter une version definitive de notreenseignement. Pour ce faire nous sommes partis a la recherche d’un public cor-respondant aux criteres requis. Il etait bien entendu impensable de choisir nostesteurs parmi un groupe de premiere baccalaureat, tant ceux-ci ont deja forta faire face a leur propre programme. Nous nous sommes alors tournes versce qui ressemble le plus a un etudiant de premiere annee, a savoir un etudiantrhetoricien. L’objectif etait d’integrer ce cours de test au programme d’unesixieme annee de l’enseignement secondaire, et de faire intervenir l’evaluationde leur travail dans leur cursus afin de remplir au maximum les conditionsd’un enseignement universitaire. Il nous fallait donc une ecole proposant unesection informatique en derniere annee, ayant une infrastructure informatique(un “pool d’ordinateurs”) et nous autorisant a monopoliser quelques heurespar semaine d’une classe durant un quadrimestre.

Nous avons entrepris des demarches aupres de plusieurs ecoles mais nousnous sommes toujours heurtes au meme probleme : aucun d’autre nous nepossedant l’agregation1, il nous etait impossible d’etre responsable d’une

1L’agregation de l’enseignement secondaire superieur est la formation pedagogique

89

classe, et encore moins de prodiguer un enseignement dont les resultats au-raient une valeur quelconque dans le cursus general des etudiants.

Puisque cette premiere possibilite nous echappait nous avons decide denous concentrer sur les associations cherchant a promouvoir l’informatique adifferents niveaux. A nouveau nous avons multiplie les demarches aupres decelles-ci, que ce soit via mail, par telephone ou a l’aide de demarches person-nelles.Quelques-unes nous ont recontactes2 mais seule une seule d’entre elle se mon-tra enthousiaste : l’universite des Aınes[25].Apres presentation de notre projet a la fin d’une de leurs conferences et pu-blication d’une annonce dans le journal de l’Universite des Aınes, nous avonspu entrer en contact avec six aınes qui avaient decide de s’inscrire a notrecours. Afin de completer notre “classe” nous avons egalement affiche quelquesannonces publicitaires dans les rues de Louvain-la-Neuve. Nous avons ainsireunir une audience de 10 etudiants, entre 23 et 75 ans. Ce groupe, tresheterogene au niveau des connaissance en informatique de chacun, pouvait,malgre sa moyenne d’age, servir de base de comparaison avec un hypothetiqueauditoire de premiere baccalaureat.

Ce groupe constitue, il nous fallait egalement trouver un lieu disposantd’ordinateurs sur lesquels nous pouvions installer notre outil pedagogique.Nous nous sommes adresses a l’Universite Catholique de Louvain (UCL) etplus precisement a la faculte de sciences appliquee qui nous a autorise l’accesaux salles situees dans le batiment “Pierre Curie”.Nous avions ainsi reuni tous les elements necessaires a l’enseignement notreserie de cours sur les principes de bases de la programmation bases sur lesmicromondes multi-agents.

Si l’experience de telles demarches devait se reproduire, nous conseillonsa nos successeurs d’abandonner l’idee d’un enseignement cote dans le cadred’un lycee. On peut des lors douter de l’efficacite d’un enseignement non cote,et de l’impossibilite d’en deduire le comportement d’etudiants de premiereannee qui seront, eux, juges en fonction de leur connaissance de la matiereet de leur implication au cours. Cependant, il semble illusoire d’imaginerpouvoir trouver un moyen d’introduire, a la derniere minute, un tel projetdans un cursus scolaire.

necessaire afin d’obtenir l’autorisation d’enseigner dans l’enseignement secondairesuperieur, avec le titre (et donc le bareme) de licencie agrege.[22]

2Academie d’Informatique[23], ADA[24]

90

Nous privilegions une initiative allant dans le sens d’un stage de vacances.Il est probable qu’un stage gratuit d’introduction a la programmation dontla publicite serait faite dans les lycees pourrait attirer un grand nombred’etudiants. Un tel modele presente cependant plusieurs inconvenients. Toutd’abord, la concentration d’un cours cense se donner sur 10 semaines enun programme de 5 ou 10 jours ne peut pas permettre a l’etudiant de sefamiliariser avec les concepts appris, a moins que le stage ne propose delongues seances d’exercices. Le second probleme provient du fait meme queles enseignants doivent se liberer de toute autre activite durant toute la dureedu stage. Les dates possibles seraient la semaine de conge de Toussaint oucelle de carnaval, dont les universitaires ne profitent pas, les deux semainesde vacances de Noel, qui correspondent au blocus a l’universite, et les deuxsemaines de vacances de Paques, qui constituent un pre blocus. La meilleuresolution serait, pour des etudiants de deuxieme ou troisieme cycle ayant unprogramme allege, de dispenser ce cours lors de la semaine de Toussaint.Cette possibilite, qui est generalement negligee a cause du peu de temps quila separe de la rentree universitaire, est envisageable des lors que le travailde preparation des cours est fourni dans le present memoire.

4.2 Organisation

Lors de nos seances de cours nous avons fait le choix de ne pas separer lescours theoriques des exercices, principalement dans un souci de facilite d’en-seignement. Ce modele est cependant facilement adaptable a un enseignementuniversitaire plus classique, separant le cours en un enseignement theoriqueen auditoire et un enseignement pratique en salles de travaux pratique. Ilest tout de meme important de remarquer que l’ensemble de la theorie estparsemee d’exemples explicites permettant d’illustrer les concepts tout nou-vellement acquis. Cette maniere d’enseigner permet, selon notre experience,une plus grande rapidite de comprehension puisqu’elle permet a l’etudiantde comprendre rapidement l’interet du concept et lui permet egalement uneutilisation immediate (qui aide souvent a la memorisation).

Nous avons dispenses nos cours a raison de deux seances de deux heurespar semaine suivant un horaire plausible pour des etudiants de premiere bac-calaureat.Afin de rendre le cours le plus proche de la realite possible nous avons prevuune evaluation des connaissances a la moitie du quadrimestre sous forme d’untest3.

3Ce test est present dans les annexes, dans la section cours. Il s’agit du neuvieme cours.

91

Micromonde CoursMicromonde 1 Cours 1Micromonde 2 Cours 2

Cours 3Cours 4Cours 5

Micromonde 3 Cours 6Micromonde 4 Cours 7Micromonde 5 Cours 8

Cours 9Cours 10Cours11Cours 12Cours 13Cours 14

Tab. 4.1 – Tableau de correspondance entre micromondes et cours

Afin de clarifier l’usage des micromondes dans notre enseignement ainsique les liens existant entre eux et chaque seance de cours, un tableau decorrespondance est presente a la table 4.1.

4.3 Seances de cours

Dans cette section nous allons presenter chaque seance de cours une aune, les nouveaux concepts enseignes, les exercices donnes,...Lors de notre experience d’enseignement nous n’avons pu donner que lesneufs premieres seances mais cela n’empeche pas de developper la suite ici.Les seances completes sont disponibles dans les annexes (Annexe A). Le coursa ete ecrit comme une entite avec differentes sections, chaque cours suit leprecedent et, tout comme pour les micromondes, necessite la comprehensiondes seances precedentes.

4.3.1 Premiere seance

Pour commencer un cours sur la programmation, il faut bien evidemmentrepartir du debut, les etudiants n’ont probablement pas tous le meme niveaude depart et il faut donc les “harmoniser”. C’est pourquoi le premier coursest probablement un des plus importants puisqu’il pose les bases pour la suite

92

(revision pour certains, apprentissage pour d’autres).Nous commencons par definir les objectifs du cours : la decouverte des fon-dements de la programmation tout en laissant un minimum de zone d’ombredans la comprehension.

Une fois les objectifs definis, il est important pour l’etudiant de se sentira l’aise avec l’environnement sur lequel il travaillera, aussi nous prenons letemps de presenter LogOz qui sera notre outil pedagogique.

Pour ce faire il nous faut deja definir la premiere notion, la premiere pierrepour la suite, la definition d’agent. A ce stade la definition ne peut se basersur des concepts de programmation et doi rester assez large : Un agent estune entite avec laquelle il est possible de communiquer grace a un certainnombre de messages bien definis qui peuvent etre compris par cet agent.

La communication entre agent se fait via la commande suivante :

{Send Agent Message}.

Une fois cette notion definie, il devient possible de comprendre les deuxprincipaux agents :

– l’agent Browser qui quand il recoit des messages les affiche simple-ment.

– l’agent Turtle qui est visible au milieu du micromonde et reagis auxdifferents messages de manieres differentes. L’ensemble des commandeset de leur consequence est repris dans le tableau 2.1 ci-dessus.

L’ensemble des commandes etant comprises de maniere intuitive, la for-malisation et la definition d’instructions vient donc naturellement. Voici unrappel des principales regles syntaxiques a respecter :

– Une instruction s’ecrit toujours entre { }– Une variable commence toujours par une majuscule– Un atome commence toujours pas une minuscule

Nous choisissons d’introduire les notions syntaxiques du langage Oz des ledebut, ceci pour deux raisons : la premiere est la rigueur indispensable pourl’utilisation d’un langage quel qu’il soit, bien que la syntaxe varie, il est utiled’en comprendre la logique pour pouvoir l’appliquer ; la seconde raison estqu’il nous semblait interessant de travailler avec un veritable langage, c’estplus motivant pour l’etudiant.

93

Il ne reste plus qu’a presenter l’interface graphique avec laquelle nous al-lons travailler pour terminer cette premiere seance afin de familiariser l’etudianta l’outil.

Cette partie du cours explique en detail chaque module de l’interface, sonutilisation, son but, leur lien et moyen de communication.

Des exemples sont proposes aux etudiants : l’envoi de message au brow-ser, deplacer la tortue,... Et via ces exemples nous introduisons les notionsde variables, d’atomes et meme d’instruction (syntaxe de Oz).

Finalement quelques exercices permettent a chacun de prendre en mainaussi bien l’interface que les connaissances acquises durant cette premiereseance.

Recapitulatif

Notions apprises :– Agent (definition restreinte)– Variable– Atome– Instruction– Prise en main de LogOz

4.3.2 Deuxieme seance

Afin d’entrer dans le vif du sujet rapidement, nous commencons cetteseance par la definition de procedure : On appelle procedure un sous-programmequi permet d’effectuer un ensemble d’instructions par un simple appel de laprocedure. Une procedure peut etre vue comme une suite d’instructions alaquelle on a donne un nom, un peu comme une recette de cuisine. Cettedefinition ne s’appuie que sur les concepts vus au cours precedent et faitappel a des elements de la vie de tous les jours pour permettre a chacun decomprendre rapidement.

La syntaxe est egalement immediatement definie et illustree par un exemplesimple (la definition d’une procedure cercle). Ici encore, et pour toute nou-velle notion, la syntaxe sera celle d’Oz[12]. Nous ne l’indiquerons plus par lasuite mais cela restera vrai tout au long de ce memoire.

Cette premiere definition de procedure est exempte d’arguments. Or ilsemble peu interessant de parler de procedures sans prendre la peine deparler egalement d’arguments de procedures, c’est pour cette raison que nousabordons a ce stade les arguments proceduraux.

94

proc{Carre X}{Send Turtle penDown}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}

end

{Carre 200}{Carre 100}{Carre 50}

Fig. 4.1 – Procedure Carre avec argument

Pour illustrer le concept de procedure avec et sans argument nous definissonsune procedure carre tout d’abord sans argument, puis proposons aux etudiantsde la modifier pour en faire une procedure avec argument pour permettre dechanger aisement la longueur du cote du carre(illustration a la figure 4.1).La realisation est direct l’interet immediat.

Lors de nos seances de cours nous nous sommes rendu compte de la diffi-culte qu’ont certains etudiants a comprendre la difference entre “definition deprocedure” et “appel de procedure”, il est donc primordial de bien expliquercette difference des le debut.

Comme a ce stade il nous est encore impossible de definir des notions tellesque la recurrence ou les boucles, nous avons decider de donner aux etudiantsune procedure qui leur permettrait de passer au dela de cette limitation sansetre trop compliquee. La fonction Repeat a donc pour signature :

{Repeat N P}

Celle-ci nous permet d’envisager un grand nombre d’exercices de des-sin dans lesquels nous pouvons faire intervenir a loisir les trois nouveauxelements.Il est possible a ce stade de creer des dessins plus complexes et plus amusantsa realiser, les figures 4.2 et 4.3 nous en montrent des exemples. Notons que

95

l’oeil demande egalement de faire appel aux couleurs ce qui nous permet derevoir les differents messages compris par la tortue.

Fig. 4.2 – Dessin d’un oeil de maniere procedurale

Recapitulatif

Notion apprises :– Procedure– Argument– Fonction Repeat

96

Fig. 4.3 – Dessin d’un donut de maniere procedurale

4.3.3 Troisieme seance

Alors qu’au depart nous pensions (tout comme nos predecesseurs) re-grouper ce cours-ci et le suivant, la pratique nous a montre que cela auraitete aller trop vite en besogne. Bien qu’a priori les operateurs et expressionsconditionnelles ne sont pas tres compliques, la syntaxe, lorsqu’on y est pashabituee, pose vite probleme. C’est pourquoi nous nous sommes limites pource troisieme cours a ceux-ci.

Nous commencons par les operateurs de calculs puisqu’ils sont presquetous connus. Il est cependant necessaire de faire la distinction entre les inte-gers et les float de maniere a pouvoir expliquer la difference entre la divisionentiere (div en Oz) et la division rationnelle (/ en Oz) ainsi que l’operateurmodulo (mod en Oz).

Viennent ensuite les operateurs de comparaison et donc logiquement lesbooleens. De nouveau la syntaxe est important a expliquer notamment poureviter des erreurs de confusion entre egalite et affectation.

Ces operateurs sont definies avec plus de precision dans les annexes auxtableaux A.2 et A.3.

Une fois les operateurs conditionnels appris, la logique veut que nous tra-vaillons sur les expressions conditionnelles. La construction “if, else” reprisedans une majorite de langages est egalement presente en Oz et illsutree a lafigure 4.4.

Cette definition formelle est suivie de quelques illustrations et exercicespour clarifier les choses.

97

if <x1> then % <x1> est la notation pour une condition

<s1> % <s1> est la notation pour une suite

% d’instructions

elseif <x2> then %

<s2>

else

<s3>

end

Fig. 4.4 – Expression if... else... end en Oz

Puisqu’apres avoir vu les expressions conditionnelles il est possible pourl’etudiant de visualiser des ”blocs” de code, cela nous permet d’introduire lesdifferentes portees de variables (locale, procedurale ou globale).

Un autre forme d’expression conditionnelle est envisagee avec le patternmatching. A ce niveau il reste tres basique et principalement axe sur lesatomes, mais sa definition nous sera tres utile dans le cours suivant puisquenous y verrons les listes.

Une definition formelle (figure 4.5) est donc fournie ainsi que quelquesexemples basiques.

case <x>

of <l1> then <s1>

[] <l2> then <s2>

[] <l3> then <s3>

textttelse<s4>

end

Fig. 4.5 – Pattern Matching en Oz

On compare x d’abord a l1. Si les deux elements correspondent (il s’agitd’une correspondance sur la forme), s1 sera execute. Sinon, on passe a laprochaine ligne. x sera alors compare a l2, puis a l3 s’ils ne sont toujourspas de la meme forme et ainsi de suite (il peut y avoir beaucoup de cas “[]”).Dans tous les autres cas, c’est-a-dire si aucune correspondance n’est trouvee,s3 sera execute.

98

Ainsi nous avons vu plusieurs manieres d’exprimer des conditions en pro-grammation, cette notion est sans doute une des plus importantes et vautdonc la peine de s’y attarder correctement. Elle est souvent la base de biendes programmes, il faut donc en profiter pour donner quelques exemplesde programmes plus grands pour appuyer les definitions et permettre auxetudiants de bien saisir l’ampleur de celles-ci.

Recapitulatifs

Notions apprises :– Operateurs de calcul– Integer Vs Float– Operateurs de comparaison– Affectation Vs egalite– Booleen– Portee de variables– Pattern Matching

4.3.4 Quatrieme seance

Dedie a la structure de donnees qu’est la liste, ce quatrieme cours estdonc un pas en avant puisqu’il nous permet de voir une autre facette de laprogrammation. Outre les operations et actions, il existe egalement les struc-tures de donnees. Bien evidemment a ce niveau nous n’allons pas debattrede l’interet d’utiliser telle ou telle structure mais c’est un debut.

Nous commencons comme de juste par definir la structure de donneesliste, cependant, et contrairement aux definitions prealables, nous allons endonner plusieurs. L’ordre dans lequel elles sont donnees n’a rien d’innocentpuisque nous la definissons d’abord de maniere intuitive avant de passer a ladefinition recursive et sa notation EBNF4 :

– Une Liste : est soit un atome nil (representant la liste vide) soit unepaire tete/queue. La tete d’une liste est son premier element, la queueest tout le reste. Le dernier element de la queue est egalement l’atomenil qui definit ainsi la fin de la liste.

– <List> ::= nil

| <Value> ’|’ <List>

4Extend Backus-Naus Form : Notation standard en informatique permettant de for-maliser les concepts syntaxiques[15]

99

La traduction de la derniere notation en francais donne : Une liste estsoit composee d’un atome nil, soit composee d’une valeur suivie d’uneautre liste.

Une fois cette definition apprise (et illustree) nous passons aux differentsoperateurs possibles sur les listes. Il parait en effet logique d’utiliser cettenouvelle notion.

Ceux-ci sont les acces a differents elements de la liste, l’ajout d’un elementen debut ou fin de liste et la suppression d’elements.

La fonction Append est donnee aux etudiants tout comme le fut la fonc-tion Repeat et a pour signature :

{Append [List] [ListBis]}

Cette seance, plus courte que les precedentes, nous permet de faire plu-sieurs exercices dont certains peuvent etre recapitulatifs de quatres premieresseances.

Recapitulatif

Notions apprises :– Listes– Operateurs sur les listes– Notion de recursion– Fonction Append

4.3.5 Cinquieme seance

Une fois que les concepts-cle de base sont assimiles il devient utile d’envi-sager des notions de programmation plus globales. Pour ce faire la recursionsemble un debut interessant. Ce concept bien que tres utilise est pourtantparticulierement difficile a saisir pour le quidam. Il faut donc prendre le tempsd’un cours complet pour etre certain qu’elle soit bien comprise.Comme de juste, la definition entame donc ce cours :

Definition : On dit qu’une procedure est recursive si elle s’appelle elle-meme. La recursivite permet, tout comme la fonction Repeat, de repeterplusieurs fois une action. Dans la recursivite on distingue souvent 2 cas :

1. le cas de base, dans lequel la procedure se termine ;

2. le cas recursif, dans lequel se trouve l’appel recursif afin de boucler.

100

proc{MoveForward X}

if(X == 0)

then skip % fin de la procedure

else

{Send Turtle forward(25)}

{Delay 1000}

{MoveForward X-1} % appel recursif de la procedure

end

end


{MoveForward 3} % appel de la procedure

Fig. 4.6 – Procedure executant plusieurs forward utilisant la recursion

Afin de rendre cette definition plus intuitive, une illustration est la bienve-nue, d’abord une procedure simpliste qui permet de decomposer la recursionaisement et d’analyser ce qui se passe a chaque appel. Le programme executeN forward comptes de maniere recursive. L’algorithme se trouve a la fi-gure 4.6.

Notons ici que le mot-cle skip est introduit de maniere a pouvoir quitterla procedure sans difficulte.

Ensuite une procedure “visuelle”, de maniere a ce que l’etudiant puissevoir la recursion se dessiner petit-a-petit. (Figure 4.7)

Il est temps d’envisager un exemple plus complexe avec de multiples ap-pels imbriques. La construction d’un arbre avec plusieurs niveaux de branchespermet d’exploiter cela car il y a de la recursion pour les branches de gauchecomme pour celles de droite. La decomposition des differents etats du systemedoit etre explique a chaque etape a l’aide de schema reprenant la valeur desdifferents parametres dans l’etat ou ils se trouvent de maniere a pouvoir iden-tifier les differents appels a l’interieur de la procedure. Prenons l’exemple dela Figure 4.8 pour illustrer cette derniere phrase.

Dans le cas present c’est la variable Depth qui permet d’identifier le ni-veau de recursion, il faut egalement savoir si l’on se situe dans un“appel degauche” ou “un appel de droite”. Ce sont les differents elements qu’il estimportant d’identifier avec l’etudiant de maniere a ce qu’il comprenne lesdifferents niveaux de recursion et par la-meme le sens de cet algorithme. Une

101

procSpirale X

if(X < 100) then

{Send Turtle forward(X)}{Send Turtle right(45)}

{Spirale X+1}else

skip

end

end

{Send Turtle penDown}{Spirale 1}

Fig. 4.7 – Procedure Recursive dessinant une spirale

proc{Tree Size Depth}

if(Depth == 0) then

skip % fin de la procedure

else

{Send Turtle forward(Size)}


{Tree (Size div 2) Depth-1}

% appel recursif pour la partie gauche



% appel recursif pour la partie droite





end

end

Fig. 4.8 – Algorithme recursif de construction d’un arbre

102

Fig. 4.9 – Dessin recursif d’un arbre

fois l’algorithme execute la figure 4.9 devrait apparaıtre.

Pour terminer cette seance un exercice plus simple est propose, faisantreference a la spirale prealablement expliquee.

Recapitulatif

Notions apprises :– Recursion– Cas de base– Cas recursif– skip– Recursion imbriquee

4.3.6 Sixieme seance

L’etape suivante dans le processus d’apprentissage passe par la possibi-lite d’utiliser plusieurs agents, de lever la limitation de cette unique tortueau milieu de notre univers.Aussi un rappel de la definition d’agent est donnee et surtout completee.

L’etat

Le premier nouvel element introduit dans la definition d’agent est sonetat. Il correspond a la description a un moment donne de l’etat de l’agent.C’est l’ensemble des variables et de leurs valeurs a un instant precis.Cet etat est defini de la maniere suivante :

103


L’etat de la tortue est compose de 5 elements distincts :

1. son nom : la tortue presente dans le monde s’appelle ‘Turtle’.

2. sa position : la position est composee de deux coordonnees, X et Y.Ces coordonnees permettent de situer la tortue dans l’espace a deuxdimensions qu’est le monde dans lequel elle evolue.

3. sa direction : la direction permet de memoriser vers quelle direction latortue est actuellement tournee.

4. PenDown : il s’agit d’un booleen (vrai ou faux) qui indique si le crayonde la tortue est actuellement pose ou non.

5. sa couleur : il s’agit tout simplement de la couleur dans laquelle lestraits du crayon apparaissent a l’ecran. Un choix de 7 couleurs est pos-sible : rouge (red), bleu (blue), vert (green), jaune (yellow), noir (black),mauve (purple) et rose (pink).

La forme particuliere dans laquelle l’etat est represente est une nouvellestructure de donnee qu’il faut egalement definir et expliquer : le tuple.Celui-ci est defini de maniere suivante : Un tuple est compose d’un label suivid’un ensemble d’elements.

– le label est le nom donne au tuple.– les elements du tuple sont l’ensemble des composants de l’etat.

Quelques exemples d’utilisation sont egalement fournis, notamment commentacceder a un champ du tuple.

Il reste donc a pouvoir utiliser l’etat de la tortue, et pour ce faire il estimportant de pouvoir le recuperer dans une variable, pour pouvoir le lire.Ceci est permis grace aux variables non-liees vu precedemment (et un petitrappel sur le sujet ne nous semble pas superflu).

Le cerveau

Comme les etudiants ont deja pu s’en rendre compte les agents possedentune certaine intelligence, une maniere de reagir aux differents messages.L’agent Turtle ne reagit pas de la meme maniere quand on lui envoie unforward(100) ou un left(60).Ceci decoule donc du concept de cerveau qui est somme tout tres basique :L’intelligence d’un agent n’est rien d’autre qu’un ensemble de messages aux-quels une action est associee.

104

La creation d’un nouvel agent tortue

Maintenant que les etudiants comprennent le mecanisme cache de l’agentTortue, il est temps d’envisager d’en creer. Cependant, avant de pouvoir fairecela une derniere chose reste a apprendre : les fonctions. En effet, jusqu’apresent nous n’avons travaille qu’avec des procedures. Or, dans la creationd’agent, il devient important de pouvoir utiliser les fonctions et leur valeurde retour.

Definition :Une Fonction est comme une procedure si ce n’est qu’elle estintroduite par le mot clef fun et non plus proc,Des exemples comparant procedures et fonctions sont donnes ainsi qu’unexercice de maniere a ce que la difference entre les deux soit bien integree.

Il ne reste donc plus qu’a definir la fonction qui permet de creer unenouvelle tortue et d’en expliquer le fonctionnement :

X = NewTurtle State.

Bien sur, lors de la creation de ce nouvel agent il faut donc lui passer sonetat en parametre celui s’exprime comme vu ci-dessus :


A ce stade les agents crees ont tous le meme cerveau, celui de la tortuede depart. C’est un choix delibere puisque nous estimons qu’il vaut mieuxbien comprendre le fonctionnement de cet agent avant de se lancer dansl’implementation d’autres “intelligences”. Cela ne tardera cependant paspuisque c’est l’objet d’un prochain cours.

Un exemple permet d’illustrer la creation et l’utilisation de deux tortuesdans le meme micromonde (Figure 4.10).

La concurrence

Cet exemple nous permet de rebondir directement sur le concept deconcurrence puisque nous pouvons remarquer que les deux tortues bougent enmeme temps dans notre micromonde et non de maniere sequentielle commel’etudiant etait en droit de l’attendre. Nous ne faisons qu’une introduction ra-pide a cette notion et l’illustrons d’un exemple supplementaire (Figure 4.12).

105

MaTortue = NewTurtle

state(tortue 200 200 0 true

yellow)

procSquaggle

{Send MaTortue forward(50)}{Send MaTortue right(150)}{Send MaTortue forward(60)}{Send MaTortue right(100)}{Send MaTortue forward(30)}{Send MaTortue right(90)}

end

{Repeat 20 Squaggle}

{Send Turtle penDown}{Send Turtle forward(100)}

Fig. 4.10 – Deux tortues evoluant dans le meme micromonde

Recapitulatif

Notions apprises :– Agent (definition etendue)– Etat– Tuple– Fonction– Cerveau– Creation d’un nouvel agent Tortue– Concurrence

4.3.7 Septieme seance

La seance precedente a permis d’aborder le concept d’agent de maniereplus globale, avec ses differentes caracteristiques. Afin d’elargir encore lesconnaissances de l’etudiant et de mettre en evidence la concurrence, un nouvelagent predefini est introduit de ce cours, l’agent metronome. Celui-ci prenddonc place dans un nouveau micromonde, le numero quatre.Il a pour fonction d’envoyer un message toutes les secondes a une liste d’autresagents. Sa declaration tout comme la declaration de son etat ne sont pas tres

106

T1 = {NewTurtle state(’mat’ 440 340 270 true black)}T2 = {NewTurtle state(’mat’ 440 440 180 true black)}T3 = {NewTurtle state(’mat’ 340 440 90 true black)}{Send Turtle penDown}

proc{Carre T X}if(X =< 0) then

{Send T penUp}{Send T forward(200)}skip

else

{Send T forward(X)}{Send T right(91)}{Carre T X-3}

end

end

{Carre Turtle 100}{Carre T1 100}{Carre T2 100}{Carre T3 100}

Fig. 4.11 – Code d’un carre implemente de maniere concurencielle

Fig. 4.12 – Dessin de carre de maniere concurrentielle

107

start Demarre le Metronomestop Arrete le Metronome

register(Agent) Ajoute un agent a la liste des agents auxquelsil faut envoyer un message

message(Msg) Definit le message Msg a envoyer aux agentsclear Reinititalise l’etat du metronome a stat(nil nil).

La liste d’agents est vide ainsi que le message a envoyer

Tab. 4.2 – Messages compris par l’agent Metronome

differents de ceux de l’agent tortue :

MyClock = NewMetronome State

state([Agents] Msg)

Il faut tout de meme souligner quelques points :– Tout comme pour l’agent tortue le cerveau est predefini dans le logiciel

de maniere a ce que l’etudiant ne doive pas encore s’en charger– State est l’unique argument de la fonction NewMetronome

– State est compose de deux elements : le premier est la liste des agentsa qui il faut envoyer le message, le second est le message a envoyer.

Comme tout agent du systeme il faut egalement definir les messages quele metronome comprend. Ceux-ci sont repris dans le tableau 4.2.

Un exemple cloture les explications sur ce nouvel agent.

Il est aise de voir que ces explications ne prendront pas les deux heures decours attribuees pour cette seance. En effet il nous semblait interessant a ceniveau-ci du cours de faire un rappel general ainsi que de laisser les etudiantsposer leurs questions. Le cours suivant etant consacre a la creation d’agentdans leur entierete il est important de s’assurer que des notions comme tuple,etat, fonction,... sont bien integrees.Pour clore quelques exercices de revisions sont egalement proposes.

Recapitulatif

Notion apprise :– Agent Metronome

108

4.3.8 Huitieme seance

Maintenant que deux des agents du systeme sont compris et integres, ilest temps de passer a l’etape suivante : creer ses agents de toutes pieces. Pource faire il est indispensable d’envisager l’agent de maniere plus “informati-que”.

La creation d’un agent se fait grace a l’appel de methode suivante :

MonAgent = NewAgent FonctionTransition Etat

De cet appel on deduit qu’il faut deux elements pour creer un agent :– Sa fonction de transition– Son etat

Fonction de transition

Nous nous attachons d’abord a definir la notion de fonction de transitionpuisque celle-ci etait jusqu’ici masquee a l’etudiant.La fonction de transition est une fonction qui doit etre definie par l’utilisateurafin de determiner le comportement de l’agent qu’elle definit. Il convient doncde definir l’ensemble des messages quel’agent peut comprendre et de leur assi-gner un ensemble d’instructions a executer une fois que ledit message est recu.

Une fonction de transition prendra en regle generale 2 arguments :

1. un message : ce message correspond aux messages que recoit l’agent.En fonction du message recu l’agent effectuera une action.

2. un etat : il s’agit de l’etat interne de l’agent. Celui-ci permet a l’agentd’avoir une memoire. Cette memoire peut l’aider a prendre certainesdecisions ou tout simplement permet de memoriser des informations.

Il est important d’insister sur le fait qu’un message non defini ne sera enaucun cas compris et risquera meme de provoquer une erreur dans le systeme.Pour pallier a ce probleme, dans l’exemple ci-dessous nous introduisons le elsequi nous permet d’envisager tout autre message sans que le programme nedetecte d’erreur tout en avertissant l’utilisateur de l’erreur. Cette fonction detransition n’est rien d’autre qu’un compteur qui s’incremente de 1 a chaquefois qu’elle recoit le message “tick”.

109

fun{Cerveau Msg State}case Msg

of tick then

{Send Browser State+1}State+1

else

{Send Browser ’I do not understand’}State

end

end

Remarque : Le message peut soit etre un atome, soit un tuple, ce quipermet d’envoyer beaucoup plus d’informations en une fois. L’etat peutegalement etre un tuple, ce qui permet a l’agent de memoriser differentesinformations (par exemple sa position, sa couleur, etc.)

Etat

Il existe en sein d’un meme agent plusieurs etats qui se succedent au fildu temps et des messages que celui-ci recoit. Le premier, l’etat initial, estdefini lors de la declaration de l’agent.Il est important de souligner le lien qu’il existe entre l’etat et la fonction detransition puisque cette derniere va jouer sur l’etat de l’agent et c’est pourcette raison que nous insistons une fois encore sur ce concept dans ce cours.

Horloge

Une fois que la fonction de transition est definie et comprise, que le lienavec l’etat est etabli, nous proposons la realisation d’un exercice ayant pourbut d’implementer une horloge.Pour construire cette horloge nous avons besoin de trois agents :

– un agent Seconde– un agent Minute– un agent Heure

ainsi que de l’agent Metronome que nous avons vu dans le cours precedent.

A chaque seconde l’agent metronome enverra un tick a l’agent Seconde,celui-ci s’incrementera jusqu’a arriver a 60 ou il enverra un message a l’agentminute et se remettra a 0. L’agent Minute s’incrementera lui aussi a chaque

110

message recu jusque 60 ou il previendra l’agent Heure et se remettra a zero.L’agent Heure, lui, s’incrementera jusque 24 avant de recommencer a 0.

Afin de rendre cet exercice plus visuel nous donnons aux etudiants dequoi creer une horloge graphique :

– Tag = {DrawLine Size Direction Color} qui permet de dessiner uneligne

– {DeleteTag Tag} qui efface une ligne

A la fin du cours les etudiants doivent arriver a obtenir l’horloge de lafigure 4.13 en s’aidant de l’interface prevue dans LogOz.

Fig. 4.13 – L’Horloge dans LogOz

Recapitulatif

Notions apprises :– Fonction de transition– Etat

4.3.9 Neuvieme seance

Composee du test de mi-parcours ainsi que de l’explication du projet,cette seance ne fonctionne donc pas selon le meme schema que les precedentes.

111

A ce stade de l’apprentissage, les concepts-cle qui constituent les bases dela programmation en modele oriente agent sont supposees acquis. Il sembledonc important de permettre aux etudiants d’etre confrontes a leurs connais-sances. Cette confrontation, mise en place dans cette neuvieme seance, sedecline en deux points.

Tout d’abord, les etudiants seront soumis a une evaluation sous forme detest portant sur les concepts abordes jusque la.Ensuite, il leur sera propose un enonce de projet qu’ils devront realiser pargroupe de deux avant la fin du semestre.

Un exemple d’interrogation est fourni dans les annexes a la neuviemeseance de cours ainsi qu’un enonce de projet realisable a ce stade par lesetudiants.Les modalites d’evaluation, que ce soit du test ou du projet, sont entierementexpliquees dans la section 3.4 ci-dessous.

4.3.10 Dixieme seance

Construire un cours base sur l’oriente agent sans laisser de place pourla visualisation de ceux-ci nous a semble impossible. Cependant la questionqui se posant etait : Ou donc introduire les diagrammes de maniere a ce quel’etudiant puisse en comprendre l’interet et puisse les realiser ?

Nous en sommes arrives a un stade du cours ou l’etudiant comprend,connaıt et meme cree ses propres agents. Les notions d’etats et de messagessont acquises.

Parallelement, il se retrouve face a son premier projet de plan grandeenvergure : le projet Pong. Il doit apprendre a gerer en groupe, a poser desbases solides pour pouvoir repartir le travail avec son partenaire.

C’est pourquoi nous avons choisi ce moment pour introduire les deuxdiagrammes qui nous semblaient les plus utiles : le diagramme de sequenceet le diagramme d’etat.

Diagramme de sequence

Puisque pour le premiere fois les etudiants doivent faire face a des agentsavec un comportement plus complexe, il est interessant d’apprendre a modeliser

112

les interactions entre eux, les echanges de messages,...

Pour commencer, quelques definitions :– Le but d’un diagramme de sequence est de pouvoir visualiser un

scenario complet, celui-ci represente un exemple typique de comporte-ment attendu des agents du systeme.

– Un scenario est une suite temporelle d’evenements correspondant ades interactions entre les agents.

Afin d’illustrer le concept, un exemple simple est directement propose :commander un verre dans un cafe.

– Client : Il appelle le barman, donne sa commande et regle l’addition.– Serveur : Prend la commande, le donne au barman, la recupere et

l’amene au client.– Barman : Une fois qu’il a l’a commande, il l’a prepare et la donne au

serveur.

Fig. 4.14 – Diagramme de sequence

Exemple sur lequel nous nous appuyons pour developper les differentspoints de theorie permettant de respecter la syntaxe graphique classique.

113

Fig. 4.15 – Diagramme d’etat d’une porte

Diagramme d’etat

Une fois que nous avons envisage les differentes relations qu’il peut exis-ter entre differents agents, il ne faut pas oublier que l’etat interne d’un agentpeut se trouver modifie par ses interactions. Les diagrammes d’etat nous per-mettent d’envisager toutes ces modifications internes.

L’introduction a ceux-ci se fait de la meme maniere que pour les dia-grammes de sequence.D’abord une definition, suivie d’un exemple :

Supposons un agent “porte”. Les etats qui le caracterisent sont :– Porte ouverte– Porte fermee

Le diagramme d’etat se trouve a la figure A.2.

Nous nous servons dans cet exemple pour enoncer les principes de forma-lisation des diagrammes d’agents. L’exemple simple permet une illustrationdirecte de presque tous ces principes.

Exemple

De maniere a ne pas obliger les etudiants a faire face a des diagrammesplus complexes sans en avoir deja vu auparavant nous prenons le temps dereprendre des agents vu prealablement et d’en dessiner les diagrammes. Dela sorte nous obtenons un diagramme de sequence pour l’agent Horloge et undiagramme d’etat pour l’agent Metronome.

Exercices

Une fois ceux-ci realises, quelques exercices se basant sur l’extension desexemples sont proposes aux etudiants de maniere a parfaire leurs connais-sances et a les confronter a des exercices directement.

114

Recapitulatif

Notions apprises :– Diagramme de sequence– Diagramme d’etat

4.3.11 Onzieme, douzieme et treizieme seances

Ces trois seances sont destinees a la presentation et a la resolution d’unprojet de plus grande ampleur : Space Invaders. Celui-ci permettra auxetudiants d’avoir les references necessaires a la realisation de leur propreprojet Pong. La realisation de ce projet necessite au moins trois seances. Lapremiere d’entre elle sera consacree a la modelisation du projet, alors que lesdeux suivantes serviront a l’implementation des cerveaux des agents consti-tuant le jeu space invaders. Avant d’entrer dans le vif du sujet, l’enseignantest invite a informer les etudiants de l’etroit lien qui existe entre les jeux videoet la programmation. Cette explication permettra de de situer les resultats deleurs apprentissages dans une application du monde reel. Il s’agira en outred’une introduction instructive pour la suite des evenements.

La modelisation

Le but de la onzieme seance est de proposer aux etudiants un premiercontact avec la logique de modelisation d’un projet. A la seance precedente,ils ont appris comment realiser les diagrammes de petites applications. Ilsvont maintenant apprendre a appliquer ces connaissances a un processusplus important.

Apres avoir pris connaissance de l’enonce, il sera propose a la classe dedebattre des differentes possibilites de realisation de l’application. On dis-cutera des differents agents qu’il sera necessaire de creer, et des differentsmessages que ceux-ci pourraient s’echanger.

Nous proposons ici ce qui pourrait ressortir de la discussion :

– Les agents evidents : Defender, Enemy, Meteore– Les agents implicites : Joueur, Jeu– Les agents de controle : EnemyLine, BombControler, MeteoreList

Si les etudiants ne pensent pas eux-meme a un systeme comparable a celuides agents de controle, l’enseignant proposera celui que nous avons integre anotre systeme, ou tentera au moins d’orienter le debat sur ce sujet. Des que

115

le resultat de la discussion sera satisfaisant, l’enseignant definira, en collabo-ration avec les etudiants, les differents messages qu’echangent les agents.

Il est important que le professeur (ou l’assistant qui s’occupera de dis-penser ses seances) ait pris connaissance de l’implementation du projet etait deja reflechi a d’autres manieres de parvenir a le realiser. En effet, lescours se voulant en le plus interactifs possible, l’enseignant doit etre capablede guider les etudiants vers une solution utilisable qu’ils aient imaginee, etpouvoir ensuite adapter la suite de son cours en fonction.

Des que les agents et les messages sont definis, l’enseignant pourra enta-mer la resolution du diagramme de sequence. Ici, en fonction de ses preferences,du temps ecoule lors de la precedente discussion, et de la motivation desetudiants, il pourra soit s’en charger lui-meme, soit demander la participa-tion du public. La figure ? ? propose un diagramme de sequence simplifiecorrespondant a nos choix d’implementation.

Selon l’importance accordee au concept des diagrammes d’etat, le profes-seur pourra aussi consacrer une partie de son cours a modeliser le diagrammede quelques etats.

Bien que le programme de chacune des trois seances n’est pas delimite,et que la modelisation puisse deborder sur la douzieme seance, il est cepen-dant necessaire que l’enseignant se reserve le temps necessaire a adapter sonimplementation du projet a la modelisation des etudiants.

Le diagramme de sequence simplifie de notre interpretation de cette ap-plication est presente a la figure 4.16.

L’implementation

Cette etape, realisee lors des seances 12 et 13, a pour but de presenteraux etudiants l’implementation des agents. Pour cette section, nous nous ba-serons sur notre modelisation et notre programmation du projet. Meme sil’implementation de tous les agents ne sont pas terminees au terme de cesdeux cours, le but sera atteint. Toutefois, il est conseille a l’enseignant quirealise au terme de la douzieme seance qu’il n’aura pas le temps de termi-ner tous les agents lors du cours suivant d’ “offrir” aux etudiants quelquesdefinitions de cerveau, de maniere a ce qu’a la fin du treizieme cours, ilspuissent tester le jeu dans sa version finale.

Nous devons separer l’implementation de ce projet en deux parties. La

116

Fig. 4.16 – Un diagramme de sequence simplifie du Space Invaders

premiere sera realisee avec les etudiants et comprend les definitions descerveaux des agents. La seconde est constituee de toutes les procedureset fonctions supplementaires qui servent a la programmation du jeu, ainsique la procedure de lancement “Main”. Cette seconde partie ne sera pasimplementee avec les etudiants, mais sera simplement incorporee au code.Cependant, a chaque fois que l’une d’entre elles sera appelee, il sera utiled’en expliquer brievement le fonctionnement.

Voici le code des agents de notre implementation. Le code complet du jeuest disponible dans les fichiers fournis avec le programme.

117

fun{BrainDefender Msg state(PosX PosY Tag)}

case Msg

of move(X) then %Deplacement

% Deplace le defenser que si ce deplacement ne fait

% pas depasser le vaisseau des limites de la feuille de dessin

if PosX =< WindowLimitLeft andthen X < 0 % limite gauche

then state(PosX PosY Tag)

elseif PosX >= WindowLimitRight andthen X > 0 % limite droite

then state(PosX PosY Tag)

else {MoveTag Tag X 0} % mouvement autorise

state(PosX+X PosY Tag)

end

[] getPos(?X) then % Lie X a la position du defenseur sur l’axe des X

X = PosX

state(PosX PosY Tag)

[] shoot then % Tir de missile

if @NbBomb < 2 then TagBomb in

% Max 2 missiles a la fois sur l’ecran

NbBomb := @NbBomb + 1

% augmentation du nombre de missile

TagBomb = {DrawBomb PosX DefenserUpper}

% creation de l image du missile

thread {BombController PosX PosY TagBomb defenser} end

% gestion du missile

end


[] dead then

{Tag delete} % suppression du tag

{Send EnemyLine gameover} % informe les ennemis de la fin de la partie

{DrawDefeat} % affichage du flag "gameover"

{Thread.terminate {Thread.this}} % tue le thread courant


118

% suite de la fonction brainDefender

[] isHit(X ?B) then

% B est lie a ’true’ si le defender chevauche la position X

if X >= PosX-(DefenserSize div 2)

andthen X =< PosX+(DefenserSize div 2) then

%vaisseau touche

B = true

{Send Defenser dead}

% signale au defenser qu’il est mort

else B = false % vaisseau rate

end


else {Send Browser Msg} state(PosX PosY Tag) %Msg non compris

end

end

119

fun{BrainEnemyLine Msg state(EnemyList)}

% Controleur des agents ’Enemy’.

case Msg

of start then EnemyList in

EnemyList = {CreateEnemies 7 3 100 100}

% cree les agents ’Enemy’ et les affiche a l’ecran.

state(EnemyList)

[] down then {SendAll EnemyList down}

% Envoie le message a tous les agents ’Enemy’

state(EnemyList)

[] left then {SendAll EnemyList left}

state(EnemyList)

[] right then {SendAll EnemyList right}

state(EnemyList)

[] shoot then Enemy X in

% Choisis aleatoirement un agent dans la liste des ’Enemy’

% et lui envoie le message ’shoot’

X = {OS.rand} mod {Length EnemyList}

{FindOneEnemy EnemyList X ?Enemy}

% Lie la variable Enemy a un agent

{Send Enemy shoot}

% Envoie le message shoot a l’agent choisi

state(EnemyList)

[] isHit(X Y ?B) then

{SendAll EnemyList isHit(X Y ?B)}

% Envoie le message isHit a tous les

% agents de la liste des ’Enemy’

state(EnemyList)

[] remove(Ref Type) then

% Enleve un element de la liste ’enemyList’

NewList in

% Ref est un port(agent) ou un tag

% selon la valeur de Type = agent|tag

NewList = {Remove EnemyList Ref Type}

% supprime l’element Ref de la liste des ’Enemy’

if NewList == nil then {DrawVictory} end

state(NewList)

[] gameover then {SendAll EnemyList dead}

% tue le controleur et avertit tous les

% ennemis de la fin de la partie

{Thread.terminate {Thread.this}}

state(EnemyList)

else state(EnemyList) %msg non compris(skip)

end

end

120

fun{BrainEnemy Msg state(PosX PosY Tag)}

case Msg

of start then state(PosX PosY Tag)

[] getPos(?X ?Y) then X = PosX Y = PosY

% lie la position courante de l’ennemi a ?X et ?Y


[] getTag(?T) then T = Tag % lie le tag de l’ennemi a ?T


[] left then {MoveTag Tag ~MoveLength 0}

% pour chaque direction on va verifier si on

% touche(collision) un meteore

if PosY+10 < MeteoreLower

andthen PosY+10 > MeteoreUpper

% zone dans laquelle se trouve les meteores

then B in {Send MetListAgent isHit(PosX ?B)}

% envoie le message ’isHit’ au controleur des meteores

if B then {Send EnemyLine remove(Tag tag)} {Tag delete} end

% Si un meteore est touche l’ennemi meurt

end

state(PosX-MoveLength PosY Tag)

[] right then {MoveTag Tag MoveLength 0} %voir left

if PosY+10 < MeteoreLower andthen PosY+10 > MeteoreUpper


if B then {Send EnemyLine remove(Tag tag)} {Tag delete}end

end

state(PosX+MoveLength PosY Tag)

[] down then {MoveTag Tag 0 MoveLength} %voir left

if PosY+10 < MeteoreLower andthen PosY+10 > MeteoreUpper


if B then {Send EnemyLine remove(Tag tag)} {Tag delete} end

end

if PosY >= DefenserUpper then {Send Defenser dead}

end

state(PosX PosY+MoveLength Tag)

121

% Suite de la fonction BrainEnemy

[] shoot then

% Tir de missile (nbre illimite pour les ennemis)

TagBomb in

TagBomb = {DrawBomb PosX PosY}

% dessine un missile sur la feuille de dessin

thread {BombController PosX PosY TagBomb enemy} end


[] isHit(X Y ?B) then %Verifie si l’ennemi est touche

% Verifie si la position du missile chevauche la position de l’ennemi

if (PosX > X-(EnemySize div 2)) andthen (PosX < X+(EnemySize div 2))

andthen (PosY+30+(EnemySize div 2) > Y)

andthen (PosY-30-(EnemySize div 2) < Y)

then

B = true

{Tag delete} %supprime l’image de l’ennemi

{Send EnemyLine remove(Tag tag)}

% envoie le message remove au controleur des ennemis

% qui va supprimer celui de sa liste


else

B = false


end

[] dead then %signale a l’ennemi qu’il est mort

{Tag delete}

{Send EnemyLine remove(Tag tag)}

{Thread.terminate {Thread.this}}


end

end

122

fun{BrainMeteore Msg state(X Y Lvl Tag)}

case Msg

of isHit(PosX ?B ?D) then

% Verifie si le meteore est touche

% D = true si le meteore est lvl 0 (delete)

% B=true si il est juste touche, false sinon

if PosX > X-(MeteoreSize div 2)

andthen PosX < X+(MeteoreSize div 2) then NTag in

% verifie la position du missile chevauche la position du meteore

{DeleteTag Tag} %supprime l’image du meteore

B = true

if Lvl > 1 then %verifie que le meteore a encore des vies

D = false

NTag = {DrawMeteore X Y Lvl-1} %dessine l’image d’un meteore.

%il descend d un niveau

state(X Y Lvl-1 NTag)

else % ou est completement mort (lvl = 0)

D = true

state(X Y 0 Tag)

end

else B = false state(X Y Lvl Tag)

end

end

end

123

fun{BrainMetList Msg state(MetList)} %Agent de controle des meteores

proc{CheckMet MetList PosX B D Ref} %verifie si un des meteores est touche

case MetList

of nil then B = false D = false %non touche

[] M|Ms then B2 D2 in {Send M isHit(PosX B2 D2)}

if B2 then B = true D = D2 Ref = M %meteore M touche

else {CheckMet Ms PosX B D Ref}

% meteore M non touche, on continue avec les autres

end

end

end

in

case Msg

of isHit(PosX ?B) then NMetList Ref D in

{CheckMet MetList PosX B D Ref}

% B = true si un meteore est touche,

% de plus D = true s il est mort completement

if D then

NMetList = {Remove MetList Ref agent}

% auquel cas on supprime l’agent meteore de la liste

else NMetList = MetList

end

state(NMetList)

else state(MetList)

end

end

4.3.12 Quatorzieme seance

Ce quatorzieme et dernier cours sera consacre aux threads. En effet,jusqu’ici, le principe de concurrence etait implique par les agents, mais lesetudiants n’ont pas eu l’occasion d’en apprendre le fonctionnement reel.

Nous levons ici le voile sur la maniere de reellement programmer la concur-rence en introduisant le concept de thread.

Un Thread : Au sens general du terme, un thread est un programmequi s’execute independamment. Plusieurs threads peuvent donc s’executer enmeme temps.

124

Une fois la definition theorique du thread donne, nous posons immediatementde la definition syntaxique :

thread <s1> end

Nous pouvons donc expliquer l’execution simultanee, expliquer commentles differente tortues pouvaient se deplacer sur la fenetre de dessin.

Afin de permettre a l’etudiant d’envisager la concurrence dans un autrecontexte, nous prenons un exemple qui ne depend pas des tortues mais restetres simple a comprendre :

fun {Gen X N}

if(X<N) then

{Delay 1000} %attente d’une seconde

X|{Gen X+1 N}

else

X|nil % fin de la liste

end

end

Z S % declaration des variables

thread Z = {Gen 1 10}end % thread qui genere une liste de

% 1 a 10

thread S = {Gen 100 110}end % thread qui genere une liste de

% 100 a 110

{Send Browser Z} {Send Browser S}

Deux listes sont generees en meme temps par le programme et afficheedans le browser simultanement.

Afin que l’etudiant comprenne la difference entre programme concurrentou programme sequentiel une illustration des deux types est donnee dansle cours (ici les figures 4.17 et 4.18). Remarquons tout de meme que cesexplications dependent du concept de pas d’execution qui se doit donc d’etreprealablement defini.

Un exemple permettant de mettre en lumiere l’ordonnancement a l’inte-rieur des threads tout comme l’ordre entre les threads est propose a l’etudiant.

Pour approfondir la comprehension de l’etudiant sur la concurrence, nousavons choisi d’aborder dans le point suivant la communication entre lesthreads et donc la notion de stream :

125

Chaque fleche represente un pasd’execution. Ci a cote est representel’ordre (total) des instructions dans unprogramme sequentiel.

Fig. 4.17 – Representation d’un programme sequentiel

Ci-contre la representation d’unprogramme concurrent avec 5threads. Notons qu’il y a unordre a l’interieur des threads(note par la fleche horizontale) etun ordre entre les threads (flechediagonale).

Fig. 4.18 – Representation d’un programme concurrent

Un Stream : Un stream est une liste de messages potentiellement non-lies qui sert de moyen de communication pour plusieurs threads.

Un moyen d’illustrer le communication entre threads est d’envisager unthread producteur (nous reprenons le generateur vu precedemment dans cetteseance) ainsi qu’un thread consommateur. Le consommateur recupere leselements produits par le producteur via le stream et les sommes entre eux.La figure 4.19 nous illustre ce principe.

Fig. 4.19 – Communication entre un thread producteur et un thread consom-mateur

Une fois l’exercice bien compris, un enrichissement de celui-ci est propose.En plus des threads producteur consommateur, nous ajoutons un threadtraducteur. Celui-ci prendra en entree le stream du consommateur, et ensortie un stream ne contenant que les nombres impairs. Ce stream sera alorslu par le consommateur dont le comportement reste identique (Illustration a

126

la figure 4.20.

Fig. 4.20 – Communication entre un thread producteur, un thread consom-mateur et un thread traducteur

Recapitulatif

Notions apprises :– Concurrence– Thread– Pas d’execution– Programme sequentiel– Programme concurrent– Stream– Thread producteur, thread consommateur et thread traducteur

4.3.13 Quinzieme seance

Cette quinzieme seance de cours est consacree a l’apprentissage des prin-cipes de composition d’agents. Maintenant que les etudiants ont appris acreer des agents et a les utiliser dans des programmes plus consequents, il estimportant de leur enseigner ce principe phare de la creation de logiciels. Auchoix de l’enseignant, ce cours peut soit suivre le cours sur les threads, soit leremplacer. Cette souplesse peut donner au professeur plus de liberte dans lesseances Space Invaders en lui permettant de deborder d’une ou deux heuresde cours.

Principe de base

Un agent est constitue d’autres agents s’il utilise ceux-ci dans le but d’ef-fectuer la tache qui lui est demandee. Cette imbrication est plus fortementmarquee si le “commanditaire” de l’action (l’utilisateur ou un autre agent)n’a pas de contact directs avec les agents qui constituent le super-agent. Lessous-agents lui sont alors caches.

127

Il est important de signifier aux etudiants l’importance de l’utilisation dece concept. Voici les avantages qu’il implique :

– Une modelisation plus precise des elements du reel– Une meilleure structure du programme, qui permet de limiter les pannes

Depuis le debut de ce cours, nous enseignons la facilite avec laquelle leprogrammeur peut, a l’aide d’agents, modeliser des elements reels. Le prin-cipe de composition va encore plus loin, en permettant de representer deselements plus importants qui seraient composes de plus petits.

Outre cette facilite de modelisation, il faut aussi insister sur le fait quediviser un gros agent en plus petits agents qui le composent permet d’aug-menter le nombre d’agents, et donc de limiter leur importance individuelle.Ceci permet, en cas de panne, de reparer le systeme le plus rapidement pos-sible.

Bien que ce cours de premiere annee ne propose pas d’enseignement rela-tif a la gestion des pannes, les etudiants, conscients des possibilites offertespar la composition d’agent, seront prets a aborder ce probleme des le debutde la deuxieme annee.

L’enseignement par l’exemple

Nous estimons que ce principe doit etre enseigne a l’aide d’un exempleparlant. Nous proposons ici de modeliser un distributeur de boissons, maisl’enseignant pourra a sa guise proposer un exemple qu’il estimera plus a songout.

Le distributeur doit etre capable de :

– Servir au client une boisson que celui-ci a paye si elle est disponible– Rendre la monnaie si le client paye plus que le montant requis– Rendre la monnaie si le client annule sa transaction– Avertir le client si la boisson n’est plus disponible

Le distributeur est compose de quatre agents :

– L’agent Distributeur : Il s’agit du gros agent qui est compose des troisautres. Son fonctionnement repond correctement a l’enonce.

128

– L’agent Coin Manager : Il est en charge de la gestion des montants apayer et de l’argent recu et a rendre

– L’agent Can Manager : Il est en charge du niveau du stock et de lalivraison des boissons

– L’agent Displayer : Il est en charge de l’affichage des informations

Afin de ne pas noyer le lecteur, nous avons decide de presenter un ver-sion simplifiee de l’implementation d’un distributeur qui propose uniquementdeux types de boisson.

Distributeur : stateEtat

L’etat du distributeur est utilise comme celui d’une machine a etat. Ilsignifie quel type de messages celui-ci attend recevoir :

– WaitingOrder : Le distributeur est au repos et attend une commande– WaitingAvailability : Le distributeur attend un message lui indiquant

si la cannette demandee par l’utilisateur est disponible– WaitingPrice : Le distributeur attend le prix de la cannette demandee– WaitingMoney : Le distributeur attend le paiement du client

CanManager : stateNombreDeBoisson1 NombreDeBoisson2 Etat

L’etat du gestionnaire de boissons comprend, pour chaque boisson, lenombre de cannette restante. Il contient en plus un etat qui prend deux va-leurs differentes :

– waitingOrder : L’agent est au repos, en attente d’une commande– waitingCoin : L’agent a recu une commande et attend le signal pour

servir la boisson

CoinManager : stateMontantAPayer BoissonAPayer

L’etat du gestionnaire de monnaie contient le montant qu’il reste a payeret la boisson a laquelle est destine ce montant.

Displayer : stateEtat

L’etat de l’afficheur n’est pas utilise. Cependant, il pourrait contenir lemessage qui est en train d’etre affiche, ou etre utilise a d’autres fins.

129

Les messages a envoyer au distributeur illustrent les actions de l’utilisa-teur. Dans un logiciel embarque, ils seraient enclenches par un pression surdes boutons ou par le machine de comptage de monnaie. Le distributeurcomprend les messages suivants :

– push(Boisson) : represente la pression d’un bouton de selection decannette.

– pay(Money) : signifie que l’utilisateur a insere une piece de valeur “Mo-ney” dans la machine.

– cancel : L’utilisateur annule la transaction et desire recuperer son ar-gent.

Voici le code de l’application simplifiee. Le code entier se trouve dans lesfichier fournis avec le logiciel.

%%% Creation des agents %%%

Distrib = {NewAgent DistribBrain DistribState}

Displayer = {NewAgent DisplayBrain DisplayState}

CanManager = {NewAgent CanBrain CanState}

CoinManager = {NewAgent CoinBrain CoinState}

%%% Creation des etats %%%

DistribState = state(nil)

CanState = state(1 4 waitingOrder) %%% Coca / Oasis

CoinState = state(0 nil) DisplayState = state(nil)

130

%%% L’agent CoinManager %%%

fun{CoinBrain Msg State}

case Msg

of want(Drink) then

%%% On veut connaıtre le montant de "Drink"

%%% {GetPrice Drink} donne le montant

{Send Distrib remainsToPay( {GetPrice Drink})}

state( {GetPrice Drink} Drink )

[]pay(Money) then %%% Money a ete paye

%%% On verifie si le montant est insuffisant

if (State.1 - Money) > 0 then

{Send Distrib remainsToPay( (State.1 - Money))}

state( (State.1 - Money) State.2 )

else

%%% Ou si il fat rendre de la monnaie et servir la boisson

{Change (State.1 - Money)}

state(0 nil)

end

[] cancel then %%% Le client annule la transaction

%%% Ajouter ici une procedure qui rend la monnaie

state(0 nil)

end

end

131

%%% L’agent Distributeur %%%

fun{DistribBrain Msg State}

case Msg

of cancel then %%% Le client annule sa commande

{Send CanManager cancel}

{Send CoinManager cancel}

state(waitingOrder)

[] push(Drink) then %%% Le client a selectionne "Drink"

{Send CanManager want(Drink)}

state(waitingAvailability)

[]pay(Money) then %%% Le client a paye le montant "Money"

{Send CoinManager pay(Money)}

state(waitingPrice)

[]available(Drink) then %%% "Drink" est disponible

{Send CoinManager want(Drink)}

state(waitingPrice)

[]unavailable(Drink) then %%% "Drink" n’est pas disponible

{Send Displayer unavailable(Drink)}

state(waitingOrder)

[]remainsToPay(Money) then %%% Il reste "Money" a payer

{Send Displayer remains(Money)}

state(waitingMoney)

else State

end

end

132

%%% L’agent Displayer %%%

fun{DisplayBrain Msg State}

case Msg

of unavailable(Drink) then %%% "Drink" n’est pas disponible

{Send Browser Drink}

{Send Browser "Unavailable"}

State

[] remains(Money) then %%% Il reste "Money" a payer

{Send Browser "Remains to pay"}

{Send Browser Money}

State

else %%% Il y a eu une erreur

{Send Browser "Error"}

State

end

end

133

%%% L’agent Can Manager %%%

fun{CanBrain Msg State}

case Msg

of want(Drink) %%% Le client desire "Drink"

then

case Drink

of coca then %%% on verifie la disponibilite

if State.1 ==0

then %%% indisponible

{Send Distrib unavailable(Drink)}

state(State.1 State.2 waitingOrder)

else %%% disponible

{Send Distrib available(Drink)}

state(State.1 State.2 waitingCoin)

end

[] orangina then

if State.2 ==0

then

{Send Distrib unavailable(Drink)}


else

{Send Distrib available(Drink)}

state(State.1 State.2 waitingCoin)

end

else

{Send Distrib error}

State

end

134

% suite de la fonction CanBrain

[] give(Drink) then %%% Ordre de servir la boisson

case Drink

of coca then

{Give Drink}

%%% Service de la boisson et modification de l’etat

state((State.1 -1) State.2 waitingOrder)

[] orangina then

{Give Drink}

state(State.1 (State.2 -1) waitingOrder)

else


State

end

[] cancel then %%% Procedure annulee


else


State

end

end

135

%%% Donne le prix d’une boisson

fun{GetPrice Drink}

case Drink

of coca then 60

[] orangina then 80

else 0

end

end

%% enclenche le service d’une boisson

proc{Give Drink}

{Send Browser Drink}

{Send Browser "The Drink is Given"}

end

%% enclenche le processus de retour de monnaie%

proc{Change Remains}

{Send Browser "Money Back"}

{Send Browser Remains}

end

Exemples d’agents imbriques

Afin de faire prendre conscience aux etudiants de l’aspect concret desagents imbriques, il peut etre utile de leur faire remarquer quelques exemplesdu quotidien.

– Un service postal : l’expediteur envoie une lettre a la poste qui, a l’aidede ses differents services (ramassage, tri et livraison), joint le destina-taire.

– Un site web : Une page web est composee de differents agents parexemple : l’agent affichage, l’agent securite, l’agent mise a jour,. . .

– Une voiture : composee d’un moteur (lui-meme compose de diversagents), de roues, d’un GPS, d’un ordinateur de bord,. . .

136

L’enseignant pourra bien sur proposer des exemples de son propre cru. Ilveillera a conserver le but de cette demarche, a savoir faire prendre conscienceaux etudiants de l’etroite collaboration entre agents et elements reels.

Methode d’enseignement de la seance

Comme le lecteur l’aura certainement remarque au fil des seances, le rolede l’enseignant prend une place plus importante dans la deroulement descours. Si lors des premieres seances, il se contentait de se reposer sur les dos-sier de cours qui lui etaient propose. Avec le projet space invaders, il a dejaacquis une plus grande liberte et surtout une plus grande responsabilite endevant adapter le programme a la propositions des etudiants.

Dans cette quinzieme seance, il lui est laisse le choix de trouver unautre exemple d’agent compose. De plus, alors que nous avions generalementsuggere de fournir le code des exemples aux etudiants, nous estimons qu’ace stade de l’enseignement, il est plus profitable que ceux-ci n’en prennentpas connaissance et le decouvrent au fur et a mesure ou le professeur le leurexplique. Il s’agit la encore d’une responsabilite supplementaire.

Nous conseillons de devoiler le code de l’application aux etudiants selon lamethode de programmation habituelle. L’enseignant programmera les agentsdans le browser de logOz en faisant part aux etudiants de ses reflexions et deson mode de fonctionnement.

Cet exercice est aussi favorable a la demonstration de la modularite d’unprogramme oriente agent. Nous conseillons a l’enseignant de programmer les4 agents en parallele, et expliquant aux etudiants qu’en fonction des messagesimplementes, il est possible de passer d’un systeme simple a un programmecomplexe. En effet, une option serait de commencer par une application quisert une boisson lorsqu’on appuie sur un bouton, pour ensuite l’ameliorerjusqu’a repondre parfaitement a l’enonce.

Il est aussi laisse a l’enseignant le choix de la complexite du distributeur.L’implementation que nous en avons fait est basique, mais il est possible d’yajouter des fonctions supplementaires (la gestion des differentes pieces demonnaie par exemple) ou des agents supplementaires (un agent d’affichagepermanent des boissons indisponibles, un agent representant les remises enrayon du stock, . . .).

137

4.4 Seances de cours supplementaires

4.4.1 Reseau

Un exemple de cours basique sur le reseau est propose en annexe. Lesoutils du logiciel necessaires a la realisation de cours plus avances sont decritsdans le chapitre relatif au logiciel LogOz. L’elaboration complete d’un telcours sort du cadre de ce memoire. Cependant nous encourageons vivementnos successeurs a se baser sur nos reflexions et LogOz 2.0 pour entamerun cours de seconde annee de programmation avec des seances relatives aureseau.

138

Chapitre 5

Resultats de la Phase de Test

Le cours decrit par ce memoire a, avant d’etre presente, ete soumis enphase de test a huit etudiants. La mise en situation se devait d’etre la plusproche possible du contexte reel (l’enseignement de la programmation a desetudiants de premiere annee de baccalaureat) afin de recueillir le plus d’in-formations possibles concernant les difficultes que pourraient rencontrer l’au-ditoire. Ces information devaient servir a modifier la methode de cours ou ainformer les enseignants des eventuelles difficultes.

Dans ce chapitre nous resumons les remarques apportees par les etudiantslors de leur presence au cours. Celles-ci ont pour la plupart entraıne desmodifications directes de la methode de cours. Il reste cependant certainsaspects qui pourraient etre ameliores ou discutes.

Nous presentons tout d’abord les remarques qui ont ete soumises par lesetudiants et les solutions que nous avons pu apporter a leurs problemes. Ladeuxieme partie met en garde quiconque desire dispenser ce cours contre lesdifficultes que pourraient rencontrer les etudiants mais qui ne necessitent pasde modification structurelle des cours.

5.1 Remarques et modifications diverses

Ces remarques ont principalement ete recueillies lors des dix seancesde cours dispensees. Celles-ci furent soit exprimees explicitement par lesetudiants, soit decelees par nous-memes. D’autres furent recoltees lors dela distribution d’un questionnaire d’evaluation du cours1.

1Ce questionnaire est disponible en annexe (D)

139

Liste et recursion

Six des etudiants qui ont participe a la phase de test ont eprouve unegrande difficulte a integrer les concepts de liste et de recursion. Pour resoudreces problemes, il a ete indispensable de modifier notre methode. Tout d’abord,nous avons du isoler le concept de liste en lui consacrant un cours entier alorsqu’il etait precedemment prevu de le lier aux operateurs, aux expressionsconditionnelles et au pattern matching. Cette modification a permis l’ajoutd’exemples et d’exercices melant pattern matching et liste.

En ce qui concerne la recursion, alors que les concepts theoriques sem-blaient facilement acquis, il s’est avere que la realisation d’exercices plus com-plexes posait de grosses difficultes aux etudiants. Des lors que l’appel recursifn’etait pas la derniere instruction de la procedure, ils ne comprenaient pasquand et comment la suite des instructions pouvaient etre executees a lasuite de l’appel recursif. Aussi, apres etre revenu maintes et maintes fois surle meme enonce2 en tentant chaque fois de modifier notre approche, noussommes parvenus, avec la contribution des etudiants, a realiser un schemaexplicatif qui convienne a chacun. Ce graphe, represente par la figure 5.1,pourra soit etre presente aux etudiants par l’enseignant si ceux-ci presententdes difficultes a integrer le concept de recursion, soit etre directement integreau cours 5 en lieu et place d’autres formess d’explications. Nous laissons cechoix a la discretion de l’enseignant, qui adaptera sa methode en fonction deson auditoire.

Le projet

La premiere ebauche de ce cours de programmation proposait aux etudiantsl’enonce d’un jeu de pong pour la realisation du projet final. Nous avons sou-mis cet enonce aux etudiants presents lors de la phase de test. Nous avonstres vite realise que, face a l’enonce d’un programme aussi vaste, ceux-ci sesentaient fortement perdus. Il est apparu clairement qu’aucun d’entre euxn’aurait ete capable de repondre a nos attentes. Il fut donc indispensablede trouver une solution qui leur permette de realiser ce projet sans trop dedifficulte mais qui n’en rendent pas pour autant la reussite immediate.

Nous avons donc choisi de planifier un projet de plus grande envergure3

lors des seances de cours. Cependant, notre phase d’experimatation touchanta sa fin, nous avons ete dans l’impossibilite de tester l’efficacite de cette

2L’exercice de l’arbre, voir Annexe A.53Le projet Space Invaders est presente aux etudiant a partir du onzieme cours (Annexe

A.11)

140

Fig. 5.1 – Explication du deroulement de l’exercice de l’arbre

141

methode. Ce projet a ete imagine dans le but de permettre d’une part deconfronter les etudiants a un exemple de processus de realisation de pro-jet important, et a d’autre part d’amener la revision de tous les conceptsenseignes jusque la.

Le changement de micromondes

Lors de l’utilisation du programme, nous avons realise qu’il est par-fois indispensable de passer d’un micromonde a l’autre. Cependant, dansla premiere version de Logoz, cette option n’etait pas disponible. Il etaitalors necessaire de quitter le programme et de replacer celui-ci dans un autremicromonde. Cette situation survenant au moins une fois pour cinq a six denos etudiants, ils etaient decourages par ce processus laborieux. Nous avonsdonc, a la demande de l’un d’entre eux, implemente une fonctionnalite quipermet le changement de micromonde a tout instant, et ce sans pour autantperdre le code ecrit dans le notepad.

Le repositionnement de la tortue

Deux etudiants ont exprime le souhait de pouvoir replacer la tortue aucentre du canvas via un message. Ce message a donc ete directement ajoutea l’environnement et des exercices utilisant la nouvelle fonction ont ete pro-poses.

5.2 Avertissement a destination de l’enseignant

Suite aux observations resultant de la phase de test, nous desirons in-former nos successeurs de certains problemes que pourraient rencontrer lesetudiants. Ceux-ci ne nous semblent pas necessiter une modification de lamethode ou du programme. Cependant, il convient d’en tenir compte lors deseances futures.

L’usage de l’anglais

Bien qu’il soit generalement suppose qu’un etudiant de 18 ans ait quelquesnotions d’anglais, il est important de traduire chaque terme utilise de manierea ne pas defavoriser un etudiant qui aurait quelques difficultes face a l’anglais.Cette verite nous est apparue lorsqu’apres 6 seances de cours, un etudiantnous a demande pourquoi on s’adressait a la tortue en utilisant le terme“Turtle”.

142

Integer et float

La distinction entre les entiers et les nombres en virgule flottante a par-fois ete assez floue pour deux ou trois etudiants. Ceux-ci imaginent les reelscomme unique representation des valeurs numerique. Il faut donc, des ledepart, aborder ces deux concepts de maniere precise en expliquant bienqu’il s’agit de deux types de representation informatique d’une valeur.

Variables locales et variables globales

Bien que l’explication du principe theorique de la portee d’une variableait ete realisee avec la plus grande attention, il est apparu qu’une fois en si-tuation, les huit etudiants avaient du mal a appliquer ce principe. Ce manquede comprehension provient peut etre de notre manque d’experience dans lemonde de l’enseignement, et il est fort probable qu’un professeur experimentepourrait transmettre ce concept avec bien plus d’efficacite.

Il est cependant important de garder en tete qu’il s’agit la d’un conceptdelicat qu’il est parfois utile d’exposer avec de courts exemples.

Definition de procedure et appel de procedure

La difference de concept entre la definition d’une procedure et l’appel dela procedure a pose quelques problemes de comprehension. Les etudiants, laou ils auraient du appeler la procedure, en ecrivaient une nouvelle definition.D’autre part, lorsqu’ils ne devaient ecrire que des petits programmes compor-tant uniquement une procedure, ils oubliaient generalement d’appeler celle-ciet s’etonnaient de ne pas observer de resultat a l’execution. Nous estimonspourtant que les elements necessaires a cette comprehension sont fournis dansles dossiers distribues aux etudiants. Il est donc du recours de l’enseignantde prendre le temps necessaire afin de mettre l’emphase sur la difference etla relation entre ces deux concepts.

L’installation de Mozart

Certains etudiants desiraient installer Mozart et les packages Oz a domi-cile afin de realiser des exercices supplementaires. S’il ne s’agissait que d’uneinitiative spontanee et facultative lors de la phase de test, il sera presqueobligatoire pour les etudiants universitaires d’installer Mozart sur leurs ordi-nateurs personnels. Le probleme principal provient de l’installation de Mozartsur des ordinateurs MacIntoch. Les tutoriels fournis sur le site4 pour aider

4www.mozart-oz.com

143

a l’installation du logiciel ne sont pas assez precis. Nous avons estime, etantdonne l’evolution actuelle des technologies Apple, qu’il n’aurait pas ete jus-tifie de proposer nous-memes un tutoriel d’installation. Il sera donc du rolede l’enseignant ou de l’assistant de s’assurer que les etudiants auront en mainles informations necessaires afin d’installer sans soucis les packages Oz.

144

Chapitre 6

Evaluation

Aucun enseignement ne s’effectue sans qu’un moyen de tester son effi-cacite ne soit mis en place. Dans ce sens, ce cours d’introduction a la pro-grammation s’accompagne d’une proposition de mode d’evaluation. Celle-ciest presentee en guise d’exemple, de piste a suivre par le professeur. Cettesection en definit les grandes lignes et rapporte les conclusions qui peuventetre tirees de la phase de test.

Bien qu’une litterature specialisee dans le domaine de la pedagogie, etplus particulierement dans l’evaluation, est disponible, nous n’avons pas eule temps de baser notre approche sur une etude des principes qu’elle propose.La presente analyse s’inspire de nos experiences en tant qu’etudiants et descritiques que nous avons pu formuler face a notre formation.

La methode d’evaluation de ce cours d’informatique se developpe surplusieurs fronts, et a pour but de permettre a l’etudiant de prouver sesconnaissances theoriques et sa capacite a programmer. Le mode d’evaluationtend a recompenser aussi bien les etudiants plus pratiques que ceux quipreferent maıtriser les concepts dans leur essence theorique. Des quatre polesd’evaluation qui sont presentes ci-apres, seul le test de mi-parcours a eteintegre a la phase de test. Les trois autres etapes ont ete adaptees selon lesresultats obtenus.

6.1 Test de mi-parcours

Comptant pour 20 % de la cote finale, ce test a pour but de dresser unetat des lieux des connaissances globales de l’auditoire. Pour l’etudiant, ilpermet de realiser a temps un eventuel retard afin d’adapter sa methode de

145

travail et de combler ses lacunes avant la prochaine echeance (le projet oul’examen final). Pour le professeur, ce test est le premier “feedback” direct del’efficacite de son enseignement. Si la moyenne generale est insatisfaisante, ilpourra modifier sa technique d’enseignement et son rythme afin de ramenerson auditoire au niveau adequat. Si, au contraire, il semble que les etudiantssont brillants, ce test arrive juste a temps pour hausser le niveau du projet.Afin de ne pas trop penaliser les etudiants qui auraient tendance a demarrerplus lentement, les points du test vaudront uniquement si l’etudiant le desire.Il exprimera ce choix en repondant ou non a deux questions supplementaires,lors de l’examen final, destinees a remplacer le test pour un total de 20%.

Les etudiants participant a la phase de test ont dispose d’une heure aconsacrer a la realisation de cette interrogation. Le test a eu lieu en salle detravaux pratiques. Les reponses theoriques ont ete rendues sur papier alorsque les exercices ont ete directement resolus dans l’environnement LogOz. Cechoix de l’utilisation du logiciel lors de la resolution des exercices est majo-ritairement motivee par l’importance que nous accordons au droit a l’erreuret a la comprehension de celle-ci.Un autre point de vue consisterait a considerer qu’un etudiant doit etre ca-pable de creer des programmes simples sans commettre la moindre faute.Cependant, il nous faudrait alors etre plus indulgent sur le niveau de perfec-tion et sur les erreurs syntaxiques rencontrees dans les reponses. L’utilisationdu compilateur permet a l’enseignant qui choisirait le meme concept que ce-lui promu dans la phase de test de faire directement, et sans concession, ladifference entre les etudiants capables de realiser des applications et ceux quine le sont pas.

Bien que le test propose en exemple ne doive pas etre reproduit a la lettredans une prochaine application du cours, nous estimons qu’il devrait couvrirles points principaux abordes a ce stade de l’enseignement. Pour chacun deces theme nous expliquons le type de question qui peut etre pose ainsi qu’unebreve justification de l’importance de leur maıtrise par les etudiants, et doncune justification de leur presence dans un test de mi-semestre.

6.1.1 Definitions theoriques des concepts

Il est indispensable que des concepts tels que agent, variable liee, variablenon liee, procedure, liste, tuple et concurrence soient parfaitement compris.Lors de la phase de test, nous avons observe que certains etudiants avaientpu jusque la realiser les exercices proposes en seance sans s’alarmer alors que

146

certaines de ces notions etaient restees floues. L’environnement LogOz, quiabstrait un grand nombre de precisions techniques en focalisant l’appren-tissage sur une representation graphique et directe de la programmation,favorise un tel type de comportement. Cependant, cette methode de travail,qui consiste alors a reproduire machinalement des routines en gardant un oeilsur les exemples, rencontrera bien vite son premier echec face a des objectifsplus complexes. Confronter ce type d’etudiant a ses lacunes peut lui per-mettre de realiser l’importance parfois negligee d’une maıtrise des principestheoriques. D’autre part, s’il devait s’averer qu’une majorite des etudiants setrouvaient incapables de repondre a cette question, il serait conseille a l’en-seignant de reprendre, en marge de son cours, un explication plus detailleeou plus structuree des notions theoriques.

Lors de la soumission aux etudiants testeurs de cette question, il s’estavere que seulement une minorite d’entre eux se trouvait incapable d’identi-fier les concepts demandes (agent, procedure, liste, concurrence). La difficultelors des seances suivantes de ces etudiants a realiser des exercices pratiquesplus complexes demontre l’importance de la comprehension de la theorie.

6.1.2 Application des principes basiques de la program-mation

A ce stade de l’enseignement, il est indispensable de verifier que lesconcepts de base de la programmation peuvent etre appliques a des exer-cices simples sans aucune aide exterieure. L’etudiant est sense etre capablede creer un programme simple repondant aux exigences d’un enonce qui re-groupe des concepts varies. Cette question devrait proposer a l’etudiant decreer un programme comprenant au moins une procedure, des tests de condi-tion, et une manipulation de la tortue de LogOz. L’exemple propose en phasede test ajoutait a ces elements l’utilisation dynamique de l’etat de la tortue.

6.1.3 Application du principe de recursion

Il s’est avere que la recursion, principe central de la programmation dansun langage declaratif, pouvait poser des problemes de comprehension a unegrande majorite des etudiants. Cet exercice doit se montrer assez simple afinde focaliser l’attention de l’etudiant sur le probleme de la recursion sansl’empetrer dans la realisation d’algorithmes complexes. Il ne doit toutefois

147

pas etre simpliste si l’on veut evaluer reellement la capacite des etudiantsa integrer la recursion dans un probleme concret. Comme tous les exercicesproposes dans ce test, il doit avoir une implication graphique directe dans lafenetre LogOz.

L’exercice propose dans le test de la phase de experimentation demandaitaux etudiants de dessiner une spirale finie a angles droits. Nous estimions queles principes de recursion se devaient d’etre acquis afin de permettre a la tor-tue d’effectuer une serie de mouvements sans utiliser la commande Repeat.La modification de l’argument passe en recursion afin d’augmenter la tailledes droites dessinees par la tortue et le test conditionnel sont des elementsque l’etudiant doit dominer.

6.1.4 Concurrence et creation d’agents

Il est indispensable que la notion d’agent soit integree par l’etudiant puis-qu’elle est a la base des differents concepts envisages dans LogOz. Deux typesd’agents ont ete vu durant les seances : les agents predefinis dans le systemeet les agents entierement crees. La difference se situe au niveau de la fonctionde transition qui est soit deja implementee dans Logoz, soit a implementerpar l’etudiant. Ce test intervient peu apres la seance de cours portant surla creation d’agents inedits avec une fonction de transition programmee parl’etudiant. Cependant, il semble premature de demander une application deces notions. C’est pourquoi nous estimons que cette question doit unique-ment tester la capacite de l’etudiant a generer de nouveaux agents predefinisainsi que ses aptitudes a manipuler l’etat de ceux-ci.

Dans cette optique, la question qui a ete posee aux etudiants deman-dait de creer des agents Turtle supplementaires. Il etait aussi necessaire al’etudiant de modifier l’etat interne des agents afin de les placer correctementdans le canvas. Il semblait important que cet exercice ait un aspect ludique,c’est pourquoi le theme choisi fut la course de tortues ! Avec ce probleme, lesetudiants se trouvent face a un but concret et directement observable dansl’environnement LogOz.

6.1.5 Identification et reparation d’erreurs de compi-lation et d’execution

Cette question propose aux etudiants une portion de code errone a cor-riger. Ce sous-programme est parseme de deux types d’erreurs : des erreurs

148

syntaxique, qui empechent la compilation, et des erreurs qui generent desincoherence a l’execution. Cette partie du test tend a mettre en exergue l’im-portance de la maıtrise du langage et de la capacite a resoudre des bugs.

Les exigences strictes de la syntaxe du langage utilise paraissent coulerde source pour le programmeur initie. Contre toute attente, il s’est avere quecertains etudiants trouvaient dans cette rigueur un aspect presque inutile. Ca-pables de comprendre pourquoi il est necessaire d’ecrire l’identificateur d’unevariable avec une majuscule, ils partagent cependant le reve d’un monde idealdans lequel les erreurs de syntaxe importent peu. Il est toutefois normal quedes programmeurs en herbe commettent des fautes d’inattention. Ces erreurs,minimes, generent des messages qu’il est indispensable de dechiffrer afin derapidement les corriger.

D’autre part, des bugs peuvent apparaıtre dans l’execution d’un pro-gramme, entraınant parfois, pour des applications de grande taille, des heuresde travail supplementaires. Bien que ce cours d’introduction a la program-mation soit dispense de maniere a aider les etudiants a maıtriser chacun desconcepts (construisant une base solide qui devrait permettre d’eviter le plusgrand nombre d’erreurs de programmation) il ne se veut pas du niveau d’uncours de methode de conception de programmes. Des lors, il est importantd’entraıner les etudiants a resoudre ces erreurs par eux-meme.

6.2 Exercices supplementaires

6.2.1 Principe

Il sera propose aux etudiants, entre chaque seance de travaux pratiques,de soumettre a l’assistant ou au professeur en charge des resolutions d’exer-cices dont eux-meme auront defini les enonces. L’assiduite d’un etudiant ace programme volontaire et la qualite des exercices proposes pourront luipermettre d’engranger jusqu’a 20% des points de la cote finale.

6.2.2 Motivation

La phase de test a demontre que la faiblesse principale des etudiantsetait leur incapacite a resoudre seuls, independamment de l’aide fourniepar les dossiers distribues en travaux pratiques, des exercices de complexitesuperieure. Ce cours se basant principalement sur un enseignement par exem-ples, il est evident que l’etudiant peut etre tente de se reposer sur ceux-ci

149

pour realiser des exercices similaires. Le but reel de ce cours et de sa philo-sophie est de donner aux etudiants les bases necessaires a la realisation deprogrammes plus complexes. Dans ce sens, il est indispensable de trouverun moyen qui puisse permettre a l’etudiant curieux et motive de surpas-ser le niveau acquis aux cours ou en travaux pratique. LogOz, grace a sonechelonnement sur micromondes et a la relative liberte que l’on eprouve danschacun d’entre-eux permet cette evolution tout en gardant un controle totalsur le notions utilisees. Le but de cette methode d’evaluation par exercicessupplementaires est de permettre aux etudiants d’explorer de fond en comblechacun des micromondes pour leur permettre de mieux saisir les limites deceux-ci et ainsi mieux apprecier l’acces au monde superieur. Les exercicesrefleteront aussi l’interet et la curiosite suscites par ce cours d’introduction ala programmation sur l’assistance, et recompenseront les etudiants qui tra-vaillent chez eux, tout en leur forgeant une experience accrue en matiere deprogrammation.

Le systeme de cotation pourra apporter a l’etudiant jusqu’a 20% de lacote finale. Ces points sont des points “bonus”, c’est-a-dire que l’etudiantqui rend des exercices toutes les semaines sera recompense par 20/20 (20 %),alors qu’un etudiant qui participera au programme une semaine sur deuxobtiendra un 10/10 (10 %). Un etudiant qui decidera de ne jamais soumettrede resolutions d’exercices ne sera pas directement penalise, mais souffriraprobablement d’une part d’une moins grande experience qu’un etudiant plusparticipatif, et devra d’autre part fournir des resultats plus importants lorsde l’examen final pour obtenir un resultat global identique.

6.3 Projet

6.3.1 Objectifs

Deux objectifs se detachent dans la realisation de ce projet : le premier,assez evident, est la mise en pratique de l’ensemble des connaissances acquisesle long des seances precedentes ; le second tend a encourager les etudiants aprofiter du caractere modulaire de l’oriente agent. Pour ce faire, nous lesincitons a travailler par groupe de deux et a se repartir la charge de travailde maniere intelligente et optimale. Il est possible de separer ce projet demaniere a ce que chacun puisse travailler sur des parties independantes lesunes des autres a condition de bien poser les bases communes.

150

6.3.2 Modalites pratiques

Cotation

Puisqu’il est indispensable qu’un tel projet soit realise avec serieux, ilest donc imperatif de lui attribuer un poids certain dans la note finaled’evaluation (c’est en effet la meilleure solution pour que tous les etudiantsprennent part a celui-ci de maniere consciencieuse). Au vu des pourcentagesreserves aux autres parties (examen, exercices supplementaires), nous avonsdecide d’accorder 30% de la note pour le projet. Cela laisse une grande lati-tude a la personne chargee de l’evaluation de nuancer la correction et imposeaux etudiants de prendre cette partie au serieux.

Support en classe

Il semble evident que de jeunes etudiants ont besoin d’une aide lors de larealisation de leur premiere application importante. L’enseignant, confrontea ce besoin, peut choisir de fournir a l’etudiant une partie du code de l’appli-cation. Il peut aussi se sentir l’obligation de proposer aux groupes de travailun soutien permanent, assure par un assistant. Cependant, ces techniquesentraınent parfois un effet pervers.

Dans le premier cas, l’etudiant n’est pas vraiment confronte a un pro-gramme qu’il se doit de realiser de A a Z, et l’objectif exprime plus haut n’estpas atteint. D’autre part, nous estimons primordial que l’etudiant ait librechoix de ses methodes de programmation et de l’architecture de ses modules.L’imposition de modules preprogrammes, bien que soulageant la charge del’etudiant, l’emprisonnerait dans des choix qui ne seraient pas necessairementles siens.

Dans le second cas, en fournissant a l’etudiant une aide exterieure, l’en-seignant prendrait, dans le cas ou plusieurs encadrants interviendraient, lerisque d’installer un facteur d’aide inegale entre differents groupes. Effecti-vement, les experiences ont montre que certains assistants etaient plus im-pliques que d’autres dans leur mission d’aide a l’etudiant, et les groupesdefavorises se sentent generalement leses. D’autre part, l’objectif de ce tra-vail est de confronter l’etudiant avec ses propres connaissances, ses propresrecherches. Lui permettre de se reposer sur une aide exterieure lui donneraitd’abord l’impression de ne pas avoir a se debrouiller par lui-meme et pourraitensuite, consequence plus grave, lui donner l’impression qu’il peine a realiserune application qui ne constitue, pour d’autres, qu’une formalite. Or, si l’ap-proche par micromonde tend a cacher l’immensite des concepts informatiquesaux etudiants afin de leur permettre de se focaliser sur leur apprentissage, ilocculte aussi le caractere basique de leur niveau d’informatique par rapport

151

a d’autres programmeurs plus experimentes. Les confronter a une aide quipourrait parfois par maladresse se montrer arrogante risquerait d’entraınerune vague de decouragement.

Compte tenu de ces reflexions, nous en avons deduit qu’une nouvellemethode de support devrait etre testee. Celle ci consiste a realiser, au cours,un projet similaire a celui que les etudiants auront a implementer par euxmeme. Cet expose leur permettra d’etre en contact avec un mode de reflexionplus mature, duquel il pourront tirer des enseignements. L’explication de larealisation par un professeur ou assistant unique, de la conception a l’implemen-tation, permettra d’une part d’eviter les inegalites entre les etudiants, etd’autre part d’apporter des explications basiques, instructives et evaluativessans aucun soupcon de condescendance ou d’arrogance. L’etudiant disposeradonc du materiel necessaire a la realisation de son propre projet sans pourautant se trouver face a un travail prefabrique qu’il ne doit plus qu’enjoliver,comme c’est parfois le cas avec des modules preprogrammes.

Realisation en groupe

Comme dans beaucoup de projets informatiques, celui-ci ne se realisepas seul. En effet cela permet de confronter l’etudiant au travail de groupequi est, en programmation, une realite quotidienne. Pour pouvoir travaillerefficacement, il est des lors important de se repartir les taches de maniere in-telligente en s’appuyant sur les proprietes des agents. Les etudiants doiventdonc s’interroger sur la structure globale ensemble avant de pouvoir com-mencer le travail individuel.

Rapport

La realisation du projet s’accompagnera de la remise d’un rapport. Celuici aura pour objectif d’une part de permettre aux etudiants de se familiari-ser avec cet exercice parfois delicat de commenter un travail et de justifierses choix d’implementation, et d’autre part de les obliger a comprendre lefonctionnement de leur application.

Un rapport preliminaire, rendu 2 ou 3 semaines apres reception de l’enonce,devra contenir un diagramme d’agent de l’application, dans lequel serontillustres les agents et les messages envoyes. Il sera aussi demande aux etudiantsde fournir une version succincte de l’explication du fonctionnement de chaqueagent. Cet exercice incitera les etudiants a construire le fonctionnement deleur jeu sur papier au lien de se lancer aveuglement dans une implementation

152

qui s’inspirerait dirrectement du jeu “Space Invaders” realise en classe.Un rapport final sera requis un moment de la remise du programme

(entre 4 et 8 semaines apres la reception de l’enonce, selon le programme desetudiants, et la rapidite de l’enseignant a corriger le rapport intermediaire).Celui ci devra contenir

– Une version corrigee et adaptee au programme final du diagrammed’agents

– Une breve explication des choix de leur architecture– Une explication de l’organisation du travail entre les deux membres du

groupe– Une explication precise du fonctionnement des agentsIl n’est generalement pas demande des choses telles qu’une explication de

l’organisation et de la repartition du travail entre les membres d’une equipede programmation. Dans ce cas-ci, il ne s’agit nullement d’une techniqueservant a reperer les etudiants deserteurs. Ce cours met regulierement enavant le caractere modulaire du modele oriente agent. En demandant auxetudiants d’ecrire un rapport sur la repartition du travail, nous les obligeonsa songer a une maniere intelligente et efficace de profiter de la modularitedu modele. L’application a leur methode de travail d’une telle repartitionprepare efficacement les etudiants a la realisation de projets plus importantsauxquels ils seront inevitablement confrontes dans les prochaines annees.

Il est aussi important de requerir une explication exhaustive du fonction-nement des agents afin de verifier si les etudiants comprennent le code qu’ilsont ecrit. Cela compense le risque encouru par le parallelisme entre le projetfinal et le jeu “space invaders” realise en seances.

6.3.3 Enonce

Le fil rouge de ce cours, outre l’enrichissement des micromondes, estl’orientation des exercices vers un aspect ludique. Le projet final etant l’abou-tissement de notre apprentissage, il est important que celui ci traduise notrevoeu de divertissement.

Tout comme pour le test, l’enonce propose ici n’est qu’un exemple parmitant d’autres. Il reflete cependant la philosophie generale de l’enseignementet est adapte au principe de support propose dans les seances 10, 11 et 12avec le jeu space invaders. Il est donc conseille de le soumettre tel quel auxetudiants qui suivront ce cours.

Ce projet consiste en la realisation d’un jeu de ping pong dans la grande

153

tradition de “Pong”1. La popularite de ce style de jeu, passe depuis long-temps dans la conscience collective, permet de susciter l’interet du plus grandnombre d’etudiants, qu’ils soient passionnes de jeu video ou non.

Dans ce memoire, nous proposons aux enseignants une implementationde ce jeu adaptee a l’environnement de programmation LogOz. Cette in-terpretation, creee par Mathieu Cuvelier et Isabelle Cambron2, est disponibleen annexe (C) et peut servir de base a la correction des travaux des etudiants,selon les criteres exposes ci apres.

6.3.4 Philosophie d’evaluation

Les etudiants seront juges sur leur rapport ainsi que sur le programmequ’ils auront realise. L’importance adjugee a chacun d’entre eux est laissee al’appreciation de l’enseignant. Il est conseille a l’enseignant de faire part desa philosophie aux etudiants au moment de leur communiquer l’enonce duprojet. Des etudiants de premiere annee sont generalement desorientes facea ce nouvel exercice. Plutot que d’attendre un cours plus avance pour leurdemander un rapport, nous preferons les y initier des ce cours d’introduction,en les aidant toutefois en leur communiquant d’une part le contenu requisdu rapport, et d’autre part les points importants aux yeux de l’enseignant.Les explications suivantes ne sont d’ailleurs pertinentes que si l’enseignantpartage avec les etudiants ses desirs et ses attentes.

Rapport

Premierement, l’enseignant sera particulierement attentif a la capacite del’etudiant a modifier son rapport intermediaire en fonction des commentairesqui y auront ete apportes par le correcteur. Il ne sera pas tolere que l’etudiantbase son travail sur des diagrammes incorrects alors qu’il lui a ete donne lapossibilite de l’ameliorer.

La capacite de l’etudiant a pouvoir justifier ses choix d’implementation estaussi importante. Bien que cette explication puisse etre breve, la demarchequi oblige un programmeur a se poser les questions permettant de justifier

1Pong est un jeu video de ping pong sorti pour la premiere fois en 1972 sur une borned’arcade Atari. De nombreuses versions ont vu le jour depuis lors, toutes tentant de conser-ver le style “old school” de l’original

2La programmation en premiere annee basee sur l’enrichissement progressif de micro-mondes multi-agents (Partie I)

154

son choix par rapport a tout autre (c’est-a-dire a poser un choix definitif uni-quement lorsqu’il est persuade qu’il s’agit de la meilleure solution) comptetenu des contraintes est a inscrire au plus tot dans les valeurs de nos jeunesetudiants.

Le chapitre concernant la repartition du travail existe lui aussi majoritai-rement dans le but de creer une discussion et une reflexion. Il est indeniableque les etudiants ayant ete capables de justifier leurs choix de repartion dutravail selon un plan modulaire devront etre recompenses par rapport auxautres.

Cependant, nous considerons ces deux derniers objectifs comme d’un ni-veau fortement avance pour un cours de premiere annee. Des lors, penaliserfortement les etudiants qui eprouveraient des difficultes a les accomplir seraiten desaccord avec la philosophie generale de l’enseignement, qui a privilegiela comprehension des concepts techniques et leurs applications dans des ap-plications ludiques, alors qu’aucun cours n’a ete consacre directement a lagestion de projet.

Le quatrieme et dernier point, a savoir l’explication du fonctionnementdes agents, est par contre beaucoup plus important. Il permettra d’une partde s’assurer que les etudiants ont programme un logiciel dont ils maitrisentle fonctionnement general, mais aussi de verifier qu’ils ont compris l’essencedu fonctionnement de l’agent dans LogOz. Ce point constitue, avec la correc-tion du rapport intermediaire, les elements a considerer lorsque l’enseignanten viendra a donner une note aux rapports rendus par les etudiants. Il estprobable que sur une base de 100%, le rapport intermediaire et sa correctionvalent pour 35%, l’explication des agents pour 35%, la repartition du tra-vail et la justification pour 15% chacun. Il semble etrange d’attribuer une sifaible importance aux deux points qui, pedagogiquement, s’averent les plusinstructifs pour les etudiants. Mais comme explique ci-dessus, nous estimonsqu’il s’agit d’un exercice de formation, d’entrainement, qui ne peut pas avoirde trop grande implication sur le resultat final.

Programme

Plusieurs caracteristiques importantes entrent en compte dans la correc-tion et dans l’evaluation du programme pong realise par les etudiants. Il estdans un premier temps indispensable de s’assurer que le logiciel suit la struc-ture annoncee par le rapport. Cela sert d’une part a deceler les cas de fraude(bien que cela ne soit pas l’objectif premier) et a s’assurer que le rapportn’a pas ete ecrit a la legere, mais cela permet surtout de juger la capacite

155

d’un etudiant a se conformer a un plan qu’il a etabli. On pourrait discuterlongtemps afin de decider si les points a imputer en cas de mauvais resultata l’evaluation de l’adequation entre le rapport et le programme sont a retirerde la cote du rapport ou de celle de programme. Nous ne pensons pas qu’ilexiste de solution plus logique ou plus exacte qu’une autre. Des lors, ce choixest laisse a la discretion de l’enseignant.

La seconde etape importante est de verifier le fonctionnement general duprogramme. Ce programme comporte t’il des erreurs majeures ? Est-ce que latotalite des agents a ete implementee ? Il se peut que certains etudiants (voireune majorite) n’ait pas ete capable de fournir un projet complet. Dans ce cas,le correcteur cherchera dans le rapport d’eventuelles raisons. L’etudiant inca-pable de finir son projet, mais qui aura dans son rapport detaille precisementles manques de son logiciel en decrivant precisement les agents ou proceduresmanquantes ne risquera pas de penalites aussi importantes qu’un etudiantn’ayant rien justifie. Ensuite, le correcteur portera son attention sur la qualitegenerale du programme. Les procedures implementees sont-elles optimales ?Les messages entre les agents sont-ils traites de la meilleure facon ? Y a t’ildes fonctionnalites “bonus” que les etudiants ont ajoutes spontanement ?

De tous ces criteres, nous estimons que le plus important est l’adequationau rapport. Un etudiant qui aura redige un rapport complet sur ses intentionsd’implemenations mais n’aura pas eu le temps de tout implementer obtien-dra de meilleurs resultats qu’un etudiant ayant un programme abouti maistotalement etranger aux diagrammes du rapport ou n’ayant pas ete capablede detailler ses agents.

6.4 Examen

Rares sont les cours qui ne se cloturent pas par un test de connaissances,souvent sous la forme d’un examen. Celui-ci n’echappera pas a la regle et doncun exemple d’examen est donne dans les annexes (annexe(B)). Dans cettesection nous prenons la peine d’expliquer aussi bien l’importance donnee acelui-ci dans la cotation du cours que le choix de nos questions. Nous sommesbien conscients qu’il ne s’agit ici que d’un exemple d’examen, cependant ilnous permet de mettre en evidence les elements incontournables du cours.

6.4.1 Cotation

En fonction de l’attitude de l’etudiant durant le semestre, la ponderationrelative a l’examen peut osciller entre 30% et 70%. Voici le detail des differentes

156

possibilites :

– Projet (30%) + Exercices supplementaires (0% - 20%) + Test (20%) +Examen (30% - 50%)

– Projet (30%) + Exercices supplementaires (0% - 20%) + Examen (50%- 70%)

Sur la totalite des points attribues au cours d’introduction a la program-mation, 30% sont fixes pour le projet. L’examen peut donc au maximumcompter pour les 70% restants.

Nous avons explique precedemment que l’etudiant pouvait engranger jus-qu’a 20% de points bonus grace aux exercices supplementaires. Cet apportpeut donc restreindre le poids de l’examen jusqu’a 50% du resultat final.

Le test (lui aussi valant pour 20% des points) peut, si l’etudiant decidede ne pas repondre aux questions d’examens permettant de le remplacer,restreindre l’importance de l’examen final a 30%.

Cette large fourchette se justifie de plusieurs manieres.

Tout d’abord, concernant le test, nous estimons qu’il est important de per-mettre aux etudiants ayant demarre un peu plus lentement de rattraper leurechec a l’occasion de l’examen. En effet, nombreux sont les etudiants qui, pourdes raisons d’horaire charge, par manque de maturite face a une premiereannee universitaire, ou simplement parce qu’ils peinent a comprendre rapi-dement des concepts enseignes, echouent lors des tests intermediaires.

Bien entendu, la partie de l’examen relative au test vaut pour 20%.Donner la possibilite de recuperer les points de l’interrogation a l’examenrecompense d’une part les etudiants qui ont fourni un travail exemplaire du-rant l’annee, tout en laissant une bonne chance de rattrapage aux autres.

L’autre facteur pouvant modifier la ponderation accordee a l’examen estla motivation de l’etudiant a rendre des exercices supplementaires tout enlong de l’annee.

Les points accordes a ces etudiants sous forme de bonus entre 0% et20% font varier la ponderation de l’examen dans une fourchette de 20%. Cesysteme de repartition permet de recompenser les etudiants actifs durantl’annee en minimisant l’importance de l’examen. Cette reduction se justifieen supposant que l’etudiant qui a rendu des exercices supplementaires per-tinents a deja fourni un travail supplementaire pour ce cours, et que celui-cidevrait pouvoir lui permettre de reduire son temps d’etude pour l’examen.

157

6.4.2 Question remplacant le test

Les deux questions permettant de laisser tomber les points du test seveulent dans la meme ligne que le test lui-meme.

Aussi, aucun etonnement face a la question de theorie puisqu’il s’agit,tout comme dans le test, de definitions.

La seconde question permet de verifier la comprehension de la recursionqui est certainement dans cette premiere partie de cours le concept le plusdifficile a apprehender. La question est directement issue d’un exemple ducours donc, bien que relativement complexe, elle ne devrait pas poser desoucis a l’etudiant ayant etudie correctement.

6.4.3 Questions theoriques

Afin de s’assurer du niveau de maıtrise du cours par l’etudiant, nousavons choisi de lui demander de retracer un plan complet de celui-ci et d’enexpliquer l’ordonnancement. Une question de resume comme celle-ci permetd’evaluer le niveau de comprehension globale de l’etudiant.

Au cours de notre enseignement, nous insistons a plusieurs reprises sur lefait qu’un cours n’est pas simplement un ensemble de concepts a apprendre.Ceux-ci sont lies entre eux et l’ordre dans lequel ils sont donnes est loin d’etreimprovise. Nous esperons donc que l’etudiant en aura saisi l’importance etsera capable de le re-expliquer.

De plus, nous demandons l’explication de trois concepts clefs du cours.Cette demarche permet a l’etudiant de choisir ce qu’il decide d’expliquertout en permettant a l’enseignant de voir quels sont les fondements retenus.Aussi bien du point de vue de l’etudiant (qui peut mettre en avant ce qu’ilconnaıt le mieux) que du point de vue du professeur, ce type de question esthautement interessante.

6.4.4 Question pratique

Dans le modele d’examen que nous soumettons en annexes, le lecteurpourra constater que la question pratique est un enonce de mini-projet. Toutau long du cours les etudiants sont encourages a realiser un maximum d’exer-cices par eux-meme, et doivent realiser un projet. Des lors il nous semblaitinteressant d’inscrire l’examen dans cette logique en proposant ce type dequestion.

158

Conscients de la difficulte que peut engendrer une question de ce type,nous avons choisi de separer la realisation du projet en differents sous-points.Chacun de ceux-ci represente une etape indispensable : le premier pointconsiste en la realisation d’un diagramme de sequence, obligeant ainsi l’etudianta identifier chacun des agents du systeme ainsi que les liens existant entreeux ; la deuxieme sous-question s’attarde sur le comportement proprement ditdes agents a la reception de differents messages, permettant ainsi une ebauchede la fonction de transition ; la troisieme partie est l’implementation de cesfonctions de transition et la derniere sous-question permet d’implementerl’appel de procedure qui lancera le programme. Au final l’etudiant aura doncentre ses mains la realisation quasiment complete d’un projet.

Il existe un double interet a separer ainsi les differentes etapes.Le premier, deja explique ci-dessus, est de permettre a l’etudiant de ne pas

se perdre completement dans l’enonce du projet et d’avancer etape par etapevers la realisation finale (a la fin d’une premiere annee de programmation ilsemble difficile d’exiger une parfaite maıtrise de la gestion d’un projet).

Ensuite, il est important de pouvoir evaluer la coherence entre les differentesparties d’un meme projet et de voir si l’etudiant respecte une certaine logique.Ce systeme permet de la mettre en evidence. D’etape en etape l’etudiantse doit de respecter les contraintes et les informations donnees au pointprecedent. Ceci permet egalement a celui qui aurait mal choisi son diagrammede sequence de ne pas etre penalise sur l’entierete de la question.

159

Chapitre 7

Critiques et Pistes

A ce stade, le lecteur a pu decouvrir les differentes forces de l’approchede l’enseignement de la programmation par l’enrichissement de micromondesmulti agents. Cependant, il serait pretentieux d’affirmer que cette methodeest infaillible. Il serait encore plus presomptueux de laisser penser que letravail que nous avons base sur cette philosophie consiste en une solutionmiracle.

Nous nous devons, d’une part par respect pour les autres tentativesd’elaboration de cours de programmation, d’autre part pour permettre anos eventuels successeurs d’apporter des ameliorations au travail, de propo-ser une discussion critique de notre systeme.

Celle-ci observera la methode sous plusieurs points de vue. Tout d’abord,nous mettrons a l’epreuve le choix d’une approche ludique en confrontantnotre methode avec les critiques apportees a l’utilisation des jeux video dansl’enseignement de la programmation.

Ensuite nous la comparerons a d’autres types de cours ou d’etudes pedago-giques afin de relever les avantages et les inconvenients que notre philosophierepresente par rapport a d’autres tentatives.

Nous proposerons finalement diverses pistes destinees a orienter quiconquedesirerait continuer notre entreprise. Celles-ci pourront soit inviter a des cor-rections de notre propre travail, soit, plus generalement, faire part de notrepoint de vue concernant la suite du projet.

160

7.1 Une approche ludique

Des les premiers pas qui ont mene a la creation de ce cours de program-mation, la philosophie d’apprentissage par micromonde s’est accompagneedu desir de proposer un enseignement ludique, base sur une representationgraphique immediate des actions de l’etudiant. Cette optique, deja abordeemaintes fois dans plusieurs types de cours de programmation, divise le mondede l’enseignement informatique. Certains chercheurs et professeurs estimentqu’il s’agit d’une methode tres efficace pour apprendre la programmationalors que d’autres avancent que l’introduction des jeux video dans l’ensei-gnement entraıne principalement une baisse de resultat.

En decembre 2003 le SIGCSE Bulletin1 publiait un etat des lieux desarguments des deux parties. Nous avons decide de confronter notre methoded’enseignement et le role que les jeux video y tiennent avec cette etude afinde demontrer le bien fonde de notre philosophie.Cette section proposera tout d’abord un rapide inventaire des aspects video-ludiques de ce cours et de LogOz. Elle presentera ensuite au lecteur les prin-cipaux points de vues exposes par l’article. Nous evaluerons ensuite notremethode selon ces criteres.

7.1.1 Le role du jeu video dans cette approche

Ce cours d’introduction a la programmation comporte differents aspectsludiques. Ce desir de rendre l’enseignement agreable et attractif trouve sarepercussion dans diverses parties du cours.

L’environnement LogOz

L’environnement LogOz propose aux etudiants d’observer directement larepercussion de leurs exercices dans un module graphique grace a la tortueet a la feuille de dessin. Le but de la programmation, plutot qu’etre de lamanipulation de chiffres, devient le controle d’un agent graphique. Les ob-jectifs des exercices consistent dans un premier temps en la realisation parcet agent Tortue de differents dessins.

1Le SIGCSE[16] est leSpecial Interest Group for Computer Science Education. Il publieregulierement les compte-rendus des conferences tenues sur le sujet de l’enseignementinformatique avec leur references

161

Les projets

Le projet propose aux etudiants ainsi que le projet realise en classeconsistent tout deux en l’implementation d’un petit jeu video. Il est de-mande a l’etudiant de mettre en pratique les fruits de son apprentissage enprogrammant les agents constituant ce jeu video.

7.1.2 Do computer games have a role in the classroom :un resume

L’article Do computer games have a role in the classroom[17] propose unecompilation des principaux arguments echanges entre les chercheurs et profes-seurs favorables a l’utilisation des jeux video dans le cadre de l’enseignementde l’informatique et ceux qui emettent des reserves a ce sujet. Ces argu-ments sont categorises en six points repris ci-dessous. Nous les presentonsbrievement afin de pouvoir structurer notre analyse en fonction de cetteetude.

Motivation

– Avantages : Certains etudiants trouvent les jeux video tres motivantspour l’apprentissage.Beaucoup d’entre eux ont une bonne experience en la matiere, soitcomme joueur, soit comme programmeur amateur de petits jeux. Uti-liser les jeux video dans le cadre d’un cours de programmation permetde se connecter a leur parcours et de joindre l’utile a l’agreable.

– Inconvenients : Certains groupes de personnes2 peuvent se trouverdesinteresses par les jeux video competitifs.Une mise en avant des jeux video peut nourrir la croyance populairequi soutient que les jeux video constituent un composant majeur dumonde de l’informatique.Les jeux video peuvent se reveler dangereusement addictifs. En encou-rageant leur utilisation et en les introduisant dans le monde educatif,on court le risque de developper chez l’etudiant un comportement anti-social.Des exercices bases sur les jeux video peuvent entraıner une distractionen classe a chaque fois que les etudiants sont tentes de montrer lesresultats de leur programme a d’autres etudiants.

2Ces groupes sous-representes sont references par l’auteur comme les femmes ou lesetudiants plus ages n’ayant pas eu de contact avec les jeux video

162

Elements graphiques

– Avantages : Les elements graphiques sont, a un niveau bien superieuraux exercices standarts, susceptibles de capturer l’interet des etudiantset de provoquer leur imagination. Ils ont aussi tendance a susciter l’ex-pression de celle-ci plus efficacement que des exercices communs.

– Inconvenients : Le temps consacre par les etudiants a la constructiondes elements graphiques peut empieter sur le temps consacre a l’ap-prentissage des principes de la programmation (algorithmes, structuresde donnees,...).

Aide a la comprehension

– Avantages : Le fonctionnement d’un jeu video est generalement plusfacile a comprendre que tout autre programme. Developper des pro-grammes qui implementent des jeux video est des lors un pretexteefficace a l’apprentissage de la resolution de problemes basiques ouplus complexes, de la creation de structure de donnees, de methodes etprocedures, ou d’autres competences de plus haut niveau.

Modularite et ajout de fonctionnalites

– Avantages : Les jeux fournissent de nombreuses possibilites pour lacreativite des travaux et des devoirs ainsi que des opportunites d’amelio-rer les travaux deja realises en enrichissant l’enonce avec nouvelles fonc-tionnalites. Cette modularite permet aussi de realiser de gros projets atravers une serie de plus petits exercices ou devoirs consecutifs.

– Inconvenients : La possibilite d’ajouter des fonctionnalites a un travaildeja realise peut encourager l’etudiant a realiser des programmes d’unecomplexite inutile, alors qu’il aurait pu consacrer ce temps a l’appren-tissage de nouveaux concepts.

Modularite et systeme de cotation

– Avantages : Comme les jeux peuvent etre realises en couches, l’ensei-gnant peut facilement coter les etudiants en fonction des fonctionna-lites ajoutees au jeu. Une realisation basique vaudrait un C, l’ajout dequelques fonctionnalites meriterait un B, et une application aux fonc-tionnalites completes serait recompensee par un A.

– Inconvenients : Lorsque les points dependent des differents niveaux defonctionnalites apportees a l’application, les vrai debutants (les groupessous-representes qui n’ont pas d’experience en jeu video) peuvent se

163

trouver face a un vrai desavantage par rapport a ceux qui sont aucontact de jeux depuis des annees et pour qui les differentes fonctionna-lites a ajouter paraissent naturelles. Cette difference de niveau empechegeneralement ces etudiants debutants a obtenir une confiance en soi etrisquent, tot ou tard, de decrocher.

Opportunite d’introduction des technologies

– Avantages : Les jeux video fournissent de nombreuses opportunitespour l’introduction de nouvelles technologies telles que les applicationsclient/serveur et la concurrence.

7.1.3 Confrontation avec notre approche

Motivation

Les etudiants qui ont teste ce cours n’avaient pour la plupart, notam-ment a cause de leur age, peu (voire pas du tout) d’experience en matierede jeu video. L’approche ludique s’est cependant revelee tres motivante pourtout le monde. Elle a permis aux etudiants qui n’avaient aucune notion deprogrammation de se rattacher a quelque chose de plus comprehensible. Eneffet, il apparaıt clairement que meme si le monde du jeu video est tota-lement etranger a l’etudiant, celui-ci prefere tout de meme avoir affaire aune representation graphique plutot que d’etre confronte a un environne-ment classique. Les projets, quant a eux, consistent volontairement en desjeux anciens, passes dans la conscience collective, et parlant meme a ceux quin’ont jamais beaucoup joue aux jeu video.

Nous avons remarque que face a la methode d’apprentissage, les etudiantsne tombaient pas dans l’erreur d’imaginer qu’informatique et jeu video ne fontqu’un. Ils comprennent naturellement que le module graphique n’est la quepour servir l’apprentissage des concepts de base de programmation. En effet,meme si les exercices consistent en la realisation de programme dirigeant latortue, ils servent avant tout a mettre en oeuvre les concepts enseignes.

En ce qui concerne le risque d’addiction, nous ne pouvons pas prendrecela en compte, etant donne que l’environnement LogOz, meme si il utilisedes elements ludiques, est base sur des principes de programmation de base.Afin de “jouer”, l’etudiant doit avant tout programmer. Si risque d’addictionil y a, nous ne pouvons que nous en rejouir, puisqu’il entraınerait l’etudianta faire des exercices supplementaires, encore et encore.

164

Il est evident que des exercices bases sur la realisation de jeu video en-traıne une distraction supplementaire lors des phases de test ou de demonstra-tion. Cependant, nous avons observe que cela induisait aussi une emulation etune certaine competition (amicale) entre les etudiants qui trouvaient la unemotivation supplementaire a la realisation de leurs exercices. Bien entendu,la phase de test du cours comprenait 8 etudiants. Il est possible qu’une classede 20 elements soit plus difficile a discipliner.

Elements graphiques

La critique apportee a l’utilisation d’elements graphiques etait que ceux-ci risquaient de monopoliser le temps de travail des etudiants aux depensde l’apprentissage de concepts plus serieux. Nous sommes conscients de cerisque, c’est pourquoi tous les elements graphiques dont la realisation n’auraitpas de but pedagogique sont fournis aux etudiants. La tortue, les palettes et laballe du jeu Pong, les vaisseaux et missiles du jeu Space invaders sont fournisaux etudiants en meme temps que l’explication des procedures permettantleurs manipulations afin qu’ils puissent les reimplementer dans le cadre ducours. Tous les autres elements graphiques sont realises par les etudiantsgrace a l’application des concepts appris precedemment, et sont donc partieintegrante du processus d’apprentissage.

Aide a la Comprehension

Nous avons bien saisi les facilites de comprehension des concepts infor-matique qu’apporte l’utilisation des jeux video. Il s’agit d’ailleurs, apres lecaractere ludique, de la raison principale de l’utilisation des jeux video dansce programme de cours. Ce principe est directement applique des les pre-miers pas grace au principe de LogOz. La reaction instantanee de la tor-tue a la programmation de l’etudiant lui permet de mieux comprendre lesconsequences des lignes de codes qu’il ecrit, ainsi que le fonctionnementgeneral des sous programmes proposes en exemples ou exercices. Cette fa-cilite de comprehension des jeux video trouve ensuite tout son sens dans ladeuxieme partie du cours, ou les etudiants decouvrent les principes de pro-grammes de plus grande ampleur grace a la realisation du jeu Space Invaders.Ce jeu, facile a apprehender, leur permet pour la premiere fois de transformerun enonce, l’image d’un objectif qu’ils s’en font, en une modelisation prete aservir de base a la programmation.

165

Modularite et ajout de fonctionnalites

Nous sommes bien conscients des possibilites offertes par la modularite etles avons d’ailleurs exploitees dans les projets proposes aux etudiants. Cettemodularite est encore accentuee par l’appproche agent, et encouragee par laseparation du travail entre les deux membres du groupe. Cependant, nousestimons qu’etant donne les echeances et le guidage fournit aux etudiants lorsde la realisation de ces travaux, il y a peu de risques qu’ils se perdent dansla realisation de fonctionnalites trop complexes. D’autre part, les projetsinterviennent a un periode de l’annee ou ils ne sont pas juxtaposes a unquelconque apprentissage. De plus, aucun encouragement ne sera donne dela part de l’enseignant pour susciter cette attitude.

Modularite et systeme de cotation

Face a cette possibilite d’axer la cotation selon les fonctionnalites supple-mentaires de l’application, nous restons assez prudents. Nous realisons qu’ilest important de recompenser les etudiants qui auraient apporte de grandesameliorations a leur programme, mais nous ne pouvons pas nous resoudre apenaliser ceux qui fournissent un travail repondant correctement a l’enonce.Nous estimons donc que l’enseignant devrait donner jusqu’a 16/20 pour destravaux repondant aux exigences de l’enonce. Des points bonus, jusque 20/20,peuvent etre accordes aux groupes ayant fait preuve d’imagination dans leurimplementation. Il nous semble que cette repartition ne devrait pas blaserou decourager les etudiants “normaux”, tout en recompensant les plus per-formants d’entre eux.

Opportunite d’introduction des technologies

Le choix du modele oriente agent pour ce cours de programmation a etefait de pair avec le choix de l’utilisation des principes de jeu video. En effet,ces deux modeles vont souvent de pairs. Des lors, le jeu video est pretexte atout apprentissage. La concurrence est expliquee par un exercice de courseentre plusieurs tortues, le principe de fonctionnement de base du jeu trouveson implementation dans l’echange de messages entre agents et les jeux enreseau servent de base au cours qui introduit les principes de reseau.

7.2 Etude comparative

Nous avons selectionne deux autres approches qui proposent une tech-nique alternative aux techniques d’enseignement actuelles. Dans cette sec-

166

tion, nous les presenterons brievement et les comparerons avec notre methode.

7.2.1 Squeak

Squeak[18] est une implementation d’un environnement de programma-tion pour Smalltalk 3. Celui-ci permet un apprentissage du langage Smalltalkbase sur la manipulation d’elements graphiques. L’etudiant cree a l’aide d’ou-tils graphiques divers objets et peut ensuite modifier leur comportement gracea des menus ou a l’aide de commandes Smalltalk. Ce projet est principalementdestine aux enfants et n’entre donc pas dans un projet d’apprentissage de laprogrammation a long terme. Son but, indiscutablement atteint, est d’intro-duire chez les enfants des notions de programmation, des automatismes, etun premier contact avec les variables et les processus.

Nous retiendrons de ce projet la facilite d’installation de son applicationet la possibilite pour les enfants de dessiner a la main leurs propres objets.Cependant, cette caracteristique, bien qu’utile lorsque l’on travaille avec desenfants sans objectifs de performance, pourrait avoir des effets indesires surune classe de jeunes adultes. Le temps consacre a realiser ces dessins risque-rait alors d’empieter sur le temps consacre a l’apprentissage des principes deprogrammation.

Si nous devions apporter une critique a l’environnement Squeak, il s’agi-rait de la richesse de ses outils qui rendent le premier contact un peu delicatsi l’on ne dispose pas d’un support precis. En effet, squeak dispose d’unecentaine d’outils et d’un menu contextuel digne d’Eclipse[20]. La figure 7.1illustre la complexite de l’interface.

D’autre part, l’enseignement est dispense sous forme de divers tutoriaux.L’etudiant autodidacte ne dispose pas vraiment de fil rouge a suivre afin deconstituer un enseignement continu. Le professeur qui voudrait appliquer leprincipe de squeak eprouverait la plus grande difficulte a constituer un courscoherent articule sur une annee.

Nous pouvons donc conclure que Squeak s’adresse a des enfants et intro-duit des concepts de programmation dans un ensemble ludique. Les “etudiants”ne realisent pas specialement qu’ils apprennent l’informatique. C’est un modelequi semble tres adapte et efficace pour les plus jeunes, mais qui ne convien-drait bien entendu pas a un public universitaire qui a besoin de connaıtre

3Smalltalk est un des premiers langages de programation objet, cree en 1972 par AlanKay et Dan Ingals[19]

167

Fig. 7.1 – L’interface de programme Squeak

les objectifs clairs et les enjeux de l’enseignement. De plus, le projet squeakn’est pas accompagne d’une structure de cours qui permette de s’en servirpour proposer une formation sur un rythme regulier et pour un temps donne.Il est cependant indeniable que des enfants ayant eu un contact avec squeakdisposeront d’une avance considerable sur des etudiants n’ayant eu aucuncontact avec la programmation.

7.2.2 ObjectKarel

ObjectKarel est un projet publie dans le SIGSCE Bulletin[21] et realisepar S. Xinogalos4 dans le cadre de la recherche sur des nouvelles methodesd’apprentissage de la programmation. Il s’agit d’un cours de programmationoriente objet base sur un micromonde et teste par des etudiants universi-taires. Bien qu’etant base sur l’enseignement d’un modele oriente objet, ils’agit du projet educatif qui se rapproche le plus du notre : micromonde, test

4University of Macedonia, Thessaloniki, Greece

168

sur des etudiants, structure claire et precise afin d’etre enseignee en premiereannee.

Nous nous demarquons tout de meme au niveau de l’utilisation des micro-mondes. ObjectKarel propose un seul micromonde, alors que notre approcheest basee sur l’enrichissement de plusieurs mondes. Cette particularite nouspermet d’avoir recours a des micromondes plus petits, plus cibles, et plusfacilement maıtrisables par l’etudiant.

Bien qu’ObjectKarel presente des similitudes avec notre approche, quiauraient rendu tres interessantes un comparatif approfondi, il ne nous a pasete possible d’en acquerir une version. Nous devons donc nous satisfaire decette analyse sommaire.

7.2.3 Remarques generales

Parmi tous les projets pouvant etre rattaches au notre, c’est-a-dire lesprojets d’enseignement integrant une aide graphique ou bien bases sur l’utili-sation des micromondes, nous n’en avons pas trouve qui puissent se comparerdirectement a ce travail. Le modele oriente agent est parfois utilise dans descours plus avances, par exemple d’intelligence artificielle, mais nous n’avonsrencontre aucun cours d’introduction de la programmation orientee agent.

D’autre part, le principe des micromondes est generalement utilise demaniere a simplifier les concepts, mais peu de cours (nous n’en avons trouveaucun) proposent de lever les barrieres de ces mondes afin de les enrichir.De plus, ces abstractions sont le plus souvent destinees aux jeunes enfants,et ne sont donc pas adaptes aux exigences des jeunes ou des adultes. Nouspouvons estimer que le projet d’apprentissage base sur l’enrichissement demicromonde oriente agent est unique en son genre. Il est semblable en certainspoints a d’autres etudes, mais propose une methode nouvelle en introduisantun support graphique sans pour autant negliger l’importance du code et desnotions theoriques, ou en instaurant un principe novateur d’enrichissementde micromondes, sans pour autant laisser croire aux etudiants qu’il s’agit lade l’entierete du monde de la programmation.

7.3 Pistes pour le futur

Le cours qui est presente ici est pret a etre enseigne. Aucune modificationmajeure ne devra etre apportee aux seances qui constituent cet enseigne-

169

ment d’un semestre. Cependant, des ameliorations pourront etre proposeespour des cours supplementaires, ou afin d’ameliorer le confort d’utilisation duprogramme et les fonctionalites qu’il comprend. Nous presentons ici certainespistes qui pourront etre suivies par nos eventuels successeurs.

7.3.1 Ameliorations du programme

La sauvegarde et le chargement d’agents

La possibilite pour les etudiants de pouvoir sauvegarder la definitiond’agents qu’ils ont crees pour pouvoir s’en servir ulterieurement est unefonctionnalite qui nous tenait a coeur. Cependant, la version actuelle duprogramme ne permet pas une utilisation optimale de ce principe.

Dans LogOz 2.0 il est possible de simuler cette propriete en sauvegardantle code de la definition d’un agent grace au menu Save. Il est ensuite possiblede charger cet agent grace a la fonction de menu Load Agent. Cependant,etant donne que ces deux fonctionalites peuvent sauvegarder et charger touttype de code, nous n’estimons pas que cette utilisation soit optimale. Ellepermet tout de meme d’avoir recours au principe de base.

Dans un premier temps, il serait interessant d’implementer une pratiquede sauvegarde qui soit capable de sauvegarder une definition d’agent selection-nee dans un code plus large. L’etudiant selectionnerait alors le nom de lafonction de transition a sauvegarder et le systeme l’ecrirait dans un fichier(dont le nom serait celui de l’agent sauvegarde), accompagne des definitionsde tous les agents qui entreraient en compte dans l’execution dudit agent (lesagents qui le constituent).

En supposant que cette fonction save soit implementee correctement, lafonction Load Agent, qui charge un agent et indique dans le browser le nomde celui ci, ne devrait meme pas etre modifiee et fonctionnerait correctement.

Une amelioration de ce principe consisterait en la creation d’une procedurequi permette de sauvegarder et de charger dynamiquement des agents “figes”.C’est-a-dire qu’on ne sauvegarderait plus uniquement la definition de l’agent,mais l’etat de l’agent. Il serait alors possible de choisir de tuer l’agent quivient d’etre sauvegarde ou de le laisser s’executer. En effet, si la sauvegardesert a figer un agent et a le relancer plus tard, on peut se debarrasser de laversion qui s’execute. Tandis que si la sauvegarde consiste en une sauvegardede securite, alors on voudra que l’agent continue a s’executer. Au chargementde cet agent, le systeme creerait en fait un nouvel agent grace a la definition

170

et a l’etat sauvegardes. Bien sur cet agent serait exactement comme celui quia ete sauvegarde au moment de la sauvegarde et le systeme tout comme l’uti-lisateur ne se soucierait pas du fait qu’il ne s’agisse pas vraiment du memeagent. Cependant, a partir du moment ou le chargement se fait dans la memeapplication que la sauvegarde (ce qui est suppose etre le cas avec un charge-ment et une sauvegarde dynamique), on peut imaginer qu’il serait suffisantde sauvegarder uniquement l’etat, la definition etant toujours accessible. Ilfaudrait alors rechercher le code a compiler et a executer dans le code del’application en cours. Le choix de la methode est laissee a la discretion duprogrammeur.

Cette fonctionnalite entraıne des challenges techniques assez complexes :– Le systeme doit etre capable de reperer la definition d’un agent dans le

code general afin de pouvoir sauvegarder celui ci– Le programmeur doit trouver une facon de sauvegarder l’etat dans un

format qui puisse etre reutilise au moment de charger l’agent– Le systeme doit etre capable de creer le nouvel agent dynamiquement,

c’est a dire qu’il doit, alors qu’un code est en execution, compiler uneautre partie de code sans que la premiere execution ait a en souffrir.

– Le systeme doit etre capable de reperer, dans la definition d’un agent,les differents agents qui le constituent, et ajouter la definition de cesagents dans le code et l’etat a sauvegarder.

L’indentation

L’indentation consiste a arranger les lignes de code en les deplacant versla droite de maniere a le structurer le programme. Cette fonctionnalite, quireleve plus du confort d’utilisation que de l’interet pedagogique, pourrait tou-tefois rendre l’aspect de LogOz plus professionnel. Nous estimons cependantque les outils QTk ne sont pas adaptes a la realisation de cette amelioration.En effet, si le developpeur desirait indenter du texte, il serait pour ce faireoblige d’y integrer des caracteres espace ou tabulation. La premiere diffi-culte serait bien entendu de creer des arbres d’interpretation de manierea determiner quelles lignes indenter et de quel espace. Mais une fois cetteprouesse technique realisee, il faudrait encore modifier le texte en lui-meme,ce qui ne serait pas une mince affaire.

171

7.3.2 Cours supplementaires

Les agents imbriques

La structure d’un programme de plus grande echelle, avec la possibilited’utiliser des agents qui sont eux-memes composes d’agents, est un conceptimportant en matiere de programmation. Nous avons realise un premier pasdans ce sens grace au micromonde 6, qui presente LogOz comme un agentindependant compose d’un agent Browser. Cependant, l’exploitation de ceconcept est limite. Il serait utile de dispenser un cours qui introduirait auxetudiants la possibilite de creer des agents imbriques ainsi que le fonctionne-ment de ceux-ci.

Un projet en reseau

Il serait interessant, apres l’enseignement du module reseau, de proposeraux etudiants de realiser un projet utilisant les concepts appris. Nous avonsdans ce but imagine un jeu de tortues en reseau.

L’enonce est le suivant : quatre tortues s’affrontent en reseau pour at-traper le plus grand nombre de salades disseminees sur le plateau de jeu.Les etudiants devront programmer une maniere de diriger leur tortue graceaux touches. Ils devront aussi creer le client (qui enverra au serveur lesdeplacements de la tortue), le serveur (qui tiendra les clients au courantdes mouvements de toutes les tortues, de la position des feuilles de salades etdes points engranges). Ils devront aussi implementer une possibilite d’aug-menter la rapidite des tortues en fonction des bonus presents sur le plateaude jeu.

A ce jour, nous avons en partie implemente ce jeu, en Oz. Celui-ci estintegre a LogozGraphics.oz.La commande pour creer le serveur est :

{CreateServer Path}

ou Path est l’adresse a laquelle se trouvera le serveur.

La commande pour connecter le client est :

{Connect Turtle Path}

ou Turtle est la tortue qui sera mise en jeu.

Il y a trois manieres de reutiliser ce travail :

172

1. Dans un but purement ludique, le jeu pourrait etre presente aux etudiantssuite a l’enseignement des principes reseau comme divertissement etcomme exemple d’une application reseau plus aboutie. Dans ce cas, ilsuffirait a nos successeurs de peaufiner le logiciel de maniere a :– gerer le compte des points en fonction de la capture des salades– implementer le principe de deplacement de la tortue grace aux touches– ajouter un systeme de bonus

2. Si l’enseignant decidait de ne se servir de LogOz que comme outil gra-phique et non plus comme environnement de programmation, il pour-rait apprendre aux etudiants a programmer directement dans l’environ-nement Mozart. Ceux-ci pourraient alors integrer leur version du jeudes tortues et des salades dans le code de LogozGraphics (comme nousl’avons fait).

3. Si par contre l’enseignant decide de ne pas sortir du principe de pro-grammation dans le notepad de LogOz, il faudrait qu’il s’arrange pourque le projet y soit programmable en utilisant les principes de pro-grammation reseau enseignes jusque-la. Cela demanderait une adapta-tion importante de l’implementation du jeu deja realisee, voire memepeut-etre sa reprogrammation complete.

La gestion des pannes

Il est important d’apprendre aux etudiants le principe de pannes et destechniques de gestion de celles-ci. Avec l’apprentissage du reseau et des agentsimbriques, nous nous trouvons a present dans une situation ou les erreurs etles pannes risquent de survenir regulierement. Bien que nous n’ayons pas eu letemps de proposer un cours complet sur la gestion des pannes, des reflexionsont porte sur le contenu d’un tel cours, dont voici le resultat.

Il faudrait tout d’abord enseigner aux etudiants le concept meme depanne. De quoi s’agit-il ? Dans quels cas cela peut-il survenir ? Quelquesexemples de pannes devraient etre donnes, et les etudiants pourraient etreinvites a ecrire quelques petits programmes destines a planter.

Dans la suite du cours, il faudrait presenter deux types de solutions auxpannes : echapper aux risques de pannes ou les reparer.

Afin d’eviter les pannes, l’enseignant pourrait tout d’abord apprendre leprincipe de la commande Try... Catch aux etudiants. Ceci serait unique-

173

Fig. 7.2 – Deux tortues a la recherche de salades

ment dans le but d’introduire un principe generique de la programmation. Ilfaudrait ensuite proposer une solution propre au modele oriente agent.

Celle-ci pourrait consister en la programmation d’agents filtres qui, comptetenu des messages envoyes et de l’etat des agents, decideraient si oui ou nonceux-ci pourraient etre envoyes.

Cependant, cette technique de gestion des pannes, qui consiste a toutmettre en oeuvre pour eviter leur apparition, n’est pas optimale. En effet,parfois, les pannes sont inevitables et il est souvent preferable d’opter pourune solution qui consiste a reparer le systeme une fois l’erreur detectee.

La technique serait alors de permettre aux etudiants de decider de lareaction du systeme face a une panne. L’enseignant devrait au prealableprogrammer dans l’environnement LogOz la possibilite de lier deux agents.La syntaxe serait la suivante

{Link AgentA AgentB}

Dans ce cas, les agents AgentA et AgentB seraient lies et se surveilleraientmutuellement. Le systeme (en fait, un agent qui serait cree a l’execution de

174

la commande Link, mais qui serait cache a l’utilisateur) enverrait alors, encas de coupure d’un des deux agents, un message d’alerte a l’autre agent.L’etudiant aura alors a programmer les deux cerveaux de maniere a ce qu’ilsreparent le systeme lorsque l’autre agent est en panne.

Plus que l’ecriture du cours en lui meme, qui n’est somme toute pas trescompliquee, ce sont les tentatives d’implementation de la commande Linkqui nous ont empeche de mener ce projet a bien avant la cloture du presentmemoire. Celles-ci n’ayant abouti a aucun resultat, nous ne pouvons propo-ser de pistes de programmation. Nous esperons cependant que les quelquesreflexions apportees ici permettront a nos successeurs de completer ce cours.

175

Conclusion

Au terme de ce memoire nous desirerions porter un regard critique surl’ensemble du travail effectue. Nous avions pour objectif de creer un coursd’introduction a la programmation et de le tester dans un but de perfec-tionnement. Cette demarche s’inscrit comme deuxieme contribution a uneentreprise plus vaste.

Notre travail consistait non seulement a developper ce cours, mais egalementa ameliorer de maniere consequente le logiciel didactique LogOz 2.0 sur le-quel il s’appuie.

Il s’est scinde en plusieurs parties : il nous a tout d’abord fallu nousplonger dans le travail precedent afin d’en comprendre l’architecture et d’enapprehender la philosophie sous-jacente.

La principale difficulte que nous avons rencontre fut, sans conteste, laprise en main de la premiere version du logiciel. Face a un code inconnu et aune architecture complexe, nous avons du faire preuve d’une grande capacited’adaptation. Pour eviter que ce genre de probleme ne se reproduise, nousavons amplifie la modularite du programme et fourni un effort supplementairesur sa documentation.

La phase suivante, l’elaboration des seances et le processus d’experimentationde celles-ci, fut au centre de nos preoccupations. Bien que les informationsrecoltees lors de cet exercice furent primordiales a la rencontre de nos ob-jectifs, trois de nos seances n’ont pas beneficie d’une confrontation a l’avisdes etudiants. Cependant, l’experience que nous avons acquise lors de cesperiodes d’enseignement ont permis de construire ces cours supplementairesdans un modele adapte. Suivant les difficultes rencontrees nous avons pro-pose deux types de resolutions : l’implementation de nouvelles fonctionnalitesdans LogOz 2.0 ou l’amelioration des sessions de cours.

176

En parallele, nous avons le temps d’opposer notre travail avec d’autres ap-proches telles que Squeak ou ObjectKarel. De ces comparaisons ressortent lesforces et faiblesses du procede d’enrichissement de micromonde multi agentet de son application dans notre methode.

Nous estimons ouvrir de nombreuses pistes pour la construction de lasuite du projet, plus specifiquement le cours de programmation de deuxiemeannee. Les nouveaux micromondes rendent possible l’elaboration de modulesde cours supplementaires relatifs au reseau, aux agents imbriques et a lagestion des pannes.

D’autre part, le cours presente est structure et defini de maniere a pou-voir etre dispense immediatement. Selon les desirs de nos successeurs, celui-ci pourra donc etre propose pour une application directe, ou attendre larealisation du cours de deuxieme annee avant d’etre presente.

Nous esperons que ces propositions permettront a d’eventuels successeursd’enrichir notre contribution, et de permettre aux chercheurs, professeurs etetudiants du monde de la programmation de disposer d’un modele d’ensei-gnement adapte, adaptable et performant.

177

Bibliographie

[1.] Isabelle Cambron et Mathieu Cuvelier. La programmation en premiereannee basee sur l’enrichissement progressif de micromondes multi agents,2006.

[2.]JAVA :www.sun.comwwww.fr.wikipedia.org/wiki/Java %28langage%29

[3.] Simula :http ://fr.wikipedia.org/wiki/Simula

[4.]David Chappel. Au coeur de Activex et Ole, 1997.

[5.] Polymorphisme :www.tchno-science.net/ ?onglet=glossaire&definition=5282www.pps.jussieu.fr/ riffet/JAVA/polymorphisme.html

[6.]Machine a etat :Langage et traducteurs - [INGI 2132] par le Pr. Baudouin Le Charlier (2006)

[7.]Effet de bords :www.linux-france.org

[8.]Python :www.python.org

[9.]Programmation oriente agent :www.csc.liv.ac.uk

[10.] Definition de Logo :http ://fr.wikipedia.org/wiki/Logo (langage)

178

[11.] Logo : Seymour Papert. Mind-Storms Children, Computers and Po-werful Ideas. The Harverster Press, 1985.www.histoire.info.online.fr

[12.] Peter Van Roy and Seif Haridi. Concepts, Techniques, and Modelsof Computer Programming. MIT Press, 2004.

[13.] Qtk. Graphical User Interface Design for Oz.www.mozart-oz.org/documentation/mozart-stdlib/wp/qtk/html/.

[14.]Environnement Mozart :www.mozart-oz.org/

[15.]EBNF :fr.wikipedia.org/wiki/Forme de Backus-Naurfr.wikipedia.org/wiki/EBNF

[16.]www.sigcse.org

[17.]Henry M WALKER. Do computer games have a role in the class-room, SIGSCE Bulletin Vol 35, num 4, dec 2003

[18.] Squeak :www.squeak.org/

[19.]Smalltalk :www.smalltalk.org

[20.]Eclipse :www.eclipse.org/

[21.]ObjectKarelS. Xinogalos . ObjectKarel : A didactic Microworld for Teaching ObjectOriented Programming, SIGSCE Bulletin, Volume 35, Issue 3 (September2003)

[22.] Agregation :www.saintluc-liege.be/Admin BD/Documents/programme%20agr%C3%A9gation.pdf

[23.]Academie de l’informatique :www.academieinformatique.be/centre.php

179

[24.]ADA : femmes et nouvelles technologieswww.ada-online.org/

[25.]L’universite des Aınes :www.uda.ucl.ac.be/

[26.]Diagramme de sequence :Cours de Genie Logiciel - [LINF2251] par Pr. Robert Darimont et Pr. Axelvan Lamsweerde (2006)

[27.]Modularite :http ://www-ic2.univ-lemans.fr

[28.] Modelisation objet :www.commentcamarche.net/poo/poointro.php3

180

Annexe A

Cours

A.1 Premier Cours : Les debutants avec le

logiciel - Micromonde 1

A.1.1 Introduction

Bonjour a tous et merci de votre presence pour ce cours d’introductiona la programmation. Celui-ci se fait, comme vous le savez, dans le cadre denotre memoire : « Cours de programmation base sur l’enrichissement pro-gressif des micromondes multiagents ».

Le but est donc de vous faire decouvrir les fondements de la programma-tion au travers d’un cours theorique et pratique. Le langage utilise importepeu. Notre but est donc que vous compreniez l’entierete des outils que nousallons mettre a votre disposition sans que ne subsistent de questions.

Durant ces seances nous allons aborder plusieurs concepts tels que procedures,variables, agents, recursion... Nous esperons qu’a la fin du cours tous cesconcepts soient clairement definis pour chacun d’entre vous.

Ce cours est experimental. Cela veut donc dire qu’il est possible quecertaines choses ne soient parfois pas expliquees suffisamment a votre gout.N’hesitez pas a nous demander des explications supplementaires, nous sommesla pour cela aussi ! Nous esperons egalement recevoir un feedback sur ce quevous aurez appris, ce que vous aurez moins bien compris, ce qu’il faudraitchanger, ameliorer ou sur n’importe quelle autre chose dont vous voudrieznous faire part.

Nous allons aborder la matiere par “micro-monde” c’est a dire qu’a chaque

181

etape, lors de l’introduction de nouveaux concepts, nous allons elargir lemonde dans lequel nous travaillons. Le premier sera des lors assez basique,mais les mondes se complexifieront au fil des seances. Certains elements pour-ront paraıtre obscurs au debut mais se verront eclaires par la suite. Cepen-dant si des zones d’ombres persistent n’hesitez pas a nous poser des questions.

Un tout grand merci pour votre aide qui nous est grandement utile. Com-mencons donc immediatement.

A.1.2 Les agents

Definition :Un agent est une entite avec laquelle il est possible de com-muniquer grace a un certain nombre de messages bien definis qui peuventetre compris par cet agent.

Un agent peut donc recevoir des messages et agir en consequence. Il peutegalement envoyer lui-meme un message a un autre agent qui reagira. Ilpeut donc y avoir plusieurs agents qui communiquent entre-eux et qui inter-agissent.

Pour commencer nous allons nous contenter d’un seul agent a qui nousallons envoyer des messages. Par la suite nous introduirons d’autres agentsqui seront capables d’interagir entre eux.

Pour envoyer un message a un agent il faut utiliser la commande Send :

{Send Agent message}

Remarque : La syntaxe en Oz (le langage que nous utilisons pour ecrire nosprogrammes) impose d’utiliser des lettres majuscules pour commencer lesnoms de procedures (ici : Send ; nous aborderons le concept de proceduredans un cours ulterieur) ainsi que pour les noms de variables (ici : Agentet Message ; nous aborderons ce concept de variable un peu plus tard dansce cours). N’oubliez donc pas de bien respecter les lettres minuscules oumajuscules lors du debut de mots !

Agents predefinis

1. L’agent Browser :L’agent Browser est un agent qui permet d’afficher dans la fenetre d’af-fichage (le Browser) ce que vous lui demandez.

{Send Browser coucou} % affiche ’coucou’ dans l’afficheur

182

Remarque : Le “%” indique ici qu’il s’agit d’un commentaire. Dansvos programmes vous pourrez ecrire des lignes de commentaires dela meme facon. Ainsi, ces lignes ne seront pas prises en compte lorsde l’execution du programme. L’utilite des commentaires est grandepuisque ceux-ci permettent d’eclairer des zones de codes avec des ex-plications comprehensible par d’autres personnes que le programmeurou bien peuvent servir de rappel pour le codeur lui meme.

2. L’agent Turtle :L’agent Turtle est la tortue visible au milieu de l’ecran. Voici la listedes messages compris par cet agent : tableau A.1

{Send Turtle message}

{Send Turtle forward(X)} demande a la tortue d’avancer de Xpixel(s)

{Send Turtle penUp} demande a la tortue de lever le crayon{Send Turtle penDown} demande a la tortue de baisser son

crayon{Send Turtle left(X)} demande a la tortue de tourner vers

la gauche d’un angle de X degres{Send Turtle right(X)} demande a la tortue de tourner vers

la droite d’un angle de X degres{send Turtle color(C)} demande a la tortue de changer la

couleur son crayon (C = green, red,blue, yellow, black, purple oupink)

Tab. A.1 – Messages compris par la Tortue

La tortue peut par exemple se deplacer de la maniere suivante :

{Send Turtle penDown}{Send Turtle forward(X)}

183

La tortue s’oriente de la maniere suivante :

A.1.3 L’interface

Voici l’interface que nous allons utiliser lors de nos seances d’exercices,il y a 3 grandes parties dans cette interface : le notepad , le Browser et lafeuille de dessin.

184

Le Notepad

Le notepad est l’endroit ou nous allons ecrire les messages qui seront envoyes al’agent. En dessous du notepad se trouvent un certain nombre d’informationset de boutons

1. Line et Char : ces deux informations indiquent la ligne a laquelle setrouve le curseur ainsi que le caractere dans la ligne ;

2. Run : en appuyant sur ce bouton la ligne de commande ecrite dans lenotepad va etre verifiee. Si cette ligne est correcte et si le message adestination de l’agent est correct, la ligne sera acceptee et le messagesera envoye a l’agent. Par contre, si la ligne de commande ou le messagene sont pas valides, l’instruction sera refusee et il y aura une erreur.

3. Clear Screen : remet le monde de l’agent dans son etat initial.

le Browser

Le Browser L’agent Browser permet l’affichage de differents elements dans lafenetre d’affichage (le Browser) en lui envoyant un message {Send Browser

...}.

Send Browser coucou % coucou

X = 2 % on assigne la valeur 2 a la variable XSend Browser X % 2

185

Definition : Les variables sont des raccourcis vers des valeurs stockeesen memoire. L’identificateur X est le nom donne a la nouvelle variable. Unidentificateur commence toujours par une lettre majuscule, suivie de lettresmajuscules, minuscules, ou de chiffres. La valeur 2 est stockee en memoire etpeut etre recuperee grace a l’identificateur X. Une variable peut etre localeou globale. Si une variable est locale, elle ne sera definie que dans une portionde code, et ne sera donc pas accessible dans le reste du code. Par contre sila variable est globale, elle sera accessible a partir de n’importe quel endroitdans le code. Ces deux concepts de « variable locale » et « variable globale »seront illustres ulterieurement.

Une variable peut egalement etre liee ou non. Lorsque l’on declare unevariable :

X

cette variable n’est pas encore liee. Pour qu’elle soit liee, il faut lui assi-gner une valeur :

X = 3

Une fois qu’une variable est liee, elle l’est jusqu’a la fin du programme(ou, s’il s’agit d’une variable locale, jusqu’a la fin de la portion de code pourlaquelle elle est definie). On ne peut donc plus lui assigner une autre valeur.Il est possible de declarer une variable, et de la lier plus tard.

X % declaration de la variable X{Send Browser X} % le browser n’affiche aucune valeur car X n’est

% pas encore lie. Il affiche seulement“ ”% (ou “X”)

{Delay 2000} % introduit un delai de 2000 micros seconde% soit 2 secondes

X = 2 % la valeur 2 est assignee a X. Le “ ” (ou% “X”)affiche par le browser est remplace par 2

Remarques :– La procedure Delay 1000 (delai) permet de faire une pause de 1000 mil-

lisecondes (1 seconde) dans le programme. Le programme s’interromptdonc pendant 1 seconde et reprend ensuite son execution la ou il enetait ;

– une suite de caracteres qui ne commence PAS par une majuscule nesera pas une variable. Il s’agira alors d’un atome ;

186

– La fenetre d’affichage permet egalement la gestion des erreurs. S’il ya, par exemple, une faute de frappe dans une instruction, un messageconcernant cette erreur apparaıtra lors de la verification de l’instruc-tion ;

La feuille de dessin

La feuille de dessin est le monde dans lequel la tortue evolue. Ce mondepermettra de visualiser l’effet des messages envoyes a l’agent.

La feuille de dessin est un tore, c’est-a-dire que lorsque l’agent depasseune des limites de l’espace de dessin, il reapparaıt de l’autre cote. Ce systemepermet de ne pas couper les dessins en plein milieu.

187

Il nous reste alors la barre de menu qui est assez explicite. Nous y re-trouvons les fonctionnalites “New”, “Save”, “Open”, “Help” comme dansbeaucoup d’autres programmes.

Il y a neanmoins certaines choses qui valent la peine d’etre observees.Tout d’abord, le menu “Edit” contient l’option “Delay”, qui permettra de

determiner le temps que va prendre l’agent entre chacune des instructions quilui seront envoyees. Un plus grand delay ralentira donc l’agent, et permettrade mieux voir ce qu’il fait. Le menu “Kill” lui permet de tuer les agents. Cemenu s’averera utile lorsque par megarde vous aurez envoye a un agent touteune serie d’instructions qui risquent de prendre beaucoup de temps, ou quirisquent meme de ne jamais s’arreter !

Kill All Turtles servira, comme son nom l’indique, a arreter les agentsTurtle. Kill All Metronomes servira dans un cours ulterieur.

188

A.1.4 Les instructions

Definition : Une instruction est une ligne de code qui permet de realiserune certaine tache.

Pour communiquer avec un ordinateur par exemple, tout se fait grace a uncertain nombre d’instructions. Lorsque nous allons communiquer avec l’agentTurtle, nous allons egalement lui envoyer des instructions. Par exemple :


est une instruction qui envoie a l’agent Turtle le message forward(100). Cen’est evidemment pas pratique d’ecrire pour chaque tache qui doit etre ef-fectuee une instruction separement.

Pour cela, nous allons par la suite voir des optimisations que sont les“fonctions” et les “procedures”, qui permettront d’envoyer en seulementquelques instructions un grand nombre de taches a l’agent.

Exemple :

{Send Turtle penDown}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle right(30)}{Send Turtle forward(100)}{Send Turtle right(120)}{Send Turtle forward(100)}{Send Turtle right(120)}{Send Turtle forward(100)}{Send Turtle left(135)}{Send Turtle forward(141)}{Send Turtle left(135)}{Send Turtle forward(100)}{Send Turtle left(135)}{Send Turtle forward(141)}{Send Turtle left(135)}{Send Turtle forward(100)}

189

{Send Turtle penDown}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}

A.1.5 Exercices

Pour lancer le programme il suffit d’ouvrir un terminal, de vous placerdans le repertoire contenant le programme et de taper la ligne de code sui-vante : ozengine TurtleGraphics.oza

Passons aux exercices :

1. Dessinez un triangle de cote 80.

2. Dessinez le meme triangle de cote 100 mais d’une autre couleur.

3. Placez la tortue sur le cote de la page de dessin avant de commencez adessiner.

4. Essayez de trouver d’autres formes simples a dessiner.

5. Dessinez une croix dont les barres ont une longueur de 100 et utilisezdes couleurs differentes pour chacune des deux barres.

6. Dessinez la lettre M

190

A.2 Deuxieme Cours : Procedures - Micro-

monde 2

A.2.1 Les procedures

Definition : On appelle procedure un sous-programme qui permet d’ef-fectuer un ensemble d’instructions par un simple appel de la procedure. Uneprocedure peut etre vue comme une suite d’instructions a laquelle on a donneun nom, un peu comme une recette de cuisine. Pour definir une procedure,il faut :

1. indiquer par le mot cle proc que l’on veut definir une nouvelle procedure ;

2. donner un nom a la procedure ;

3. marquer la fin de la procedure par le mot cle end.

proc{Carre}{Send Turtle penDown}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}{Send Turtle forward(100)}{Send Turtle left(90)}

end

{Carre}

A.2.2 Les arguments

Il est possible de passer des arguments a une procedure, c’est-a-dire luifournir une valeur ou le nom d’une variable afin que la procedure puisse effec-tuer des operations sur ces arguments, ou grace a ces arguments. Le passaged’arguments a une procedure se fait en ecrivant les arguments separes parun espace suivant immediatement le nom de la procedure, toujours entre lesaccolades.

191

Lors de l’appel de la procedure, le nombre et le type d’arguments doitcorrespondre au nombre et au type d’arguments dans la declaration de laprocedure. Sinon il y aura une erreur lors de la compilation... Les argumentssont uniquement definis dans la procedure, ce sont donc des variables localesqui n’existent pas en dehors de la procedure. On dit que leur portee estlimitee a la procedure.

A.2.3 Procedures et arguments

Nous allons maintenant modifier la procedure Carre definie precedemmenten lui ajoutant un argument X qui sera la taille d’un cote du carre. X rem-placera le 100 dans le message forward(X). Ainsi il sera possible de creer descarres de taille differente.

proc{Carre X}{Send Turtle penDown}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}{Send Turtle forward(X)}{Send Turtle left(90)}

end

{Carre 200}{Carre 100}{Carre 50}

La procedure Repeat

Une procedure particuliere mais neanmoins fort importante est la procedureRepeat.

{Repeat N P}

Cette procedure permet de repeter N fois la procedure P. Souvent il estplus efficace de repeter certains blocs d’instructions plutot que de les ecrire

192

plusieurs fois. Grace a cette procedure nous pourrons realiser par la suite desurprenants dessins.

La procedure Cercle

Un second exemple est la procedure qui dessine un cercle :Pour dessiner un cercle, il suffit de demander a la tortue d’avancer d’un petitpas, de tourner d’un petit angle, d’avancer d’un petit pas, de tourner d’unpetit angle, et ainsi de suite jusqu’a avoir tourne de 360 degres au total.Pour ce faire, nous allons bien entendu utiliser la procedure Repeat N P, ouN est le nombre de fois que l’on veut repeter la procedure P. Il faudra repeterces 2 actions de maniere a ce que la tortue fasse au total un angle de 360degres.Nous definissons tout d’abord une procedure nommee Cercle qui fera avanceret tourner la tortue. Ensuite cette procedure est repetee 360 fois de manierea dessiner un cercle. La procedure Repeat N P prend donc 2 arguments : Net P. Il faut tout d’abord lui passer pour N le nombre 360 (degres) et ensuitepour P le nom donne a la procedure :

{Cercle}

Attention ! il ne faut pas oublier de demander a la tortue de baisser lecrayon pour voir le cercle dessine !

proc{Cercle}{Send Turtle forward(1)}{Send Turtle left(1)}

end

{Send Turtle penDown}{Repeat 360 Cercle}

Une autre facon de dessiner un cercle est l’utilisation de la procedureRepeat : Rappelons que {Repeat N P} repete N fois la procedure P. Ilest possible de dessiner le meme cercle en creant la procedure a l’interieurdu“Repeat”. P n’est donc plus le nom de la procedure qui dessine le cercle(un lien vers cette procedure) mais c’est la procedure qui definit le cercle enelle meme. Le mot cle “proc” est toujours utilise, mais il n’est plus necessairede lui donner un nom puisque la procedure ne sera pas appelee explicite-ment, d’ou la notation proc {$}. Le $ defini un nom sans importance pour

193

la procedure. La notation suivante est alors utilisee : proc {$} ... end. Onpeut egalement voir ces 2 mots cles comme de simples delimiteurs des ins-tructions a repeter.

{Send Turtle penDown}{Repeat 360 proc{$}

{Send Turtle forward(1)}{Send Turtle left(1)}

end}

Pourquoi deux types de declaration de procedures ?

L’interet de pouvoir appeler une procedure par son nom est de ne pasdevoir la reecrire a chaque utilisation. Un interet double puisque d’abord ily a gain de temps pour le programmeur qui ne doit la definir qu’une seulefois puis simplement l’appeler : {Procedure } Ensuite un gain de place enmemoire, une seule ecriture de procedure suffit.

Mais il y a un bemol a ce type d’appel. En effet lorsque nous faisons appela une procedure prealablement definie, le programme doit retourner jusqu’al’emplacement de sa definition pour pouvoir l’executer. Le temps qu’il utilisea “sauter” d’un endroit du programme est donc perdu.

C’est pourquoi le second type de declaration existe : si la procedure nedoit etre utilisee qu’une seule fois, alors pas besoin de la definir puis deperdre son temps a l’appeler. La definition se fait directement a l’endroit oul’on desire qu’elle s’execute : proc{$} ... end

A.2.4 Dessins procedurals

Nous allons presenter ici quelques exemples de dessins que vous pouvezrealiser grace aux connaissances accumulees.

Une fleur

Voici pour commencer le dessin d’une fleur. Ce dessin est un exempleassez complet utilisant les concepts simples expliques jusqu’a present. Pourdessiner la fleur nous aurons besoin de differentes choses :

1. Une procedure {QCercle} qui va dessiner un quart de cercle (pour for-mer les petales) ;

194

proc{QCercle}{Repeat 45 proc{$} {Send Turtle forward(2)} {Send Turtle

left(2)} end}

remarquez que l’on repete deux fois un left(2) ce qui fait bien 90 ;

2. Une procedure {Petale} qui va dessiner un petale de la fleur en utilisantla procedure {QCercle}. Un petale n’est rien d’autre que 2 quarts decercle ;

proc{Petale}{Repeat 2 proc{$} {QCercle} {Send Turtle left(90)} end}

end

3. Une procedure {Fleur} qui va dessiner la fleur. La fleur est dessinee icicomme un ensemble de 10 petales (d’ou le right(36) car 10 ∗ 36 = 360) ;

proc{Fleur}{Repeat 10 proc{$} {Petale} {Send Turtle right(36)} end}textttend

4. une procedure {Plante} qui dessinera la fleur accompagnee d’une tige ;Comprenez bien les 3 procedures donnees car elles vont vous servir adessiner la plante.

N’oubliez pas qu’une plante n’est pas noire donc il faut egalement ajouterdes couleurs ! Voici la ligne de code qui permet de demander a la tortue dechanger la couleur de son trait :

{Send Turtle color(green)}

Vous devriez obtenir un dessin semblable a celui-ci :

195

Un Oeil

Dessiner un oeil a la main peut sembler fort complique, mais nous allonsici vous montrer comment realiser ce dessin de maniere fort simple. Il suffitde dessiner une multitude de carres en tournant chaque carre d’un petit anglede maniere a faire un tour complet. Il suffit de deux procedures :

1. une premiere procedure pour dessiner un carre (nous choisirons un cotede longueur 80) ;

2. une seconde procedure qui va repeter le dessin d’un carre et modifierl’angle de dessin afin de faire un tour complet.

proc{Carre}{Repeat 4 proc{$} {Send Turtle forward(80)} {Send Turtle right(90)}

end}end

proc{Oeil}{Send Turtle penUp}% on deplace la tortue une fois que le dessin est fini

{Send Turtle forward(200)}% pour bien visuliser le dessin

196

Un donut

Un autre exemple de dessin est celui du donut. La facon de procederressemble fort a celle de l’oeil. Il suffit a nouveau de deux procedures :

1. une premiere procedure pour dessiner un cercle ;

2. une seconde procedure pour repeter le dessin du cercle, un leger deplacementet le changement de l’angle pour chaque cercle. Un conseil, ce dessinprend beaucoup de temps pour la tortue, veillez donc a reduire le delaidans le programme.

proc{Cercle}{Repeat 90 proc{$} {Send Turtle forward(2)} {Send Turtle right(4)}

end}end

{Send Turtle penDown}{Donut}

A.2.5 Exercice

1. Ecrivez une procedure pour dessiner une maison.Indice : vous pouvez utiliser le code de la maison fourni dans le cours1 pour realiser la procedure.

197

2. Dessinez un carre de taille fixe en utilisant la procedure Repeat N P ;

3. Modifiez votre programme de maniere a pouvoir choisir la taille ducarre.

4. Modifiez le programme de l’oeil (3.2) de maniere a ce que l’iris soitbleu.

5. Realisez la plante a l’aide des procedures fournies dans ce cours.

6. Realisez serie de maison sachant que certaines procedures peuvent etreutilisees plusieurs fois avec des parametres differents.

198

A.3 Troisieme Cours : Operateurs et expres-

sions conditionnelles - Micromonde 2

A.3.1 Les operateurs

Avant de passer a des dessins et des concepts plus compliques, il esturgent d’aborder certaines specificites du langage Oz. Commencons par par-courir la liste des operateurs arithmetiques classiques dans le tableau A.2Voici quelques exemples simples pour illustrer ces concepts :

+ Addition- Soustraction∗ Multiplication

div Division entiere/ Division rationnelle

mod Modulo (reste de ladivision entiere)

Tab. A.2 – Operateurs Binaires

{Send Browser 1+1} % 2{Send Browser 1-1} % 0{Send Browser ~2∗2} % -4{Send Browser 3 div 2} % 1{Send Browser 3.0/2.0} % 1.5{Send Browser 4 mod 3} % 1

Remarques importantes : Dans le langage Oz comme dans beaucoupd’autres langages il existe differentes manieres de representer les nombres enfonction de si on desire les representer comme des entiers (appeles integer etnotes 1, 2,...) ou des nombres avec virgule (appeles float et notes 1.0, 2.0,...).C’est pour cela que ci-dessus deux types de divisions sont donnees :

1. / : division pour les nombres a virgule

2. div : division pour le nombre entier, le reste est donne par l’operateurmod

Quelques exemples pour clarifier :

{Send Browser 2/1} % erreur{Send Browser 2/1.O} % erreur{Send Browser 2.0/1.0} % ok

Un autre element a noter en l’en-

199

== Egalite\= Difference< strictement plus petit

=< Plus petit ou egal> strictement plus grand

>= Plus grand ou egale

Tab. A.3 – Operateurs binaires (suite)

codage des chiffres negatifs qui se fait avec un “˜” devant le chiffre, ainsi -2s’ecrit en Oz ˜2 (cfr les exemples ci-dessus)

Continuons avec la liste des operateurs binaires les plus courant dont vousallez sans doute avoir besoin lors d’exercices (tableau A.3).

Voici des exemples pour illustrer ce tableau :

{Send Browser 1 == 1} true{Send Browser 1 \1} false{Send Browser 3 > 2} true{Send Browser 3 =< 2} false

Le browser affiche l’atome “true” ou “false”, celui-ci est nomme booleenet exprime simplement le vrai ou faux (0 ou 1) dans une comparaison. Lebooleen a d’autres utilite mais nous ne nous attardons pas dessus a ce niveau.

Notons que “==” represente l’egalite, etant donne que “=” est deja uti-lise pour l’affectation.

X = 1 % affectationY = 1

X == Y % test d’egalite

A.3.2 Les expressions conditionnelles

if... then... else... end

La commande if est une commande conditionnelle, c’est-a-dire qu’elle vapermettre de poser une condition dans le programme. Si cette condition estremplie le programme executera une serie d’instructions, sinon il en executerad’autres.

200

if <x1> then % <x1> est la notation pour une condition

<s1> % <s1> est la notation pour une suite

% d’instructions

elseif <x2> then %

<s2>

else

<s3>

end

Si la condition x1 est remplie, s1 est execute. Sinon, si la condition s2 estremplie, s2 est execute. Sinon, s3 sera execute.

Exemples :

1. Y = 3 if Y \= 3 then

{Send Browser erreur}else

{Send Browser correct}end

2. X = 3

if X > 3 then

{Send Browser plusGrand}elseif X < 3 then

{Send Browser plusPetit}else

{Send Browser egal}end

Le if tout seul existe aussi. Dans ce cas le code entre if et le end n’estexecute que si la condition if est remplie. Tout ce qui suit sera de toutemaniere execute.

X = 3

if(X == 3) then

{Send Browser ‘la valeur de X’}{Send Browser ‘vaut trois’}

end

{Send Browser ‘bonjour’}

201

Si vous modifie la valeur de X vous verrez que ‘bonjour’ s’affiche toujoursdans le browser.

Patter Matching : case ... of

La commande case of permet de comparer deux elements entre eux, etd’executer la suite du programme en fonction du resultat de cette comparai-son.

case <x>

of <l1> then <s1>

[] <l2> then <s2>

[] <l3> then <s3>

else

<s4>

end

On compare x d’abord a l1. Si les deux elements correspondent (il s’agitd’une correspondance sur la forme), s1 sera execute. Sinon, on passe a laprochaine ligne. x sera alors compare a l2, puis a l3 s’ils ne sont toujourspas de la meme forme et ainsi de suite (il peu y avoir beaucoup de cas “[]”).Dans tous les autres cas, c’est-a-dire si aucune correspondance n’est trouvee,s3 sera execute.

Exemple :

case Msg of coucou then

Send Browser coucou

[] salut then

Send Browser salut

else

Send Browser auRevoir

end

On voit clairement dans cet exemple que la reconnaissance se fait sur laforme du message “Msg”.

Plusieurs conditions

a. andthenDans certains cas il peut etre interessant de n’executer qu’une partie du

202

code que si deux conditions (ou plus) sont reunies. Il existe deux maniere dele traduire dans le langage que nous utilisons :

– La premiere possibilite consiste a emboıter les expressions condition-nelles les unes dans les autres :

X = 2

Y = 4

if(X mod 2) == 0 then

if(Y mod 2) == 0 then

{Send Browser ‘les deux sont pairs’}end % le end du second if

else

{Send Browser ‘un des deux est impairs’}end

– le seconde possibilite est une sorte de raccourcis (appele sucre syn-taxique en informatique) de l’ecriture ci-dessus :

X = 2

Y = 4

if((X mod 2) == 0 andthen (Y mod 2) == 0) then

{Send Browser ‘les deux sont pairs’}else

{Send Browser ‘un des deux est impairs’}end

b. orelseIl peut etre aussi interessant de pouvoir tester si une condition parmi plu-

sieurs est remplie, le systeme est le meme que pour le andelse :

Definition d’une variable a l’interieur d’une fonction/procedure

Il est possible de creer une variable a l’interieur d’une fonction/procedure.Pour ce faire, on utilise le mot cle in.

proc{Test X}

if(X < 3) then Y in

Y = X

203

{Send Browser Y}

end

% ici Y n’existe plus !!!

% {Send Browser Y} generera une erreur !

end

{Test 2}

La variable Y existe a partir de sa definition jusqu’au prochain mot cle end.Sa portee est donc limitee entre le in et le end. Cette variable n’existe bienentendu pas non plus a l’exterieur de la procedure.

A.3.3 Exercices

Expressions Conditionnelles

Creez une procedure qui, en fonction de l’argument binaire qu’elle pren-dra (1 ou 0), desinera un cercle ou un carre. Vous pouvez pour ce faire utiliserles procedures Cercle et Carre realisees aux seances precedentes.

Creez une procedure qui en fonction de l’argment numerique qu’elle prend,envoie des messages differents a la tortue (forward, left, center, color, etc.).Vous dessinerez ensuite diverses figures en utilisant cette procedure plutotqu’en envoyant directement les messages a la tortue.

Pattern Matching

Modifiez la procedure que vous venez de creer afin d’utiliser le paternmatching a la place des expressions conditionnelles.

Modifiez cette procedure pour qu’elle prenne en argument des atomes.Essayez de creer une procedure qui permette a un utilisateur qui ne comprendpas l’anglais de manipuler la tortue grace a des termes francais (avance,droite, gauche) etc. Par exemple {BougeTortue avance 20} enverra a l’agentTurtle forward(20).

204

A.4 Quatrieme Cours : Nouvelle structure de

donnees : Les Listes - Micromonde 2

A.4.1 Definitions

Une Structure de Donnees : Est un ensemble d’informations (ayant unpoint commun) organise de maniere structure.

Pour illustrer ce concept il est possible de revenir au monde reel : parexemple un dictionnaire est une structure de donnees puisqu’il contient unensemble de mots suivis de leur definition et est structure sur l’ordre al-phabetique.

Une Liste : est soit un atome nil (representant la liste vide) soit une pairetete/queue. La tete d’une liste est son premier element, la queue est tout lereste. Le dernier element de la queue est egalement l’atome nil qui definitainsi la fin de la liste.

Notons que la liste est une structure de donnees tres particuliere puis-qu’elle repose sur le principe de recursivite. Ce concept est tres important eninformatique mais egalement assez complexe. Nous allons donc l’aborder icivia les listes (il sera vu plus en details par la suite).

Il existe deux notations pour les listes :

1 | 2 | 3 | 4 | 5 | nil == [1 2 3 4 5]

Remarquons que dans la premiere notation le nil de fin est explicite alorsque dans la deuxieme notation il est implicite.Ici il s’agit d’une liste d’entier mais on pourrait imaginer une liste d’atomes :

[voici une liste d atomes] = voici|une|liste|d|atomes|nil

Ou encore une liste de listes :

[1 2 [3 4 5] 6 [7 8]] == 1 | 2 | (3 | 4 | 5 | nil) | 6 | (7 | 8 | nil) | nil

On definit dans la notation EBNF1 la liste comme :

1Extend Backus-Naus Form : Notation standard en informatique permettant de for-maliser les concepts syntaxiques

205

<List> ::= nil

| <Value> ’|’ <List>

Si nous traduisons cette notation en francais cela donne : Une liste est soitcomposee d’un atome nil, soit composee d’une valeur suivie d’une autre liste.Aussi les elements suivants sont bien des listes :

– [3 2 1]Assez evident ici, puisqu’il s’agit d’une valeur (3) suivie d’une liste(2 | 1 | nil).

– [2 1]Meme principe que ci-dessus : une valeur (2) suivie d’une liste (1 | nil).

– [1]Il s’agit bien d’une valeur (1) suivie d’une liste (nil) puisque le premierterme de la definition specifie que l’atome nil est bien une liste.

– nilNous revenons au premier terme de la definition : l’atome nil.

Par l’exemple ci-dessus il est egalement possible de se rendre compte ducote recursif des liste puisqu’une liste est definie a partie d’une liste.

A.4.2 Operations sur les listes

Acceder aux elements d’une liste

Il est indispensable de pouvoir acceder aux differents elements d’une listeet pour cela il faut se rappeler que celle-ci est une tete et une queue :L = [H—T].

Il est donc facile d’acceder au premier element, il suffit de faire L.1.

La ou cela se complique c’est pour acceder aux autres elements.Comme la liste est recursive il faut donc considere la queue comme une listea proprement dit et donc pour acceder au deuxieme element : L.2.1 (si ondecompose, L.2 est la sous-liste [2 3 4 5] et L.2.1 est donc le premier elementde la sous-liste).

L = [1 2 3 4 5]

{Send Browser L.1} % 1

{Send Browser L.2} % [2 3 4 5]

206

{Send Browser L.2.2.2.1} % 4

Ajout d’element

Il existe deux maniere differentes d’ajouter un element a une liste. Eneffet suivant que l’on desire insere un element devant la liste ou derriere lamarche a suivre n’est pas la meme.Pourquoi ? Simplement parce qu’avec le nil qui termine la liste il est plusdifficile d’ajouter des elements derriere.

Dans le premier cas (ajout devant) il suffit de faire l’operation suivante :

X = [4 3 2 1]

Y = 5|X % l’operateur "|" nous permet de fusionner les

% deux listes dans l’ordre ecrit

Z = 6|5|X

W = [6 5]|X % ceci ne fonctionne pas de la meme maniere puis-

% qu’il ajoute toute la liste comme premier element

{Send Browser Y} {Send Browser Z}

Le second cas est un peu plus delicat. Il faut d’abord enleve le nil defin de liste, ensuite, ajouter les elements un par un et pour finir terminer lanouvelle liste par un nil.Heureusement pour nous il existe une fonction2 en Oz qui permet de le faired’une fois.

{Append [Liste] [Listebis]}

L = [1 2 3 4 5]

Liste = {Append L [6]}

{Send Browser Liste}

Notons immediatement que la fonction Append (dont le fonctionnementprecis sera explique au cours prochain) prend deux listes en arguments doncsi on ne veut ajouter qu’un seul element il faut le mettre sous forme de liste :[X].

2La definition exacte du mot fonction viendra plus tard dans le cours, pour le momentil suffit de considerer que c’est une procedure qui renvoit un resultat.

207

Suppression d’element

Pour retirer des elements d’une liste on ne prend qu’une partie de celle-cicomme vu ci-dessus avec L.2. Les elements enleves sont donc toujours lespremiers de la liste.

L = [1 2 3 4 5]

L.2 % nous renvoit [2 3 4 5] donc bien une partie de la liste

% Le 1 a donc bien ete supprime.

A.4.3 Exercices

1. Passez cette expression de liste dans l’autre notation (avec nil expli-cite) :

[1 [2 3 [4 5] 6] 7 8 [9]]

2. Dans la liste suivante, trouvez le moyen d’acceder au ”7”

[1 2 [3 4 5] 6 [7 8]]

3. Comment creer la liste [1 2 [3 4 5] [a b] 6 [7 8]] (pensez a deconstruireet reconstruire la liste)

208

A.5 Cinquieme Cours : La Recursion - Mi-

cromonde 2

A.5.1 Theorie

Definition : On dit qu’une procedure est recursive si elle s’appelle elle-meme. La recursivite permet, tout comme la fonction Repeat, de repeterplusieurs fois une action. Dans la recursivite on distingue souvent 2 cas :

1. le cas de base, dans lequel la procedure se termine ;

2. le cas recursif, dans lequel se trouve l’appel recursif afin de boucler.

Attention ! toutes les instructions ecrites apres l’appel recursif seront sauve-gardees sur la pile (stack)3 pour pouvoir etre executees par la suite !

Un exemple simple :Voici un exemple qui consiste a faire plusieurs forward les uns apres les autresen utilisant la recursion :

proc{MoveForward X}

if(X == 0)

then skip % fin de la procedure

else


{Delay 1000}

{MoveForward X-1} % appel recursif de la procedure

end

end


{MoveForward 3} % appel de la procedure

Remarques :

1. X represente le nombre de fois que l’on souhaite executer un forward,c’est-a-dire le nombre d’appels recursifs qui seront effectues ;

2. Le mot cle skip est utilise pour quitter une procedure. Cette instruc-tion permet donc de sortir de la procedure et le programme se termine ;

3La pile est l’endroit de la memoire ou sont enregistrees les instructions ainsi que lesvariables.

209

Comment fonctionne ce programme ?

1. on appelle le programme avec ’3’ comme argument.

2. le programme teste si X est different de 0. Ce n’est pas le cas car Xvaut 3. Le programme entre donc dans le else et demande a la tortued’avancer de 25. Le Delay 1000 est la uniquement pour permettre devisualiser la recursivite. Une fois la seconde ecoulee, le programme rap-pelle la procedure Forward en decrementant 4 l’argument (c’est-a-direX) de 1 ;

3. X vaut maintenant 2. 2 etant different de 0, le programme entre anouveau dans le else et la tortue avance de 25. Un nouvel appel recursifest ensuite effectue avec X - 1 ;

4. X vaut maintenant 1. 1 etant toujours different de 0, la tortue avancea nouveau de 25 et la procedure est rappelee avec X - 1

5. X vaut maintenant 0. Le programme entre donc dans la condition if(X== 0) et tombe sur l’instruction skip. Le programme quitte donc laprocedure et se termine.

Dessiner une spiraleVoyons maintenant comment faire des dessins en utilisant la recursivite. Com-mencons par un dessin de spirale :

procSpirale X

if(X < 100) then

{Send Turtle forward(X)}{Send Turtle right(45)}

{Spirale X+1}else

skip

end

end

{Send Turtle penDown}{Spirale 1}

4Decrementer signifie diminuer, soustraire.

210

Observez ce qui se passe lorsque l’on change l’angle right(45) en right(70).Vous devriez obtenir le dessin suivant :

Dessiner un arbreLe dessin d’un arbre est un exemple typique de dessin qui utilise la recursion.L’objectif est de dessiner un arbre tel que celui de la figure ci-dessous.

La difficulte consiste a identifier l’arbre comme un probleme recursif.Voyez-vous les differents sous-problemes ? L’arbre consiste en un tronc avecdeux petites branches attachees, auxquelles on attache encore 2 petites branches,et ainsi de suite. Il existe deux approches pour limiter le nombre de branchesde l’arbre. Premiere approche La premiere approche va nous permettre d’ex-primer la profondeur, c’est-a-dire le nombre d’etages de l’arbre, lors de l’appelde la procedure recursive.

211

A.5.2 Premiere Approche

La procedure Arbre aura alors 2 arguments :– Size, la longueur des branches.– Depth, la profondeur de l’arbre ;

proc{Tree Size Depth}

if(Depth == 0) then

skip % fin de la procedure

else




% appel recursif pour la partie gauche



% appel recursif pour la partie droite





end

end

{Send Turtle left(90)} {Send Turtle penDown} {Tree 200 5}\\

La tortue commence donc par dessiner le tronc. Ensuite elle pivote a gaucheet l’appel recursif est fait avec Size div 2 pour que les branches soient pluspetites et Depth - 1 pour indiquer que le premier etage est termine.Afin de comprendre comment ce programme fonctionne, examinons l’ordredans lequel les instructions sont executees.

Supposons ici que l’on execute le programme {Tree 100 2} afin de sim-plifier l’explication. La premiere colonne represente les instruction executeespar la tortue et la deuxieme represente la pile d’instructions :

212

La tortue execute donc un forward suivi d’un left. Ensuite il y a un appelrecursif, les instructions qui n’ont pas pu etre executees (c’est-a-dire cellesqui suivent l’appel recursif) sont sauvees sur la pile et l’appel recursif est fait.Le programme revient donc au debut de la procedure.

Le scenario est le meme : les instructions qui suivent l’appel recursif sontsauvees sur la pile. La pile est une pile LIFO (Last in, First out, un peucomme une pile d’assiettes). Les instructions mises en dernier sur la pile sontau sommet de cette pile. L’appel recursif est fait :

Le programme se retrouve a nouveau en debut de procedure, et cette fois-ci Depth == 0 est vrai ! Le programme tombe sur l’instruction skip et la

213

procedure se termine. A ce moment la les instructions restantes sur la pilevont etre executees. La tortue va donc executer les 2 instructions entourees :right et l’appel recursif.

Apres avoir execute le right et l’appel recursif qui etaient sur la pile, leprogramme revient en debut de procedure et cette fois encore Depth ==0 est vrai ! On tombe sur l’instruction skip et la procedure se termine. Lesinstructions qui restent sur la pile sont executees. La tortue va donc executerles 6 instructions entourees :

Apres avoir execute les instructions et l’appel recursif, le programme seretrouve au debut de la procedure. Cette fois-ci Depth == 0 est faux. Latortue execute alors a nouveau un appel recursif :

214

Une fois que le programme arrive a l’appel recursif il faut sauver sur la pileles instructions qui suivent cet appel. Apres l’appel recursif le programmearrive au debut de la procedure et Depth == 0 est vrai ! On tombe sur l’ins-truction skip et la procedure se termine. Les instructions qui sont sur la pilesont alors executees :

Apres avoir execute right et l’appel recursif, Depth == 0 est vrai. La procedurese termine donc et les instructions restantes sur la pile sont executees :

215

OUF ! C’est fini ! En reprenant la liste des instructions executees par la tortueon peut constater qu’elle dessine bien un arbre avec 2 branches. Si mainte-nant la procedure Tree 200 5 est executee, on obtiendra le meme arbre queci-dessus.

A.5.3 Seconde Approche

La deuxieme approche pour dessiner le meme arbre consiste a garderle nombre de branches de l’arbre superieur a un minimum raisonnable, parexemple 4. Voici comment proceder :

procTree Size

if(Size < 4) then

skip

else



Tree (Size div 2)

Send Turtle right(40)

Tree (Size div 2)





end

end


Send Turtle penDown

Tree 200

216

A.5.4 Exercices

En vous basant sur le principe utilise ci-dessus, dessinez un soleil. Voiciquelques indices pour vous guider :

1. Creer une procedure Soleil a 2 arguments, Longueur et Angle :

Soleil Longueur Angle ;

2. Tester si la longueur est plus petite que 400, par exemple (400 seraalors la longueur maximale du trait) ;

3. Cas recursif : avancer de ”Longueur”, tourner de ”Angle” degres (l’angledoit etre legerement superieur a 180 de maniere a dessiner les rayonsdu soleil, 185 par exemple), rappeler la procedure en incrementant lalongueur (de 2 par exemple) ;

4. Cas de base : sortir de la procedure.

Vous devriez obtenir un dessin semblable a celui-ci :

217

Dessinez une toile d’araignee a 6 cotes dont la fonction prend en pa-rametre le nombre de couche qui la compose et la longueur des cotes dupremier hexagone.

Dessinez une ondulation (en utilisant le message giveYourState).

218

A.6 Sixieme Cours : Multi-Turtles - Micro-

monde 3

A.6.1 Agent : Rappel de le definition

Comme vu precedemment lors du premier cours, un agent est une entiteavec laquelle il est possible de communiquer grace a un certain nombre demessages bien definis qui peuvent etre compris par cet agent.

Un agent peut donc recevoir des messages et agir en consequent. Il peutegalement envoyer lui-meme un message a un autre agent qui reagira. Ilpeut donc y avoir plusieurs agents qui communiquent entre eux et qui in-teragissent. Jusqu’a present nous nous sommes contentes d’un seul agent, latortue, a qui nous avons envoye des messages deja predefinis.Nous allons maintenant examiner d’autres aspects concernant les agents :leur etat, leur cerveau, la communication entre differents agents, etc.

A.6.2 Etat

Chaque agent possede son propre etat qui peut etre compose d’elementsvaries. L’etat d’un agent correspond a l’etat dans lequel il se trouve a unmoment donne.

Etat de la tortue

Examinons l’etat de notre tortue que nous connaissons maintenant sibien :


L’etat de la tortue est compose de 5 elements distincts :

1. son nom : la tortue presente dans le monde s’appelle ‘Turtle’. Lorsquel’on cree une nouvelle tortue il est preferable lui donner un nom. Cenom est un atome (cf cours 1) ;

2. sa position : la position est composee de deux coordonnees, X et Y.Ces coordonnees permettent de situer la tortue dans l’espace a deuxdimensions qu’est le monde dans lequel elle evolue. Les coordonneesX et Y sont mises a jour lors de chaque deplacement de la tortue,c’est-a-dire lors de chaque reception d’un message de type forward(N) ;

219

3. sa direction : la direction permet de memoriser vers quelle direction latortue est actuellement tournee. A chaque envoi de message left(N) ouright(N) cette direction est mise a jour ;

4. PenDown : il s’agit d’un booleen (vrai ou faux) qui indique si le crayonde la tortue est actuellement pose ou non. Le booleen passera a vrailors de la reception d’un message du type penDown, et repassera a fauxlors de la reception d’un message penUp ;

5. et sa couleur : il s’agit tout simplement de la couleur dans laquelleles traits du crayon apparaissent a l’ecran. Un choix de 7 couleurs estpossible : rouge (red), bleu (blue), vert (green), jaune (yellow), noir(black), mauve (purple) et rose (pink).

L’etat de la tortue peut etre vu en cliquant une fois dessus a l’aide dubouton gauche de la souris.L’etat de la tortue est donc compose de plusieurs elements. Un structure dedonnees un peu particuliere est utilisee pour le representer : le tuple.

Les Tuples

Un tuple est compose d’un label suivi d’un ensemble d’elements.– le label est le nom donne au tuple. Dans notre cas, le tuple se nomme

”state” ;– les elements du tuple sont l’ensemble des composants de l’etat (nom,

position, etc.). Le fait que l’etat soit un tuple represente un certainavantage. En effet, notre tuple ”state” pourrait se recrire de la fa¸consuivante :

Etat = state(1 :Name 2 :X 3 :Y 4 :Direction 5 :PenDown 6 :Color)

Chaque element est donc numerote, en commencant a 1. Grace a cela, lesinformations contenues dans le tuple peuvent etre accedees tres facilement.Par exemple, pour trouver le nom de l’agent, il suffit d’ecrire

Etat.1 % renvoie l’element occupant la premiere position

% dans le tuple

Exemple :

220

Etat = state(turtle 200 300 45 true blue)

{Send Browser Etat.5} % blue

{Send Browser Etat.3} % 300

% Un tuple peut contenir un autre tuple

X = test(100 tuple(200 300) 400)

{Send Browser X.2} % tuple(200 300)

{Send Browser X.2.2} % 300

Obtenir l’etat de la tortue dans une variable

Nous savons que nous pouvons visualiser l’etat de la tortue en cliquantdessus. Mais si maintenant nous avons besoin d’avoir cet etat dans une va-riable afin de l’utiliser dans un programme, la technique est fort differente.Le principe est le suivant :

– Definir une variable non liee (cf Cours 1) ;– Envoyer un message a la tortue en lui demandant de mettre son etat

actuel dans cette variable. La tortue va lier la variable a son etat ;– On peut alors lire et utiliser cette variable.

X % variable non liee

{Send Turtle giveYourState(X)}

{Send Browser X} % la variable est liee et contient

% l’etat de la tortue

A.6.3 Cerveau

Vous l’avez sans doute deja decouvert mais l’agent tortue possede unecertaine intelligence, bien qu’elle soit limitee. En effet, elle ne comprendqu’un certain nombre de messages bien determines. Dans le cadre du cours6 vous aurez l’occasion de creer vous memes vos propres agents et de definirleur propre intelligence. L’intelligence d’un agent n’est rien d’autre qu’unensemble de messages auxquels une action est associee.

A.6.4 Creation d’un nouvel agent tortue

Comment creer un nouvel agent tortue ? Voici la question a laquelle nousallons tenter de repondre dans la section qui suit.Commencons tout d’abord par introduire un nouveau concept : les fonctions.

221

Une Fonction est comme une procedure si ce n’est qu’elle est introduitepar le mot cle fun et non plus proc, et qu’elle renvoie un resultat, une valeurdite “valeur de retour”.

Exemple :Procedure :

proc {CarreP X Solution}

Solution = X*X

end

X

{CarreP 2 X} % la solution est conservee a l’interieur

% de la procedure

{Send Browser X} % affiche 4

Fonction :

fun {CarreF X}

X*X

end

Y = {CarreF 2} % la fonction CarreF renvoie une valeur qui

% est associee a Y

{Send Browser Y} % affiche 4

{Send Browser {CarreF 2}}

La Fonction NewTurtlePour creer une nouvelle tortue on utilise la fonction X = NewTurtle State.

La fonction renvoie un nouvel agent tortue. Le nouvel agent est associe al’identificateur X. Le cerveau de cet agent est identique a celui de la tortued’origine. Il repond donc aux memes messages mais possede son propre etat.Lorsque l’on cree une nouvelle tortue il faut lui passer comme argument sonetat initial State.Attention ! il faut passer le tuple avec tous les parametres de l’etat en pa-rametre a la fonction. L’ordre de ces parametres a de l’importance. Un etatcorrect est par exemple le suivant :

state(maTortue0 200 200 0 false black)

Cet etat representera une tortue appelee ’maTortue’ positionnee en (200,200)avec une direction de 0, un crayon leve et une couleur de crayon noire. Unefois la nouvelle tortue creee, elle est prete a recevoir des messages.

222

MaTortue = NewTurtle

state(tortue 200 200 0 true

yellow)

procSquaggle

{Send MaTortue forward(50)}{Send MaTortue right(150)}{Send MaTortue forward(60)}{Send MaTortue right(100)}{Send MaTortue forward(30)}{Send MaTortue right(90)}

end

{Repeat 20 Squaggle}

{Send Turtle penDown}{Send Turtle forward(100)}

A.6.5 Concurrence

La concurrence apparaıt lorsque deux ou plusieurs activites independantespeuvent etre executees simultanement. Il ne devrait y avoir aucune interferenceentre ces activites, a moins que le programmeur ne decide qu’il est necessairequ’elles communiquent entre elles.Le programme avec les deux tortues a la figure ?? est deja un programmeconcurrent puisque les deux tortues realisent leur dessin simultanement et demaniere independante.

Nous vous presentons ici un autre exemple de concurrence dans lequelquatre tortues vont apporter leur contribution a la realisation d’un dessincommun :

T1 = {NewTurtle state(’mat’ 440 340 270 true black)}T2 = {NewTurtle state(’mat’ 440 440 180 true black)}T3 = {NewTurtle state(’mat’ 340 440 90 true black)}{Send Turtle penDown}

proc{Carre T X}

if(X =< 0) then {Send T penUp}{Send T forward(200)}skip

else

223

{Send T forward(X)}

{Send T right(91)}

{Carre T X-3}

end

end

{Carre Turtle 100} {Carre T1 100} {Carre T2 100} {Carre T3 100}

A partir du moment ou il y a plusieurs agents dans un programme et queceux-ci agissent simultanement, le programme est un programme concurrent.

A.6.6 Exercices

1. Le but de l’exercice est de realiser un visage tres simple, comme le des-sinerait un enfant, mais utilisant plusieurs tortues en concurrence. Chaquetortue realisera une partie du visage independamment des autres tortues.Vous aurez besoin de sept tortues distinctes.Voici la demarche que nous vous proposons de suivre :

– Creez sept tortues, positionnez-les a des endroits strategiques (une tor-tue pour la bouche, une tortue pour le nez, une tortue pour chaqueoreille, une pour chaque oeil et une pour les cheveux) ;

– Creez chacune des procedures necessaires. Vous pouvez mettre la tortueen argument de maniere a rendre vos procedures generales :

procNez T Send T ... ... endPour les yeux, reprenez la procedure que vous avez realisee au cours2 ;

224

– Votre dessin devrait ressembler a ceci :

2. Ecrire une procedure qui donne le nom de la tortue (qui est le premierchamp de son etat). Faites de meme avec une fonction.

3. Dessinez le logo des jeux olympiques avec une tortue par cercle. (at-tention aux couleurs)

4. Dessinez un terrain de foot. Une tortue fait les lignes exterieures. Uneautre tortue fait la ligne centrale (+ rond centrale) et une troisieme qui faitles petits et grands rectangles de chaque cote.

225

A.7 Septieme Cours : Le Temps - Micromonde

4

A.7.1 Objectif

L’objectif de cette seance est de mettre en evidence la concurrence ainsique la communication entre differents agents. Ce cours s’appuie sur un autretype d’agent predefini, le Metronome.

A.7.2 L’Agent Metronome

Il existe un autre agent predefini, dans le logiciel Logoz, qui est un agentde type “Metronome”. Il permet d’envoyer exactement toutes les secondes unmessage a d’autres agents. Cet agent n’est rien d’autre qu’un active object,tout comme la tortue. Il a donc besoin d’une fonction de transition et d’unetat. Comme pour la tortue, la fonction de transition est deja existante dansle logiciel. Il suffit donc, pour creer l’agent, de lui fournir son etat. Voici lasyntaxe utilisee :

MyClock = {NewMetronome State}

La fonction “NewMetronome” prend un seul argument : State. Quel estl’etat d’un tel agent ? Il envoie un message a un certain nombre d’agents.Il s’attend donc a avoir le message a envoyer et une liste d’agents auxquelsil doit envoyer le message. L’etat de notre nouvel agent est donc un tuplecompose de deux variables :

– la liste des agents a qui il doit envoyer le message ;– le message a envoyer a ces agents.

state([Agents] Msg)

Les agents dans la liste d’agents peuvent etre de n’importe quel type,qu’ils soient des agents Turtle ou des agents que vous aurez definis vous-memes. Bien sur le message qui sera envoye doit pouvoir etre compris parchacun des agents se trouvant dans la liste.

Les messages acceptes par l’agent Metronome

Voici un tableau reprenant les messages que l’on peut envoyer a un agentde type Metronome :

226

start Demarre le Metronomestop Arrete le Metronome

register(Agent) Ajoute un agent a la liste des agents auxquelsil faut envoyer un message

message(Msg) Definit le message Msg a envoyer aux agentsclear Reinititalise l’etat du metronome a state(nil nil).

La liste d’agents est vide ainsi que le message a envoyer

Prenons un exemple concret : imaginons que l’on souhaite faire avancernotre tortue de 100 pas toutes les secondes. Voici deux facons de proceder :

Premiere facon

on definit l’etat du metronome lors de sa creation .

{Send Turtle penDown}MyClock = {NewMetronome state([Turtle] forward(100))}{Send MyClock start}

Deuxieme Facon

on definit un etat vide (le mot cle nil signifie qu’on ne met rien dans letuple) et on definit ensuite l’agent a qui l’on souhaite envoyer le messageainsi que le message a envoyer. Cet exemple sert a illustrer l’utilisation desmessages register(Agent) et message(Msg).

{Send Turtle penDown}MyClock = {NewMetronome state(nil nil)}{Send MyClock register(Turtle)}{Send MyClock message(forward(100))}{Send MyClock start}

Pour arreter la tortue, il faut arreter l’agent Metronome. Pour cela, ilsuffit de lui envoyer un message stop, ce qui arrete le metronome. Nouspouvons aussi cliquer sur le bouton AllMetronome dans le menu deroulantKill du logiciel. Ceci va detruire tous les metronomes crees. Si vous utilisez cebouton, vous devrez recreer tous vos metronomes car ils auront ete detruits.

227

A.7.3 Exemple

{Send Turtle kill}% supprime l’agent Turtle

T1 = {NewTurtle state(’t1’ 440 340 270 true green)}T2 = {NewTurtle state(’t2’ 100 200 0 false blue)}MyClock = {NewMetronome state(nil nil)}

{Send MyClock register(T1)}{Send MyClock register(T2)}{Send MyClock message(forward(100))}{Send MyClock start}

A.7.4 Exercice

Dessinez un carre toutes les secondes.

A.7.5 Exercices de revision

Procedure VS fonction

Passez la fonction suivante en procedure :

fun{Double X}

X*2

end T = 125 {Send Turtle forward({Double T})}

Liste, pattern matching et recursion

Faites une fonction ou une procedure qui a partir d’une liste donnee ren-voit une nouvelle liste contenant les elements plus petits que X

signature de la methode : {PlusPetit [] X}

228

A.8 Huitieme Cours : Les Agents - Micro-

monde 5

A.8.1 Objectifs

L’objectif de ce cours est d’apprendre a creer des agents autres que desagents Turtle et des agents Metronome. Ces agents auront un comportementpropre, defini par le cerveau que leur createur leur attribuera. Nous nousfocaliserons dans ce cours sur la creation d’un agent horloge, qui afficheral’heure sous forme d’une montre a aiguilles.

A.8.2 Creation d’un nouvel agent

Nous allons maintenant nous interesser a la creation d’un agent. Jusqu’apresent nous avons cree des agents dont la fonction de transition (c’est-a-direson cerveau) etait integree au logiciel. En d’autres mots, nous ne pouvionspas definir le comportement de l’agent (tortue et Metronome).Dans cette section, nous nous interessons a la creation d’agents dont le com-portement sera defini a l’aide d’une fonction de transition que nous allonsdefinir nous-memes. De quoi avons-nous besoin pour creer un agent ?

1. une fonction de transition pour definir son comportement (cerveau) ;

2. un etat initial

Tout comme pour la creation d’une tortue, il existe une fonction permettantde creer un nouvel agent :

MonAgent = NewAgent FonctionTransition Etat

La fonction NewAgent renvoie le nouvel agent cree et associe ce dernier al’identificateur MonAgent. Cette fonction possede deux arguments : la fonc-tion de transition et l’etat initial. La fonction de transition de l’agent (soncerveau) doit etre une fonction definie par l’utilisateur. L’etat initial doit etrel’etat dans lequel l’agent se trouvera lors de sa creation. Nous allons mainte-nant voir comment il est possible de definir une fonction de transition.

Definir une fonction de transition pour un agent

Une fonction de transition prendra en regle generale 2 arguments :

229

1. un message : ce message correspond aux messages que recoit l’agent.En fonction du message recu l’agent effectuera une action. Cette tech-nique est communement appelee”message passing” (echange de mes-sage). L’action effectuee peut etre, par exemple, l’envoi d’un messagea un autre agent, un deplacement ou l’affichage d’une information.

2. un etat : il s’agit de l’etat interne de l’agent. Celui-ci permet a l’agentd’avoir une memoire. Cette memoire peut l’aider a prendre certainesdecisions ou tout simplement permet de memoriser des informations.

Remarque : Le message peut soit etre un atome, soit un tuple, ce quipermet d’envoyer beaucoup plus d’informations en une fois. L’etat peutegalement etre un tuple, ce qui permet a l’agent de memoriser differentesinformations (par exemple sa position, sa couleur, etc.)

Voici un exemple de fonction de transition qui se comporte comme uncompteur :

fun{Cerveau Msg State}

case Msg

of tick then

{Send Browser State+1}

State+1

else

{Send Browser ’I do not understand’}

State

end

end

Comment fonctionne cette fonction ?Des que l’agent va recevoir un message il va l’inspecter a l’aide du patterncase of (cf cours 3). Si le contenu correspond a un des messages connus parl’agent, alors une action predefinie sera executee. Dans notre exemple, onsouhaite implementer un petit compteur. Des qu’un message tick est envoyea notre agent compteur, celui-ci va incrementer son etat et l’afficher.

Attention ! Une fonction renvoie toujours une valeur. L’element que ren-voie la fonction doit etre le nouvel etat de l’agent !. Dans le cas d’un messagetick le nouvel etat est l’ancien etat incremente. Dans le cas d’un autre mes-sage, c’est-a-dire un message que l’agent ne comprend pas, le nouvel etat estle meme que l’ancien (comme s’il ne s’etait rien passe). En ce qui concerne lacreation de l’agent “Compteur”, on lui passe comme fonction de transition

230

celle que nous venons de definir et comme etat initial 0.

Voici un exemple complet :

Il est bien entendu possible d’utiliser l’agent Metronome pour envoyerdes messages tick toutes les secondes a notre agent Compteur. Dans ce cas,il faudrait remplacer les {Send MonAgent tick} par l’appel au Metronomeque nous avons deja vu precedemment :

MyClock = {NewMetronome state([Compteur] tick)}{Send MyClock start}

A.8.3 Exercice : une horloge

Pour cet exercice vous allez devoir implementer une horloge en utilisantles concepts d’agents et d’echange de messages comme nous les avons etudiesplus haut. L’agent Metronome est evidemment indispensable pour menera bien cet exercice. Nous mettons a votre disposition deux fonctions quivont vous permettre de dessiner une ligne a l’ecran (afin de representer lesaiguilles) et d’effacer une ligne (afin de pouvoir faire bouger les aiguilles) :

fun{Cerveau Msg State}

case Msg

of tick then

{Send Browser State+1}

State+1

else

{Send Browser ’I do not

understand the message’#Msg}

State

end

end

Compteur = {NewAgent Cerveau 0} {Send Compteur tick} {Send

Compteur tick} {Send Compteur tack}

231

Fonction permettant de dessiner une ligne :

Tag = {DrawLine Size Direction Color}

Cette fonction possede trois arguments :– Size qui permet de definir la longueur de la ligne que l’on dessine a

l’ecran (en pixel) ;– Direction qui permet d’orienter la ligne que l’on dessine a l’ecran (en

degres). L’orientation est la convention trigonometrique classique ;– Color qui permet de definir la couleur de la ligne que l’on dessine a

l’ecran.

Cette fonction renvoie ce que l’on appelle un Tag qui permet d’identifier laligne dessinee. Ce Tag va permettre de retrouver une ligne qui a ete dessineeet de l’effacer par la suite.

Procedure permettant d’effacer une ligne :

{DeleteTag Tag}

Cette procedure possede comme seul argument Tag. Elle supprime l’imagea l’ecran identifiee par le Tag.

A.8.4 Autres exercices

Creez un agent basique(une balle) qui peut se deplacer sur la feuille dedessin(drawBall, MoveTag). Cet agent doit comprendre au moins les mes-sages suivants : up(X) , left(X) , right(X) et down(X) qui deplace la balledans la direction(up,left,right,down) de X pixels. (attention : left(ou right)n’a pas le meme effet que pr la tortue, ici ca pivote pas, ca se deplace vers la

232

gauche(ou droite)).

Creez un agent de calcul qui comprend les messages suivants et affiche lareponse dans le browser :

– plus(X Y) - affiche le resultat de X+Y– moins(X Y) - affiche le resultat de X-Y– fois(X Y) - affiche le resultat de X*Y– div(X Y) - affiche le resultat de X / Y

Variante : Cet agent doit pouvoir prendre des ’integers’ aussi bien quedes ’floats’. (utiliser Float.is X et Int.is X)

233

A.9 Neuvieme Cours : Test de mi-parcours

et explication du projet

A.9.1 Test (20 points)

1. Definitions (2 points)

Definissez avec vos mots, et de maniere la plus correcte possible– Agent– Procedure– Liste– Concurrence

2. Programmation de base (5 points)

A l’aide de la tortue, dessinez le schema suivant

Vous creerez une procedure qui determine l’angle d’orientation de la tortue,Si la tortue est orientee vers la droite, elle avancera, tournera a gauche, avan-cera et tournera encore a gauche.Si la tortue est orientee vers la gauche, elle avancera, tournera a droite, avan-cera et tournera encore a droite.

Vous utiliserez la fonction {repeat} pour arriver au schema final. Indice :utilisez le message giveYourState pour connaıtre l’etat de la tortue.

234

3. Recursion (5 points)

A l’aide de la tortue, dessinez le schema suivant. Vous utiliserez uneprocedure recursive qui dessine une portion composee d’une droite et d’unangle droit. Chaque appel recursif verra la taille de ces droites augmenter.Trouvez un moyen pour que la fonction ne boucle pas indefiniment.

4. Concurrence (5 points)

Course de tortues !Creez 2 tortues en plus de la Turtle (une qui ecrit jaune, et une qui ecritbleu), et placez les de part et d’autre de celle-ci sur la meme ligne verticale.Vous appellerez un certain nombre de fois une procedure qui fera avancerchacune de ces tortues d’une distance aleatoire ( vous utiliserez la valeur(random mod 50) pour determiner cette distance)Que la tortue la plus chanceuse gagne !

5. Debug (3 points)

Voici un morceau de programme pour lequel l’environnement logoz ren-verra une erreur. Identifiez les erreurs et corrigez le code de maniere a ce quele programme s’execute correctement.Justifiez vos modifications (ecrivez les en commentaires dans votre code).

proc{Tree size depth}

if(Depth = 0) then skip

else

{Send Turtle forward (Size)}


{Tree Size div 2 (Depth-1.0)}

235


{Tree Size Div 2 Depth-1}

{Send Turtle Left(20)}


{Send Turtle forward(size)}


end

{Send Turtle left(90)} {Send Turtle PenDown}

236

A.9.2 Projet : Pong

Afin de prouver que vous avez bien acquis les concepts enseignes au coursainsi que votre capacite a les mettre en oeuvre dans le cadre d’un programmeinformatique de plus grande ampleur, vous allez devoir realiser un petit pro-jet.

Il vous est demande de creer un jeu du type Pong. Dans ce type de jeu,deux joueurs se renvoient une balle a l’aide de palettes.

Vous realiserez que ce projet contient trois agents principaux : la balle,la palette de droite et la palette de gauche. Il vous faudra programmer lescerveaux de ces 3 agents de maniere a ce qu’ils puissant constituer le jeufinal.Vous pourrez egalement ajouter un agent Compteur de points.

La premiere etape consiste a analyser la projet afin d’en retirer les differentescas d’utilisation et les differents messages que les agents devront s’envoyer.

Il vous faudra ensuite programmer les cerveaux des agents en fonction deces messages, comme vu au cours 8.

237

Pour vous aider, nous vous indiquons les signatures des cervaux des 3agents principaux :

fun{BrainBall Msg state (PosX PosY Angle Tag) }

fun{BrainPaddleR Msg state(PosX PosY Tag) }

fun{BrainPaddleL Msg state(PosX PosY Tag) }

Tag correspond aux images des palettes et de la balle.

Pour modifier la position des Tags, on utilise la procedure :

{MoveTag Tag X Y}

ou tag est l’image a bouger, et X et Y les nouvelles coordonnees de l’image

La functions qui permettent d’envoyer un message en cliquant sur unetouche (par exemple “F1” est la suivante :

{Window bind(event:"<F1>" action:proc{$} {Send Agent msg } end )}

Ce projet est a programmer dans l’interface Ping pong world de LogOz.

238

A.10 Dixieme Cours : Introduction aux dia-

grammes

A.10.1 Objectifs

A l’approche d’une formation a la creation d’applications plus impor-tantes, il semble necessaire d’apprendre a construire celles-ci correctementselon des standards qui seront utilises dans le monde professionnel et dansles cours de programmation plus avances.

Dans cette optique, ce cours presentera les syntaxes graphiques et lesprincipes de deux types de diagrammes : les diagrammes de sequences, et lesdiagrammes d’etat.

A.10.2 Diagrammes de sequence[18]

Interet

Le but d’un diagramme de sequence est de pouvoir visualiser un scenario5

complet, il represente un exemple typique de comportement attendu desagents du systeme.

Pour obtenir le comportement complet d’un systeme il est imperatif derepresenter plusieurs diagrammes de sequence, un pour chaque cas d’utilisa-tion. L’ensemble de ces diagrammes permet donc de visualiser l’ensemble desliens entre les agents. Lors de l’etape d’implementation, on peut ainsi verifierqu’aucun n’oubli n’a ete fait notamment au niveau des differents messagesqu’un agent peut recevoir (ou envoyer).

Exemple

Nous allons tout d’abord considerer un scenario simple, issu de la viede tous les jours : commander un verre dans un cafe. pour ce scenario troisagents sont actifs :

– Client : Il appelle le barman, donne sa commande et regle l’addition.– Serveur : Prends la commande, le donne au barman, la recupere et

l’amene au client.

5Un scenario est une suite temporelle d’evenements correspondant a des interactionentre les agents.

239

– Barman : Une fois qu’il a la commande, il l’a prepare et la donne auserveur.

Fig. A.1 – Diagramme de sequence

Le graphique de la figureA.1 nous donne un exemple de diagramme desequence pour ce scenario. Remarquons qu’il s’agit bien d’un scenario etqu’il ne represente pas l’ensemble des possibilites d’interaction entre ces troisagents.

Syntaxe graphique

Comme nous l’avons dit precedemment les diagrammes de sequence sontutilises aussi bien dans des cours plus avances que dans le cadre professionnel.C’est pourquoi une certaine harmonisation est necessaire pour que chacunpuisse “traduire” les diagrammes des autres. La syntaxe graphique est doncla suivante :

1. Chaque agent est represente par un rectangle6 contenant une etiquettea son nom.

6ou un bonhomme s’il s’agit d’agent de l’environnement mais nous ne nous enpreoccuperons pas dans ce cours

240

Fig. A.2 – Diagramme d’etat d’une porte

2. La ligne verticale represente pour chaque agent une ligne du temps.Plus une action est etendue verticalement, plus longue est sa realisation.L’evolution de temps se fait du haut vers le bas.

3. Les arcs horizontaux representent la transmission d’un evenement d’in-teraction entre deux agents (pouvant etre identiques), par exemple latransmission d’un agent vers un autre.

4. L’etiquette d’un arc est le nom de l’evenement.

5. La longueur des intervalles de temps entre deux interactions n’a pas designification.

6. L’alignement de deux arcs au meme point temporel signifie la simul-taneite des interactions correspondantes.

A.10.3 Diagramme d’etat

Interet

Un autre type de diagramme qu’il est interessant d’envisager est le dia-gramme d’etat (egalement machine a etat). Ce diagramme ne se concentreque sur un seul agent et decrit les tous les enchaınements possibles de sonetat interne.

Exemple

Prenons un nouvel exemple pour illustrer ce type de diagramme. Suppo-sons un agent “porte”. Les etats qui le caracterisent sont :

– Porte ouverte– Porte fermee

Le diagramme d’etat se trouve a la figure A.2.

Le diagramme d’etat permet donc de verifier que tous les etats internesd’un agent ont ete envisages dans l’implementation de l’agent concerne.

241

Syntaxe graphique

Tout comme pour le diagramme de sequence, le diagramme d’etat possedeune syntaxe propre et quelques proprietes en vue d’etre compris de tous.

1. Un etat dans un diagramme d’etats a generalement une certaine duree(non representee) : l’objet reste un certain temps dans cet etat.

2. On distingue deux etats particuliers :– L’etat initial : c’est l’etant lors de son apparition dans le systeme

represente de la maniere suivante :– L’etat final : c’est son etat lors de la sortie du systeme (ou de

son entree dans un systeme plus grand) represente de la maniere

suivante :Notons que tous les diagrammes d’etat n’ont pas necessairement d’etatde sortie. Dans l’exemple de la porte, il n’y a pas de condition pourque celle-ci sorte du systeme d’ou l’absence d’etat final.

3. Chaque etat est represente par un rectangle contenant son nom.

4. Les arcs entre les etats representent les transition entre les differentsetats.

5. Les etiquettes des arcs represente l’action qui induit un changementd’etat dans l’agent.

A.10.4 Un exemple

Afin d’illustrer les principes qui viennent d’etre introduit, nous allonsrealiser ensemble les diagrammes illustrant de deux exemples d’applicationmulti agents bien connus : l’horloge et le metonome. Bien entendu, il s’agitd’une application “a l’envers”du principe habituel, etant donne que nousavons dans ce cas ci deja realise l’application. Cependant, cela nous permet-tra d’avoir un premier contact avec ce principe de modelisation d’applicationtout etant certain d’avancer sur le bon chemin.

L’horloge

Un petit rappel : L’agent Metronome envoie un tick a chaque secondea l’agent Seconde, celui-ci, une fois que son compteur interne arrive a 60,envoie un message a l’agent Minute et ainsi de suite.

242

Fig. A.3 – Diagramme de sequence de l’horloge

Nous vous demandons de reflechir au diagramme de sequence le pluslogique.Quelques pistes pour commencer le diagramme :

– Bien definir le scenario qui nous interesse (ou se situe le debut, la fin,quelles sont les actions prises en compte,...)

– Identifier les agents actifs dans ce scenario– Reperer les liens entre eux (ne pas oublier les interaction automatique)– . . .La solution se trouve a la figure A.3.

Le Metronome

Pour rappel, l’agent Metronome peut envoyer toutes les secondes un mes-sage a une liste d’agent. Il est important de ne pas oublier les etats ou lemetronome n’aurait pas d’agent, ou bien pas de message a envoyer.

243

Fig. A.4 – Diagramme de sequence de l’horloge

Nous vous proposons d’essayer de realiser un diagramme d’etat pour lemetronome.Quelques pistes :

– Definir avec precision l’agent duquel on s’occupe– Identifier les differents messages que peut recevoir l’agent concerne et

regarder s’ils modifient son etat interne– Verifier les liens entre les etats– . . .Le diagramme d’etat du metronome se trouve a la figure A.4.

A.10.5 Exercices

Diagramme de sequence

L’exemple donne ci-dessus (commander un verre) n’est qu’un des dia-grammes de sequence possible. En effet d’autres interactions entre ces troisagents peuvent etre interessantes a modeliser, nous vous en proposons quelquesune en exercices :

– Le verre est offert au client.– La commande arrivee n’est pas la bonne, il faut donc en refaire une.– Le serveur n’a plus de monnaie, il doit en demander au barman.– Il n’y a plus dans les stocks du barman ce que le client voulait boire.

244

– Alors que le serveur a deja donne la commande au barman, le client luiannonce qu’il change de commande.

Diagramme d’etat

Dans l’exemple que nous avons choisi sur al porte nous avons consideredeux etats seulement, “la porte fermee” ou “la porte ouverte”, que se passe-t-il si nous considerons l’etat “la porte entreouverte” en plus ?

Supposons une machine a laver qui possede deux types de programmes,un programme a froid et un programme 30 , a quoi ressemblerait sa machinea etat ?

245

A.11 Onzieme, Douzieme et Treizieme Cours :

Projet “Space Invaders” - Micromonde

5

A.11.1 Introduction

Deroulement de l’apprentissage

Le but des cours a venir est d’illustrer les etapes de la realisation d’unprogramme de jeu video oriente agents. Le jeu, adaptation en OZ du clas-sique ”Space invaders”, sera realise en classe. Grace aux techniques et rai-sonnements que nous exposerons et discuterons au cours, les etudiants serontcapables de realiser le projet ”Pong” par eux meme.

La premiere seance proposera une discussion sur la transformation d’unenonce en un modele constitue d’agents et d’echanges de messages. Ce modeleest represente par un diagramme d’agents. Nous apprendrons tout d’abordla syntaxe et les regles d’un tel diagramme, et nous realiserons ensuite lediagramme qui traduit notre enonce.

Une fois la modelisation effectuee, nous pourrons nous atteler a l’implementationdu projet. Il faudra creer les differents agents et leur cerveau, s’assurer del’envoi des messages et du traitement de ceux ci.

Le jeu video et la programmation orientee agents

Si nous realisons aujourd’hui des jeux video, c’est parce que leur principes’adapte tout naturellement a la programmation orientee agent. Et si nousavons choisi de dispenser une formation orientee agent, c’est tout simplementparce que cela permet la programmation naturelle des jeux video !

Le principe de base d’un jeu video est le suivant : le joueur controle unpersonnage qui evolue dans un environnement afin de realiser un tache pouratteindre un objectif. Face a ce personnage se dressent des obstacles, fixes oumobiles, intelligents ou non. Le jeu consiste en une sequence d’interactionsentre ces differents elements.

En observant cette definition, on realise a quelle point elle est adapteeau modele oriente agents. En effet, nous pouvons remplacer ”personnage”et ”obstacles” par le terme generique ”agent”, et nous pouvons transformer

246

”interaction” par ”echange de messages”. Nous sommes des lors en presenced’un modele ou des agents s’echangent des messages. Nous pouvons reduiretout jeu video plus ou moins complexe a une echange de message entre agents.C’est ce que nous allons faire dans les lecons suivantes.

Enonce

Le projet consiste en la realisation d’un jeu de type ”Space Invaders”,ou un vaisseau allie doit empecher des creatures extraterrestres d’envahir laterre. Le vaisseau ”defender”, place en bas de l’ecran, ne peux se deplacer quesur l’axe horizontal. Il peut tirer des missiles pour detruire les ennemis. Lesennemis se deplacent en lignes en partant du haut de l’ecran, lateralement etverticalement, et se rapprochant du defender de maniere reguliere. Ils sontaussi capable d’envoyer des bombes. Des meteores sont situes entre le defen-der et les ennemis. Un meteore se reduit (jusqu’a disparaıtre), si il est touchepar un missile allie ou une bombe ennemie ou si il est percute par un ennemi.Un ennemi est detruit si il est touche par un missile allie ou si il entre encollision avec un meteore. Le joueur perd la partie si il est touche par unebombe ennemie, si il entre en collision avec un ennemi, ou si un ennemi at-teint le bas de l’ecran.

Nous devons modeliser les differents agents en presence, determiner lesmessages qu’ils s’echangent, et implementer leur cerveau afin qu’ils reagissentcorrectement aux messages qu’ils recoivent.

Une fois ce projet realise en classe, les etudiants seront libre de modifierle code afin de rendre le jeu encore plus interessant !

A.11.2 Modelisation

Discussion intuitive de la repartition des agents

– Les agents evidents : Defender, Ennemy, Meteore– Les agents implicites : Joueur, Jeu– Les agents de controle : EnnemyLine, BombControleur, MeteoreList

247

Une modelisation du projet : Diagrammes de sequences et dia-grammes d’etats

Les agents et messages

1. Defender– move(X)– getPos( ?X)– shoot– dead– isHit(X ?B)

2. Ennemy– getPos( ?X ?Y)– getTag( ?T)– left– right– down– shoot– isHit(X Y ?B)

3. Meteore– IsHit(X ?B ?D)

4. MeteoreList– isHit(X ?B)

5. EnemmyLine– start– down– left– right– shoot– isHit(X Y ?B– remove(Ref Type)– gameOver

248

Le diagramme de sequence

A.11.3 Implementation

Implementation des agents

L’agent Defender

L’agent EnemyLine

L’agent Enemy

L’agent Meteore

L’agent MeteoreList

A.12 Quatorzieme Cours : Les threads - Mi-

cromonde 5

A.12.1 Concurrence

La Concurrence : On dit d’un programme qu’il est concurrent lorsqueplusieurs morceaux de son code s’executent simultanemment dans leur propre

249

environnement. Il ne peut y avoir d’interference entre ces parties sauf si leprogrammeur le decide.

a. Executions simultanees

La concurrence a deja ete abordee lors de l’utilisation de plusieurs tortues,en effet chacune executait une portion de code en meme temps que les autres.Les mecanismes permettant cette realisation etaient cache par l’instruction :X ={NewTurtle State}.Nous allons voir ici comment dire au programme d’executer plusieurs mor-ceaux de son code en meme temps. Il est alors indispensable de definir lesparties qui peuvent s’executer en meme temps.

Un Thread : Au sens general du terme, un thread est un programmequi s’execute independamment. Plusieurs threads peuvent donc s’executer enmeme temps. Dans le cas present, on peut considerer qu’il existe a la baseun thread principal, le programme. Ensuite, a l’aide de l’instruction thread¡s1¿ end, on cree un nouveau thread qui execute la suite d’instruction ¡s1¿.

Voici la maniere de definir dans l’environnement que nous utilisons lesthreads :

thread <s1> end

Entre le thread et le end se trouve une serie d’instructions qui serontexecutees en meme temps que le reste du programme. Nous pouvons definirplusieurs threads dans un meme programme, voire meme des threads dansd’autres threads.

Exemple :

fun {Gen X N}

if(X<N) then

{Delay 1000} %attente d’une seconde

X|{Gen X+1 N}

else

X|nil % fin de la liste

end

end

Z S % declaration des variables

thread Z = {Gen 1 10}end % thread qui genere une liste de

250

% 1 a 10

thread S = {Gen 100 110}end % thread qui genere une liste de

% 100 a 110

{Send Browser Z} {Send Browser S}

Dans l’exemple ci-dessus, si nous observons le browser nous remarquonsque les deux listes generees dans les threads s’affichent petit-a-petit. On re-marque ainsi facilement que les deux appels de fonctions sont simultanes, etdonc leur execution se fait en parallele.Si vous relancez l’execution de ce code plusieurs fois vous pourrez voir que leslistes ne s’affichent pas toujours dans le meme ordre. Cela est du a la naturedes threads. Puisque leur execution est simultanee, ce n’est pas toujours lememe qui donne le resultat au browser en premier. Cependant, conformementa la definition de la concurrence, cela ne signifie pas qu’ils interferent (puisquetelle n’est pas la volonte du programmeur) et donc a la fin les resultats sonttoujours identiques.

A ce stade il peut etre interessant de voir la difference entre la program-mation sequentielle (c’est a dire comme vu precedemment) et la program-mation concurrente (avec les threads), comment connaitre l’ordonnancementdes instructions,... Pour ce faire nous avons besoin de definir ce qu’est un pasd’execution :

Pas d’execution : Un pas d’execution represente chaque etape dansl’execution d’un programme, c’est-a-dire chaque instruction.

Chaque fleche represente un pasd’execution. Ci a cote est representel’ordre (total) des instructions dans unprogramme sequentiel.

Ci-contre la representation d’unprogramme concurrent avec 5threads. Notons qu’il y a unordre a l’interieur des threads(note par la fleche horizontale) etun ordre entre les threads (flechediagonale).

Il y a donc bien un ordre a l’interieur des threads similaire a l’ordre de laprogrammation sequentielle (ordre de lecture des instructions).

L’ordre entre les threads provient du fait que certains threads doivent

251

attendre des informations que d’autres leur donne. Ils ne peuvent s’executerque lorsqu’ils ont ces informations.

Exemple

X1 X2 Y1 Y2

thread % thread 1

{Browse X1}

end

thread % thread 2

{Browse Y1}

end

thread % thread 3

{Delay 1000}

X1 = toutes|les|routes|X2

end

thread % thread 4

{Delay 1500}

Y1 = all|roads|Y2

end thread

%{Delay 1000} % thread 5

X2 = menent|a|rome|nil

end

thread % thread 6

%{Delay 1500}

Y2 = lead|to|rome|nil

end

Dans cet exemple il y a trois choses a remarquer :– Pour que les threads 3 et 4 s’achevent, il faut que les threads 5 et 6

soient termines puisqu’ils definissent la variables qui terminent les deuxprecedents. Ceci illustre l’ordre entre les threads.

– Si on enleve les commentaires devant les deux Delay des threads 5et 6, le temps que met le browser pour afficher la solution n’est pasmodifie. Pourquoi ? Simplement parce que tous les threads attendenten meme temps donc ca ne ralentit pas le programme (les delay se fonten parallele).

– Les variables utilisees sont declarees avant de commencer les threadspuisque chacun des thread doit les connaıtre, la portee de ces variablesdoit etre globale.

252

b. Communication entre threads

Comme vu dans la definition, le programmeur peut decider de faire com-muniquer les threads entre eux. Il existe un grand nombre de possibilites pourcela, nous allons aborder un probleme classique et pourtant tres utilise : celuidu producteur/consommateur. Pour se faire nous allons introduire la notionde stream :

Un Stream : Un stream est une liste de messages potentiellement non-lies qui sert de moyen de communication pour plusieurs threads.

Envoyer un message a un thread c’est par exemple lier la queue de la listece qui peut permettre au thread de continuer son execution avec l’informa-tion ainsi recuperee. On en deduit donc facilement que recevoir un messageconsiste a lire un element du stream.

Afin de rendre tout ceci un peu plus claire, voici un exemple :

fun {Generate N Limit}

{Delay 1000}

if N<Limit then

N|{Generate N+1 Limit}

else nil end

end

fun {Sum Xs A}

case Xs

of X|Xr then {Sum Xr A+X}

[] nil then A

end

end Xs S

thread Xs={Generate 0 15} end % Producer thread

thread S={Sum Xs 0} end % Consumer thread

{Browse S} {Browse Xs}

Nous observons que le premier thread genere un liste de nombre, il est doncconsidere comme producteur. Le second, quant a lui, consomme les va-riables (ici les nombres) du stream, c’est donc le consommateur.Le stream est donc bien utilise pour passer de l’information d’un thread al’autre.

253

Il est egalement possible d’avoir plusieurs consommateurs du meme streamsans que ceux-ci n’interferrent les uns avec les autres :

Xs S1 S2 S3 in

thread Xs={Generate 0 150000} end

thread S1={Sum Xs 0} end



Chaque tread consommateur recoit les elements du stream independammentdes autres. Les consommateurs n’interferent pas les uns avec les autres puis-qu’ils ne consomment pas vraiment le producteur, ils le lisent. Et donc plu-sieurs sont capables de lire le meme stream.

En plus de producteurs et consommateurs, on peut envisager les traduc-teurs :

Un traducteur : Il lit le stream du producteur et cree un autre stream(a partir de stream producteur) qui est lu par le consommateur.Exemple : Reprenons les deux fonctions utilisees ci-dessus (en enlevant lesdelais qui ne sont plus utiles) et ajoutons y un traducteur qui aura pour butd’enlever les nombres paires de la somme de fin :

fun{IsOdd X Res}

if(X mod 2 \= 0)

then Res = true

else

Res = false

end

end

fun {Filter Xs F}

case Xs

of nil then nil

254

[] X|Xr andthen {F X} then X|{Filter Xr F}

[] X|Xr then {Filter Xr F}

end

end

Xs Ys S in thread Xs = {Generate 0 1500} end

thread Ys = {Filter Xs IsOdd } end

thread S = {Sum Ys 0} end {Browse S}

REM : Un nouveau mot clef apparaıt ici : andthen, celui signifie simplementles deux conditions doivent etre remplies pour que s’execute ce qui se trouveapres le then. Si une seule des deux conditions est remplie alors le programmeagira de la meme maniere qui si aucune n’etait correcte.

255

A.13 Quinzieme Cours : Composition d’agents

- Micromonde 5

Apres avoir decouvert le principe des agents, et alors que nous venonsd’experimenter la realisation de projets de plus grande envergure, nous allonsaborder un theme tres important dans la realisation de programmes orienteagents : la composition d’agents.

Definition : Un agent est constitue d’autres agents s’il utilise ceux-cidans le but d’effectuer la tache qui lui est demandee. Cette imbrication estplus fortement marquee si le “commanditaire” de l’action (l’utilisateur ouun autre agent) n’a pas de contact directs avec les agents qui constituent lesuper-agent. Les sous-agents lui sont alors caches.

Si on decide de creer des programmes qui representent des elements dureel, il est indispensable d’envisager l’existence d’agents plus importants quifonctionnent grace a l’utilisation de plus petits. Plus on se rapproche de larealite, plus il est facile d’imaginer quelles sont ces imbrications.

A.13.1 Un exemple : Le distributeur de boissons

Un exemple simple d’un super-agent compose d’agents plus petits est ledistributeur de boissons. Il est interessant car il est facile de se representer lesdifferents parties qui le constituent, et celles-ci sont aisement modelisablespar des agents.

256

Enonce

Nous devons programmer le logiciel de gestion d’un distributeur de bois-sons. Celui-ci doit, le plus possible, etre conforme a ce qu’on attend habituel-lement d’un appareil de ce type. Il doit servir des cannettes aux utilisateursen echange d’argent et rendre la monnaie. L’utilisateur doit etre capabled’annuler la procedure a tout instant.

Le super agent : L’agent Distributeur

L’agent Distributeur correspond a l’ensemble du logiciel. Son role est defournir des boissons en fonction des desirs de l’utilisateur et de la disponibilitede celles-ci. Il ne doit bien sur offrir de boisson que si le client dispose de lasomme suffisante, et il doit etre capable de rendre la monnaie. L’utilisateurdesire aussi etre informe du prix de la boisson selectionnee.

Un agent imbrique : L’agent CanManager

L’agent CanManager est en charge de tout ce qui concerne les boissons.Cela veut dire que c’est lui qui s’occupe de servir les cannettes au client.C’est aussi lui qui est au courant du niveau du stock de l’appareil.

Un agent imbrique : L’agent CoinManager

L’agent CoinManager s’occupe de tout ce qui est en rapport avec l’argent.Il determine le prix de la boisson desiree, verifie que le client paie le montantexacte, calcule le montant a rendre, et declenche le processus de retour de lamonnaie.

Un agent imbrique : L’agent Displayer

L’agent Displayer est responsable de l’affichage d’informations diverses.Ceci concerne principalement le prix des boissons, le montant qu’il reste apayer, le montant qui va etre rendu, et les messages signifiant que la boissonn’est plus disponible

Pour quelle structure opter ?

Nous sommes dans un modele oriente agent, chaque entite peut doncdiscuter avec toute autre. Cependant, afin d’organiser notre programme demaniere a modeliser parfaitement l’imbrication des trois agents dans l’agentprincipal, il est preferable d’eviter l’envoi de messages entre les sous-agents.Cette technique permet de plus de suivre un modele de programmation axe

257

sur l’agent central, avec une architecture plus simple, et qui evite donc ungrand nombre de problemes que l’on peut rencontrer dans les codes “spa-ghetti” (mal structures).

Nous insisterons donc sur le fait que tous les messages doivent transiterpar l’agent Distributeur, qui s’occupe, en fonction de son etat, d’obtenir lesinformations necessaire et de donner des ordres aux sous-agents.

Vers un perfectionnement de l’agent

Nous encourageons les etudiants, apres l’implementation du principe debase du distributeur, de discuter des possibles ameliorations. Cela peut consis-ter en de nouveaux agents imbriques, ou en de nouvelles capacites de cesagents.

A.14 Cours Supplementaire sur le Reseau -

Micromonde 7

A.14.1 Introduction

Dans les cours precedents, nous avons appris a concevoir des petites ap-plications basees sur la construction d’agents et sur les echanges de messagesentre ces agents. Jusqu’a present, ces agents s’executaient tous sur la mememachine. Ce cours permettra de realiser qu’un langage oriente agent offreune base solide pour le portage d’une application en reseau. Nous compren-drons que seule une simple modification d’implementation est necessaire pourenvoyer des messages vers un agent en reseau.

A.14.2 Les Turtles en reseau dans Logoz

Principe

Chaque utilisateur Logoz peut rendre public ses tortues sur un groupedu reseau. Pour cela, il doit definir un nom de groupe, auxquels les autresutilisateirs pourront se connecter pour envoyer des messages a cette tortue,ou simplement pour suivre ses deplacements sur leur propre canvas. L’utilited’un tel groupe est de pouvoir, en choisissant ou non d’en communiquerl’adresse, determiner qui pourra acceder aux agents du reseau.

syntaxe et instructions

La syntaxe pour creer un groupe est la suivante :

258

NomDuGroupe = {CreateGroup UserName AdresseDuGroupe}

La syntaxe pour connecter un Agent au reseau sous un groupe est lasuivante :

{Send Groupe turtleWorld(nomT Turtle UserName)}

– Turtle est la tortue que l’on ajoute au groupe– “nom” est le nom sous lequel sera referencie dans le groupe la tortue

que l’on y ajoute. Dans l’etat de la tortue, son nom est dirrectementremplace par “nom”.

– Groupe est le nom du groupe auquel la tortue appartiendra

Pour avoir acces a une tortue qui a ete rendue disponible en reseau, ilfaut se connecter a un groupe. Une fois la connexion realisee, toutes les tor-tues de ce groupe seront disponibles et affichees en bleu dans le cansvas del’utilisateur..

La syntaxe pour se connecter au groupe est la suivante :

Groupe = {ConnectToGroup Adresse}

Une fois la connexion effectuee, le Browser affiche la liste des tortues dis-ponibles dans le browser ainsi que les images des tortues dans le canvas.

Si l’on veut pouvoir envoyer des messages a une tortue connectee, il fautensuite creer un identifiant pour cette tortue sur la machine locale. Pour cefaire la commande est la suivante :

{Send Group get(nom TurtleID)}

– TurtleID est l’identifiant de la tortuet en reseau grace auquel le clienty accedera.

– nom est le nom de la tortue qui est connu par le reseau (il a ete affichedans le browser)

A.14.3 Exemples

Application 1 :

MonGroupe = {CreateGroup "/Users/maximeromain/Documents/srv"}

{Send MonGroupe add(tortue_toto Turtle)

Application 2 :

259

MyGroup = {ConnectToGroup "/Users/maximeromain/Documents/srv"}

TortueReseau in

{Send MyGroup get(tortue_toto TortueReseau)}

{Send TortueReseau penDown} {Send TortueReseau forward(1000)}

A.14.4 Exercices

On veut que votre tortue suive les deplacements (chaque seconde) d’unetortue reseau(nommons la tortue A). Pour ce faire, il faut que le proprietairede la tortue A cree un agent qui renvoie l’etat de A. En ajoutant cet agenta la liste des agents disponibles sur le reseau, les autres utilisateurs(dontvous) peuvent avoir acces a tout moment a l’etat de la tortue A (il faudrautiliser le message giveYourState). Il suffit ensuite de suivre les positions deA avec votre tortue. Afin d’y arriver, il faut ecrire une fonction qui deplacevotre tortue vers des coordonnees passees en argument. - Il est possible decommuniquer via les LogOz en reseau. Il suffit de mettre son agent browsera disposition dans la liste des agents. Ainsi, il suffira de recuperer la liste desagents disponibles et d’envoyer le message voulu a l’agent browser destina-tion.

260

Annexe B

Examen

Cet examen est separe en deux parties, la premiere partie sert a remplacerle test de mi-quadrimestre, la seconde est pour tous. Vous disposez de 3 heurespour le realiser.

B.1 PREMIERE PARTIE

1. Definir, avec vos mots mais de maniere precise, les concepts suivants :

– Diagramme d’agent

– Thread

– Fonction de transition

2. Realisez une procedure qui permettra a la tortue de Logoz de dessinerde maniere recursive un arbre binaire de profondeur 4 (comme surl’exemple de la figure B.1).Cet exercice se fait directement dans l’environnement Logoz et doit etre

261

sauvegarde.

Fig. B.1 – Exemple d’arbre binaire recursif

B.2 SECONDE PARTIE

B.2.1 Theorie

1. Retracez un bref plan du cours en expliquant trois des concepts qui vousont semble les plus importants. Justifiez en quelques mots le bien fondede l’ordonnancement de leur apprentissage (en quoi la comprehensiond’un concept a permis la comprehension du concept suivant)

262

263

B.2.2 Pratique

La societe Montenlair a recemment cree un systeme revolutionnaire dedistributeur de boisson destine aux palaces. Les clients, dans leur immenseparesse, refusent de descendre au bar pour s’hydrater. De meme, ils ne sup-portent plus le derangement occasionne par l’intrusion du service de chambre.Leurs exigences variees et la gamme de produits desires ne permet pas l’ins-tallation d’un mini bar (qui ne serait des lors plus mini du tout) dans leschambres.

Montenlair a donc resolu ces exigences en creant un principe de distribu-teur geant monte sur ascenceur. Les clients peuvent l’appeler de leur chambreet choisir leurs boissons ou autres types de marchandises.

Le palace Toutquibrille dispose de 40 etages et de deux super distribu-teurs Montenlair. Comme cet hotel se veut luxueux, chaque etage est occupepar une seule suite.

Il vous est demande de modeliser et d’implementer le programme de ges-tion des assenceurs-boissons selon les contraintes suivantes :

– Bien que les deux assenceurs puissent acceder a toutes les chambres,seul un d’entre eux peut s’y trouver en meme temps.

– Lorsqu’un client appelle un distributeur, celui qui est le plus procheparmis ceux qui sont disponibles s’y rend immediatement

– Un assenceur qui se rend a une chambre est considere indisponible pourles autres clients

– Un ascenceur redevient disponible quand l’utilisateur rappuie sur lebouton afin de signifier qu’il a fini de prendre sa commande

Afin de vous permettre de realiser cette application sans trop de difficultes,nous considererons les hypotheses simplificatrices suivantes :

– Les assenceurs ne tombent jamais en panne– Vous pouvez considerer qu’un assenceur redevient disponible immediatement

apres avoir atteint sa destination– Si les deux ascenceurs sont occupes, le bouton de l’utilisateur clignote

pour dire a celui-ci de reessayer plus tard.– On consirere qu’un ascenceur se rend immediatement a l’etage requis

sans devoir modifier son etat en fonction des etages intermediaires.– Ce trajet prend 3 secondes, qu’importe la distance a parcourrir.

Nous vous donnons quelques pistes pour faciliter votre modelisation. On

264

considere trois types d’agents :

1. L’agent utilisateur : Dans le systeme, il represente l’action de l’utili-sateur qui appuie sur le bouton et qui envoie le message contenant lenumero de l’etage au controleur. Si un ascenseur est a cet etage, cela si-gnifie que celui-ci redevient libre. Sinon, cela signifie que le client desirerecevoir la visite d’un distributeur. Son etat (allume ou eteint) permetde signifier a l’utilisateur si un des deux ascenceurs est libre ou s’il doitattendre avant d’appeler. Il y a donc 45 agents de ce type. Cependant,lors de votre modelisation, vous n’en considererez qu’un.

2. L’agent controleur : Il recoit les appels de l’utilisateur, et apres verificationde la disponibilite et de la proximite des ascenceurs, appelle l’un d’entreeux ou envoie a l’utilisateur un message de refus. Son etat contient l’etatde chacun des deux assenceurs.

3. L’agent ascenceur : Son etat contient sa disponibilite et l’etage auquel ilse trouve. A la demande du controleur, il lui envoie un message de refussi il est occupe, ou un message contenant le numero d’etage ou il Fsetrouve (etage(X)). Il y a deux agents ascenceur. Leurs etats contiennentl’etage auquel ils se trouvent ainsi que leur disponibilite.

265

1. Il vous est demande de realiser un diagramme de sequence prenant encompte chacun des agents specifies dans l’enonce.

266

2. Detaillez les reactions des agents a la reception des messages definis aupoint precedent.

267

3. Implementez les fonctions de transition

4. Implementez une procedure ou une fonction qui demarre l’application.

268

Annexe C

Le projet Ping-pong

L’objectif de ce projet est d’apprendre a realiser des petits programmesmulti-agents, c’est-a-dire des programmes ou plusieurs agents interagissententre eux. L’exercice de l’horloge vu aux cours etait deja un programme multi-agent. Il existe un tas d’applications pour des programmes multi-agents, etil en existe beaucoup dans le domaine des jeux. Vous connaissez sans doutetous le jeu de ping-pong dans lequel y a deux palettes et une balle, le butetant de renvoyer la balle a l’adversaire. Nous vous proposons, dans ce projet,un fil conducteur pour realiser le jeu du ping-pong.

La figure C.1 vous donne un petit apercu de ce a quoi vous devriez arriverapres la realisation de ce projet.

Le jeu est compose de 3 agents :

1. la palette de gauche ;

2. la palette de droite ;

3. la balle.

Pour chaque agent il faudra ecrire une fonction de transition et lui attri-buer un etat.

C.1 Notre vision du jeu de ping-pong

Nous allons ici decrire la facon dont nous avons choisi de realiser ce jeu.L’agent balle se deplace dans une certaine direction (vers la droite ou vers lagauche). Sa direction ainsi que sa position sont memorisees a l’interieur deson etat. Pour visualiser le deplacement de la balle, nous la faisons avancera petits pas. Apres chaque pas, la balle envoie sa position a la palette vers

269

Fig. C.1 – Jeu de Ping-Pong

laquelle elle se dirige.

L’agent palette peut uniquement se deplacer de haut en bas a l’aide decertaines touches du clavier. Nous reviendrons plus tard sur ce point. L’etatde palette contient la position de celle-ci. Lorsque la balle envoie sa position ala palette, cette derniere verifie si la position (sur l’axe horizontal) de la balleest differente de sa propre position horizontale, qui correspond a la limite duterrain de jeu.Si la position est differente, cela veut dire que la balle n’a pas encore atteintla limite. La palette envoie donc un message a la balle pour lui dire de conti-nuer d’avancer.Si les deux positions sont egales, cela signifie que la balle a atteint la limitedu terrain. Dans ce cas il va falloir verifier si la balle a bien touche la paletteen comparant leurs positions verticales.Si les positions verticales correspondent, la balle touche la palette et rebon-dit. La palette envoie alors un message a la balle pour lui dire de changer dedirection (la nouvelle direction peut par exemple etre un angle aleatoire).Si les positions verticales ne correspondent pas, cela veut dire que la ballen’a pas touche la palette et qu’elle a donc quitte le jeu. C’est perdu et le jeuse termine.

270

C.2 Les etats des agents

Voici le detail de l’etat des agents palette et balle.

Etat de l’agent palette :


Etat de l’agent balle :

state(PosX PosY Angle Tag)

PosX est la position de l’agent sur l’axe X et PosY est la position del’agent sur l’axe Y. Angle est l’angle de la direction de la balle (conventiontrigonometrique) et Tag est la reference vers l’image de l’agent. C’est iciqu’apparaıt une premiere difficulte car il faudra toujours veiller a ce quel’agent se trouve a la meme position que son image (grace a son tag).

C.3 Fonctions et procedures donnees

C.3.1 Fonctions de dessin

Voici deux fonctions mises a votre disposition afin de vous aider a dessinera l’ecran la balle et les palettes.

1. TagBall = {DrawBall X Y } : cette fonction dessine a l’ecran uneballe a la position (X, Y ) et renvoie un tag permettant d’identifiercette balle ;

2. TagPaddle = {DrawPaddle 200 200} : cette fonction dessine a l’ecranune palette de taille fixe (100 pixels) a la position (X, Y ) qui correspondau haut de la palette, et renvoie egalement un tag.

C.3.2 Procedure pour deplacer une image

Voici une procedure qui va vous permettre de deplacer une image :

{MoveTag Tag X Y }

Cette procedure deplace le dessin identifie par le tag de sa position horizon-tale actuelle posX vers (posX + X) et de sa position verticale actuelle posYvers (posY + Y).

Attention ! La palette ne se deplace que de haut en bas donc seule laposition Y sera utilisee (X sera donc toujours egal a 0).

271

C.3.3 Deplacement des palettes

Afin de rendre le jeu plus interactif, les palettes sont deplacees a l’aidede certaines touches clavier. Il faut donc lier l’action d’enfoncer une toucheau deplacement de l’agent palette, egalement au deplacement de son image !Voici quatre lignes de code a “copier/coller” dans votre application. Ellesvous permettent de lier une touche a une action :

Window bind(event :“<Up>” action :proc{$}{Send PaddleL move( 10)} end)Window bind(event :“<Down>” action :proc{$}{Send PaddleL move(10)} end)Window bind(event :“<F1>” action :proc{$}{Send PaddleR move( 10)} end)Window bind(event :“<F2>” action :proc{$}{Send PaddleR move(10)} end)

Cette ligne de code va lier (bind) a l’evenement (event) ”appuyer sur unetouche” (par exemple : Down) une action {Send PaddleL move(10)}.Dans le ”Send” vous mettrez l’identificateur de votre agent palette a qui lemessage est destine. Ce message permet a l’agent palette, lorsqu’il le recoit, dechanger de position et deplacer son image. Vous pouvez bien entendu choisirle message que vous lui envoyez. Il faut prevoir deux touches pour chaqueagent, une pour le deplacement vers le haut et l’autre pour le deplacementvers le bas.

C.3.4 Fonction Random

Une autre fonction fort interessante dans le milieu des jeux video est lafonction Random. Cette fonction renvoie un nombre aleatoire entier positif.

X = {Random}

C.3.5 Fonctions sinus, cosinus et conversion nombreentier nombre a virgule

Afin de gerer le deplacement de la balle dans toutes les directions, vousaurez besoin des fonctions qui calculent le sinus et cosinus d’un angle endegres.

X = {Cosinus 90}Y = {Sinus 45}

272

L’angle passe a la fonction est un nombre entier (Integer). Cette fonctionrenvoie un nombre a virgule (Float) car le sinus et le cosinus d’un angle sontcompris entre −1 et 1. Etant donne que nous souhaitons travailler sur desnombres entiers, il faudra faire une conversion de nombre a virgule vers lenombre entier apres avoir effectue vos calculs pour la direction de la balle.

UnNombreEntier = {Float.toIntUnNombreAVirugle}UnNombreAVirgule = {Int.toFloatUnNombreEntier}

Exemple :

X = {Float.toInt 3.2}

{Send Browser X} % 3

Y = {Int.toFloat 3}

{Send Browser Y} % 3.0

Rappelons que l’on ne peut pas melanger les deux types en Oz. On nepeut pas additionner un Float et un Integer !

C.3.6 Exemple de fonction de transition

Voici un exemple de fonction de transition pour l’agent Palette et l’agentBalle.

Fonction de transition de l’agent Palette de droite

fun{BrainPaddleR Msg state(PosX PosY Tag)}

case Msg

of start then

{Send Ball moveLeft(138)}


[] position(X Y Angle) then

if(X>=PosX) then

if(Y>=PosY andthen Y=<PosY+100) then

NewAngle = ({Random} mod 90)+135 in

{Send Ball moveLeft(NewAngle)}

end

else % quand on rate la balle

if(Y =< YMIN orelse Y>=YMAX) then

{Send Ball moveRight(~Angle)}

else

{Send Ball moveRight(Angle)}

273

end

end


[] move(Y) then

{MoveTag Tag 0 Y}

state(PosX PosY+Y Tag)

end

end

Rappel : pour creer une variable temporaire a l’interieur d’une fonction ouprocedure on utilise le mot cle in (cf cours2). Rappel : pour creer une variabletemporaire a l’interieur d’une fonction ou procedure on utilise le mot cle in.

Fonction de transition de l’agent Balle

fun{BrainBall Msg state(PosX PosY Angle Tag)}

case Msg

of moveRight(A) then

{MoveTag Tag {Float.toInt {Cosinus A}*5.0}

{Float.toInt {Sinus A}*5.0}}

{Delay 50}

{Send PaddleR position(PosX+{Float.toInt {Cosinus A}*5.0}

PosY+{Float.toInt {Sinus A}*5.0} A)}

state(PosX+{Float.toInt {Cosinus A}*5.0}

PosY+{Float.toInt {Sinus A}*5.0} A Tag)

[] moveLeft(B) then

{MoveTag Tag {Float.toInt {Cosinus B}*5.0}

{Float.toInt {Sinus B}*5.0}}

{Delay 50}

{Send PaddleL position(PosX+{Float.toInt {Cosinus B}*5.0}

PosY+{Float.toInt {Sinus B}*5.0} B)}

state(PosX+{Float.toInt {Cosinus B}*5.0}

PosY+{Float.toInt {Sinus B}*5.0} B Tag)

end

end

Pour le deplacement de la balle nous nous sommes aides du calcul trigo-nometrique a l’aide des fonctions sinus et cosinus des angles. Les fonctionssinus et cosinus renvoient un nombre a virgule, il faut donc utiliser des nombrea virgule lorsque l’on multiplie le resultat obtenu par une valeur. La valeur ici

274

est 5.0. Cette valeur est choisie volontairement de maniere a ce que la ballese deplace par pas de 5 pixels. On convertit le resultat en nombre entier demaniere a garder dans l’etat uniquement des nombres entiers.

275

Annexe D

Questionnaire d’Evaluation

Quels sont les concepts qui vous ont pose le plus de probleme ?

Est-ce que le cours vous a donne envie d’en apprendre plus sur la pro-grammation ? Pourquoi ? Que desirez-vous apprendre ?

Remarques libres

276

Cours

Pas

du

tout

Un

peu

Moyennem

ent

Plu

tot

Tout

afa

it

La

vites

sed’e

nse

ignem

ent

est

trop

elev

eeLes

conce

pts

ense

ignes

sont

clai

res

L’o

rdre

d’a

ppre

nti

ssag

edes

conce

pts

est

adap

teLe

regi

me

de

4h/s

emai

ne

est

trop

elev

ele

sob

ject

ifs

du

cours

sont

clai

rem

ent

expliques

Tab.D

.1–

Rap

por

td’E

valu

atio

ndes

cours

277

Exerc

ices

Pas

du

tout

Un

peu

Moyennem

ent

Plu

tot

Tout

afa

it

La

pro

por

tion

entr

eex

erci

ces

etco

urs

theo

rique

est

adeq

uat

eLes

exer

cice

sper

met

tent

de

com

pre

ndre

lath

eorie

Les

exer

cice

sso

nt

trop

diffi

cile

sLe

nom

bre

d’e

xem

ple

ses

ttr

opel

eve

Tab.D

.2–

Rap

por

td’E

valu

atio

ndes

exer

cice

s

Evalu

ation

Pas

du

tout

Un

peu

Moyennem

ent

Plu

tot

Tout

afa

itLe

test

etai

ttr

opdiffi

cile

Le

pro

jet

etai

ttr

opdiffi

cile

Le

cours

m’a

bie

npre

par

ea

lare

alis

atio

ndu

pro

jet

Le

pro

jet

m’a

aide

dan

sla

com

pre

hen

sion

de

lam

atie

reL’e

xam

enet

ait

trop

diffi

cile Tab.D

.3–

Rap

por

td’E

valu

atio

ndes

diff

eren

tes

eval

uat

ions

278