Comparer l'implémentation d'un algo en plusieurs langages - Page 1

Bonjour à tous,

Pour l'un de mes modules de ce semestre, il m'est demandé d'implémenter un algo en prolog et haskell, et de comparer l'exécution toussa. Voici l'extrait du sujet:

Il vous est aussi demandé d'écrire un essai comparant les deux languages à la fois l'un à l'autre et avec un langage impératif tel que Java. Utilisez Google pour trouver une référence d'implémentation impérative ou vous pouvez en implémenter une vous même. Pour empêcher qu'une minorité d'étudiants fasse une utilisation non originale des nombreux essais déjà disponibles comparant les paradigmes, vous devez illustrer chaque point du code que vous avez écrit avec une référence spécifique.

J'ai implementé l'algo en Python pour mon 3ème langage, mais à partir de là je ne sais pas vraiment où aller pour faire une comparaison objective et de qualité des 3 implémentations (je suis nouveau au domaine de la programmation declarative et fonctionelle pure, donc je n'ai pas vraiment de bases sur lesquelles m'appuyer). Les cours n'aident pas vraiment non plus- on apprend Haskell et Prolog, mais nul part des méthodes de comparaison, etc., et de fait cet essai qui compte pour 1/3 de la note (1/3 pour l'implémentation Haskell, et le dernier tiers pour l'implémentation Prolog) sort un peu de nulle part.

Instinctivement, je penserais à comparer les temps d'exécution, ressources utilisées, etc., mais ça me semble un peu trop superficiel comme approche.

Y'a t'il des outils permettant d'analyser en profondeur l'exécution de code arbitraire, et d'effectuer des comparaisons?

On a 2 semaines pour le projet (1 restante maintenant ) donc je doute qu'il soit attendu que l'on se plonge en détail dans l'analyse asymptotique de l'algorithme (surtout que les anglais ont tendance à être des quiches en maths) ou dans de l'analyse du code ASM généré par le compilateur (surtout que en plus faudrait comparer les divers compilateurs pour chaque langage, etc).

Donc voilà, j'ai l'impression que soit mon analyse sera trop superficielle et pas vraiment utile, soit bcp trop complexe pour ce qui est attendu (et me prendrait plus d'une semaine).

Des pistes ou informations pour seraient grandement appreciées

Es-tu sûr que c'est le résultat obtenu qu'il faut comparer, et pas aussi d'autres aspects ?

Par exemple :
- facilité de transcription de l'algorithme dans le langage visé
- caractéristiques du langage qui font qu'il est bien/mal adapté à la résolution de ce genre de problèmes
- ...

Les ressources utilisées, et le code assembleur généré, ça dépend aussi de la qualité du code que tu as écrit (qui n'est pas forcément la même si ce sont des langages dans lesquels tu débutes), et de celle du compilateur. On peut en extraire des tendances générales, bien sûr, mais comme point de comparaison ce n'est pas entièrement objectif.

Puisque ton problème semble se focaliser sur des problématiques algorithmiques, je ne suis pas sûr que parler du code ASM généré ou du temps exact d'exécution soit très pertinent (mais je ne connais pas le problème entier, donc je me trompe peut-être).

J'aurais plutôt eu tendance, comme Zerosquare, à remarquer les caractéristiques de chaque langage qui sont mises en valeur lors de l'implémentation (ou au contraire les manques flagrants qui alourdissent la traduction).

Tu peux par exemple séparer les sections qui traduisent littéralement le principe algorithmique de celles qui n'existent que pour satisfaire aux contraintes du langage, et en tirer déjà à mon avis un bon nombre d'observations.

idées de métrique:
* taille du code
* le nombre de ligne de commentaire que tu as instinctivement mis
* le nombre de ligne de commentaire que tu as du mettre pour que ton programme soit compréhensible par quelqu'un d'autre que toi
* le temps que tu as mis à le coder
* taille du code de tests unitaires ?

Mmmmh que des bonnes idées, merci

Python ne produit même pas du code ASM, mais du bytecode qui est ensuite interprété. Certaines implémentations de Prolog et Haskell aussi, d'ailleurs, d'autres sont compilées. (Lesquelles utilises-tu?)

Mais je pense aussi que le but est de comparer les paradigmes logique, fonctionnel et impératif (en faisant abstraction des différents paradigmes impératifs (linéaire/"spaghetti" style BASIC classique, procédural, OO) parce que ce n'est pas le sujet focal du cours en question), non pas au niveau du code généré, mais à un niveau que le programmeur remarque (tout ce qui touche à la facilité de programmation, surtout, mais éventuellement aussi la performance, mais si tu compares par exemple le Python interprété à du Haskell compilé avec GHC, ça ne va pas être idéal comme comparaison).