Quelle est la meilleure façon de se familiariser avec une grande base de code? [fermé]

https://stackoverflow.com/questions/215076

03-07-2019
|

Question

Rejoindre une équipe existante avec une grande base de code déjà en place peut être décourageant. Quelle est la meilleure approche?

large; essayez d'obtenir un aperçu général de la manière dont tout se lie, à partir du code
étroit; concentrez-vous sur de petites sections de code à la fois, en comprenant leur fonctionnement complet
Choisissez une fonctionnalité à développer et à apprendre au fur et à mesure
Essayez de vous familiariser avec les diagrammes de classes et les uml, si ceux-ci sont disponibles (et à jour)
Quelque chose d'autre?

Je travaille actuellement sur une application & amp; C ++ d'environ 20 000 lignes. bibliothèque (Edit: petit dans le grand schéma des choses!). Dans l'industrie, j'imagine que vous auriez une introduction par un programmeur expérimenté. Cependant, si ce n’est pas le cas, que pouvez-vous faire pour ajouter de la valeur aussi rapidement que possible?

-
Résumé des réponses:

Passez en revue le code en mode débogage pour voir comment cela fonctionne
Associez-vous à une personne plus familière avec la base de code que vous, se relayant pour être la personne en train de coder et celle qui regarde / discute. Faites pivoter les partenaires parmi les membres de l'équipe afin que les connaissances soient diffusées.
Écrire des tests unitaires. Commencez par affirmer comment le code fonctionnera. Si cela vous convient, vous avez probablement compris le code. Sinon, vous avez un casse-tête à résoudre et / ou une demande à poser. (Merci Donal, c'est une excellente réponse)
Parcourez les tests unitaires existants pour le code fonctionnel, de la même manière que ci-dessus
Lisez les diagrammes de classes générés UML, Doxygen et d’autres documents pour avoir une idée globale du code.
Apportez de petites modifications ou des corrections de bugs, puis construisez-vous progressivement
Conservez des notes, n'intervenez pas et ne commencez pas à vous développer; Il est plus utile de perdre du temps à comprendre que de générer un code compliqué ou inapproprié.

cet article est une copie partielle de le meilleur moyen de se familiariser avec une base de code héritée

La solution

Commencez si possible par une petite tâche, corrigez le code autour de votre problème. Parcourir le code en mode débogage est le moyen le plus simple d’apprendre comment quelque chose fonctionne.

Autres conseils

Une autre option consiste à rédiger des tests pour les fonctions qui vous intéressent. La configuration du faisceau de tests est un bon moyen de déterminer les dépendances du système et l'emplacement de son état. Chaque test commence par une affirmation sur la façon dont le système devrait fonctionner. Si cela fonctionne ainsi, vous avez réussi quelque chose et vous avez un exemple de code de travail pour le reproduire. Si cela ne fonctionne pas ainsi, vous avez un casse-tête à résoudre et une piste d'investigation à suivre.

Une chose que je suggère généralement aux personnes qui n’a pas encore été mentionnée est qu’il est important de devenir un utilisateur compétent de la base de code existante avant de pouvoir devenir développeur. Lorsque de nouveaux développeurs arrivent dans notre grand projet logiciel, je leur suggère de perdre du temps à devenir des experts avant de plonger pour essayer de travailler sur le code.

C’est peut-être une évidence, mais j’ai vu beaucoup de personnes essayer de s’intégrer trop rapidement au code car elles ont hâte de commencer à progresser.

Cela dépend assez du type d'apprenant et du type de programmeur que vous êtes, mais:

Large d'abord - vous avez besoin d'une idée de la portée et de la taille. Cela pourrait inclure écrémer docs / uml s’ils sont bons. Si c'est un projet à long terme et que vous aurez besoin d'une compréhension complète de tout, je pourrais en fait lire la documentation correctement. Encore une fois, si ils sont bons.
Étroit - choisissez quelque chose de gérable et essayez de le comprendre. Obtenez un "goût" " pour le code.
Choisissez une fonctionnalité, éventuellement différente de celle que vous venez de regarder si vous vous sentez confiant, et commencez à apporter de petits changements.
Itérer - évaluez l'état de la situation et voyez s'il serait utile de répéter une première étape plus en profondeur.

Couplage avec rotation stricte.

Si possible, tout en parcourant la documentation / base de code, essayez d’apparier avec une rotation stricte. Cela signifie que deux d'entre vous sont assis ensemble pendant une période déterminée (par exemple, une session de 2 heures), puis vous changez de paire, une personne continue à travailler sur cette tâche tandis que l'autre se déplace vers une autre tâche avec un autre partenaire.

Par deux, vous collecterez un élément de connaissance qui pourra ensuite être transmis aux autres membres de l’équipe lors de la rotation. Ce qui est également intéressant, c’est que lorsqu’un nouveau couple est réuni, celui qui a travaillé à la tâche (dans ce cas-ci, l’investigation du code) peut alors résumer et expliquer les concepts d’une manière plus facile à comprendre. Au fur et à mesure que le temps passe, tout le monde devrait avoir le même niveau de compréhension et éviter, espérons-le, "Oh, seul John connaît ce bout de code". syndrome.

D'après ce que je peux dire de votre scénario, vous avez un bon chiffre pour cela (3 paires). Cependant, si vous êtes distribué, ou si vous ne travaillez pas dans le même délai, il est peu probable que ce soit possible.

Je suggérerais d'exécuter Doxygen sur celui-ci pour obtenir un diagramme de classes à jour, puis de l'inclure pendant un moment. Cela vous donne une grande image que vous pouvez utiliser lorsque vous vous approchez du code.

Je conviens que cela dépend entièrement de votre type d'apprenant. Cela dit, je suis allé dans deux entreprises qui avaient d’abord de très grandes bases de code. En général, je travaille comme ça:

Si possible, avant d'examiner un code fonctionnel, je passe par des tests unitaires déjà écrits. Ceux-ci peuvent généralement aider beaucoup. S'ils ne sont pas disponibles, je procède comme suit.

Tout d'abord, j'ignore en grande partie l'implémentation et ne regarde que les fichiers d'en-tête ou uniquement les interfaces de classe. J'essaie de me faire une idée de l'objectif de chaque classe. Deuxièmement, je vais un peu plus loin dans la mise en œuvre en commençant par ce qui semble être le domaine le plus important. C’est difficile à évaluer, c’est pourquoi j’ai parfois commencé par le haut et descendu dans la liste des fichiers. J'appelle cela l'apprentissage en largeur d'abord. Après cette étape initiale, je vais généralement en profondeur dans le reste du code. Le premier coup d'œil initial aide à solidifier / corriger les idées que j'ai obtenues au niveau de l'interface, puis le regard sur la profondeur me montre les modèles utilisés pour mettre en œuvre le système, ainsi que les différentes idées de conception. Par profondeur d'abord, je veux dire que vous parcourez le programme à l'aide du débogueur, que vous entrez dans chaque fonction pour voir comment cela fonctionne, etc. Cela n’est évidemment pas possible avec des systèmes très volumineux, mais 20k LOC ne sont pas si nombreux. :)

Travaillez avec un autre programmeur plus familiarisé avec le système pour développer une nouvelle fonctionnalité ou résoudre un bogue. C’est la méthode que j’ai vu travailler le mieux.

Je pense que vous devez associer cela à une tâche particulière. Lorsque vous avez le temps, choisissez l’approche qui vous convient le mieux.

Lorsque vous avez quelque chose à faire, concentrez-vous sur votre objectif et faites-le.

Demandez à l'équipe de vous mettre en correction de bogues pendant deux semaines (si vous en avez deux) Ils se feront un plaisir de demander à quelqu'un d'assumer la responsabilité de cette tâche et, à la fin de la période, vous aurez passé tellement de temps à résoudre les problèmes avec la bibliothèque que vous le saurez probablement très bien.

S'il dispose de tests unitaires (je parie que ce n'est pas le cas). Commencez petit et assurez-vous que les tests unitaires n'échouent pas. Si vous regardez immédiatement la base de code entière, vos yeux deviendront vitreux et vous vous sentirez submergé.

S'il n'y a pas de tests unitaires, vous devez vous concentrer sur la fonctionnalité souhaitée. Exécutez l'application et examinez les résultats de l'impact de votre fonctionnalité. Ensuite, commencez à parcourir le code en essayant de comprendre comment l'application crée les éléments que vous souhaitez modifier. Enfin changez-le et vérifiez que les résultats sortent comme vous le souhaitez.

Vous avez mentionné qu'il s'agissait d'une application et d'une bibliothèque. Commencez par changer l'application et continuez à utiliser la bibliothèque en tant qu'utilisateur. Ensuite, après avoir appris la bibliothèque, il sera plus facile de changer.

À partir d’une approche descendante, l’application dispose probablement d’une boucle principale ou d’une interface graphique principale contrôlant l’ensemble des actions. Il est utile de comprendre le flux de contrôle principal de l'application. Lisez le code pour vous donner une vue d'ensemble du flux principal de l'application. S'il s'agit d'une application à interface graphique, créez un document indiquant quels sont les écrans et comment passer d'un écran à l'autre. S'il s'agit d'une application en ligne de commande, comment le traitement est-il effectué?

Même dans les entreprises, il n’est pas rare d’avoir cette approche. Souvent, personne ne comprend parfaitement le fonctionnement d'une application. Et les gens n'ont pas le temps de vous faire visiter. Ils préfèrent des questions spécifiques sur des choses spécifiques, vous devez donc vous plonger et expérimenter vous-même. Ensuite, une fois que vous avez obtenu votre question spécifique, vous pouvez essayer d’isoler la source de connaissances pour cette partie de l’application et de la poser.

Commencez par comprendre le «domaine problématique» (s’agit-il d’un système de paie, d’un inventaire, d’un contrôle en temps réel ou autre). Si vous ne comprenez pas le jargon utilisé par les utilisateurs, vous ne comprendrez jamais le code.

Ensuite, regardez le modèle d'objet; il se peut qu'il y ait déjà un diagramme ou que vous deviez peut-être en désosser un (soit manuellement, soit à l'aide d'un outil, comme suggéré par Doug). À ce stade, vous pouvez également examiner la base de données (le cas échéant), si elle doit suivre le modèle objet, mais ce n’est pas le cas, et il est important de le savoir.

Consultez l'historique des modifications ou la base de données de bogues. Si un domaine est souvent évoqué, examinez-le d'abord. Cela ne veut pas dire que c'est mal écrit, mais que c'est ce que tout le monde utilise.

Enfin, gardez quelques notes (je préfère un wiki).

Les gars existants peuvent l’utiliser pour vérifier vos hypothèses et vous aider.
Vous devrez y revenir plus tard.
Le prochain nouveau membre de l'équipe vous en sera vraiment reconnaissant.

J'ai eu une situation similaire. Je dirais que tu vas comme ça:

S'il s'agit d'une application basée sur une base de données, commencez à partir de la base de données et essayez de donner un sens à chaque table, à ses champs, puis à sa relation avec les autres tables.
Une fois que tout va bien avec le magasin sous-jacent, passez à la couche ORM. Ces tables doivent avoir une sorte de représentation dans le code.
Une fois cela fait, passez à comment et d'où ces objets viennent. Interface? quelle interface? Des validations? Quel prétraitement a-t-il avant de se rendre au magasin de données?

Cela vous familiariserait mieux avec le système. N'oubliez pas qu'essayer d'écrire ou de comprendre les tests unitaires n'est possible que si vous savez très bien ce qui est testé et pourquoi il doit être testé dans seulement de cette façon.

Et dans le cas d'une application volumineuse qui n'est pas orientée vers les bases de données, je recommanderais une autre approche:

Quel est l'objectif principal du système?
Quels sont alors les composants principaux du système pour résoudre ce problème?
Quelles sont les interactions entre chacun des composants? Faire un graphique qui décrit les dépendances des composants. Demandez à quelqu'un qui travaille déjà dessus. Ces composants doivent échanger quelque chose entre eux. Essayez donc de les comprendre également (comme IO pourrait renvoyer un objet File à une interface graphique, etc.)
Une fois que cela vous convient, plongez dans le composant le moins dépendant des autres. Maintenant, étudiez comment cette composante est divisée en classes et comment elles interagissent. De cette façon, vous maîtrisez un seul composant au total
Passer au composant suivant le moins dépendant
À la toute fin, passez au composant principal qui dépend généralement de nombreux autres composants que vous avez déjà abordés
Tout en regardant le composant principal, vous faites peut-être référence aux composants que vous avez examinés précédemment, alors ne vous inquiétez pas, continuez à travailler dur!

Pour la première stratégie: Prenons l'exemple de ce site stackoverflow par exemple. Examinez le magasin de données, ce qui est stocké, comment il est stocké, quelles représentations ont ces éléments dans le code, comment ces emplacements sont présentés sur l'interface utilisateur. D'où viennent-ils et quel traitement leur est appliqué une fois qu'ils sont retournés au magasin de données.

Pour le second Prenons l'exemple d'un traitement de texte par exemple. Quels composants sont là? IO, UI, Page et aiment. Comment ceux-ci interagissent les uns avec les autres? Avancez à mesure que vous apprenez plus loin.

Soyez détendu. Le code écrit est l’esprit de quelqu'un, sa logique figée et son style de pensée, et il faudrait du temps pour le lire.

Tout d'abord, si vous avez des membres de l'équipe disponibles qui ont une expérience du code, vous devez leur demander de vous en faire une vue d'ensemble. Chaque membre de l'équipe doit vous fournir des informations sur leur domaine d'expertise. Il est généralement utile de demander à plusieurs personnes d’expliquer certaines choses, car certaines seront plus explicites que d’autres et certaines auront une meilleure compréhension que d’autres.

Ensuite, vous devez commencer à lire le code pendant quelque temps sans aucune pression (quelques jours ou une semaine si votre supérieur hiérarchique vous le fournira). Il est souvent utile de compiler / de construire le projet vous-même et de pouvoir l'exécuter en mode débogage pour pouvoir parcourir le code. Ensuite, commencez à vous mouiller les pieds, à corriger de petits bugs et à apporter de petites améliorations. Espérons que vous serez bientôt prêt pour un projet de taille moyenne et, plus tard, un grand projet. Continuez à vous appuyer sur vos coéquipiers au fur et à mesure de vos déplacements - vous pouvez souvent en trouver un en particulier qui est disposé à vous encadrer.

Ne soyez pas trop dur envers vous-même si vous vous battez - c'est normal. La compréhension d'une base de code volumineuse peut prendre un certain temps, voire des années. En fait, il arrive souvent que, même après des années, certaines parties du code restent un peu effrayantes et opaques. Lorsque vous avez du temps libre entre les projets, vous pouvez vous plonger dans ces domaines et vous constaterez souvent qu'après quelques essais, vous pourrez même identifier ces éléments.

Bonne chance!

Vous pouvez envisager de consulter les outils de reverse engineering du code source . Je connais deux outils:

Trousse SWAG (Linux uniquement) link
Bauhaus académique commercial

Les deux outils proposent des ensembles de fonctionnalités similaires, qui incluent une analyse statique qui produit des graphiques des relations entre les modules du logiciel.

Il s’agit principalement de graphes d’appel et de décences de type / classe. L'affichage de ces informations devrait vous donner une bonne idée de la relation entre les parties du code. En utilisant ces informations, vous pouvez chercher dans la source réelle les pièces qui vous intéressent le plus et que vous devez d'abord comprendre / modifier.

Je trouve que le simple fait de passer au code peut être un peu écrasant. Essayez de lire le plus de documentation possible sur la conception. J'espère que cela expliquera le but et la structure de chaque composant. C'est mieux si un développeur existant peut vous aider, mais ce n'est pas toujours possible.

Une fois que vous êtes à l'aise avec la structure de haut niveau du code, essayez de corriger un ou deux bugs. cela vous aidera à comprendre le code actuel.

J'aime toutes les réponses selon lesquelles vous devriez utiliser un outil tel que Doxygen pour obtenir un diagramme de classes et essayer d’abord de comprendre la situation dans son ensemble. Je suis totalement d'accord avec cela.

Cela dit, cela dépend en grande partie de la qualité de la factorisation du code. Si c'est un désordre gigantesque, il sera difficile à apprendre. Si c'est propre et bien organisé, ça ne devrait pas être si grave.

Voir Cette réponse explique comment utiliser les outils de couverture de test pour localiser le code d’une fonctionnalité qui vous intéresse, sans rien savoir de son emplacement, ni de la manière dont elle est répartie dans de nombreux modules.

(marketing éhonté à venir)

Vous devriez consulter nWire . C'est un plugin Eclipse pour naviguer et visualiser de grandes bases de code. Nombre de nos clients l’utilisent pour intégrer de nouveaux développeurs en imprimant des visualisations des principaux flux.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow