Université de Moncton

DÉPARTEMENT D’INFORMATIQUE
DEVOIR 1
INFO 4009
FONCTIONNALITÉ DE LA MÉTHODE N-VERSIONS

NI ÉTUDIANT :
PATRICK GODIN A00188402
MATHIEU ALLAIN A00188843
Table des matières
1 CONTEXTE 2

2 INTRODUCTION 2

3 MOTIVATION 2

4 FONCTIONNALITÉ 3

5 DESCRIPTION DES FONCTIONS 3

6 IMPLÉMENTION DE LA MÉTHODE N-VERSIONS 4

6.1 N-VERSION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6.2 DRIVER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

7 PORTÉE FUTURE 6

8 CONCLUSION 6
Table des matières

1
1 CONTEXTE
La programmation N-versions (NVP) est une méthode de développent de logiciel
où plusieurs programmes équivalents sont créées à partir des mêmes spécifications
initiales. À partir de ces spécifications, deux versions ou plus du programme sont
développées. Idéalement, chaque version utilise un différent algorithme, un différent
langage de programmation ou est programmée par différentes équipes. Ensuite on
évalue ces N-versions avec un algorithme de décision.

2 INTRODUCTION
Ce premier devoir a pour but de rédiger un programme qui démontre la méthode
N versions. Comme appris dans le cours, celle-ci peut aider avec la conception d’un
système ; plus spécifiquement, sa fiabilité. En comparant différentes méthodologies et
algorithmes à l’aide de points spécifiques, on peut trouver l’implémentation parfaite
pour notre système. Pour démontrer la fonctionnalité de la méthode N versions, nous
avons décidé de créer un programme de recherche de chemins.

3 MOTIVATION
Comme ce devoir nous donne la liberté de choisir notre sujet, nous étions motivés à
créer quelque chose d’intéressant avec un aspect visuel. Nous avons l’idée de recherche
de chemin et nous avons poussé plus loin pour y implémenter les aspects de N-
Versions.

2
4 FONCTIONNALITÉ
Le programme a été écrit dans Python, avec plusieurs fonctions de la librairie Py-
game. Cette librairie permet de coder des aspects visuels portables à plusieurs pla-
teformes assez facilement. Python comme tel n’est pas très utile pour des systèmes
temps réel, mais fonctionne très bien pour coder un genre de programme comme
celui-ci.
Lorsque vous lancez le programme, un onglet Pygame ouvrira. Vous pouvez choisir
un des trois modes avec votre souris et même changer de langue vers l’anglais. Dans
la langue respective, les instructions vont être clairement indiquées. Assurez-vous que
le programme et le dossier photos sont dans le même répertoire lors de l’exécution,
sinon le programme ne pourra pas exécuter.

5 DESCRIPTION DES FONCTIONS

i.main menu()
La fonction main menu() agit comme notre main. Si on active la touche escape n’im-
porte où dans le programme, on se fait ramener ici. On a un bouton anglais/français
ainsi que trois options pour visualiser les algorithmes.

ii.game(SELECTION,francais)
Selon le choix de langue et de tableau, cette fonction fait appel aux instructions et
au tableau respectif. Par suite, cette fonction appelle nos 4 algorithmes. On exécute
les algorithmes une première fois avec une animation, ensuite chaque algorithme
exécute 4 fois sans animation. Une moyenne est prise pour chaque algorithme.

iii.reponses(arrReponses, francais)
Cette fonction prend les résultats de la fonction précédente, sélectionne le meilleur
algorithme selon notre heuristique et ensuite affiche les résultats. En fait, cette fonc-
tion agit comme le driver, tous les calculs de la réponse finale sont faits ici.

3
iv.aStar(draw, grid, start, end,num, FR)
Cette fonction s’agite de notre implémentation de l’algorithme A*. Il garantit tou-
jours le meilleur chemin en utilisant une combinaison de distance Manhattan et de
poids des noeuds. Il retourne la longueur du chemin, le temps requis et le nombre
de noeuds visités.

v.dijkstra(draw, grid, start, end,num)

Cette fonction s’agite de notre implémentation de l’algorithme Dijkstra. Il garantit
toujours le meilleur chemin en utilisant le poids des noeuds. Il retourne la longueur
du chemin, le temps requis et le nombre de noeuds visités.

vi.bfs(draw, grid, start, end,num)

Cette fonction s’agite de notre implémentation de l’algorithme Breadth First Search
ou recherche en largeur. Il garantit toujours le meilleur chemin, cependant il ne suit
aucune heuristique pour arriver à cette réponse. Il retourne la longueur du chemin,
le temps requis et le nombre de noeuds visités.

vii.dfs(draw, grid, start, end,num)

Cette fonction s’agite de notre implémentation de l’algorithme Depth First Search ou
recherche en profondeur. Il ne garantit pas toujours le meilleur chemin,comparativement
aux autres algorithmes il peut être très lent. Il retourne la longueur du chemin, le
temps requis et le nombre de noeuds visités.

6 IMPLÉMENTION DE LA MÉTHODE N-VERSIONS

6.1 N-VERSION
Nous respections les principes de N-Versions, on a A*, Dijkstra, Breadth-first search
et Depth-first search qui retrouvent tous un parcours. Leur choix est très simple ;
premièrement, ce sont des algorithmes qui ont déjà été couverts dans autres cours du
département, alors leurs implémentations étaient familière. Deuxièmement, on peut
dire que chaque algorithme a ses avantages ainsi que ses désavantages. A*, Dijkstra
et BFS donnent toujours le chemin le plus court.

4
Cependant, leurs méthodes de recherches diffèrent l’un à l’autre. DFS n’a pas tou-
jours le chemin le plus court, mais peut être très rapide dans certaines situations.
Ces différents points mènent à des comparaisons plus intéressantes, ainsi que des
scénarios qui testent plus le driver.

6.2 DRIVER
Chaque algorithme est tourné 5 fois. Cependant, la démonstration visuelle de son
chemin est seulement faite durant son premier appel. Trois aspects de nos pro-
grammes sont vérifiés durant l’exécution du programme. Le plus important pour
nous est la longueur du chemin. Pour ce devoir, nous voulant le chemin le plus court
entre le point A et le point B. Trois des quatre algorithmes nous donne le chemin le
plus court chaque fois. DFS est très souvent plus long, mais dans certaines situations,
il peut avoir la même longueur de chemin que les autres.
On vérifie ensuite le temps pris par chaque algorithme. On tourne 5 fois pour avoir
une moyenne des temps. Ceci offre un niveau de précision un peu plus haut comparé
à un seul calcul. Dans une situation plus avancée, on pourrait facilement tourner
plus que 5 fois pour avoir un temps encore plus précis, mais ce niveau de précision
est bon assez pour un devoir. Le temps est en secondes, arrondi à 7 points après la
virgule. Il est rare qu’un algorithme prenne plus qu’une seconde, mais ceci pourrait
facilement arriver sur une vieille machine.
Généralement, le choix du meilleur algorithme serait fait à l’étape du temps. Celui
avec le chemin le plus court et qui prend le moins de temps à trouver celui-ci est
évidemment le meilleur. Cependant, qu’est-ce qui arrive si les temps sont identiques ?
Ce cas s’est réellement arrivé durant les tests. Pour avoir un dernier  tie-breaker ,
nous vérifions le nombre de nœuds visités par chaque algorithme. Ce facteur étudie la
complexité spatiale, ce qui est moins important pour nous dans ce cas. Généralement,
ce chiffre sera différent pour A* et DFS. Cependant, dans le cas de Dijkstra et BFS,
ils auront toujours l’exact même nombre. Heureusement, il est presque sûr que cette
comparaison ne sera pas nécessaire. Ces deux sont très similaires visuellement, mais
leur efficacité est différente, alors leurs temps devraient toujours varier. Lorsque les
calculs sont faits, le meilleur algorithme est souligné, ainsi que toutes ses valeurs.

5
7 PORTÉE FUTURE
Seulement une erreur a été trouvée pendant nos tests. Parfois, lorsqu’un chemin
est trop court ( 9 blocs de distance entre le début et la fin), le temps pris par
l’algorithme est affiché comme 0.0. Ceci semble arriver exclusivement lorsque le
programme est tourné sur Windows. Puisque nous avons complètement rédigé ce
programme en travaillant sur Linux, ce problème est seulement apparu vers la fin du
développement, lorsque nous avons finalement testé notre programme sur un autre
système d’opération. Avec plus de temps, une vérification en détail du bogue pourrait
être faite, ainsi qu’une vérification de compatibilité avec macOS. Ceci ferait notre
programme disponible à utiliser par les trois systèmes d’opération les plus populaires.
Ceci dit, si l’usager a Python 3 et Pygame installé, notre programme devrait être
capable de s’exécuter, peu importe la plateforme.

8 CONCLUSION
La méthode N-versions démontre clairement l’utilité de tester une application dans
une variété de manières et augmente la fiabilité d’un programme. La différence
de performance entre chaque algorithme peut être énorme, et le choix final d’une
implémentation effective est très important pour notre système en totalité.
Bien que cette méthode couvre seulement l’aspect logiciel cependant, autres méthodes
de conception peuvent aussi être implémentés pour assurer la fiabilité du côté matériel.
Cependant, à l’aide de N-versions, on peut faire notre choix avec confiance, tant que
nos tests sont bien écrits.