← Derniers articles
💻 computer science

Do Developers Read Type Information? An Eye-Tracking Study on TypeScript

Cette étude de suivi oculaire impliquant 26 étudiants de premier cycle révèle que les développeurs ne regardent pas directement les annotations de type plus fréquemment lors des tâches de compréhension de code ou de localisation de bogues en TypeScript, suggérant que si les types peuvent servir de documentation, ils ne sont pas activement lus de la manière précédemment hypothéquée.

Auteurs originaux : Samuel W. Flint, Robert Dyer, Bonita Sharif

Publié 2026-02-05
📖 5 min de lecture🧠 Analyse approfondie

Auteurs originaux : Samuel W. Flint, Robert Dyer, Bonita Sharif

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous lisez un livre de cuisine. Certaines recettes comportent de petites notes autocollantes sur la liste des ingrédients disant « 2 tasses de farine » ou « poulet, sans os ». Ces notes sont comme des annotations de type dans un code informatique. Elles indiquent au programmeur (le cuisinier) exactement quel genre de donnée (ingrédient) est utilisé.

Pendant des années, des experts ont cru que ces « notes autocollantes » agissent comme un manuel d'instructions intégré. La théorie est que lorsqu'un programmeur est bloqué ou essaie de comprendre une recette, il consulte ces notes pour l'aider.

La grande question :
Les programmeurs regardent-ils réellement ces notes lorsqu'ils lisent du code, ou les ignorent-ils simplement ?

Pour le découvrir, les chercheurs de cet article ont mis en place une expérience de « cuisine ». Ils ne se sont pas contentés de demander aux programmeurs ce qu'ils pensaient faire ; ils ont utilisé des lunettes de suivi oculaire (comme des lunettes de haute technologie qui enregistrent exactement où vos yeux regardent) pour observer 22 étudiants qui essayaient de comprendre du code et d'y trouver des bogues.

Voici ce qu'ils ont découvert, décomposé en concepts simples :

1. Le phénomène de la « note fantôme »

L'attente : Si les notes autocollantes sont utiles, les gens devraient les regarder souvent, surtout lorsqu'ils sont confus.
La réalité : Les données de suivi oculaire ont montré que les programmeurs regardaient à peine les annotations de type.

  • L'analogie : C'est comme avoir une carte avec un autocollant rouge vif « Vous êtes ici », mais le conducteur continue de fixer la route et l'écran du GPS, ignorant complètement l'autocollant. Même quand les notes étaient présentes, les yeux des programmeurs ne s'attardaient pas sur elles plus qu'en leur absence.
  • Le résultat : La présence de ces notes n'a pas changé la façon dont les programmeurs lisaient le code. Ils ne regardaient pas les notes plus souvent, et ils ne revenaient pas les relire lorsqu'ils étaient bloqués.

2. Le test de la « mémoire »

L'attente : Peut-être que les notes servent d'aide à la mémoire ? Si un programmeur a beaucoup de choses à mémoriser (mémoire de travail élevée), il utilise peut-être moins les notes car il peut garder l'information en tête. S'il a du mal à se souvenir, il compte peut-être davantage sur les notes.
La réalité : Les chercheurs ont testé la mémoire des étudiants (comme demander de se souvenir d'une liste de lettres tout en faisant des mathématiques).

  • Le résultat : Cela n'avait pas vraiment d'importance de savoir si leur mémoire était bonne ou non. Qu'ils aient une « super mémoire » ou une « mémoire normale », ils ne regardaient toujours pas les notes de type de manière significative, plus ou moins. Les notes ne semblaient pas servir de béquille pour leur mémoire comme les chercheurs l'espéraient.

3. Le facteur « Cela dépend de la recette »

Le résultat : La chose principale qui a changé la façon dont les programmeurs lisaient le code n'était pas les notes, mais le code lui-même.

  • L'analogie : Certaines recettes sont plus faciles à lire que d'autres. Si une recette est désordonnée ou confuse, le cuisinier passe plus de temps à la fixer. Si elle est claire, il la parcourt rapidement. Les chercheurs ont trouvé que la pièce de code spécifique importait bien plus que la présence de « notes autocollantes ». Certains codes étaient simplement plus difficiles à comprendre, qu'il y ait des annotations ou non.

4. Le paradoxe du « J'adore les notes »

Le rebondissement : Après l'expérience, les chercheurs ont demandé aux étudiants : « Aimez-vous ces notes autocollantes ? »

  • Le résultat : Les étudiants ont dit OUI ! Ils ont affirmé de manière écrasante que les annotations de type sont utiles pour écrire du code et le comprendre. Ils pensent qu'elles sont utiles.
  • Le paradoxe : C'est la partie déroutante. Les étudiants disent que les notes sont géniales, mais leurs yeux prouvent qu'ils ne les regardent pas. C'est comme dire : « J'adore lire l'étiquette nutritionnelle », mais ne jamais la regarder quand on achète des céréales.

Qu'est-ce que cela signifie ?

L'article conclut que, bien que les programmeurs croient que les annotations de type sont comme une documentation intégrée au code, ils ne les lisent pas réellement de la manière dont nous pourrions l'attendre. Ils ne les fixent pas, et ils n'y reviennent pas lorsqu'ils sont bloqués.

Qui devrait s'en soucier ?

  • Les concepteurs d'outils : Si les programmeurs ne regardent pas les notes, peut-être que les outils (comme les éditeurs de logiciels qu'ils utilisent) doivent présenter cette information d'une manière différente, plus évidente, plutôt que de simplement l'afficher à l'écran.
  • Les enseignants : Si les étudiants ne lisent pas les notes, les enseignants pourraient devoir leur apprendre comment lire et utiliser cette information, plutôt que de supposer qu'ils l'apprendront naturellement.
  • La communauté : Cela suggère que le simple fait d'ajouter ces notes au code n'est pas une solution miracle pour la compréhension ; les notes doivent être utilisées d'une manière spécifique que nous n'avons pas encore tout à fait comprise.

En bref : Les programmeurs adorent l'idée des annotations de type, mais en pratique, leurs yeux racontent une histoire différente : ils les ignorent pour la plupart.

Noyé(e) sous les articles dans votre domaine ?

Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.

Essayer Digest →