Comment lire des milliers de lignes de code sans aucune documentation? [fermé]

Auparavant, je cherchais un bon contrôle TimeLine pour un projet WPF. J'ai trouvé une réponse dans Here qui m'oriente vers ce projet CodePlex .

Maintenant, je veux changer le code pour répondre à mes besoins culturels. Mais il y a des décalages!

Ma question est:

Comment interagissez-vous avec ces milliers de lignes de code?

ÉDITER:

Tout raccourci sera génial!

Vous ajoutez des commentaires au code source lorsque vous l'avez suffisamment compris pour pouvoir le faire. Refactorisez vigoureusement ces commentaires à mesure que vous comprenez de plus en plus.

1. Parcourez le code
2. Renommer au besoin
3. Refactoriser au besoin
4. Répétez jusqu'à ce que vous compreniez complètement

... et le code vous en remerciera. ;-)

Prenez une seule action, déboguez (encore et encore) le code pour trouver comment cette action est accomplie. Notez la même chose dans un langage simple pour mieux comprendre!

Quelque chose que Joel Spolsky a écrit il y a longtemps quand sur son blog (je ne trouve pas l'article maintenant) m'a vraiment collé à ce sujet:

Il a dit que le code n'est pas un langage humain naturel, mais en tant que programmeurs, nous sommes facilement bercés en pensant qu'il l'est, et que nous devrions être capables de le lire tel quel. Par conséquent, beaucoup d'entre nous regardent le nouveau code et s'attendent à pouvoir simplement le "lire" et le comprendre immédiatement, comme s'il s'agissait d'un bloc de texte en anglais.

Je pense donc que la clé est d'être simplement lent, méthodique et scientifique. Et comme d'autres l'ont dit - commentez-le (et même refactorisez) au fur et à mesure. Ne tombez pas dans la mentalité de "je devrais simplement le regarder et comprendre immédiatement".

Oh, et oui, je tombe encore parfois dans ce piège moi-même. "Faites ce que je dis, pas ce que je fais", et tout ça. :)

SE-Radio a interviewé Dave Thomas à ce sujet

Cet épisode de podcast contient de nombreux conseils et techniques pour entrer dans la «culture» du projet et comprendre comment vivaient les habitants d'origine.

J'ai dû le faire récemment avec un projet de plus de 100 000 LOC. Ma première idée était qu'il est plus facile de voir des modèles à partir de graphiques de 100 ou même 1000 nœuds que de 100 000 lignes de texte.

J'ai donc passé 45 minutes et écrit un court programme Python (<100LOC) pour analyser ce dont j'avais besoin et dessiner les relations entre les objets. J'ai généré la source Graphviz , qui est un langage vraiment facile à générer. (Il n'y a rien de spécial à propos de Python ici: Ruby ou C # ou Common Lisp ou tout ce qui pourrait le faire aussi bien.)

Sur d'autres projets, j'ai vu des gens utiliser Graphviz pour les dépendances de modules, les graphes d'appels, l'historique des versions, toutes sortes de choses. Le plus grand méta-outil de visualisation de programmes jamais créé.

(Peut-être que c'est parce que j'ai pris des compilateurs , mais je trouve bizarre que lorsqu'un programmeur est confronté à un problème, la réponse semble toujours être "écrire un programme!", Sauf lorsque le problème implique le code source d'un programme.: - )

Parcourez-le dans le débogueur pendant son exécution, c'est presque le seul moyen de comprendre une nouvelle base de code volumineuse.

Comprenez qu'il n'y a vraiment aucun raccourci pour grogner en plénitude. (Et si vous avez du mal avec cette phrase, votre éducation a été TRÈS négligée. C'est de "Stranger In a Strange Land", de Robert A. Heinlein.)

Lisez-le, une page à la fois, une routine à la fois. Ajoutez des commentaires. Dessinez des images des principales structures de données. Reconnaître les algorithmes. Tirez parti de vos connaissances antérieures.

Résistez à la tentation de lancer le débogueur. La fenêtre du débogueur est trop petite: vous voyez une ligne à la fois, mais vous ne voyez vraiment pas où vous avez été ni où vous allez.

Quoi que vous fassiez, écrivez autant que vous le pouvez au fur et à mesure afin que personne ne se retrouve jamais dans la même position que vous.

vous devez utiliser des indices. obtenez un indice de ce que vous devez rechercher et utilisez largement la fonctionnalité de recherche de votre environnement ou IDE qui peut vous amener à la section souhaitée du code que vous devez modifier.

lire 14 mille lignes de code java n'a aucun sens. La fonctionnalité de recherche est votre bouée de sauvetage

Différentes personnes ont des styles d'apprentissage différents, donc YMMV. La première chose que je fais dans cette situation est de lire l'intégralité de la base de code au moins une fois. Cela me donne une idée générale de tout. Ensuite, je choisis une section à examiner plus en détail. Les structures de données seraient un bon point de départ. Une fois que j'ai une idée générale de ce qui se passe, je fais de même avec une autre partie du code qui interagit avec la première. Après suffisamment d'itérations, j'ai une bonne idée du fonctionnement du code.

La meilleure façon, comme pour toute programmation, pas seulement de gros morceaux de code non commenté, est de le décomposer en morceaux. C'est à la fois quelque chose que vous devez faire dans votre tête ainsi que visuellement dans le code. Cela peut signifier ajouter de gros commentaires en gras ou plusieurs sauts de ligne. Cela aide tout en le faisant défiler pour voir les pièces. Essayez de trouver les morceaux logiques de code.

Bien sûr, lorsque vous comprenez des éléments, commentez-les pour ce que vous savez à ce moment-là, en ajoutant éventuellement des notes sur quelque chose que vous ne comprenez pas.

Je recommanderais également de ne pas essayer de comprendre la pièce entière dès le début. Essayez plutôt de comprendre les éléments que vous devez connaître dès maintenant et de travailler sur le reste plus tard.

Je commencerais par utiliser l' éditeur Leo en mode @shadow avec une utilisation active des nœuds clonés . Cela permet d'ajouter des notes et des commentaires pour chaque section de code à l'étude sans changer le code , et les annotations seront toujours en contexte, à côté du code dont il s'agit. Voici un exemple de flux de travail des documents:

Par exemple, lorsque je corrige un bogue dans Leo, je crée un nœud ordinaire pour représenter le bogue. Ce nœud de bogue est ma vue de toutes les données du code source de Leo qui se rapportent au bogue. Lorsque je découvre le code lié au bogue, je clone leurs nœuds et les déplace sous le nœud de bogue. J'ajouterai également des nœuds ordinaires en tant qu'enfants du nœud de bogue. Ces nœuds contiennent le rapport de bogue d'origine, des descriptions de la façon dont j'ai corrigé le bogue, des données de test ou toute autre note que je pourrais vouloir conserver.

Une fois que j'ai créé le nœud de bogue, je me concentre uniquement sur ce nœud et ses enfants. Je peux examiner le nœud de bogue et ses enfants sans avoir à sauter le contour. Tout ce dont j'ai besoin est au même endroit. Lorsque je parviens à corriger le bogue, je peux le faire en changeant les clones. Encore une fois, je n'ai pas à sauter le contour. Peu importe la taille ou la complexité de l'ensemble du plan: je ne traite que du nœud de bogue et de ses enfants. Cette focalisation extrêmement étroite facilite la correction des bogues.

Dessinez des diagrammes de la source: les relations de données, les relations fonctionnelles, les relations d'objet. Déterminez l'agrégation, le flux de données et le flux de code. Les images sont bien meilleures que les commentaires pour cela et peuvent être séparées du code.

Avant de refactoriser quoi que ce soit, écrivez des tests. Beaucoup de tests. Des tests très spécifiques à de petits blocs de code qui sont au moins appelables, car cela dépendra de la façon dont votre désordre hérité est écrit.

L'avantage d'écrire des tests pour commencer est que vous devez avoir une certaine compréhension du code avant de pouvoir le tester, donc chaque test que vous écrivez sera, espérons-le, un peu de connaissances acquises. Vous pouvez également commenter les tests avec vos hypothèses à côté des assertions.

En le testant d'abord, vous ne courez pas le risque de modifier quelque chose dans le code qui a des effets d'entraînement que vous ne pouvez pas connaître. Vous aurez également un filet de sécurité lorsque vous viendrez refactoriser le code.

J'utilise des outils comme doxygen, pour générer un diagramme de classe global, qui ajoute ma compréhension de ce que fait chacune des classes.

Ensuite, je récupère un bogue facile dans la file d'attente des bogues (avant que mon responsable ne m'en attribue un dur: P), puis j'exécute cette fonctionnalité dans le débogueur et j'essaie de générer un flux de données approximatif ou un modèle de flux de code.

Par exemple, la fonctionnalité d'exportation dans certains logiciels: j'essaie donc de comprendre comment les données source sont lues, d'où dans le code (interface de base) puis-je évaluer que les données sont lues correctement en utilisant ma classe et les diagrammes de flux de code, dont les classes sont responsables quel type d'exportations, etc. Je pense que la moitié de la compréhension est faite, une fois que vous avez les diagrammes de classes et les organigrammes.

Abordez un défaut trivial, par exemple une NullPointerException. Évitez tout ce qui concerne la concurrence au début, tout ce qui, de par sa nature, impliquera de comprendre une grande partie du code à la fois.

Une fois que vous aurez corrigé quelques bugs, vous aurez probablement une assez bonne idée. Fonctionne pour moi, en tout cas.

Fondamentalement, l'action d'écrire un code propre doit commencer dès la conception. Si nous codons en langage OOP, proposez un UML, partagez-le avec vos pairs et soyez convaincu que le design n'est pas ambigu. Dans tous les cas, nous, les développeurs, devons être convaincus que la conception résout le problème et non les ambiguïtés.

En ce qui concerne le codage, nous devons nous assurer que le design est converti en code, c'est-à-dire une entité en classe ou structure, une opération en fonction, etc.

Et j'ai parcouru un livre blanc http://queue.acm.org/detail.cfm?id=2063168 qui parle du style de codage ou de la façon dont nous pouvons utiliser l'espace, l'indentation, la variation de police comme la plupart des IDE que nous pouvons utiliser pour écrire BEAUCOUP Un code plus propre où nous, les humains, pouvons comprendre autant que les machines. Il insiste davantage sur l'écriture de code sans commentaire afin que notre code apparaisse comme paragraphes lui-même.