• Vorträge

    Viele Vorträge, die auf Konferenzen gehalten werden, landen irgendwo im Internet. Wir haben sie für euch zusammengesucht.

    • Größe eines Projektes bestimmen – phploc

    von Nils Langner am 18. Juni 2009

    Das Projekt an dem ich gerade sitze, hat bestimmt eine Millionen Zeilen! Oder eher 100.000? Auf jeden Fall sind es tausenden von Dateien, oder halt auch nicht.

    Bis jetzt habe ich immer noch geraten oder besser geschätzt, welchen Umfang die Projekten haben, mit denen ich hantiere. Aber wie immer, gibt es hier auch ein Tool, dass einem behilflich dabei ist, wenn man genaue Zahlen an den Mann bringen will.

    phploc

    Das Tool von dem ich rede nennt sich phploc, was wohl so viel wie “php lines of code” heißen soll. Und wie fast alle Tools, die wir hier vorstellen – zumindest gefühlt – stammt auch dieses Helferchen aus der Feder von Sebastian Bergmann. Das Tool kann dazu verwendet werden die Anzahl an Zeilen PHP Code zu bestimmen. Dabei unterscheidet phploc zwischen Kommentaren und richtigem Code. Zusätzlich zählt es die Interfaces, Klassen, nicht- und statische Methoden und die Funktionen. Das alles auch noch in einer relativ kurzen Zeit.

    Installiert wird das Tool, wie viele andere auch, über den PEAR Installer. Ganz einfach

      pear channel-discover pear.phpunit.de
  pear install phpunit/phploc

    eingeben und schon habt ihr das alles benötigte auf der Platte und könnt es verwenden. In meinem Screenshot seht ihr die Statistik meines Wordpress phphatesme Themes. Das würde zumindest erklären, warum keine Interfaces drinnen sind, denn normalerweise bin ich der König des Interfaces.

    Ihr könnt ja mal aus Spaß eure aktuellen Projekte analysieren und hier posten. Würde mich mal interssieren, wie viele Zeilen ihr so im Durchschnitt zu bieten habt.

    Nils Langner Nils Langner

    Auch wenn Ihr es mir nicht glauben werdet, aber ich habe nichts gegen PHP. Ich rege mich einfach nur gerne auf. Ok so schlimm ist es auch nicht. Eigentlich wollte ich schon immer einen Blog haben und da ...

    Zum Profil von Nils Langner

    22 Kommentare »


    • Tobi
      am 18. Juni 2009 um 08:57 Uhr

      Ich hab mich die letzte Zeit auch mit Metriken beschäftigt und bin mittlerweile sehr skeptisch was die Aussagekraft angeht. Für einen ersten Überblick finde ich solche Tools ganz gut, insgesamt muss man solche Zahlen schon für eigene Projekte validieren um hier wirklich Rückschlüsse auf das Programm folgern zu können.

      Viele Grüße
      Tobi


    • Nils Langner
      am 18. Juni 2009 um 09:44 Uhr

      @Tobi Metriken geben ja nur einen Anhaltspunkt, wann es es ich lohnt mal genauer nachzuschauen. Ich würde niemals in einem Projekt verbieten, dass z.B. eine McCabe Metrik den Wert 4 nicht übersteigen darf. Wenn der Wert dies aber übersteigt, würde ich verlangen, dass argumentiert wird warum.


    • Jörg Kirchhoff
      am 18. Juni 2009 um 09:53 Uhr

      Meine aktuelle interne Webanwendung hat folgende Eckdaten:

      Directories: 15
      Files: 143

      Lines of Code (LOC): 15867
      Comment Lines of Code (CLOC): 5124
      Non-Comment Lines of Code (NCLOC): 10743

      Interfaces: 1
      Classes: 61
      Non-Static Methods: 385
      Static Methods: 48
      Functions: 2

      Gruß
      Jörg


    • Nils Langner
      am 18. Juni 2009 um 09:58 Uhr

      @Jörg: Kaum Interfaces? Schade ;) Aber danke, dass du den Anfang gemacht hast!


    • Jörg Kirchhoff
      am 18. Juni 2009 um 10:03 Uhr

      Das eine Interface hab ich für meine Debugger Klassen gebastelt, welche per Factory Pattern verwendet werden. Für die Datenexport Klassen wird dann noch ein weiteres Interface kommen ;-) Dann sind es wenigstens 2


    • Seb
      am 18. Juni 2009 um 10:12 Uhr

      In einem dir bekannten Projekt: ;)

      Directories: 715
      Files: 3797

      Lines of Code (LOC): 713116
      Comment Lines of Code (CLOC): 207252
      Non-Comment Lines of Code (NCLOC): 505864

      Interfaces: 76
      Classes: 2360
      Non-Static Methods: 14941
      Static Methods: 643
      Functions: 2523

      Und noch ein sehr lange nicht mehr angefasstes privates Projekt:
      Directories: 10
      Files: 36

      Lines of Code (LOC): 3834
      Comment Lines of Code (CLOC): 1297
      Non-Comment Lines of Code (NCLOC): 2537

      Interfaces: 0
      Classes: 28
      Non-Static Methods: 155
      Static Methods: 25
      Functions: 5

      Ok, auch sehr wenige interfaces.. Das meiste geht da über ein paar Abstrakte Klassen, die hätten aber auch in Interface vertragen können ;)


    • Nils Langner
      am 18. Juni 2009 um 10:14 Uhr

      @Seb: Und ich wette dass 30 von den Interfaces von mir sind ;)


    • Elvis Nefsky
      am 18. Juni 2009 um 10:15 Uhr

      Dann poste ich mal auch mal meine Eckdaten vom letzten Projekt

      Directories: 10
      Files: 83

      Lines of Code (LOC): 19937
      Comment Lines of Code (CLOC): 5186
      Non-Comment Lines of Code (NCLOC): 14751

      Interfaces: 0
      Classes: 66
      Non-Static Methods: 239
      Static Methods: 6
      Functions: 42


    • Jörg Kirchhoff
      am 18. Juni 2009 um 10:38 Uhr

      Hab mal noch unser selbstentwickeltes DMS absuchen lassen:

      Directories: 244
      Files: 1353

      Lines of Code (LOC): 375031
      Comment Lines of Code (CLOC): 82827
      Non-Comment Lines of Code (NCLOC): 292204

      Interfaces: 0
      Classes: 447
      Non-Static Methods: 4131
      Static Methods: 102
      Functions: 1890

      Leider gar kein Interface :-/

      Gruß
      Jörg


    • Nils Langner
      am 18. Juni 2009 um 10:42 Uhr

      Ich glaube ich muss mal eine “Rettet das Interface” Aktions ins Leben rufen.


    • Dennis Becker
      am 18. Juni 2009 um 10:47 Uhr

      Leider habe ich noch kein Projekt so weit, dass essich lohnt, da mal phploc drüber laufen zu lassen, daher gibt’s mal die Daten zum Zend Framework 1.8.3, dass ich für’s Projekt verwende:

      Directories: 348
      Files: 1689

      Lines of Code (LOC): 335953
      Comment Lines of Code (CLOC): 156373
      Non-Comment Lines of Code (NCLOC): 179580

      Interfaces: 84
      Classes: 1603
      Non-Static Methods: 9981
      Static Methods: 669
      Functions: 412

      So hat man mal ne ganz andere Vorstellung vom Umfang des ZF. Was mir persönlich noch fehlt, ist neben den Interfaces die abstrakten Klassen, welche im ZF häufig verwendet werden. Ein sehr interessantes Tool :)

      Wer sich noch andere Daten anschauen möchte, dem kann ich noch sloccount (http://www.dwheeler.com/sloccount/) empfehlen. Hier mal ein Teil des Outputs, den man beim ZF 1.8.3 kriegt:

      Total Physical Source Lines of Code (SLOC) = 148,458
      Development Effort Estimate, Person-Years (Person-Months) = 38.13 (457.50)
      (Basic COCOMO model, Person-Months = 2.4 * (KSLOC**1.05))
      Schedule Estimate, Years (Months) = 2.14 (25.64)
      (Basic COCOMO model, Months = 2.5 * (person-months**0.38))
      Estimated Average Number of Developers (Effort/Schedule) = 17.84
      Total Estimated Cost to Develop = $ 5,150,216
      (average salary = $56,286/year, overhead = 2.40).
      SLOCCount, Copyright (C) 2001-2004 David A. Wheeler
      SLOCCount is Open Source Software/Free Software, licensed under the GNU GPL.
      SLOCCount comes with ABSOLUTELY NO WARRANTY, and you are welcome to
      redistribute it under certain conditions as specified by the GNU GPL license;
      see the documentation for details.
      Please credit this data as “generated using David A. Wheeler’s ‘SLOCCount’.”

      Vielleicht hat ja noch jemand Spaß mit diesem Tool :)

      Gruß Dennis


    • Frank Kleine
      am 18. Juni 2009 um 11:29 Uhr

      Stubbles, mit Tests:

      Directories: 180
      Files: 804

      Lines of Code (LOC): 101309
      Comment Lines of Code (CLOC): 48281
      Non-Comment Lines of Code (NCLOC): 53028

      Interfaces: 88
      Classes: 906
      Non-Static Methods: 4859
      Static Methods: 216
      Functions: 9

      Ohne Tests:

      Directories: 94
      Files: 466

      Lines of Code (LOC): 50038
      Comment Lines of Code (CLOC): 26659
      Non-Comment Lines of Code (NCLOC): 23379

      Interfaces: 77
      Classes: 388
      Non-Static Methods: 2316
      Static Methods: 170
      Functions: 4

      Definitiv noch zu viele statische Methoden. :-/


    • Nils Langner
      am 18. Juni 2009 um 11:39 Uhr

      @Frank: Ich würde sagen Stubbles ist trotzdem mein Favorit bis jetzt :) Zumindest durch die Interface-Brille betrachtet.


    • Michael Haszprunar
      am 18. Juni 2009 um 12:21 Uhr

      Hi,
      Für solche Dinge verwende ich immer den “Lines of Code Wichtel” (Java-Programm ).
      Der kann zwar keine Klassen zählen, dafür aber alle Sorten von Code, also auch HTML/CSS/JS zum Beispiel, der ja bei Projekten einen nicht unerheblichen Teil ausmacht. Man kann hier auch selbst einen Haufen Einstellungen machen, z.b. was als KOmmentare gewertet werden soll und was nicht, etc etc.

      BTW: Das Beispiel sieht komisch aus. 64 Files und nur 3 Funktionen? Da kann doch was nicht stimmen ;-)


    • Nils Langner
      am 18. Juni 2009 um 12:51 Uhr

      @Michael: Doch doch, das stimmt schon. Sind 63 Template Files und eine Datei mit Funktionen, die in den Templates gebraucht werden und noch nicht von Wordpress abgedeckt sind.


    • Michael
      am 18. Juni 2009 um 14:48 Uhr

      Dann auch meine beiden größeren Projekte in der Firma (kleinere Webseiten, die in wenigen Manntagen erstellt wurden, lasse ich mal weg). Das erste Projekt ist ca. 1 Jahr alt, da arbeite ich allein dran:

      ————————————————————
      Directories: 113
      Files: 318

      Lines of Code (LOC): 42600
      Comment Lines of Code (CLOC): 10565
      Non-Comment Lines of Code (NCLOC): 32035

      Interfaces: 0
      Classes: 317
      Non-Static Methods: 1852
      Static Methods: 176
      Functions: 37
      ————————————————————

      Das zweite Projekt gibt es seit ca. 2 Jahren, und es arbeiten ca. 2,5 Personen daran.

      ————————————————————
      Directories: 159
      Files: 643

      Lines of Code (LOC): 213698
      Comment Lines of Code (CLOC): 31037
      Non-Comment Lines of Code (NCLOC): 182661

      Interfaces: 3
      Classes: 571
      Non-Static Methods: 3448
      Static Methods: 294
      Functions: 69
      ————————————————————

      Interfaces sind bei uns auch Mangelware ;)

      Interessant finde ich das Verhältnis von Code zu Kommentaren bei ALLEN Beispielen hier. Es scheint immer zwischen 15% und 50% zu liegen.


    • Nils Langner
      am 18. Juni 2009 um 14:51 Uhr

      @Michael: Sehr schöne Feststellung: Zwischen 15% und 50% :) Aber das mit den Interfaces finde ich schon erschreckend.


    • Ulf
      am 19. Juni 2009 um 06:36 Uhr

      Und wenn euer pear nicht mehr aktuell genug ist (da phploc mindestens 1.8.1 benötigt), müsst ihr als erstes noch “pear upgrade PEAR” laufen lassen.

      Mein größtes Projekt sieht so aus:
      ————————————————————
      Directories: 478
      Files: 1702

      Lines of Code (LOC): 209632
      Comment Lines of Code (CLOC): 61686
      Non-Comment Lines of Code (NCLOC): 147946

      Interfaces: 266
      Classes: 1372
      Non-Static Methods: 9755
      Static Methods: 182
      Functions: 168


    • Nils Langner
      am 19. Juni 2009 um 14:32 Uhr

      @Ulf: Danke für den Update Hinweis. Hätte ich eigentlich hinschreiben sollen, denn ich stand vor dem Problem. Ich musste sogar den –force Parameter noch mit anhängen.


    • Elvis Nefsky
      am 19. Juni 2009 um 15:23 Uhr

      @Nils: Da lobe ich mir den altbewährten Parameter: “–force –doWhatIwant” :)


    • Malf
      am 20. Juni 2009 um 18:01 Uhr

      Leider kommt bei mir immer folgender Fehler. Die memory_size in der php.ini habe ich auf 128MB erhöht

      Fatal error: Allowed memory size of 33554432 bytes exhausted (tried to allocate
      35 bytes) in C:\xampp\php\PEAR\PHPLOC\Analyser.php on line 82


    • admin
      am 21. Juni 2009 um 16:58 Uhr

      @Malf: Es kann sein, dass für die Kommandozeilenversion (CLI) eine andere php.ini verwendet wird, als du angegeben hast. Versuch doch mal über “php -i” rauszufinden, wie groß der maximale Speicher sein darf.

    RSS-Feed für Kommentare zu diesem Artikel. TrackBack-URL

    Einen Kommentar hinterlassen

    Werbung
    PHP Magazin
    Ausgabe 02/2010

    Dieses Mal mit Artikeln zu den Themen OpenSocial und Apache Shindig, Graphentheorie, Smarty3

    t3n
    Ausgabe 19

    Social Media (R)evolution. Weitere Themen sind noSQL, Crowdsourcing ...

    PHP Journal
    Ausgabe 2/2010

    PHP & Windows optimal nutzen, die besten PHP-CMS im Überblick, Google-API mit Zend Framework nutzen.

    Wir wurden schon öfters gefragt, ob man uns nicht irgendwie unterstützen kann. Die Antwort war immer einfach: Klar! Am einfachsten ist es eure nächsten Einkäufe bei Amazon über unsere Link abzuwickeln. Damit würdet ihr uns schon sehr helfen. Über Co-Autoren freuen wir uns aber noch mehr.