ZFX + Developia

Moin,

ich programmiere jetzt schon seit Jahren an meiner Engine / Framework/ Game herum und würde mir gerne mal anschauen, was genau ich da jetzt gemacht habe. Einerseits aus Eigeninteresse, andererseits um es auch mal anderen zeigen zu können ("Was heißt es eigentlich, seine eigene Engine zu machen?"). Ein Problem dabei ist, dass ich ja nicht nur eigenen Code habe, sondern auch viele andere Bibliotheken auf die ein oder andere Art verwende. Sprich: Irgendwie muss auch klar sein, was ich gemacht habe und was nur benutzt wird.

Ein paar Ideen:
- Quellcode 'ausdrucken' und eine lange pdf daraus machen. Dann hat man ein dickes Buch mit vielen kurzen Zeilen. Naja.
- Ordnerstruktur visualisieren: Ich habe verschiedene Projekte (Utilities, Engine, Render, Game) und auf Dateiebene kann man schon ganz nett sehen, was da wo drin steckt. Man könnte auch die Größe der Dateien in die Visualisierung aufnehmen, die ist nämlich recht unterschiedlich.
- Ein cooler Graph. Ich glaube, das ist, was ich eigentlich will. Das Problem ist, dafür muss man schon den Code parsen um zu verstehen, was wo wie benutzt wird. Eigentlich fände ich es cool, wenn es ein Tool gäbe, das mir auf Dateien, Klassen, oder Funktionsebene einen entsprechenden Graphen generieren würde (ein bisschen wie ein UML Diagramm, nur eben nicht so hässlich :P). Hier wäre halt wichtig, dass externe Abhängigkeiten nicht komplett aufgenommen werden, ansonsten explodiert das Ding ja direkt vollständig.

hat sich jemand von euch damit schonmal beschäftigt? Ich stelle mir das ein wenig so vor, wie eine große Uhr, deren Kasten man öffnet: Man sieht ganz viele Zahnräder und wo es welche Mechanismen gibt und kann sich eine Vorstellung davon machen, wie komplex (oder simpel, hehe) welche Teile sind, versteht aber nicht notwendigerweise alles was passiert.

Ahja: Ich will daran jetzt auch nicht 2 Wochen tüfteln. Gesucht ist eher irgendetwas nettes, womit man mal einen Abend rumspielt und dann gute Ergebnisse hat und dann wieder an ernsteren Themen weiterarbeiten kann :D

Sowas hier: https://gource.io/

Kleiner Spaß, der Dir die Commit History an Deiner Verzeichnisstruktur als hübsche Neon-Pflanzen visualisiert.

Ich habe da nur mal auf einer Konferenz was von Autor gesehen, machte erst mal nen guten Eindruck: http://moosetechnology.org/ keine Ahnung, wie gut man das mit C++ zum Laufen kriegt.

Ja gource habe ich früher auch mal getestet. Das ging schnell und einfach, aber ist halt mehr auf die zeitliche Entwicklung ausgelegt. Was aber ansich auch sehr cool ist.

Ich habe nachgedacht: GraphViz hab ich so schonmal benutzt, das lässt sich recht easy ansteuern. Hat irgendjemand Ahnung, wie schwierig es wäre die entsprechend benötigten Informationen z.B. mit LLVm zu extrahieren? Man hat da doch irgendwo als Zwischenschritt einen Abstract-Syntax-Tree, d.h. man sollte für jede Datei darüber iterieren können, welche Symbole definiert werden und welche Funktionen andere Funktionen aufrufen. Klingt doch fast so, als könne man da innerhalb eines langen Abends sich den Graph selber zusammen basteln und dabei dann noch sehr flexibel entscheiden, was genau man inkludieren will. Ist die Zeitschätzung realistisch oder muss man sich doch eher eine Woche einarbeiten?

Also das extrahieren/dumpen des AST ist so schwierig nicht bei Clang, dein Source muss halt mit Clang bauen ;)

Das parsen des AST scheint auch nicht so kompliziert zu sein, ich wollte das mal probieren und einen neuen checker für clang-tidy, schreiben, bin aber zeitlich nie über das Tutorial raus gekommen, und da war das komplizierteste das aufsetzen der Toolchain.

Ob man das an einem Abend hinbekommt, kein Ahnung aber an so nem Wochenende bestimmt.

Also generell kann man ja aus dem Clang AST ein JSON machen. Dann müsstest du halt davon irgendwie deinen GraphViz Teil erzeugen, je nach dem was du visualisieren willst.

Würde erwarten, dass es 1-6 Monate Arbeit mit clang ist, wenn es wirklich erkennbar besser sein soll als das, was dir gource macht. Schon alleine, weil man extrem schnell an den Punkt kommt, dass man sich mit kompakter Darstellung und tausend C++-Dingen, von denen man nie was wissen wolte, auseinandersetzen muss. Das Layouting wird GraphViz ohne Hilfe vermutlich auch nicht mehr einfach hinbekommen, wenn du mehr als grob 20-50 Knoten oder zu viele Kantentypen hast. Auf meinen Debugausgaben ist es mittlerweile eine Herausforderung Anfang und Ende des CFG zu finden; hab' jetzt aber glaube auch acht oder neun Kantentypen :-/

Edit: Sprach's und wurde 'ne halbe Stunde später mit folgendem Kunstwerk konfrontiert: Das ist einfach eine Disziplin, die einem immer wieder Bilder liefert, bei denen man eigentlich nur das Gefühl hat, dass irgendwas jetzt kaputt ist. Was genau kann man den Bildern fast nie entnehmen. Und das Problem ist halt, dass es auch einfach sein kann, dass du im dot-Generator irgendwo den falschen Variablennamen verwendet hast, um die Kante zu erzeugen.

Habe eben noch mal nach Moose geschaut. Keine Ahnung wie da genau der Zusammenhang zwischen Moose und Glamorous Toolkit ist. Mir scheint das fast wie ein Rebranding. Das was der Autor damals auf der OOP Konferenz gezeigt hat, war echt gut. Ich würde es mir echt mal anschauen: https://gtoolkit.com/docs/analyzing-cpp/

Für mehr von Haus aus gibt's glaube ich unter anderem das hier: https://www.hello2morrow.com/products/sonargraph
Das wird auch von Carola Lilienthal angepriesen. Ich glaube, wenn dich sowas interessiert, interessiert dich sicher auch ihr Talk: https://www.youtube.com/watch?v=QYG7dFPwSrM Ihr Buch "Langlebige Software-Architekturen: Technische Schulden analysieren, begrenzen und abbauen" finde ich auch ziemlich gut.