Le concept d'Entropy peut-il être utilisé pour analyser le code source d'une manière utile?

Il me semble logique que l'on puisse définir un contexte pour l'analyse de code source statique qui inclue des règles pour produire une valeur relative de complexité. Je sais que ce n'est pas comme dans le sens physique parce que le code souce n'a pas "Energy" mais je parie qu'il y a eu des efforts, au moins académique, pour faire un parallèle. Quelqu'un en a-t-il connaissance et, dans l'affirmative, dans quelle mesure cela at-il produit des résultats utiles?

Il existe déjà un certain nombre de mesures de la complexité du code:

• Complexité cyclomatique
• Durée du cours
• Longueur de la méthode
• nombre de champs
• Nombre de paramètres de méthode
• Complexité du chemin N
• Fan-in et fan-out
• Analyse de flux de données (chaînes DU / DD)

Un travail a été fait pour les corréler à la densité des défauts, aux efforts de maintenance et à la facilité de compréhension. Certains sont plus significatifs que d'autres, selon ce que vous essayez d'apprendre de votre analyse. Je ne connais pas très bien le concept d'entropie des sciences physiques, mais je me demande si le suivi de mesures et de métriques comme celles que j'ai nommées au fil du temps, et les reliant à des défauts au fil du temps, serait similaire à ce que vous recherchez.

Vous pourriez également être intéressé par la définition d'Ivar Jacobson de l'entropie logicielle et de la pourriture logicielle . L'idée générale de ces sujets est qu'au fil du temps, à mesure que le code ainsi que l'environnement d'exécution changent, le système logiciel commence à se dégrader. Le refactoring est considéré comme une méthode pour minimiser l'entropie ou la pourriture, et, au moins dans mes expériences, les métriques et les mesures que j'ai mentionnées ci-dessus seraient des indicateurs que le refactoring pourrait être nécessaire dans un système ou un sous-système.

Je pense que vous essayez de faire un parallèle entre l'entropie thermodynamique et la «complexité». Le fait est que l'entropie est une mesure du désordre et non de la complexité . Je ne pense pas que les deux soient équivalents et interchangeables.

L'analogue le plus proche de l'entropie thermodynamique est l'entropie de Shannon qui mesure la quantité de désordre dans une variable aléatoire. Cette notion concerne principalement la quantité d '"informations" dans un message.

À cet égard, un morceau de code peut avoir beaucoup d'informations (entropie élevée) mais une complexité très faible. Imaginez un programme qui imprime simplement une très longue chaîne de caractères arbitraires. Il contient beaucoup d'informations, mais une faible complexité.

L'entropie est une «mesure du désordre [ou] de l'imprévisibilité». Un éventail plus large de modèles uniques dans les informations (c'est-à-dire à peu près "plus de sens") indique un degré d'entropie plus élevé.

Appliqué au code source informatique, je pense que ce principe pourrait être utile. Cependant, il serait nécessaire de concevoir un modèle probabiliste pour le code source avec lequel calculer l'entropie. (Une structure de données qui vient à l'esprit est un graphique avec différents types de bords: appel, héritage de classe, etc.)

Une fois que le modèle est conçu puis rempli avec le code source d'une application logicielle (c'est-à-dire les fréquences pour les nœuds / bords), l'entropie peut être calculée.

Je ne connais aucune recherche à ce sujet, mais mon intuition est qu'un faible degré d'entropie signifierait que le code source réutilise des modèles communs tout au long de l'application (c'est-à-dire DRY ). Inversement, un haut degré d'entropie signifierait que le code source est très complexe et n'a pas été bien pris en compte.

Une façon de penser à l'entropie est "l'information moyenne à gagner", donc je pense qu'il vaut mieux revenir à la modélisation de l'information. Je connais deux approches de base de la modélisation mathématique de l'information. (Pardonnez-moi d'avoir donné des références Wikipédia, mais à mon humble avis, ils ne sont pas mauvais.)

• Shannon Information , qui examine les jeux de symboles, les distributions de probabilité sur ceux-ci, les codes qui peuvent transférer des informations entre les jeux de symboles et les longueurs de ces codes. Les concepts généraux de l'efficacité du code, du bruit, de la détection et de la correction des erreurs par redondance, etc. sont formulés en termes de théorie de l'information de Shannon. Une façon d'exprimer des informations consiste à dire que c'est la longueur du code binaire le plus court qui pourrait représenter un symbole. Ceci est basé sur la probabilité, qui est une valeur numérique attribuée à un symbole ou à un événement par un observateur.

• Informations sur Solomonoff (ou Kolmogorov ). Voici une autre explication. Dans cette formulation, le contenu informationnel d'un symbole ou d'un événement est représenté par la longueur du programme le plus court qui pourrait le calculer. Là encore, il est relatif, non à un observateur attribuant une probabilité, mais à une machine universelle capable d'exécuter le programme. Étant donné que chaque machine universelle peut être simulée par une machine de Turing universelle, cela signifie, dans un certain sens, que le contenu informatif du symbole ou de l'événement n'est pas relatif, mais absolu.

Si je peux me permettre de dire ce que je pense que cela signifie au quotidien, à propos duquel j'ai écrit un livre , cela signifie simplement que la complexité d'un programme est sa longueur, lorsque des choses comme les spécifications fonctionnelles et le langage sont maintenues constantes, avec des allocations pour des choses comme les commentaires et la longueur des noms. Mais il y a un problème avec cela - le "tarpit APL", où concision équivaut à incompréhensibilité.

Il vaut beaucoup mieux considérer (comme je l'ai fait lors de mes études en IA) que la spécification fonctionnelle du programme consiste en un modèle mental, qui est non seulement réel, mais encodé efficacement, c'est-à-dire avec une redondance suffisamment petite pour changer d'avis sur les exigences peut être fait sans trop de risque de le rendre incohérent en interne - c'est-à-dire d'avoir un "bug". Ensuite, le processus de programmation est un canal d'information qui prend en entrée le modèle mental, et sa sortie est le code source de travail. Puis, lorsqu'un changement est effectué dans le modèle mental, ce delta doit être alimenté par le processus de programmation et transformé en delta correspondant dans le code source. Ce delta est facilement mesurable. Différez la source entre avant d'appliquer ce delta et après l'avoir appliqué (complètement, avec tous les bogues résolus), et comptez le nombre de blocs de code insérés, supprimés et remplacés. Plus il est petit, mieux le langage du code source représente le langage dans lequel le modèle mental est représenté (en termes de noms, de verbes et de structure). Si cette mesure est en quelque sorte moyenne sur l'espace des changements fonctionnels probables, c'est un concept d'entropie du langage source, et moins c'est mieux. Il y a un terme pour cela -Langage spécifique au domaine (DSL)

Je suis désolé si les références sont faibles / personnelles, mais je pense que cette question globale est très importante.

Jon Jagger et Olve Maudal ont une vision légèrement différente de Code Entropy, comme on peut le voir dans leur session de conférence Accu 2011 Code Entropy et Physics of Software .

Ils parlent de la stabilité du code en fonction de la probabilité que les futurs développeurs / mainteneurs modifient ce code.

Pour le démontrer, ils ont effectué une enquête avec un certain nombre d'extraits de code et les résultats étaient assez intéressants.

• Il semblait y avoir un fort parti pris contre le style à une seule accolade .
• Mais un fort parti pris pour embrasser une seule déclaration si.
• Il y avait un fort biais contre l'utilisation de variables temporaires.
• Il y avait un fort biais pour l'ajout de parenthèses pour rendre la priorité de l'opérateur évidente.

plus 16 autres.

La tendance générale semble être de rendre le code plus facile à comprendre et plus difficile à mal comprendre.

Ils examinent également certaines des modifications apportées à une grande base de code au fil des ans.

Bien que les diapositives à elles seules souffrent de ne pas être une transcription de la session, il y a encore quelques points intéressants.

J'ai étudié auprès d'un professeur qui a utilisé l'entropie comme mesure de la complexité des programmes (notre manuel était une ancienne édition de celui-ci , certains de ses pubs sont ici ). Il y avait un certain nombre de dissertations à la FAU où c'était l'une des principales mesures, mais le site Web de l'école a changé depuis ma dernière recherche, et je ne suis pas en mesure de localiser la thèse / dissertation des étudiants.

Une telle thèse est la théorie de l'information et la mesure logicielle .

Si vous voulez une définition qui est "mathy" dans la façon dont l'entropie est, vous voudrez peut-être regarder la complexité de Kolmogorov, qui mesure la complexité par la quantité minimale de code dans laquelle quelque chose pourrait éventuellement être fait. Cependant, ce n'est pas la complexité du code, mais de ce que vous essayez de faire avec le code. Mais vous pourriez penser que c'est pertinent parce que vous pourriez théoriquement comparer un morceau de code particulier avec le minimum. Cependant, ce n'est pas actuellement une technique utile pour mesurer la complexité du code du monde réel.

Je pense que ce n'est pas viable, on pourrait faire valoir qu'une base de code bien écrite devrait avoir une entropie plus élevée (trouble). Pensez à une base de code où l'extrait de code est répété maintes et maintes fois, il peut être compressé avec un taux de compression élevé en raison de la répétition de la partie (entropie / taille de fichier inférieure), mais si vous déplacez le code vers une fonction distincte, le taux de compression sera inférieur (entropie / taille de fichier plus élevée).

Donc, on peut penser, alors je peux calculer quelque chose comme Entropy / CodeLines en utilisant le taux de compression comme coefficient, pour mesurer la qualité du code, mais cela a le problème que l'entrée aléatoire totale ressemblerait au meilleur code au monde, ce qui n'est évidemment pas le cas.

En effet, le taux de compression est un bon indicateur pour mesurer l'entropie du code, mais les deux ne sont pas de bons indicateurs pour la qualité du code.

Eh bien, le terme entropie n'apparaît pas seulement dans la thermodynamique et la théorie de l'information, il apparaît également dans le monde réel de la compression de données. Dans ce contexte, l'entropie que voit le compresseur est égale au nombre de bits qu'il produit. (Notez que j'ai dit "l'entropie que voit le compresseur ", car ce qui est considéré comme l'entropie dépend du modèle que le compresseur utilise pour décrire les données d'entrée. C'est la raison pour laquelle différents compresseurs produisent des fichiers de taille différente: Qu'est-ce que l'entropie pour le l'un est une structure exploitable à l'autre.)

Cela peut, en principe, être magnifiquement appliqué à la complexité du code source: "Il suffit" d'écrire un compresseur qui ne fonctionne que sur du code source entièrement conforme, et qui le comprime en le analysant comme le ferait un compilateur, produisant l'arborescence de syntaxe correspondante. Ensuite, il peut parcourir cet arbre de syntaxe et décider à chaque nœud quels nœuds auraient été possibles à chaque point, codant ce nœud avec cette connaissance.

Ainsi, par exemple, si la langue autorise un identifiant existant, ou quelque chose entre parenthèses, ou un produit à un point spécifique, le compresseur comptera les identifiants existants possibles, en tenant compte des informations de type (par exemple, vous avez 3 de ces identifiants ) et ajoutez 2 pour les deux sous-expressions possibles, ce qui donne 5 possibilités. Ainsi, le nœud serait codé avec des lb 5 = 2.32bits. Dans le cas des deux sous-expressions possibles, plus de bits seraient nécessaires pour coder leur contenu.

Cela donnerait en effet une mesure très précise de la complexité du code tel qu'il est. Cependant, cette mesure est toujours inutile! C'est inutile pour la même raison que toutes les mesures de complexité de code sont inutiles: elles échouent à établir le lien entre la complexité de code mesurée (quelle qu'elle soit) et la complexité du problème que le code résout. Vous pouvez toujours trouver des solutions ridiculement complexes à vos problèmes de programmation pour impressionner votre employeur avec vos comptes LOC, mais aucune mesure de complexité du code ne vous dira que la tâche aurait pu être résolue avec une fraction de l'effort.

Le code a exactement autant d'entropie que le nombre π.

La maintenance et le changement de code peuvent introduire l'entropie (car il existe un changement d'état possible).

Mais le code n'est qu'un grand nombre. Avec une représentation binaire.