Comment visualiser la conception d'un moteur physique?

Je fais un moteur physique et il devient assez difficile de garder une trace de tout cela. Souvent, lorsque je reviens à mon code après une pause, je ne me souviens simplement pas pourquoi cela ne fonctionne pas. La plupart des problèmes ne sont pas de simples erreurs de programmation mais des défauts de conception dans mon moteur physique. C'est pourquoi je devrais juste finir de le concevoir avant de le programmer.

Cependant, j'ai besoin d'un moyen d'écrire sur papier toute la conception de mon moteur physique. Sinon, je vais juste l'oublier demain et être à nouveau perdu. Un diagramme de classes UML n'est pas du tout approprié pour la conception d'un moteur physique. Je ne me soucie pas vraiment des cours mais du processus. Je ne pense pas que le diagramme de processus métier soit vraiment utile car la modélisation d'une seule étape (trame) de mon processus ne m'aidera pas à comprendre le comportement final de mon moteur sur de nombreuses étapes.

Alors, quel type de diagramme dois-je utiliser pour m'aider à suivre le processus? Quel type de diagramme les professionnels utilisent-ils pour fabriquer un moteur physique?

FAIRE des listes sont des choses merveilleuses.

Je ne parle pas de // #TODO: blah blah comments. Je veux dire obtenir un cahier honnête envers Dieu.

On ne sait jamais quand on se souviendra de quelque chose d'important à faire. Un cahier sera tranquillement assis là et vous permettra de réfléchir sans vous plaindre de la façon dont votre écriture ne se compilera pas. Certaines de mes meilleures idées se produisent dans la salle de bain (oui, je possède un cahier étanche mais vous n'avez pas besoin d'aller aussi loin).

Vous pouvez en avoir des de poche qui sont cousues (non collées) afin qu'elles ne se désagrègent pas dans votre poche. Vous n'avez pas réussi à en obtenir un avec un marque-page intégré? Du ruban adhésif, des ciseaux, du ruban et personne ne le saura jamais.

Quand une idée arrive, notez-la. Dessinez de petites cases à côté de chaque idée et vous pouvez facilement la marquer comme terminée. Mettez une case en haut de la page et vous savez quand la page est terminée.

Quel accès séquentiel ne vous convient pas? Oui, ils font aussi des reliures de poche. Tout cela peut sembler un peu trop, mais c'est mieux que de se noyer dans des notes post-it ou d'essayer de tout capturer dans Jira.

Ne laissez pas les choses à moitié mises en œuvre

Gardez vos améliorations petites et réalisables. Ne commencez rien qui ne peut pas être terminé en une seule séance. Si c'est trop grand pour cela, décomposez-le en étapes plus petites. Laissez toujours le code qui compile et réussit ses tests. Oh et ne laissez pas passer des tests que vous n'avez jamais vus échouer. Faire un test à la fois réussir et échouer est la façon dont vous testez le test.

Arrêtez de penser que vous avez besoin de tout le design sur papier

Ce que vous devez faire, c'est capturer votre plan en évolution. Vous ne savez pas à quoi les choses vont ressembler lorsque vous aurez terminé, alors arrêtez de faire semblant. Capturez ce que vous avez compris du mieux que vous pouvez. Utilisez une serviette et un crayon au besoin. Peu de gens comprennent de toute façon 90% d'UML. Utilisez tout ce que vous pouvez pour montrer ce que vous devez montrer. Je me concentre sur l'affichage de mes interfaces et ce qui sait quoi.

Écrire des notes lorsque vous arrêtez de coder

Le moment où vous enlevez vos doigts des touches est la dernière fois que vous comprendrez ce que vous avez fait (et ce que vous avez prévu) ainsi que vous le faites maintenant. Capturez cette compréhension du mieux que vous pouvez dans certaines notes. Si tout ce que vous avez, ce sont des commentaires, vous êtes toujours attaché à l'ordinateur et vous risquez de laisser une flaque dans le fauteuil. Encore une fois, avoir un cahier est une chose formidable.

De cette façon, vous pouvez atterrir votre cerveau avec élégance, enregistrer votre vessie et décoller plus tard sans recourir à la caféine et au grincement des dents.

"Tout doit être construit de haut en bas, sauf pour la première fois", disent-ils.

Je commencerais par le niveau le plus bas (par exemple, les mathématiques vectorielles de base), et je m'assurerais de bien le comprendre et qu'il a une bonne couverture de test. Ensuite, je construirais une couche supplémentaire en plus de cela, permettant des opérations plus abstraites (par exemple, groupes / entités, détection de collision, mécanique des collisions). Encore une fois, je le couvrirais de tests; cela m'aiderait à réfléchir aux cas d'utilisation réels de ces abstractions dans le moteur.

Sauf si vous avez une très bonne compréhension de l'ensemble du moteur (par exemple lorsque vous réimplémentez un moteur existant bien connu), il est généralement bon d'avoir ces couches; il vous permet de penser à une couche particulière en termes de la couche précédente, et généralement pas beaucoup plus profond. Vous pouvez expérimenter et créer une couche avec de nouvelles abstractions utiles; ce qui s'avère pratique en réalité s'écarte souvent des idées initiales.

J'espère que chaque couche est suffisamment petite pour que vous n'ayez pas besoin d'un diagramme compliqué, ou il est facile d'en créer un utile.

Je n'ai jamais rencontré de diagramme de code complexe qui était utile. Les diagrammes d' interaction et de cycle de vie sont cependant utiles. Assez souvent, un diagramme comme celui-ci est contraint à 1-2 couches, et est donc simple.

Ce que je trouve généralement le plus précieux, ce sont les descriptions d'interface et les garanties fournies par chaque niveau. Par exemple, le format des mathématiques vectorielles et ce qui se passe sur les erreurs numériques; le format des descriptions d'objets plus grands (toujours convexe? toujours dans le sens des aiguilles d'une montre?, comment se croiser? etc.), les paramètres mécaniques de l'interaction (comment le temps avance? comment la masse est gérée? l'élan est-il toujours préservé? comment les forces sont-elles calculées?) puis interactions appropriées (comment gérer le frottement? la déformation? la fragmentation? est-ce que transformer l'énergie mécanique en pertes de chaleur est une chose?).

Chaque couche doit être suffisamment petite pour avoir une quantité observable de choses qu'elle introduit et garantit qu'elle fournit. Cette description peut même être rédigée sans qu'aucun code d'implémentation ne soit (encore) écrit. Cela réduit la chance de déterminer que vous avez fait quelque chose d'horriblement mal à trois niveaux de profondeur; si vous le faisiez, il serait déjà visible à au plus deux couches de profondeur.

Faites des diagrammes de l'architecture! Les diagrammes de pipeline OpenGL FrustratedWithFormsDesigner publiés dans les commentaires sont un excellent exemple pour le flux de programme , mais ce n'est qu'un type de diagramme qui peut être utile.

Lors de la conception de diagrammes, vous souhaitez rendre la compréhension du code simple et intuitive; cela peut englober à la fois des concepts de haut niveau (comme la ligne supérieure des nœuds dans ce diagramme de pipeline OpenGL, en disant quelque chose) ou des détails techniques très granulaires (comme un graphique d'appel de fonction complète).

Idéalement, votre documentation devrait également faciliter la compréhension du code par d'autres personnes; cela peut faciliter la révision de code ou la collaboration open source. Regardez les grands projets pour voir comment ils y parviennent - lorsque vous travaillez avec des centaines de milliers ou des millions de lignes de code, comprendre le fonctionnement du programme sans avoir à le lire est extrêmement important pour garder une trace de la base de code ou la présenter à d'autres. . Le référentiel Vim, avec 1,3 million de LOC, a une très bonne documentation de haut niveau (IMO) pour cela dans /src/README.txt . Il présente:

• Quel code dans chaque fichier fait
• Variables globales importantes et leurs valeurs
• Que se passe-t-il dans la boucle principale et quelles sont les fonctions qu'elle appelle
• Que se passe-t-il dans chacun des modes et les principales fonctions qui les gèrent
• Quelles sont les fonctionnalités de débogage natives

Si je veux apporter un correctif, je sais généralement quel fichier je dois modifier pour atteindre mes objectifs sans trop creuser.

L'une des meilleures caractéristiques de Vim /src/README.txtest sa facilité de recherche et son exhaustivité; ce n'est pas granulaire dans tous les sens, mais si vous cliquez sur le srcdossier sur Github, il se charge automatiquement et donne des indications pour trouver d'autres codes ou de la documentation. Comparez cela avec le dépôt Powershell, que j'ai cherché pour un exemple mais que je n'ai pas pu trouver de fichier ou de fichiers équivalents à ceux de Vim /src/README.txt. (Un mauvais signe pour un projet avec 988 mille LOC!)

Certaines choses que vous voudrez peut-être schématiser ou documenter incluent:

• Flux conceptuel du programme (Qu'est-ce que le programme accomplit et dans quel ordre?)
• Graphique du flux de programme / appel de fonction implémenté (Comment le programme atteint-il ses objectifs? Quelles fonctions sont appelées ou classes créées?)
• Quel code est dans quels fichiers? Quel est le schéma organisationnel et quelles règles avez-vous pour déterminer où va une nouvelle fonction? Si vous avez un schéma organisationnel solide, il sera facile de savoir dans quel fichier rechercher une fonction ou une classe donnée, même sans IDE ou fonction de recherche à l'échelle du projet de type IDE.
• De même, quels fichiers incluent quels autres fichiers (liés à un graphique d'appel de fonction)?
• Quelles classes héritent de quelles autres classes? Quel est le but de chaque classe?

Comment pouvez-vous faire ces diagrammes? À votre niveau, et pour les premiers brouillons, le crayon et le papier sont probablement la méthode la meilleure / la plus rapide. Lorsque les diagrammes et la documentation deviennent plus raffinés, vous pouvez examiner:

• Dot / Graphviz, un ensemble de programmes pour générer des graphiques à partir de .dotfichiers.
• LaTeX / TikZ, un outil très complexe et détaillé pour générer des graphiques ou des images de toute sorte - il peut être trop lourd pour vos besoins, d'autant plus que tout le positionnement des nœuds est manuel, mais doit être gardé à l'esprit, surtout si vous prévoyez d'écrire un papier ou quoi que ce soit de ce genre plus tard.
• Pour C, gson egypts'accroche gccet génère un .dotgraphe d'appel. Peut être automatisé ou intégré dans une makecommande, ce qui est bien!
• De manière similaire, GNU cflowpeut générer des graphes d'appels texte uniquement pour C. Des outils équivalents peuvent exister pour d'autres langues, bien que vous souhaitiez peut-être vous éloigner des outils automatisés en général - ne pas créer le graphique manuellement peut entraver votre compréhension du code ou fournir un niveau de détail complexe (il printf()n'est généralement pas utile de savoir quelles fonctions appellent ).

Essayez d'utiliser un diagramme basé sur des réseaux de Petri. Il est possible de traduire le diagramme en programmes informatiques de manière systématique, et il est possible d'intégrer des diagrammes de haut niveau avec des diagrammes de bas niveau.

Les références

Éléments nets et annotations: un langage de programmation visuel à usage général (2016). Disponible sur https://www.academia.edu/31341292/Net_Elements_and_Annotations_A_General-Purpose_Visual_Programming_Language .

Éléments nets et annotations pour la programmation informatique: calculs et interactions en PDF (2014). Disponible sur https://www.academia.edu/26906314/Net_Elements_and_Annotations_for_Computer_Programming_Computations_and_Interactions_in_PDF .