Oto, un outil d'aide à la correction de programmes

 
Oto, un outil d’aide à la correction de
                 programmes :

    Guide d’utilisation à l'intention des enseignants
           et des auxiliaires d'enseignement

         F. Guérin, G. Tremblay, P. Lessard et A. Demange
                         Départment d’informatique, UQAM
                                               Octobre 2014
                                                       Oto 2
Aperçu
Oto est un logiciel qui assiste enseignants et étudiants dans le cadre des travaux pratiques de
programmation. Oto permet aux étudiants de remettre leurs travaux en ligne et, en plus, de faire vérifier
(de façon préliminaire) leurs travaux avant de les remettre. Oto permet ensuite aux enseignants de
corriger les travaux remis. Nous aborderons successivement ces trois points, puis nous présenterons un
exemple concret d‟utilisation d‟Oto. Nous présenterons aussi des exemples de script de correction.
Enfin, à titre de référence, nous fournirons la liste des commandes et des modules Oto.

Ce guide se veut une introduction à l‟utilisation de l‟outil Oto. Pour des informations additionnelles, on
peut aussi consulter le mémoire de maîtrise de F. Guérin (Dép. d‟informatique, UQAM, octobre 2005)
et, pour le nouveau langage de script de correction, le mémoire de P. Lessard (Dép. d‟informatique,
UQAM, février 2010), tous deux disponibles sur le site Web d‟Oto : http://oto.uqam.ca.1

Soulignons que ce guide d‟utilisation présente les diverses commandes du noyau d’Oto, qui est une
application fonctionnant sous Unix en mode ligne de commandes.2 Une application Web permettant,
tant aux étudiants qu‟aux enseignants, d‟utiliser Oto à l‟aide d‟une interface graphique est aussi
disponible : http://oto.uqam.ca/application-web, Toutefois, nous ne décrirons pas cette application
dans le présent document, son utilisation étant relativement facile lorsqu‟on connaît les principales
commandes d‟Oto.

1
     Signalons que certains noms de commandes ont été modifiés par rapport à la version décrite dans le mémoire de
    maîtrise de Frédéric Guérin. Le présent document décrit la version courante du logiciel.
2
     À l‟UQAM, oto fonctionne, de façon transparente entre les machines, sous les machines
    {zeta,oto}.labunix.uqam.ca. Pour cela, il faut toutefois utiliser un code usager de style « code MS » (par ex.,
    tremblay_gu), et non un ancien code usager de la machine arabica. De plus, pour qu‟oto fonctionne correctement,
    le niveau supérieur de répertoire de l‟enseignant doit être mis en mode exécution (0711) pour les usagers du groupe et
    les autres usagers.

Oto: Guide de l'enseignant                                                                                              1
Table des matières

Contenu
  Vue d‟ensemble du processus d‟utilisation d‟Oto................................................................................................4
  1    Remise des travaux ......................................................................................................................................5
    ....1.1          Création d‟une boîte de remise de travaux ............................................................................5
    ....1.2          Affichage des boîtes de remise disponibles ...........................................................................7
    ....1.3          Remise d‟un travail par un étudiant .......................................................................................7
    ....1.4          Confirmation de la remise d‟un travail par un étudiant .........................................................7
    ....1.5          Réception des travaux par l‟enseignant .................................................................................8
    ....1.6          Destruction d‟une boite de remise de travaux .......................................................................8
  2    Vérification préliminaire des travaux ..........................................................................................................9
    ....2.1          Activation d‟une évaluation ...................................................................................................9
    ....2.2          Affichage des évaluations disponibles .................................................................................10
    ....2.3          Vérification préliminaire d‟un TP........................................................................................10
    ....2.4          Désactivation d‟une évaluation ............................................................................................11
  3    Correction des travaux ...............................................................................................................................11
    ....3.1          Affichage des évaluations privées .......................................................................................12
    ....3.2          Correction d‟un groupe de travaux ......................................................................................12
    ....3.3          Correction directe d‟un groupe de travaux ..........................................................................14
  4    Exemple illustrant le processus typique d‟utilisation d‟Oto ......................................................................15
  5    Exemples de scripts Oto ............................................................................................................................18
    ....5.1          Un script simple sans détails et sans statistiques .................................................................18
    ....5.2          Un script avec détails des tests et des statistiques, trié selon les codes permanents ............20
    ....5.3          Un script avec traitement des erreurs de compilation ..........................................................22
    ....5.4          Un script avec pénalité de retard..........................................................................................24
    ....5.5          Un script pour détection du plagiat ......................................................................................25
    ....5.6          Un script avec utilisation de commandes Unix ...................................................................25
    ....5.7          Un script de remise conditionnelle au résultat d‟une vérification préliminaire ...................27
    ....5.8          Arguments de la méthode each de l‟objet groupe .............................................................28
  6    Les commandes Oto ..................................................................................................................................29
    ....6.1          Liste des commandes ...........................................................................................................29
    ....6.2          Liste des arguments .............................................................................................................31
    ....6.3          Liste des options ..................................................................................................................32
    ....6.4          Commandes pour cas d‟utilisation particuliers ....................................................................34
  7    Les modules de correction Oto ..................................................................................................................35
    ....7.1          Le module compiler_javac..........................................................................................36
    ....7.2          Le module tester_junit ............................................................................................38x
    ....7.3          Le module tester_filtre ............................................................................................39
    ....7.4          Les modules tester_methodes et tester_classe ................................................41
    ....7.5          Le module compiler_c ...................................................................................................42
    ....7.6          Le module detecter_plagiat .....................................................................................42
    ....7.7          Le module tester_pep8 .................................................................................................45
    ....7.8          Le module tester_hunit ..............................................................................................46
    ....7.9          Le module produire_statistiques .........................................................................47
  8    Les modules de rapports Oto .....................................................................................................................48
    ....8.1          Module produire_rapport_complet ......................................................................48
    ....8.2          Module envoyer_rapports_courriel ....................................................................48

Oto: Guide de l'enseignant                                                                                                                                     2
Oto: Guide de l'enseignant   3
Vue d’ensemble du processus d’utilisation d’Oto
La figure suivante illustre, à l‟aide d‟un diagramme d‟activités UML, une séquence typique
d‟utilisation d‟Oto. Plus précisément, il s‟agit d‟un scénario où l‟enseignant ne permet pas que des
travaux soient remis après qu‟il ait débuté la correction (i.e., il rend impossible toute remise dès que la
date limite est atteinte en supprimant aussitôt la boîte de remise).

                                                                       Script et
                                                                                                  Rapport
                                                                     testspublics

                                                                           2.          Étudiant
                                                     1.               activer_eval                     3.
                                                creer_boite                                       verifier_tp
          Enseignant                                                    --public

                                                                                           TP
           Script et               7.                                      6.
         testsprivés          activer_eval                           detruire_boite

                                    8.                                    5.           Délai          4.
           Rapport                                   LesTP
                             corriger_groupe                          prendre_tp      écoulé      rendre_tp

                                                         10.
                                    9.
                                                   desactiver_eval
                              desactiver_eval
                                                       --public

Une évaluation, qu‟il s‟agisse d‟une vérification préliminaire publique accessible aux étudiants ou
d‟une évaluation privée utilisée par l‟enseignant pour effectuer la correction finale, est généralement
composée d‟un script (écrit en Ruby étendu : voir section 5) et d‟un ensemble de jeux d‟essais (par
exemple, des jeux de tests spécifiés à l‟aide de JUnit). Bien qu‟une même évaluation puisse être utilisée
à la fois pour les vérifications préliminaires et pour la correction finale, règle générale on utilisera
plutôt deux évaluations distinctes, et ce de façon à garder privés les détails de la correction finale. En
pratique, il arrivera souvent que les jeux de tests utilisés pour les vérifications préliminaires formeront
simplement un sous-ensemble de ceux utilisés pour la correction finale, le script étant adapté en
conséquence. Règle générale, le script pour la correction finale contiendra aussi certaines instructions
permettant d‟attribuer une note au travail corrigé, ce qui ne sera pas nécessairement le cas pour une
vérification préliminaire.

Dans les sections qui suivent, nous discutons plus en détail de ces différents aspects et des différentes
commandes Oto.

Oto: Guide de l'enseignant                                                                                      4
1 Remise des travaux
Un étudiant peut utiliser Oto pour remettre un travail de programmation à un enseignant. Ce travail
peut comprendre un seul fichier, plusieurs fichiers, un seul répertoire ou une combinaison de fichiers et
de répertoires. Lorsqu‟un répertoire est remis, c‟est tout son contenu qui est copié et remis par la même
occasion.

Avant qu‟un étudiant puisse déposer un travail, l‟enseignant doit tout d‟abord avoir créé une boîte à TP
virtuelle ─ i.e., une boîte de remise de travaux. Une telle boîte de remise sert à recevoir les fichiers des
étudiants. Elle est analogue à une boîte de remise des travaux comme celle que l‟on retrouve dans
plusieurs départements d‟informatique et qui sert à recevoir les travaux et rapports des étudiants.

L‟ensemble du processus de remise peut se détailler comme suit, l‟action rendre_tp étant effectuée
par des étudiants alors que les autres actions le sont par l‟enseignant:

                                 creer_boite                    rendre_tp

                               detruire_boite                   prendre_tp

L‟enseignant commence par créer une boîte à TP. Puis les étudiants rendent leurs TPs. À n‟importe
quel moment, l‟enseignant peut prendre possession des TPs qui sont dans la boîte. Les étudiants
peuvent continuer à déposer de nouveaux TPs, et l‟enseignant pourra à nouveau prendre possession de
ces TPs, et ainsi de suite. Finalement, une fois la date limite de remise atteinte, l‟enseignant détruit la
boîte. La boîte peut être recréée au besoin plus tard, si nécessaire. Nous abordons tour à tour ces
différentes étapes.

....1.1             Création d’une boîte de remise de travaux
Oto, à la base, fonctionne sous Unix en mode ligne de commandes. C‟est donc sous cette forme que,
dans ce qui suit, nous décrirons les commandes Oto – tel que mentionné précédemment, il existe
toutefois une interface Web pour l‟utilisation d‟Oto, que nous ne décrivons pas ici (décrite dans un
autre document : voir http://oto.uqam.ca). La commande Unix pour créer une boîte à TP est la suivante:

oto creer_boite 

où  est le nom que l‟enseignant a choisi de donner à la nouvelle boîte. Nous suggérons de
donner à la boîte un nom composé du sigle du cours suivi du nom du TP, par exemple INF1000-TP1.
Pour éviter toute ambiguïté, on peut ajouter le nom du groupe et le nom de la session, par exemple
A05-INF1000-10-TP1. Notez que Unix, et donc Oto, fait la distinction entre les majuscules et les
minuscules. Notez aussi que le nom de la boîte est strictement unique à l‟enseignant, plus précisément,

Oto: Guide de l'enseignant                                                                                5
unique à l‟identité du compte Unix sur lequel la boîte est créée. Deux enseignants avec des comptes
Unix différents peuvent donc sans problème utiliser un même nom de boîte de remise.

Diverses options peuvent être spécifiées lors de la création d‟une boîte de remise :

   --avec_code_permanent : Lors de la remise d‟un travail (voir section 2.3), chaque membre de
    l‟équipe doit être identifié à l‟aide d‟un identifiant. Cette option impose que l‟identifiant utilisé soit
    un code permanent valide, donc en gros de la forme NOMPJJMMAA99.3

   --avec_liste_exacte : Cette option est utilisée pour spécifier la liste exacte des fichiers qui
    peuvent et doivent être remis dans la boîte. Les noms des divers fichiers sont spécifiés à la suite de
    l‟option (avec guillemets et parenthèses). Par exemple, la commande suivante permet de créer une
    boîte B1 dans laquelle un étudiant ne pourra effectuer une remise que s‟il fournit les deux fichiers
    indiqués (f1.h et f1.c) :
       oto creer_boite --avec_liste_exacte="(f1.h f1.c)" B1

 --avec_liste_minimum : Cette option est semblable à la précédente, à la différence qu‟un
  étudiant doit remettre au moins les fichiers indiqués, mais il peut aussi remettre des fichiers
  additionnels.

 --avec_liste_maximum : Cette option est semblable à la précédente, à la différence qu‟un
  étudiant doit remettre au plus les fichiers indiqués, donc il peut ne remettre qu‟un sous-ensemble
  (non-vide) des fichiers indiqués.

   --echeance="(JJ,MM,AAAA,HH,MM)" : Cette option permet de spécifier une date limite de
    remise. Un travail remis après cette date ne sera pas déposé dans la boîte.

   --max_remises=n : Cette option permet de spécifier le nombre maximal de remises (n, un
    nombre entier positif) que peut faire un même étudiant dans la boîte, l‟étudiant étant identifié par
    son nom d‟utilisateur Unix. Elle n‟empêche cependant pas l‟étudiant d‟effectuer d‟autres remises à
    l‟aide d‟un autre compte (par exemple, dans le cadre d‟un travail d‟équipe).

 --avec_verification : Cette option permet d‟associer à une boîte de remise un script de
  vérification de remise. Le nom du script est spécifié après le nom de la boîte. Par exemple,
  supposons un script verif_compil.oto (voir Section 5 pour les scripts Oto) qui permet de
  vérifier qu‟une remise effectuée par un étudiant consiste en un unique fichier Tp1.java, lequel
  fichier compile correctement. La commande suivante permettrait alors de n‟accepter dans la boîte
  B1 que les fichiers Tp1.java qui compilent sans erreur :

              oto creer_boite --avec_verification B1 verif-compil.oto

Signalons que les options avec_liste_exacte , avec_liste_minimum ou avec_liste_maxi-
mum ne peuvent pas être utilisées conjointement.

3
     Plus précisément, certaines vérifications lexicales sont effectuées, par exemple, le premier J doit être 0, 1, 2 ou 3, le
    premier M doit être 0, 1, 5 ou 6, le deuxième M doit être 0, 1 ou 2, etc. Toutefois, l‟analyse exacte (sémantique) de la date
    n‟est pas effectuée.

Oto: Guide de l'enseignant                                                                                                      6
Finalement, signalons aussi qu‟une fois la boîte créée, ses divers attributs peuvent être obtenus (par le
créateur de la boîte seulement) à l‟aide de la commande decrire_boite, qui affichera aussi la liste des
travaux ayant été remis et qui sont encore présents dans la boîte.

....1.2             Affichage des boîtes de remise disponibles
Pour obtenir la liste des boîtes de remise de travaux créés par un enseignant, la commande suivante
peut être utilisée, et ce par n‟importe quel usager, où  indique le nom d‟usager Unix
de l‟enseignant :

oto lister_boites 

....1.3             Remise d’un travail par un étudiant
Pour rendre son TP, l‟étudiant ou son mandataire (par exemple, une application Web : cf. plus bas) doit
utiliser la commande Oto suivante, et ce à partir d‟un compte Unix valide sur la machine où réside Oto:

oto rendre_tp    

où  est le nom du compte Unix de l‟enseignant à qui il faut rendre le TP, 
est le nom de la boîte,  est la «liste» des membres de l‟équipe qui rend ce TP, et
 est la liste de fichiers ou répertoires qui composent le TP. Notez que la liste des
membres de l‟équipe ne doit comporter aucun espace ; les identifiants des membres sont plutôt séparés
par des virgules. Nous suggérons d‟employer les codes permanents ou la combinaison NomPrénom
pour désigner les membres, par exemple, TROL12127602,GUIR12556502. Signalons qu‟un même
étudiant peut remettre plusieurs copies de son travail. Dans ce cas, toutes les copies sont conservées
dans la boîte à TP, chacune étant horodatée.

Il est important de souligner qu‟une application Web est aussi disponible pour la remise des TP. Plus
précisément, cette application Web permet à un étudiant, à partir d‟une machine sur laquelle un fureteur
standard (Internet Explorer, Firefox) est installé, de remettre un travail avec Oto. Une restriction
importante est que l‟étudiant doit posséder un compte usager valide sur la machine où réside Oto,
puisque c‟est via le nom d‟usager et le mot de passe de ce compte étudiant que la connexion à Oto via
ssh pourra s‟effectuer et que la remise avec la commande rendre_tp pourra se faire. Signalons que
tous les étudiants d‟informatique ont maintenant un tel compte usager, qui leur permet d‟accéder à
toutes les machines, tant Windows qu‟Unix et Linux.

....1.4             Confirmation de la remise d’un travail par un étudiant
Un étudiant peut vérifier que la remise a été effectuée correctement en utilisant la commande suivante –
plusieurs résultats seront affichés si plusieurs remises ont été effectuées sans que l‟enseignant ait retiré
les travaux remis de la boîte de remise :

oto confirmer_remise   

Oto: Guide de l'enseignant                                                                                7
....1.5              Réception des travaux par l’enseignant
Pour prendre les TP déposés par les étudiants, l‟enseignant doit préalablement se positionner dans le
répertoire où il veut recevoir les TP, puis utiliser la commande Oto suivante:

oto prendre_tp 

où  est le nom de la boîte. Les TP seront transférés dans le répertoire courant, chaque TP
étant déposé dans un sous-répertoire qui lui est propre. Chacun de ces sous-répertoires possède un nom
aggloméré, et peu lisible, qui indique notamment le nom d‟usager de l‟étudiant qui a déposé le travail
(plus précisément, son code usager Unix), la date du dépôt et le nom des membres de l‟équipe à qui
appartient le travail. Normalement, l‟enseignant n‟a pas à décoder toutes ces informations car c‟est le
rapport de correction d‟Oto qui s‟en charge (voir la commande corriger_groupe).

Tel que mentionné précédemment, la commande rendre_tp permet à un étudiant ou à un groupe
d‟étudiants d‟effectuer plusieurs remises dans une boîte donnée. Lorsque la boîte contient plusieurs
remises pour un même nom d‟usager Unix, la commande prendre_tp récupérera simplement toutes
les remises ayant été effectuées. Toutefois, l‟enseignant ne voudra généralement conserver que la
remise la plus récente. Pour ce faire, n‟importe quand après avoir exécuté la commande prendre_tp,
l‟enseigner peut exécuter la commande suivante, et ce à partir du répertoire où ont été transférés les
travaux :

oto supprimer_doublons

L‟exécution de cette commande aura pour effet de créer un répertoire nommé Doublons où seront
conservées toutes les remises multiples, sauf la plus récente (telle que déterminée par la date de remise
encodée dans le répertoire créée pour le travail) – des exécutions répétées de cette commande
préserveront les fichiers déjà présents dans le répertoire Doublons.

....1.6              Destruction d’une boite de remise de travaux
Pour détruire une boîte, l‟enseignant doit utiliser la commande Oto suivante:

oto detruire_boire 

où  est le nom de la boîte. Une boîte qui contient des travaux ne peut pas être détruite. Il
faut d‟abord prendre les travaux qu‟elle contient.4 Mentionnons que tant et aussi longtemps qu‟une
boîte n‟est pas détruite, un étudiant peut y déposer des travaux, à moins qu‟une date d‟échéance n‟ait
été spécifiée lors de la création de la boîte avec l‟option « --echeance ».

4
     Toutefois, il existe une option «--detruire_travaux » qui permet d‟indiquer que la boîte doit être détruite même si
    elle contient encore des travaux.

Oto: Guide de l'enseignant                                                                                                 8
2 Vérification préliminaire des travaux
L‟objectif de l‟étape de vérification préliminaire est de guider l‟étudiant dans la réalisation du TP, de
lui permettre de vérifier qu‟il est sur la bonne voie. La vérification joue donc un rôle de filtre, assurant
qu‟un TP remis pour correction fonctionne minimalement, mais sans nécessairement révéler en quoi
consistera la correction finale.

Avant que l‟étudiant puisse vérifier son travail, les modalités précises de cette vérification doivent
d‟abord être spécifiées par l‟enseignant. Entre autres, il faut indiquer quels sont les tests à exécuter sur
le travail étudiant. Peut-être aussi faut-il compiler le travail au préalable? La séquence exacte des tâches
à exécuter lors de la vérification est spécifiée dans un script Oto, spécifique au travail à vérifier. Ce
script est généralement accompagné des tests (et possiblement de fichiers associés) qui doivent être
exécutés par la même occasion. L‟ensemble script, tests et/ou fichiers auxiliaires est ce qui compose
une évaluation. Nous reviendrons sur cette question dans une section ultérieure. Pour le moment, nous
nous concentrons sur le processus de vérification, lequel est schématisé dans la figure suivante où
verifier_tp est exécutée par les étudiants alors que les autres actions sont effectuées par
l‟enseignant :

                                        a
                                        c tiv
                                            er_eval
                                         --p ub
                                              lic

                                                                 v
                                                                 erifie
                                                                      r_tp

                                       d
                                       esactiv
                                             er_eva
                                                  l
                                         --
                                          p ublic

Dans un premier temps, l‟enseignant active l‟évaluation (le script) en mode public, de façon à ce qu‟il
soit accessible aux étudiants. Ensuite, les étudiants procèdent à la vérification de leur travail autant de
fois qu‟ils le désirent. Enfin, l‟évaluation (i.e., le script plus les tests) est retirée de la circulation, donc
désactivée. Si une évaluation doit être modifiée, il faut tout d‟abord la désactiver puis activer la
nouvelle version. Dans les sections suivantes, nous aborderons successivement chacune de ces étapes.

....2.1             Activation d’une évaluation
Pour publier une évaluation qui sera utilisée par les étudiants pour des vérifications préliminaires de
leurs TPs, l‟enseignant doit utiliser la commande Oto suivante (toujours sur la machine Unix où réside
Oto):

oto activer_eval --public  

où  est le nom donné à cette évaluation, et  est la liste de fichiers et
répertoires qui composent l‟évaluation. Au minimum, cette liste comprend un script Oto – dénoté par
un nom de fichier avec l‟extension « .oto ». En outre, elle inclut en général des fichiers pour tester les
programmes étudiants, par exemple des tests JUnit dans le cas d‟un TP en Java – soulignons que ces

Oto: Guide de l'enseignant                                                                                     9
fichiers doivent déjà être compilés, puisque le script Oto ne fera qu‟utiliser directement les fichiers
fournis – à moins que le script n‟effectue explicitement leur compilation.

Ici, l‟utilisation de l‟option « --public » est nécessaire, autrement l‟évaluation ne serait pas accessible
aux étudiants. En guise de nom pour l‟évaluation, nous recommandons, même si ce n‟est pas
strictement nécessaire, d‟utiliser le même nom que la boîte à TP qui devra servir à recevoir les travaux.
Il est également possible de spécifier l‟option « --delai=N » où N représente le nombre de secondes
d‟exécution maximal. Dans le cas où un délai est également mentionné au moment de la correction,
cette dernière valeur a préséance. Cette option est expliquée plus en détails à la section 3.2 sur la
correction des travaux.

....2.2             Affichage des évaluations disponibles
Un étudiant qui désire obtenir la liste des évaluations publiées par un enseignant peut utiliser la
commande suivante, où  indique le nom d‟usager Unix de l‟enseignant (donc seules
les évaluations activées avec l‟option public seront indiquées) :

oto lister_evaluations 

Dans le cas d‟une évaluation activée avec l‟option public, l‟étudiant peut également afficher
l‟ensemble des fichiers composant une évaluation publiée par un enseignant, ce qui inclut le fichier de
script Oto ainsi les autres fichiers la composant :

oto afficher_evaluation  

....2.3             Vérification préliminaire d’un TP
Pour faire vérifier son TP, de façon à obtenir du feedback avant de continuer, l‟étudiant ou son
mandataire (par exemple, une application Web : cf. plus bas) doit utiliser la commande Oto suivante, et
ce à partir d‟un compte Unix valide sur la même machine où réside Oto:

oto verifier_tp   

où  est le nom du compte Unix de l‟enseignant qui a publié l‟évaluation, 
est le nom de l‟évaluation, et  est la liste de fichiers et répertoires qui composent
le TP. Cette commande a pour effet d‟exécuter le script Oto associé à l‟évaluation concernée, ainsi que
les tests associés. Elle fournit ensuite à l‟étudiant un compte-rendu de cette exécution avec, le cas
échéant, les erreurs détectées. Le script est exécuté dans le compte usager de l‟étudiant sur la machine
où réside Oto, et ce avec l‟identité de l‟étudiant sur cette machine. S‟il y avait des dégâts pour une
raison ou une autre, c‟est donc l‟étudiant qui devrait en assumer la responsabilité.

Encore une fois, il faut souligner qu‟une application Web est disponible pour l‟utilisation d‟Oto. Cette
application Web permet à un étudiant, à partir d‟une machine munie d‟un fureteur, de faire vérifier un
travail. Une restriction est que l‟étudiant doit posséder un compte usager valide sur la machine où
réside Oto, puisque c‟est via le nom d‟usager et le mot de passe de ce compte que la connexion à Oto
via ssh pourra s‟effectuer et que la vérification par l‟intermédiaire de la commande verifier_tp se
fait.

Oto: Guide de l'enseignant                                                                              10
....2.4             Désactivation d’une évaluation
Pour désactiver une évaluation préliminaire qui a été publiée et la rendre inaccessible aux étudiants,
l‟enseignant doit utiliser la commande Oto suivante:

oto desactiver_eval --public 

où  est le nom de l‟évaluation à désactiver.

3 Correction des travaux
Supposons que les étudiants ont remis leurs travaux ─ chacun à l‟aide de la commande rendre_tp ─
et que ces travaux sont maintenant disponibles dans un répertoire donné du compte Unix de
l‟enseignant ─ qui les a obtenus à partir de la boîte de TPs à l‟aide de la commande prendre_tp (cf.
Section 2.3). L‟enseignant peut maintenant procéder à la correction de ces divers travaux. Les étapes de
la correction des travaux sont les suivantes:

                                a
                                c
                                t
                                i
                                v
                                er
                                 _
                                 ev
                                  al                                  d
                                                                      e
                                                                      s
                                                                      a
                                                                      c
                                                                      ti
                                                                       v
                                                                       er
                                                                        _
                                                                        ev
                                                                         a
                                                                         l
                                                 c
                                                 o
                                                 r
                                                 r
                                                 i
                                                 g
                                                 er
                                                  _
                                                  gr
                                                   o
                                                   u
                                                   pe
                                -
                                -
                                pr
                                 i
                                 v
                                 e                                    -
                                                                      -
                                                                      pr
                                                                       i
                                                                       ve

L‟enseignant commence par activer l‟évaluation (i.e., le script et les tests) devant servir à la correction.
Puis, il procède à la correction de l‟ensemble des travaux. Enfin, il désactive l‟évaluation. Notons que
l‟évaluation pour fin de correction est privée et accessible de lui seul, contrairement à l‟évaluation pour
fin de vérification préliminaire (section précédente) qui elle est mise à la disposition des étudiants pour
les guider et assurer qu‟ils sont sur la bonne voie. Ces deux évaluations sont le plus souvent distinctes
l‟une de l‟autre car la correction finale est généralement plus sévère et complète que la vérification
préliminaire.

Il est possible qu‟il soit nécessaire, dans certains cas, de mieux examiner le comportement d‟un travail
donné ou encore de corriger des travaux remis en retard. Dans ce cas, le processus de correction peut
être affiné de la manière suivante:

                                a
                                ctiver_eval
                                  --prive

                                                                         verifier_tp--prive
                                               corriger_groupe

                             desactiver_eval
                                 --prive

Oto: Guide de l'enseignant                                                                               11
L‟enseignant commence par activer l‟évaluation. Puis, il procède à la correction du groupe. Peut-être
qu‟un peu plus tard des travaux remis en retard s‟ajouteront à l‟ensemble des travaux disponibles.
L‟enseignant pourra alors procéder à une nouvelle correction de groupe, mais cibler cette fois
uniquement les nouveaux travaux, ou bien il pourra procéder à une correction individuelle des
nouveaux travaux, un à la fois, à l‟aide de la commande de vérification, la même que celle qui est
utilisée par les étudiants, mais en utilisant plutôt le script privé de correction. Autre cas de figure :
l‟enseignant désire modifier le script ou les tests, auquel cas il devra désactiver l‟évaluation et la
réactiver de nouveau, puis recorriger l‟ensemble du groupe. Comme l‟indique implicitement le dia-
gramme, les cas de figure sont multiples.

La plupart des étapes de ce processus (activer_eval, verifier_tp, desactiver_eval) ont
été détaillées à la section précédente dans leur forme publique, i.e., vérification préliminaire de travaux
par les étudiants. La seule différence entre les formes publiques et privées d‟activation d‟une évaluation
(commande activer_eval) est simplement l‟utilisation de l‟option correspondante (--public ou,
par défaut, privé). Dans les sections qui suivent, nous ne détaillons donc que les éléments qui diffèrent,
à savoir obtenir la liste des évaluations privées et effectuer la correction d‟un groupe.

....3.1             Affichage des évaluations privées
Une différence à souligner entre les évaluations publiques (accessibles par les étudiants) et celles
privées (utilisées par l‟enseignant) concerne la commande lister_evaluations. Un enseignant qui
désire obtenir la liste des évaluations privées qu‟il a activées peut utiliser la commande suivante – dans
ce cas, le nom de l‟enseignant n‟a pas besoin d‟être (et ne doit pas être) indiqué, le nom utilisé étant
alors implicitement le nom d‟usager Unix de l‟enseignant :

oto lister_evaluations --prive

Pour obtenir les évaluations publiques, l‟enseignant peut évidemment utiliser la même commande que
les étudiants, à savoir :

oto lister_evaluations 

Finalement, un enseignant qui a associé un ou des scripts de vérification de remise à une ou plusieurs
boîtes peut obtenir la liste de ces évaluations à l‟aide de la commande suivante :

oto lister_evaluations --verif_remise

Signalons toutefois que ces évaluations pour vérification de remise ne peuvent pas être manipulées
(activées ou désactivées) comme les autres évaluations : la création/destruction d‟une telle évaluation
de vérification de remise est strictement liée à la création/destruction de la boîte correspondante.

....3.2             Correction d’un groupe de travaux
Pour corriger un groupe de travaux, l‟enseignant doit utiliser la commande suivante:

oto corriger_groupe  

Oto: Guide de l'enseignant                                                                              12
où  est le nom de l‟évaluation (nécessairement privée) devant servir à corriger les travaux
étudiants, et  est un ensemble de répertoires, chacun de ces répertoires contenant
un TP étudiant. Cette commande a pour effet d‟exécuter le script Oto associé sur chacun des TPs puis
de produire un rapport global relatant le détail de chacune de ces exécutions. Ce rapport étant généré
sur la sortie standard (stdout, par défaut l‟écran), on utilisera donc habituellement une redirection de
fichiers pour conserver le résultat, par exemple :

oto corriger_groupe tp2 TP2_recus/*.tp_oto > rapport_tp2.txt

Pour chacun des travaux ainsi corrigés, le rapport indiquera l‟identité des membres l‟équipe ayant
produit ce travail, le nom d‟usager Unix et le nom de famille de l‟étudiant ayant effectué la remise,
ainsi que les détails de la correction du travail.

Il faut souligner que, par défaut, la correction d‟un groupe de travaux se fait sans qu‟aucun feedback
immédiat ne soit généré. Lorsque le nombre de copies à corriger est élevé, le temps d‟exécution peut
donc être relativement long (plusieurs minutes). Pour voir la progression dans l‟exécution du script de
correction, on peut alors activer l‟option « ++TRACE »5, qui permet de générer (sur stderr) une trace
d‟exécution.

Une autre option utile est l‟option « --delai=N » – où N est un entier – qui permet de spécifier le
temps CPU maximum alloué pour l‟exécution de chacun des travaux, ce qui peut être utile pour avorter
l‟exécution d‟un programme en cas de boucle infinie. Par défaut, la valeur de cette option est de 2
secondes. Un exemple d‟exécution combinant ces deux options pourrait être le suivant, où un
maximum de 4 secondes CPU par travail est alloué :

oto ++TRACE corriger_groupe --delai=4 tp2 TP2_recus/*.tp_oto > rapport_tp2.txt

Une autre option du même style est l‟option « --sortie_maximum=N », qui permet de spécifier la
taille maximum des fichiers et de la sortie (stdout) générés par un programme. Cette option peut être
utile pour faire avorter l‟exécution d‟un programme contenant une boucle infinie d‟écriture. Par défaut,
la valeur de cette option est de 512 blocs (de 512 K octets).

Finalement, signalons que si les rapports produits pour chacun des travaux contiennent certains
résultats particuliers, signalés à l‟aide d‟un mot-clé approprié, alors il est aussi possible d‟obtenir, dans
le sommaire de correction du groupe, la distribution des résultats obtenus pour les divers travaux. Pour
ce faire, il suffit d‟utiliser le module (collectif) produire_statistiques : voir plus loin pour un exemple
(section 5.2).

La section 4 présente un exemple illustrant le processus complet d‟utilisation de commandes Oto, alors
que la section 5 présente divers exemples de script de correction.

5
    Option qui peut aussi être utilisée dans sa forme abrégée « ++T ».

Oto: Guide de l'enseignant                                                                                13
....3.3             Correction directe d’un groupe de travaux
Il est possible de corriger un ensemble de travaux sans travailler avec une évaluation explicite – donc
sans passer par le processus consistant à activer une évaluation (privée), à faire un appel à
corriger_groupe, puis à désactiver l‟évaluation.

Pour utiliser ce processus simplifié de correction, il suffit simplement de donner comme premier
argument à Oto le nom d’un script Oto plutôt que le nom d’une commande. Par exemple :
      oto script-plagiat.oto *.tp_oto > rapport-plagiat.txt

Dans ce cas, les divers travaux contenus dans les répertoires *.tp_oto seront traités à l‟aide du script
indiqué (lequel ici effectue une détection de plagiat : voir section 5.5) et le rapport de correction sera
mis dans le fichier rapport-plagiat.txt. Signalons que si l‟évaluation requiert l‟utilisation de
certains fichiers auxiliaires (par exemple, un programme de tests), il suffit simplement d‟indiquer ces
fichiers comme arguments sur la ligne de commande, après le nom du script.

Oto: Guide de l'enseignant                                                                             14
4 Exemple illustrant le processus typique d’utilisation d’Oto
La figure suivante illustre une séquence typique d‟utilisation des commandes Oto dans le cas où
l‟enseignant ne permet pas que des travaux soient remis après qu‟il ait débuté la correction (i.e., il rend
impossible toute remise dès que la date limite est atteinte).

                                                                       Script et
                                                                                                  Rapport
                                                                     testspublics

                                                                           2.          Étudiant
                                                     1.               activer_eval                     3.
                                                creer_boite                                       verifier_tp
          Enseignant                                                    --public

                                                                                           TP
           Script et               7.                                      6.
         testsprivés          activer_eval                           detruire_boite

                                    8.                                    5.           Délai          4.
           Rapport                                   LesTP
                             corriger_groupe                          prendre_tp      écoulé      rendre_tp

                                                         10.
                                    9.
                                                   desactiver_eval
                              desactiver_eval
                                                       --public

L‟enseignant commence par créer une boîte à TP, puis il active le script public devant servir aux
vérifications préliminaires par les étudiants. Ensuite, les étudiants vérifient leurs TPs respectifs,
plusieurs fois s‟il y a lieu, et enfin remettent ces TPs. Une fois écoulé le délai prévu pour la remise,
l‟enseignant prend possession des TPs et détruit la boîte à TPs pour empêcher de nouveaux dépôts. Il
peut aussi attendre à plus tard pour détruire la boîte si les retards sont acceptés. Enfin, l‟enseignant
active le script privé pour son usage personnel, procède à la correction de l‟ensemble des travaux remis,
et finalement retire les évaluations publique et privée de la circulation.

Les commandes Oto et Unix associées à cette séquence typique d‟actions sont indiquées et commentées
ci-après. On suppose dans cet exemple que les étudiants doivent réaliser une classe Tp.java dans le
cadre de la séance de laboratoire numéro 3. L‟étape K est numérotée par KEns si elle est exécutée par
l‟enseignant, alors qu‟elle est numérotée par KÉtud si elle est exécutée par un étudiant.

1Ens. oto creer_boite --avec_code_permanent --avec_liste_exacte="(Tp.java)" labo3

L‟enseignant crée d‟abord la boîte à TP à laquelle on donne le nom de labo3.

2Ens. oto activer_eval --public labo3 script_public.oto TestTpPublic.class

Oto: Guide de l'enseignant                                                                                      15
L‟enseignant active ensuite une évaluation publique. On lui donne aussi le nom de labo3. Cette
évaluation comprend un script Oto et une classe de test JUnit (déjà compilée).

3Étud. oto verifier_tp tremblay labo3 Tp.java

Un étudiant effectue ici une vérification. On suppose ici que le nom d‟usager de l‟enseignant qui a
publié l‟évaluation est tremblay.

4Étud. oto rendre_tp tremblay labo3 DURN27518401,DAVA26116702 Tp.java

Un étudiant rend son travail. Plus précisément, on suppose ici que les étudiants travaillent en équipe.
Cette équipe est ici formée de deux acolytes, avec les codes permanents indiqués.

5aEns. mkdir labo3_recus ; cd labo3_recus

Avant de prendre les TPs, l‟enseignant crée un répertoire pour recevoir les travaux.

5bEns. oto prendre_tp labo3

Puis, l‟enseignant prend les travaux. Après l‟exécution de cette commande, le répertoire courant
contient un ensemble de sous-répertoires, plus précisément, un sous-répertoire par travail remis (pour
chaque exécution de la commande rendre_tp qui a été effectuée). Chacun des ces répertoires
possède l‟extension «.tp_oto» (cf. plus bas).

6Ens. oto supprimer_doublons

L‟enseignant ne désire corriger qu‟une copie par étudiant, donc il supprime les doublons, i.e., les
remises multiples – elles sont toutefois conservées dans le répertoire Doublons.

7Ens. oto detruire_boite labo3

L‟enseignant détruit la boîte – il n‟accepte plus aucun travail après qu‟il a débuté la correction.

8Ens. oto activer_eval labo3 script_prive.oto TestTpPrive.class

L‟enseignant active l‟évaluation privée devant servir à la correction, en fournissant le script de
correction et la classe de tests (déjà compilée). Ici, on donne à cette évaluation le même nom que
l‟évaluation publique correspondante. Les espaces de noms pour les évaluations publiques et privées
étant indépendants, les deux évaluations sont parfaitement distinctes.

9Ens. oto corriger_groupe labo3 *.tp_oto > rapport_labo3.txt

L‟enseignant corrige l‟ensemble des travaux reçus. Comme les TP récupérés sont déposés dans des
sous-répertoires qui ont l‟extension « .tp_oto », il est possible d‟utiliser une notation compacte
pour spécifier l‟ensemble des TP à corriger. Le rapport produit est plutôt long et il est souhaitable
d‟utiliser la redirection de fichiers pour récupérer ce rapport (produit sur stdout) dans un fichier texte
qui pourra ensuite être imprimé.

Oto: Guide de l'enseignant                                                                             16
10Ens. oto desactiver_eval labo3

L‟enseignant désactive l‟évaluation privée.

11Ens. oto desactiver_eval --public labo3

L‟enseignant désactive l‟évaluation publique.

Pour les actions 9 à 11, l‟enseignant aurait aussi pu simplement exécuter la commande suivante, donc
sans passer par l‟activation explicite d‟une évaluation puis sa désactivation, mais en utilisant plutôt le
mode implicite décrit à la section 3.3 :

9’Ens. oto script_prive.oto TestTpPrive.class *.tp_oto > rapport_labo3.txt

Oto: Guide de l'enseignant                                                                             17
5 Exemples de scripts Oto
Écrire un script Oto, c‟est dans un premier temps déterminer la séquence des opérations à effectuer
pour une évaluation préliminaire ou pour une correction de TP, par exemple, tout d‟abord compiler le
programme de l‟étudiant, puis le tester avec certains jeux d‟essai. Toutefois, ce n‟est pas le seul aspect
à définir, puisque l‟exécution du script peut aussi produire un rapport. Il faut donc spécifier, dans le
script Oto associé à une évaluation, divers éléments de ce rapport. Nous aborderons ces divers aspects
dans les exemples qui suivent.

Avant d‟examiner un premier exemple, signalons que pour comprendre les scripts Oto, il faut savoir
qu‟un script Oto est essentiellement un programme Ruby, défini via un « langage spécifique au
domaine» (plus précisément, un internal DSL = internal Domain Specific Language). En d‟autres
mots, un script Oto est un script Ruby, mais avec des instructions additionnelles propres à Oto.

....5.1             Un script simple sans détails et sans statistiques
Le listing suivant illustre un script Oto typique. Les numéros de ligne ne font pas partie du script et sont
indiquées ici simplement pour pouvoir se référer à la ligne correspondante dans le texte explicatif. On
suppose, dans le cadre de cet exemple, que les étudiants doivent remettre un fichier Compte.java.

1. groupe.each do |tp|
2.     # Compilation
3.     comp = compiler_javac( tp ) {
4.        :fichier >> 'Compte.java'
5.     }
6.     tp['Compilation'] = if comp.reussi? then "OK" else "Erreurs!?" end
7.
8.
9.     # Execution des tests
10.    tests = tester_junit( tp ) {
11.        :classe >> 'TestCompte'
12.    }
13.    nbErrs = tests[:nberreurs]
14.    nbTests = tests[:nbtests]
15.
16.    # Elements a inclure dans le rapport
17.    tp['Nb erreurs'] = nbErrs
18.    tp['Note']        = 100 * ( nbTests - nbErrs ) / nbTests
19. end
20.
21. puts produire_rapport_complet( groupe )
   À la ligne 1, on retrouve la construction qui permet de traiter les divers travaux d‟un groupe : dans
   un script Oto, la variable prédéfinie groupe représente une collection contenant l‟ensemble des
   travaux à traiter. Cette collection possède un itérateur each – standard en Ruby pour les collections
   – qui va retourner les divers éléments de cette collection. Ici (ligne 1), chaque travail ainsi obtenu
   via l‟itérateur sera associé à la variable tp dans le corps de l‟instruction do. À la ligne 2, on retrouve
   un commentaire – qui débute par le dièse (#) et se poursuit jusqu‟à la fin de la ligne. Aux lignes 3
   à 5, on fait appel au module Oto compiler_javac pour traiter le travail tp. Le module compi-
   ler_javac, comme son nom l‟indique, permet de compiler un programme Java. La liste des

Oto: Guide de l'enseignant                                                                                18
fichiers à compiler est fournie en argument, associée au mot-clé :fichier – ici, il y a un seul
   fichier à compiler, mais on peut en spécifier plusieurs, séparés par des virgules (“,”), auquel cas on
   peut aussi utiliser le mot-clé :fichiers. De façon générale, dans un script Oto, les arguments pour
   les appels de modules de correction sont indiqués avec la notation :arg >> val.
   Lorsqu‟on fait appel à un module de correction, le module va généralement retourner divers
   résultats. Pour conserver ces résultats de façon à pouvoir ensuite y référer, il suffit, comme à la
   ligne 3, d‟associer l‟appel du module à une variable, ici la variable comp.
   Parmi les résultats associés à un appel de module, on retrouve toujours l‟attribut reussi?, qui
   détermine si l‟objectif du module a été réussi pour le travail corrigé, dans le cas présent, est-ce que
   le travail a été compilé sans erreur. Toutefois, alors que certains résultats sont communs à tous les
   modules, par ex., reussi?, d‟autres sont spécifiques à un module particulier, par ex., le module
   compiler_javac produit un résultat stdout qui indique les détails de la compilation du travail.
   (Pour plus de détails sur les divers modules et leurs résultats, voir section 8.) Alors que les résultats
   du premier type sont obtenus via des attributs, par exemple, comp.reussi? (ligne 6), les résultats
   de l‟autre type sont obtenus à l‟aide de l‟opérateur d‟indexation, par exemple, comp[:stdout]. 6
   Lorsqu‟on corrige un travail, on peut aussi vouloir conserver certaines informations spécifiques au
   traitement de ce travail, pour utilisation ultérieure dans un rapport de correction. Pour ce faire, il
   suffit d‟utiliser implicitement l‟objet tp comme un hash Ruby, , comme à la ligne 6 où l‟attribut
   Compilation pour l‟objet tp est associé à une chaine ("OK" ou "Erreurs!?") qui indique si la
   compilation a réussi correctement ou non, et ce en fonction de l‟attribut reussi? du résultat de
   cette compilation.
   Aux lignes 9 à 12, on fait ensuite appel au module tester_junit. Ce module reçoit en entrée le
   nom de la classe qui servira à tester le code étudiant (TestCompte). Ici, la tâche est nommée
   tests, ce qui nous permet ensuite d‟accéder aux résultats associés à l‟exécution de ces tests plus
   loin dans le script (lignes 13 et 14).
   À la ligne 18, on calcule la note de l‟étudiant, sur 100, associée à l‟objet tp via l‟attribut Note. Pour
   effectuer ce calcul, on utilise les deux variables auxiliaires introduites aux lignes 13 et 14.
   À la sortie de la boucle do (ligne 20), l‟ensemble des travaux du groupe ont été traités. On indique
   alors, à la ligne 21, que l‟on désire générer un rapport complet pour le groupe, qui incluera chacun
   des rapports individuels des divers TPs, eux-mêmes étant constitués des divers attribués définis
   durant l‟exécution du script. Il est aussi possible de n‟inclure que certains éléments dans le rapport:
   pour plus de détails, voir le mémoire de Paul Lessard (2010). L‟appel à la commande
   produire_rapport_complet retournant une chaîne, on l‟émet ici sur la sortie standard à l‟aide
   de l‟instruction puts.7

   6
     Ces résultats sont en fait conservés sous forme d‟un hash Ruby, d‟où la notation. Et d‟où le fait que tous les modules
   retournent un attribut resultats, qui est ce hash Ruby.
   7
    Si on désire inclure, dans le rapport, le contenu du script oto utilisé pour effectuer la correction et produire le rapport,
   on peut l‟obtenir en spécifiant l‟option suivante :
   { :avec_script >> true }

Oto: Guide de l'enseignant                                                                                                     19
....5.2    Un script avec détails des tests et des statistiques, trié selon
    les codes permanents
   Si on exécute le script Oto de la section précédente, on obtiendra un rapport individuel, donc pour
   un travail spécifique d‟un étudiant (ou d‟une équipe), qui ressemblerait à ce qui suit:

TRAVAIL:        tremblay_gu+2010.05.15.18.29.46.137069+TREG12121212.tp_oto

Equipe:           TREG12121212
Depot:            2010-05-15 a 18:29
Deposeur:         tremblay_gu
Nom:              Guy Tremblay
Courriel:         tremblay.guy@uqam.ca

RESULTATS:

   Compilation:
       OK

   Nb erreurs:
       0

   Note:
       100

Si on ne s‟intéresse qu‟à la note, le rapport qui précède fournit tout ce qu‟il faut savoir. Toutefois, en
général, l‟enseignant peut aussi vouloir connaître la nature des erreurs détectées par les tests, ne
serait-ce que pour connaître les erreurs commises par les étudiants afin de savoir quels sont les
concepts qui ont été mal compris. Il peut aussi vouloir produire des statistiques sur les notes des
étudiants. Finalement, il faut savoir que l‟ordre par défaut de présentation des rapports individuels au
sein du rapport global est fondé sur le nom usager du déposeur. Or, puisque ce seront généralement les
codes permanents qui seront utilisés pour les noms des équipes, il peut être préférable d‟ordonner les
rapports individuels selon les codes permanents. Ceci est possible comme l‟illustre le script suivant.

Oto: Guide de l'enseignant                                                                             20
Vous pouvez aussi lire
DIAPOSITIVES SUIVANTES ... Annuler