Mesurer la lisibilité et la compréhension du code

Les développeurs passent beaucoup de temps à essayer de comprendre le Code source pendant qu'ils bossent sur des logiciels. Pouvoir vérifier automatiquement à quel point ce code est facile ou difficile à lire et à comprendre peut aider dans plein de domaines, comme les revues de code et la gestion des tâches. Bien que certaines recherches se soient penchées sur la manière de prédire la Lisibilité et la Compréhensibilité du code, elles se concentrent principalement sur des détails à petite échelle. En plus, les résultats ne sont souvent pas à la hauteur de nos attentes.

Notre objectif est de voir comment on peut mesurer la lisibilité et la compréhensibilité du code en prenant en compte comment les gens apprennent les langues. Plus précisément, on veut voir s'il y a un lien entre la difficulté du vocabulaire et la façon dont le code parait Naturel.

#Approche de l'étude

Pour mesurer à quel point le code est naturel, on va utiliser une méthode appelée l'entropie croisée. Pour la difficulté du vocabulaire, on va créer une liste d'éléments de code avec leurs niveaux de difficulté. Ensuite, on analysera ces données pour découvrir s'il y a des corrélations et si ces facteurs peuvent nous aider à faire de meilleures prédictions sur la lisibilité et la compréhensibilité du code. On va se servir de jeux de données existants pour notre analyse.

#Importance de la compréhension du programme

Comprendre le code est super important dans le développement de logiciels. Des études montrent que les développeurs peuvent passer jusqu'à 70 % de leur temps là-dessus. Un code clair et facile à comprendre aide de plein de manières, comme rendre la revue de code plus simple pour les autres ou aider les nouveaux membres de l'équipe à se mettre à jour. Les chercheurs ont essayé de regarder ce problème sous différents angles, en considérant des aspects comme la lisibilité et la compréhensibilité.

La lisibilité concerne la facilité de lecture du code, tandis que la compréhensibilité se rapporte à la simplicité avec laquelle le code peut être compris. Souvent, un développeur peut lire le code facilement mais avoir du mal à en saisir pleinement le sens à cause d'éléments peu familiers. Être capable d'évaluer automatiquement la lisibilité et la compréhensibilité peut être bénéfique dans diverses situations, comme pendant les revues de code ou lors de l'attribution de tâches à des développeurs juniors. De bons exemples de code lisible peuvent également être utiles pour enseigner la programmation.

#Limitations des recherches actuelles

Malgré quelques avancées, de nombreuses méthodes existantes pour évaluer la lisibilité et la compréhensibilité du code ont des limites. La plupart se concentrent uniquement sur des caractéristiques locales du code, comme des métriques de complexité ou des commentaires, et ne prennent pas en compte comment cela se rapporte à d'autres bases de code. De plus, les études passées ont souvent échoué à trouver un lien clair entre les métriques utilisées et la compréhensibilité globale du code.

Dans cette étude, on va adopter une approche différente en voyant comment la difficulté du vocabulaire et le naturel peuvent être liés à la lisibilité et à la compréhensibilité du code. Tout comme lorsqu'on lit des textes avec des mots ou des phrases difficiles qu'on n'utilise pas souvent, le code de programmation peut aussi devenir dur à suivre s'il utilise des éléments complexes ou s'il est écrit de manière inhabituelle.

#Questions de recherche

Notre objectif principal est de voir si la difficulté du vocabulaire et le naturel du code influencent la lisibilité et la compréhensibilité. On va poser deux questions principales :

1. La difficulté du vocabulaire est-elle liée à la lisibilité et à la compréhensibilité du code ?
2. Le naturel du code est-il connecté à la lisibilité et à la compréhensibilité ?

En plus, on va explorer si la difficulté du vocabulaire peut aider à améliorer la précision des prévisions sur la lisibilité et la compréhensibilité du code.

#Difficulté du vocabulaire et naturel du code

Pour la difficulté du vocabulaire, on va créer une variable d'intervalle qui indique combien de vocabulaire avancé est utilisé dans un extrait de code. Cela sera basé sur une liste qu'on développera, qui évaluera la difficulté de divers éléments de code.

Pour le naturel du code, on va aussi créer une variable d'intervalle qui reflète à quelle fréquence certains éléments de code apparaissent dans d'autres projets logiciels. On pense que le code plus répétitif et commun dans les pratiques de codage sera plus facile à comprendre.

#Ensembles de données pour l'analyse

Cette étude se concentrera principalement sur les projets Java, car Java est un langage de programmation largement utilisé. On va utiliser des ensembles de données existants rassemblés par des études précédentes qui mesurent à la fois la lisibilité et la compréhensibilité.

#Ensembles de données de lisibilité

1. Un ensemble de données avec 120 extraits de code Java notés pour la lisibilité sur une échelle de 1 à 5.
2. Un autre ensemble de données qui inclut des versions modifiées d'extraits de Java existants, où les utilisateurs ont noté la lisibilité sur la même échelle.
3. Un troisième ensemble de données qui inclut 200 méthodes de divers projets Java open source, également notées par des évaluateurs.

#Ensembles de données de compréhensibilité

On va aussi utiliser divers ensembles de données pour la compréhensibilité, qui mesurent à quel point les développeurs comprennent le code :

1. Un ensemble de données qui suit si les participants comprenaient les méthodes Java et collecte leurs réponses lors de tests de compréhension.
2. Un autre ensemble de données qui combine des scores de lisibilité perçue avec des tests mesurant les performances des participants sur des tâches de compréhension.
3. Un troisième ensemble de données qui inclut des extraits où les étudiants déterminent les sorties et leur précision.

#Plan d'exécution

#Évaluation de la difficulté du vocabulaire

Pour comprendre la difficulté du vocabulaire, on va regarder comment différents éléments de code Java se classent en termes de complexité. On va utiliser des manuels et la documentation officielle pour aider à attribuer des niveaux à ces éléments.

La notation ne suivra pas seulement l'ordre dans lequel ces éléments apparaissent, car certains peuvent être considérés comme plus faciles que d'autres, même s'ils apparaissent plus tard dans les matériaux d'apprentissage.

#Évaluation du naturel du code

On va examiner à quel point le code est naturel en considérant à quelle fréquence des éléments spécifiques apparaissent dans d'autres bases de code connues. Cela sera mesuré à travers une technique qui observe les patterns dans le code écrit auparavant, rendant plus facile la compréhension du code qui contient des éléments dont on a déjà l'habitude.

#Validation des résultats

Pour confirmer nos résultats, on va analyser les données recueillies pour voir comment la difficulté du vocabulaire et le naturel du code sont corrélés avec la lisibilité et la compréhensibilité. Cela se fera en utilisant des méthodes statistiques pour s'assurer qu'on peut trouver des relations significatives sans supposer que les données correspondent à une distribution spécifique.

#Facteurs confondants et menaces à la validité

En analysant les données, on doit rester conscient des facteurs confondants qui pourraient interférer avec nos résultats. Par exemple, la longueur des extraits de code pourrait influencer leur lisibilité ou leur compréhensibilité. On va contrôler cela en standardisant la longueur des extraits que l'on analyse.

De plus, les commentaires dans le code peuvent jouer un rôle dans la manière dont les développeurs interprètent le code, donc on va analyser les extraits avec et sans commentaires pour voir si la corrélation se maintient.

On doit aussi prendre en compte comment nos résultats pourraient s'appliquer plus généralement. Comme notre focus est principalement sur Java, il sera intéressant de voir si nos résultats tiennent aussi pour d'autres langages de programmation.

#Conclusion

Le but de notre étude est de trouver des connexions entre la difficulté du vocabulaire et le naturel du code avec sa lisibilité et sa compréhensibilité. En examinant de plus près ces facteurs, on espère fournir des nouvelles perspectives sur la manière de mieux évaluer la qualité du code et d'améliorer l'expérience de codage pour les développeurs. Nos résultats pourraient conduire à des méthodes améliorées pour prédire à quel point un code est lisible et compréhensible, ce qui serait bénéfique tant pour la gestion des projets logiciels que pour l'enseignement de la programmation.