Comment dois-je visualiser la structure de mon code? [fermé]

J'ai essayé d'utiliser un certain nombre D'outils UML et j'ai trouvé que les capacités de rétro-ingénierie dans la plupart des outils UML n'étaient pas utiles pour comprendre le code . Ils se concentrent sur la conception des besoins et des capacités de rétro-ingénierie finit souvent par montrer d'énormes images de beaucoup d'informations inutiles. Quand je travaillais sur la base de code Microsoft Office, j'ai trouvé que l'utilisation d'un stylo et d'un papier était plus utile que les outils de conception/modélisation typiques.

Vous voulez généralement penser à faire ceci dans un certain nombre de façons:

1. Utilisez votre cerveau : Quelqu'un d'autre l'a mentionné - il n'y a pas de substitut à essayer de comprendre une base de code. Vous devrez peut-être prendre des notes et y revenir plus tard. Des outils d'aide? Certainement. Mais ne vous attendez pas à faire la plupart du travail pour vous.
2. Trouver de la documentation et parler à des collègues: Il N'y a pas de meilleur moyen que d'avoir une source décrivant les concepts principaux dans une base de code. Si vous pouvez trouver quelqu'un vous aider, prendre un stylo et du papier, aller à lui et prendre beaucoup de notes. Combien de bug l'autre personne? Au début, autant que possible pour votre travail, mais aucun montant n'est trop petit.
3. pensez aux outils : Si vous êtes nouveau dans une partie d'un projet - vous allez passer beaucoup de temps à comprendre le code, alors voyez combien d'aide vous pouvez obtenir automatiquement. Il y a de bons outils et de mauvais outils. Essayez de comprendre quels outils ont des capacités qui pourraient être utile pour vous d'abord. Comme je l'ai mentionné ci-dessus, l'outil UML moyen se concentre plus sur la modélisation et ne semble pas ne pas être la bonne solution pour vous.
4. Temps vs coût : Bien Sûr, gratuit est génial. Mais si un outil gratuit n'est pas utilisé par beaucoup de gens - peut-être que l'outil ne fonctionne pas. Il y a beaucoup d'outils qui ont été créés juste comme une exploration de ce qui pourrait être fait, mais ne sont pas vraiment utiles et donc juste mis à disposition gratuitement dans l'espoir que quelqu'un d'autre va l'adopter. Un autre façon de penser à ce sujet, décider combien votre temps vaut - il pourrait être logique de passer un jour ou deux pour obtenir un outil pour travailler pour vous.

Une fois sur place, gardez-les à l'esprit lorsque vous essayez de comprendre le projet:

1. The Mile High View : un diagramme architectural en couches peut être très utile pour savoir comment les concepts principaux dans un projet sont liés les uns aux autres. Des outils comme Lattix et Architexa peut être vraiment utile ici.
2. Le noyau : Essayez de comprendre comment le code fonctionne en ce qui concerne les concepts principaux . Les diagrammes de classe sont exceptionnellement utiles ici. Stylo-et-papier fonctionne assez souvent ici, mais les outils peuvent non seulement accélérer le processus, mais aussi vous aider à enregistrer et partager de tels diagrammes. Je pense AgileJ et Architexa sont vos meilleurs paris ici, mais la moyenne de votre outil UML peut souvent être assez bon.
3. Utilisation De La Clé Cas : je suggère de tracer au moins un cas d'utilisation clé pour votre application. Vous pouvez probablement obtenir les cas d'utilisation les plus importants de n'importe qui dans votre équipe, et le parcourir sera vraiment utile. La plupart des IDE sont vraiment utiles ici. Si vous essayez de les dessiner, alors les diagrammes de séquence sontle plus approprié. Pour les outils ici je pense MaintainJ, JDeveloper et Architexa sont vos meilleurs paris ici.

Note: je suis le fondateur de Architexa - nous créer des outils pour vous aider comprendre et documenter le code Java, mais j'ai essayé d'être impartiale ci-dessus. Mon intention est de suggérer des outils et des options étant donné que c'est ce sur quoi je me suis concentré dans le cadre de mon doctorat.

, Il est stocké dans plusieurs fichiers. Il utilise différentes classes avec différentes méthodes. Le code est grand et compliqué.

Tout le code Java écrit en dehors de l'école est comme ça, en particulier pour un nouveau développeur débutant un projet.

C'est une vieille question, mais comme cela arrive dans les recherches Google, j'ajoute ma réponse ici afin qu'elle puisse être utile aux futurs visiteurs. Permettez - moi également de révéler que je suis l'auteur de MaintainJ .

N'essayez pas de comprendre l'ensemble de l'application

Laissez-moi vous demander ceci-Pourquoi voulez-vous comprendre le code? Très probablement, vous corrigez un bug ou améliorer une fonctionnalité de l'application. La première chose que vous ne devriez pas essayer de faire est de comprendre toute l'application. Essayer de comprendre toute l'architecture tout en redémarrant un projet vous submergera.

Croyez-moi quand je dis cela-développeurs avec 10 + années de une expérience de codage solide peut ne pas comprendre comment certaines parties de l'application fonctionnent même après avoir travaillé sur le même projet pendant plus d'un an (en supposant qu'ils ne sont pas les développeurs d'origine). Ils peuvent ne pas comprendre comment fonctionne l'authentification ou comment fonctionne la gestion des transactions dans l'application. Je parle d'applications d'entreprise typiques avec des classes 1000 à 2000 et utilisant différents frameworks.

Deux compétences importantes nécessaires pour maintenir une grande les applications de

Alors, comment survivent-ils et sont payés beaucoup d'argent? Développeurs expérimentés comprennent généralement ce qu'ils font; ce qui signifie, si ils sont à corriger un bug, ils vont trouver l'emplacement de la bogue, corrigez-le et assurez-vous qu'il ne rompt pas le reste de l'application. S'ils ont besoin d'améliorer une fonctionnalité ou d'ajouter une nouvelle fonctionnalité, la plupart du temps, ils doivent simplement imiter une fonctionnalité existante qui fait une chose similaire.

Il y a deux compétences importantes qui les aident à faire ce.

1. Ils sont capables d'analyser l'impact des changements qu'ils font tout en corrigeant un bug. D'abord, ils localisent le problème, changent le code et le testent pour s'assurer que cela fonctionne. Ensuite, parce qu'ils connaissent bien le langage Java et les frameworks "assez bien", ils peuvent dire si cela va casser d'autres parties de l'application. Si pas, ils sont fait.

2. J'ai dit que ils ont simplement besoin d'imiter pour améliorer l'application. Pour imiter efficacement, il faut connaître Java bien et comprendre les cadres "assez bien". Par exemple, lorsqu'ils ajoutent une nouvelle classe D'Action Struts et qu'ils ajoutent au fichier XML de configuration, ils vont d'abord trouver une fonctionnalité similaire, essayer de suivre le flux de cette fonctionnalité et comprendre comment cela fonctionne. Ils peuvent avoir à modifier un peu de la configuration(comme les données 'form' étant dans 'request' que dans 'Session' scope). Mais s'ils savent les cadres 'assez bien', ils peuvent facilement le faire.

La ligne de fond est, Vous vous n'avez pas besoin de comprendre ce que toutes les classes 2000 font pour corriger un bug ou améliorer l'application. Il suffit de comprendre ce qui est nécessaire.

Mettre l'accent sur la valeur immédiate

Est-ce que je vous décourage de comprendre l'architecture? Non, pas du tout. Tout ce que je vous demande, c'est de livrer. Une fois que vous démarrez un projet et une fois que vous avez configuré l'environnement de développement sur votre PC, vous ne devriez pas prendre plus d'une semaine pour livrer quelque chose, aussi petit soit-il. Si vous êtes-vous un programmeur expérimenté et ne livrez rien après 2 semaines, comment un manager peut-il savoir si vous travaillez vraiment ou lisez des nouvelles sportives?

Donc, pour rendre la vie plus facile pour tout le monde, livrer quelque chose. Ne pas aller avec l'attitude que vous devez comprendre toute l'application pour livrer quelque chose de précieux. C'est complètement faux. L'ajout d'une validation Javascript petite et localisée peut être très utile pour l'entreprise et lorsque vous la livrez, le gestionnaire se sent soulagé que il a une certaine valeur pour son argent. De plus, il vous donne le temps de lire les nouvelles sportives.

Comme le temps passe et après avoir livré 5 petites corrections, vous commenceriez à comprendre lentement l'architecture. Ne sous-estimez pas le temps nécessaire pour comprendre chaque aspect de l'application. Donner 3-4 jours pour comprendre l'authentification. Peut-être 2-3 jours pour comprendre la gestion des transactions. Cela dépend vraiment de l'application et de votre expérience antérieure sur des applications similaires, mais je suis juste donner les estimations approximatives. Voler le temps entre la réparation des défauts. Ne demandez pas à l'époque.

Lorsque vous comprenez quelque chose, écrivez des notes ou dessinez le diagramme du modèle de classe/séquence/données.

Les Diagrammes de

Haaa...it il m'a fallu si longtemps pour mentionner les diagrammes :). J'ai commencé avec la divulgation que je suis l'auteur de MaintainJ, l'outil qui génère des diagrammes de séquence d'exécution. Laissez-moi vous dire comment cela peut vous aider.

La grande partie de la maintenance est de localiser la source d'un problème ou pour comprendre comment une fonction.

Les diagrammes de séquence générés par MaintainJ montrent le flux d'appel et le flux de données pour un seul cas d'utilisation. Ainsi, dans un diagramme de séquence simple, vous pouvez voir quelles méthodes sont appelées pour un cas d'utilisation. Donc, si vous corrigez un bug, le bug est probablement dans l'une de ces méthodes. Il suffit de le réparer, de s'assurer qu'il ne casse rien d'autre et de sortir.

Si vous avez besoin d'améliorer une fonctionnalité, comprenez le flux d'appels de cette fonctionnalité en utilisant le diagramme de séquence, puis l'améliorer. L'amélioration peut être comme l'ajout d'un champ supplémentaire ou l'ajout d'une nouvelle validation, etc. Généralement, l'ajout d'un nouveau code est moins risqué.

Si vous avez besoin d'ajouter une nouvelle fonctionnalité, trouvez une autre fonctionnalité similaire à ce que vous devez développer, comprenez le flux d'appels de cette fonctionnalité en utilisant MaintainJ, puis imitez-la.

Semble simple? C'est en fait simple, mais il y aura des cas où vous ferez des améliorations plus importantes comme la construction d'un entièrement nouvelle fonctionnalité ou quelque chose qui affecte la conception fondamentale de l'application. Au moment où vous essayez quelque chose comme ça, vous devriez être familier avec l'application et comprendre l'architecture de l'application raisonnablement bien.

Deux mises en garde à mon argument ci-dessus

1. J'ai mentionné que l'ajout de code est moins risqué que de modifier le code existant. Parce que vous voulez éviter de changer, vous pourriez être tenté de simplement copier une méthode existante et d'y ajouter plutôt que de changer le code existant. Résister à cette tentation. Toutes les applications ont une certaine structure ou "uniformité". Ne le gâchez pas par de mauvaises pratiques comme la duplication de code. Vous devez savoir quand vous vous écartez de l '"uniformité". Demandez à un développeur principal sur le projet d'examiner les changements. Si vous devez faire quelque chose qui ne suit pas les conventions, assurez-vous au moins qu'il est local à une petite classe (une méthode privée dans une classe de 200 lignes ne ruinerait pas l'esthétique de l'application).

2. Si vous suivez l'approche décrite ci-dessus, bien que vous puissiez survivre pendant des années dans l'industrie, vous risquez de ne pas comprendre les architectures d'application, ce qui n'est pas bon à long terme. Cela peut être évité en travaillant sur des changements plus importants ou en un peu moins de temps sur Facebook. Passez du temps à comprendre l'architecture lorsque vous êtes un peu libre et documentez-la pour d'autres développeurs.

Conclusion

Mettre l'accent sur la valeur et l'utilisation immédiates les outils qui offrent cela, mais ne soyez pas paresseux. Les outils et les diagrammes aident, mais vous pouvez vous en passer aussi. Vous pouvez suivre mes conseils en prenant juste un certain temps d'un développeur senior sur le projet.

Quelques plugins que je connais pour Eclipse:

Architexa

Http://www.architexa.com/

NWire

Http://www.nwiresoftware.com/

Si vous voulez désosser le code, vous devriez essayer architecte D'entreprise

Avez-vous essayé Google CodePro Analytix ?

Il peut par exemple afficher des dépendances et est gratuit (capture d'écran de cod.google.com):

Jude Community UML était capable d'importer Java, mais ce n'est plus le cas. C'est un bon outil gratuit.

Si votre application est vraiment complexe, je pense que les diagrammes ne vous transporteront pas très loin. Lorsque les diagrammes deviennent très complexes, ils deviennent difficiles à lire et perdent leur pouvoir. Certains diagrammes bien choisis, même s'ils sont générés à la main, pourraient suffire.

Vous n'avez pas besoin de toutes les méthodes, paramètres et valeurs de retour. Habituellement, il est juste les relations et interactions entre les objets ou les packages dont vous avez besoin.

Voici un outil non UML qui a de très belles fonctionnalités de visualisation.

Vous pouvez mapper les lignes de code par classe / méthode aux couleurs / longueur latérale des rectangles. Vous pouvez également afficher les dépendances entre les classes.

Http://www.moosetechnology.org/

La bonne chose est, vous pouvez utiliser SMalltalk scripting pour afficher ce dont vous avez besoin: http://www.moosetechnology.org/docs/faq/JavaModelManipulation

Ici vous pouvez voir comment un tel visualisation ressemble: http://www.moosetechnology.org/tools/moosejee/casestudy

Voici un autre outil qui pourrait faire l'affaire: http://xplrarc.massey.ac.nz/

Vous pouvez utiliser l'outil JArchitect, un outil assez complet pour visualiser votre structure de code en utilisant le graphique de dépendance , et parcourir votre code source comme une base de données en utilisant CQlinq. JArchitect est gratuit pour contributeurs open source

Quelques excellents outils que j'utilise -

StarUML (permet la conversion du code au diagramme)

Mme Visio

XMind (très très utile pour une vue d'ensemble du système)

Stylo et papier!