Oto, un outil d'aide à la correction de programmes
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
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 1Table 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 2Oto: 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 41 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 5unique à 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 6Finalement, 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 82 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 9fichiers 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 11L‟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 144 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 15L‟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 18fichiers à 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 20Vous pouvez aussi lire
