Code Effizienz überprüfen

  • Allgemein

Es gibt 21 Antworten in diesem Thema. Der letzte Beitrag () ist von hal2000.

    Code Effizienz überprüfen

    Hallo Zusammen,

    da es sich um eine Programmiersprachen-unabhängige Frage handelt, packe ich es mal ins Off-Topic.

    Gibt es eine Möglichkeit, ein vorhandenes Skript auf seine Effizienz zu überprüfen?
    Bzw. gibt es bereits eine Möglichkeit (ohne Algorithmus) nach dem man Code und seine Effizienz überprüfen kann?

    Nach was für Kriterien kann man Code beurteilen? -> Ausführungszeit, Durchläufe von Schleifen, Zeilen (?)

    In der Programmierung führen mindestens 1000 Wege nach Rom, aber welcher ist der effizienteste?


    Das Problem was sich mir bei der Überlegung stellt, ist: Womit soll ich den vorhandenen Code vergleichen? Ich müsste die ganze Logik des Codes aufnehmen und schauen, ob man etwas effizienter gestalten kann. Und das it aus meiner Sicht mit meinen bisherigen Kenntnissen nicht möglich. Klar, wenn da 3x IF steht in der die gleiche Variable auf den Wert X, Y oder Z überprüft wird, kann man sagen mach ein switch-case daraus. Aber da hört es eigentlich schon auf.


    Jemand eine Idee wie eine Code-Überprüfung aussehen bzw. aufgebaut sein könnte?

    Danke schonmal :thumbsup:


    VG Acr0most

    *Topic verschoben*
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    Schau mal in der VBA Hilfe msdn.microsoft.com/de-de/library/office/dn467914.aspx
    zu deinen jeweilig angewendeten Methoden, Functionen usw. da steht manchmal sogar bei, wenn es Leistung erfordert oder was aktueller ist. Du könntest deine Effizienzprüfung also dann nach diesen Methoden usw. suchen lassen und daraus deine Effizienz ermitteln. Und ich habe schon öfters hier im Forum mitbekommen, dass ein kompakter Code auch meistens effizienter ist.
    Du könntest ebenso deine Effizienz davon Abhängig machen wie viele Variablen definiert werden. Vielleicht reichen ja schon wenige im Modulkopf definierte Variablen und man muss nicht in jeder Private Sub alle Variabeln wieder neu definieren.
    "Der Visual Basic ist nur so schlau wie der, der davor sitzt" - Na schön! Dann steh ich eben auf!

    "Wenn du denkst es geht nicht mehr kommt irgendwo ein Lichtlein her"
    If Tunnel.Licht = JemandImTunnelDerVerzweifeltIst Then Licht.Aus = True
    wenn was berechnet wird, könntest du die Rechenzeit mit anderen Algo-Möglichkeiten vergleichen...

    ansonsten vllt die Anzahl der Schleifen etc untersuchen...ich denke es kommt immer auf die konkrete Funktion des zu testesten Codes an...und du musst natürlich auch einen Vergleich Code haben...
    Genitiv ins Wasser, weil es Dativ ist!
    Rettet den Regenwald
    Vielen Dank @Kathleen, @Runshak

    Wie gesagt ich habe derzeit das Hirngespinst, solche Vorgaben in einem Tool zusammenzufassen um damit Code (später vllt auch in X Programmiersprachen) zu überprüfen. Bis es soweit ist benötige ich erstmal so viel Input wie möglich, um mir überhaupt über die Ausmaße und Möglichkeiten klar zu werden und dann zu entscheiden ob es machbar ist oder zu einer unmöglichen Eierlegenden Wollmilchsau ausartet.
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:
    Definiere

    Acr0most schrieb:

    Effizienz
    Es gibt Tools und Methoden, Code zu analysieren und (automatisch) zu testen.
    Wenn Du in etwa beschreibst, was Du tun willst, lässt es sich besser helfen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    was Du tun willst


    Es gibt derzeit noch keine Notwendigkeit, etwas zu tun. Ich möchte nur in Sachen Code-Effizienz und Überprüfung einen Überblick über mögliche Kriterien sowie bereits vorhandene Algorithmen bekommen, um daraus vielleicht in naher Zukunft ein Tool zu schreiben, was aufgrund dieser Kriterien und Algorithmen einen Code bewerten kann und ggf. sogar Verbesserungen vorschlägt.
    Es ist demnach bislang noch reines Interesse.

    Das Schlagwort Effizienz wird aus meiner Sicht aus den 'Kriterien' definiert, von denen ich immer spreche. (Ausführungszeit, Durchläufe von Schleifen, Zeilen, was noch so kommt)





    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:
    Effizienz sollte nicht nur in vermeintlichen Geschwindigkeitsvorteilen gesehen werden, sondern m.E. vor allem in Codewartbarkeit. Was hast Du davon, wenn Du eine Funktion statt in 10 nur noch in 3 Zeilen ausdrückst, der Computer das ganze 18 ms schneller bearbeiten kann, Du jedoch den Code nach 3 Wochen 5x lesen musst, um ihn wieder zu verstehen? Den Spaß hatte ich schon hinter mir. In ner alten Bibliothek nen sehr kompakten Code gefunden, der zwar funktionierte, aber ich brauchte 5 Minuten, um zu verstehen, warum er funktionierte. Das sehe ich dann eben nicht als effizient an. Effizienz ist vielschichtig. Und m.E. braucht es vor allem Erfahrung und auch das Lesen fremden Codes zur Problemlösung, um effizient zu programmieren.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Ja das ist der größte Stolperstein bei der Idee.
    Wie definiere ich Effizienz bzw. worauf kann ich den Code überprüfen.

    Ich finde so Standard-Metriken wie Lines of Code oder Wie viele Abzweige durchgehe ich in einer Funktion maximal ganz interessant.
    Nur ist das aus meiner Sicht noch nicht aussagekräftig genug für eine Code-Überprüfung.


    Und weil du meinst Geschwindigkeit weniger als Codewartbarkeit. Guter Einwand. Aber man könnte das Tool auch so auslegen, dass es in Bereichen überprüft. Sprich einmal die Wartbarkeit und einmal die Geschwindigkeit und zum anderen irgendwas anderes. Das wäre dann kein Problem.


    Bin weiterhin für jede Meinung oder jeden Einwand dankbar!
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:
    Das wäre schon ein ganz krasses Tool, wenn man die Wartbarkeit prüfen könnte. Das einzige mir bekannte, halbwegs zuverlässige funktionierende Tool dafür sitzt 50 cm vor dem Bildschirm; ist aber versionsabhängig, da bei solchen Kandidaten mit längerer Entwicklungszeit meist eine höhere Erkennungsrate von schlecht zu wartbaren Code zu erwarten ist. ;)
    Ich quäl mich gerade durch Clean Code (allerdings die deutsche Papiervariante, aber die ist für mich schon anstrengend genug), da gibt es eine schönes Bild zum Thema "Die einzig brauchbare Methode, um Code zu bewerten": Probier mal Google-Bildersuche nach "wtf per minute".
    Denn: Dem Compiler ist es Wurscht, ob eine Funktion GetCustomNameFromDataSet oder gcnfds oder BestellMirAusDenUSAneCurryWurscht heißt. Und ihm ist es auch egal, ob Du ne 20 Funktionen mit 5 Zeilen oder eine mit 500 schreibst. Wenn es zum gleichen Ergebnis kommt, stört es weder den Compiler noch den User. Aber wehe, es muss was umgeschrieben werden. Dann hat nur einer erstmal das Problem, und zwar der Programmierer. Und dann stellt sich die Frage, wie effizient man die Änderung vornehmen kann.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Ich denke eines der größten Probleme ist, dass wir alle verschiedene Geschmacksrichtungen haben. So gibt es jene, die es lieben C# mit so wenig Klammern wie nur möglich zu schreiben, und das auch "Wartbarer" finden, als wenn sie sich durch einen Wald von Klammern schlagen müssen. Und dann gibt es wieder die Kehrseite.
    Klar kann man einen gemeinsamen nennen finden, doch der wird bei jedem irgendwie anecken.
    Daher ist es immer gut, wenn für ein Projekt vorher definiert wird, wie die Syntax auszusehen hat. Das müsste ein Programm dann aufnehmen und danach prüfen können. (VS hat ja allerhand Einstellungen dafür)

    Und was Funktionseffizienz angeht, müsstest du für jedes noch so popelige Problem eine Funktion definieren, die die Effizienz 1 hat. Und das gilt auch für sachen wie if(x==1), könnte man ja auch if(x.Equals(1)), oder u.U. if(x.CompareTo(1) == 0) schreiben. Und von dieser "Vergleichsfunktion" aus berechnest du die Effizienz aller anderen Funktionen die auf das Problem passen. Wird halt spätestens dann Problematisch, wenn du vom Code her prüfen willst, wie effizient ein Aufbau zur IPC ist. Da kann man so vieles tun. TCP/UDP Listener/-Client, Sockets, Remoting, WCF, WebClient/WebRequest Alles teils grundverschiedene Technologien, um über teils grundverschiedene Wege Daten von Prozess 1 zu Prozess 2 zu schicken. Und jetzt noch herausfinden was am effizientesten ist? Wo liegt der schwerpunkt? Geschwindigkeit? Verlässlichkeit? Komplexität? Codezeilen? Ne mischung aus allem? und was wenn ich aber Geschwindigkeit über alles stellen möchte?
    Post-AGB:
    §1 Mit dem Lesen dieses Posts stimmst du den AGB unverzüglich zu
    §2 Ein Widerruf muss innerhalb von 3 Sekunden nach Lesen des Hauptbestandteil des ersten jemals gelesenen Posts erfolgen
    Abs.1 Die Signatur zählt nicht zum Hauptbestandteil des Posts
    §3 Ein erfolgreicher Widerruf zwingt zu einem Besuch bei einem Hypnotiseur oder Neurochirurg, sodass der gelesene Text aus den Erinnerungen entfernt werden kann
    Abs.1 Die Kosten und Risiken sind jeweils selbst zu tragen
    Jenachdem um was für Applikationen es sich handelt könnte es sinnvoll sein die Allokationen zu reduzieren, denn allokationen kosten nicht nur Zeit(in .Net relativ wenig), aber sorgen dafür, dass später irgendwann der GC einspringt, was natürlich dem Rest der Applikation dann fehlt, dafür kann man dafür sorgen, dass immer außerhalb von Schleifen und ähnlichem allokiert wird, oder eben über MemoryPooling, oder erst gucken, dass gar nichts auf dem Heap landet(C# structs, C++ einfach ohne new/alloc, Java nicht möglich)
    blogs.msdn.microsoft.com/dotne…-with-visual-studio-2012/

    Bei vielen Sachen kann man auch Berechnungen außerhalb von Schleifen darstellen, oder Dinge die mit Schleifen gemacht werden über eine fertige Vorhandene Funktion lösen(Ein Beispiel, woran viele z.B. nicht denken: de.wikipedia.org/wiki/Gau%C3%9Fsche_Summenformel)

    Erst gestern hat wollte ein Kumpel von mir GPU mit .Net Code bei einer einfachen Berechnung in einer Schleife vergleichen, er hat den Fehler gemacht, dass nur die letzte Ausführung für das Ergebnis relevant war.
    Beispiel:

    C#-Quellcode

    1. for(int i=0;i<int.MaxValue;i++)
    2. {
    3. r=a*b;
    4. }
    5. return r;

    auf der GPU wenige MS auf der CPU um einige Zeit länger, Problem dabei ist, die meisten nativen Sprachen optimieren wesentlich besser zur Compilezeit als .Net es(bisher) kann. C# hat die Schleife einfach ausgeführt, während CUDA einfach die Schleife komplett entfernt hat(ist schließlich dasselbe Ergebnis - bis auf die Ausführungszeit). Falls man es doch ausführen will gibt es in vielen Sprachen etwas wie "volatile", was verhindert dass der Compiler hier optimierungen vornimmt.(Vermute jedoch, dass der Compiler im Release schlauer gewesen wär)

    Was ich damit Sagen will, falls es um .Net/Java geht such nach solchen und Ähnlichen Optimierungsmöglichkeiten, denn hier ist der Compiler oftmals nicht besser als der Mensch(kommt der Kompilezeit zu gute und manchmal auch Plattformabhängigen Optimierungen).

    Mikrooptimierungen, die ich bereits intuitiv mache(lohnen sich erst bei wahnsinnig vielen Aufrufen):
    Math.Pow(2,n) == 1 << n
    i % Math.Pow(2,n) == i % (n-1)
    n / 2 == n >> 1
    n * 2 == n << 1

    Wobei diese Mikroptimierungen(zumindest die letzten 3) z.B. vom C++ Compiler gemacht werden, kann ich mit Sicherheit sagen, dass diese Optimierungen nicht gemacht wurden und bei mir tatsächlich einen relevanten Geschwindigkeitsvorteil gebracht haben, jedoch ist anzumerken, dass die letzten beiden der Mikrooptimierungen ggf. vom C# Compiler übernommen werden und jenach Umständen auch besser(in meinem Fall war dies nicht der Fall), deshalb gilt bei allen Optimierungen -> Testen

    msdn.microsoft.com/en-us/library/ms182372.aspx
    Damit kann man sehr geschickt Bottlenecks in Applikationen finden.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    @EaranMaleasi @VaporiZed Da gibt es einen StyleCop (kostenpflichtig), dem kann man sagen, wie man es gerne hätte, und da passt der auf, dass der ganze Code dann den vorgegebenen Regeln entspricht.
    Der zählt auch die Zeilen pro Prozedur und Klasse usw. usf.
    Was mir besonders wichtig ist, ist die Codeanalyse des Studios: Eigenschaften, unterster Vertikal-Tab. Allerdings ist dieses Tool nicht in der einfachen Version drin.
    Auch da kann man Regeln zumindest auswählen und man kann diese Codeanalyse zu- und abschalten.
    Ein besonderes Feature daran ist, dass er überprüft, ob Dispose()-bare Objekte disposed werden.
    Dieses Tool sollte man gelegentlich aktivieren, da es doch etwas länglich dauert.

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Hallo,

    Habe ich etwas falsch verstanden, oder wieso hat noch niemand die Zeitkomplexität angesprochen(Big-O etc.)? Ich würde mal grob nach t-Komplexitätsklassen einteilen. Heisst, Laufzeit in Abhängigkeit der Eingabegrössen abschätzen. Dann bekommst du je nach Problem eine Komplexitätsklasse(z.B.
    $f\in\mathcal O(n^2\log n)$
    ). Wenn's genauer sein muss, einfach die Vereinfachungen weglassen und Additionen niederer Glieder und Konstanten beibehalten.

    Grüsse,

    Higlav

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Higlav“ ()

    Vorhandenes Skript prüft man am besten auf Effizienz wenn man es laufen lässt, Komplexitätsklassen sind schön und gut um grundsätzlich unterschiedliche Algorithmen zu vergleichen, aber mMn einfach nicht aussagekräftig für eine tatsächliche Implementierung, denn für die einzelnen Algorithmen gibt es nochmal 1000 Implementationsmöglichkeiten, die gut oder Schlecht mit dem Cache klar kommen, viel oder wenig allozieren, alles vorher machen, gar nichts vorher machen, all das wird bei der Komplexitätstheorie in aller Regel außen vor gelassen, weil viele Dinge davon schwer vorherzusehen sind, oder aber auch einfach nur schwer zu bewerten sind.

    Versteh mich nicht falsch, Komplexitätstheorie ist ne gute Sache, aber wenn es um die tatsächliche Implementierung geht ist messen immer noch der beste Weg. Aber Komplexitätstheorie hilft einem z.B. bei der Auswahl des Algorithmus den man implementieren will(gerne aber auch mehrere probieren, denn Aufgrund von Input Datenmenge kann auch mal der O(n^2) besser sein als der O(n log n) oder was auch immer).
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    VaporiZed schrieb:

    Das einzige mir bekannte, halbwegs zuverlässige funktionierende Tool dafür sitzt 50 cm vor dem Bildschirm


    Effizienz ist relativ. Der eine versteht darunter schnelligkeit, der andere wartbarkeit und ein anderer wieder etwas ganz anderes. Daher stimme ich @VaporiZed hier voll und ganz zu.

    Du kannst da sicher nen Tool schreiben was deinen Code nach deinen Ansprüchen analysiert. Jedoch, da du vorgibst was Effizient ist, wäre das einfachste die eigenen Kriterien der Effizienz direkt beim Programmieren zu befolgen :)
    "Gib einem Mann einen Fisch und du ernährst ihn für einen Tag. Lehre einen Mann zu fischen und du ernährst ihn für sein Leben."

    Wie debugge ich richtig? => Debuggen, Fehler finden und beseitigen
    Wie man VisualStudio nutzt? => VisualStudio richtig nutzen
    @AcroMost: Herzlichen Glückwunsch! Du hast in deim Thread gradezu die optimale Antwort erhalten, nämlich, dasses eine Antwort nicht gibt.

    Ich zB rede lieber von "Code-Qualität" als von Effizienz. Effizienz ist nur ein Kriterium von vielen, und kann auch noch verschieden gedeutet werden (Performance-Effizienz, Resourcen-Effizienz, weitere Effizienzen...). Weitere Kriterien sind v.a. Wartbarkeit, Skalierbarkeit (d.i.: ob was mit wenigen Daten funzt, auch bei sehr hohen Belastungen noch gut performt), und auch die Entwicklungs-Zeit ist ein Kriterium.

    Also stell dir Code-Qualität als mehrdimensionales Koordinatensystem vor, und es gibt kein Patent-Rezept, wie die Skalen zu gewichten sind.
    Und leider beeinflussen sich die Dimensionen erheblich, also was performance-mäßig suuuper sein mag, kann vonne Wartbarkeit her ebenso grauenhaft sein.
    Tendenziell ist Wartbarkeit wesentlich ausschlaggebender, insbesondere eine gute Modularisierung eröffnet oft erst Möglichkeiten, kleine, aber höchst performante Code-Elemente einzusetzen, und dann ist jeder andere Code hoffnungslos abgeschlagen, wenn in dieser Form Wartbarkeit und Performance miteinander arbeiten statt gegeneinander.

    Jdfs. kann ich mir nicht vorstellen, dass ein brauchbares Tool geschrieben werden kann, was CodeQualität auch nur leidlich "messen" kann.

    Mit StyleCop, FxCop, etc sind wohl Versuche gegeben, Tools, die zumindest die Erfüllung von Code-Richtlinien bemessen (und auch weitere Parameter, wie "Verzweigung" u.ä. - ich kenn mich da aber nicht aus).
    Ich persönlich halte nicht soo viel davon, denn Richtlinien-Erfüllung macht keinen guten Code aus. Also du kannst alle Richtlinien wunnebar erfüllt haben, Doku-Tags, Benamung etc. und trotzdem können deine Methoden noch immer den grössten Unfug enthalten.

    Ein anderes Mittel ist Unit-Testing.
    Das ist - wenn konsequent eingesetzt der Ansatz: Für jede Funktionalität erstmal TestCode schreiben, der das erwünschte Verhalten zu überprüfen imstande ist.
    Danach erst die Funktionalität implementieren.
    Konsequent eingesetzt führt das zu riesigen Testing-Projekten (was gut ist), und das eigliche Projekt wird sich automatisch stark modular entwickeln, weil Unit-Testing testet immer nur kleine Module.
    Also der Ansatz hat was, eine test-driven entwickelte Anwendung soll wohl sehr gut und übersichtlich strukturiert sein.
    Ich sehe als Nachteil den hohen Aufwand, den Testing-Code ständig mit-zu pflegen, bei mir verändert sich die Architektur sehr häufig, deswegen setze ich Tests nur punktuell ein. Die Gefahr, die ich bei test-driven Developement sehe ist, dass man derlei Architektur-Änderungen nur noch ungern in Angriff nimmt, weil einem vor dem Aufriss mit den ganzen Testings graut.
    Aber das geht in Fragen des Projekt-Managements über, in eim Team mit gutem Management mag Architektur besser konzipiert sein, und ändert sich dann nicht ständig. Und gleichzeitig ist bei Arbeitsteilung ein gemeinsamer Stil vonnöten, und vor allem Verlässlichkeit der Funktionalität ist von allerhöchster Priorität - das schreit gradezu nach einer durchdachten "Testing-Kultur".



    Hmm - vlt. bin ich mit meiner Abhandlung auch auffm falschen Dampfer - du sprichst ja ausdrücklich von einem "Effizienz-Mess-Tool" - und ich befürchte, du meinst damit wirklich nur Performance und Resourcen-Verbrauch.

    Da kann ich dir kundtun: Solche Tools gibts schon, es heißt "Profiler" - also du würdest nur das Rad neu erfinden ;)
    Profiler hängt man iwie an die laufende Anwendung, und die loggen dann, wann und wo wieviel Speicher belegt oder freigegeben wird, und in welchen Schleifen der Prozessor die meisste Zeit vertrödelt.

    Das ist bereits seit ewig in den 3 Rules niedergelegt, dass man niemals! Effizienz in diesem Sinne zu optimieren suchen soll, zumindest nicht ohne zunächstmal im Profiler geguckt zu haben, wo's überhaupt hakt.

    Also wenn du Effizienz so verstehst (Performance, Resourcen), dann sorry für diesen Offtopic-Post, weil dann habich eiglich nur mitzuteilen, dass derlei ziemlich irrelevant ist.
    Bzw. diese Art Effizienz ist ein autmatisches Mitbringsel qualitativ hochwertigen Codes in meim Sinne: v.a. Wartbarkeit, insbesondere gute Aufteilung (was ja auch unter Wartbarkeit fällt).

    Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „ErfinderDesRades“ ()

    tl;dr - Effizienz definiert sich dadurch, wie viel Arbeit ein Programm in einem festen Zeitintervall schafft, gemessen unter identischen Umgebungsbedingungen. Das bedeutet, dass du zur Beurteilung der Effizienz mindestens zwei Programme benötigst, die dieselbe Aufgabe auf unterschiedlichem Wege lösen. Bei der Evaluierung bekommen beide Programme dieselbe Zeit zur Verfügung und laufen auf derselben Hardware. Natürlich bleibt die Definition von Effizienz nicht auf die erledigte Menge an Arbeit beschränkt. Andere Messungen zielen z.B. auf den Energieverbrauch ab, wobei die Arbeitsmenge gleich bleibt. Gleichzeitig wird oft die benötigte Zeit gemessen, um auszuschließen, dass ein energietechnisch sehr effizientes Programm insgesamt zu lange zur Lösung des Problems benötigt.

    Konkrete Tipps sind ja hier nicht gefragt - ich könnte aber auch keine geben, weil jede Messung vom Anwendungsfall abhängt. Es gibt nämlich keinen Algorithmus, der die Korrektheit eines Programms für eine Eingabe beweisen kann - der Informatiker sagt, das Halteproblem sei nicht entscheidbar. Daher muss eine automatisierte Beurteilung der Korrektheit schonmal auf eine endliche (und vor allem bekannte) Eingabemenge beschränkt sein. Wenn ein Programm nicht einmal die Korrektheit eines anderen Programms entscheiden kann, muss es dessen Korrektheit auch noch voraussetzen. Soll die Effizienzmessung automatisch stattfinden, muss das Messprogramm eine sinnvolle Eingabe finden, mit der das zu beurteilende Programm geprüft wird. Weil es aber keine Möglichkeit gibt, die Sinnhaftigkeit irgendeiner vorgeschlagenen Eingabe zu beweisen (--> Halteproblem), muss der Benutzer eine Eingabe vorgeben. Dadurch findet die Messung aber nicht mehr automatisch statt.

    Die Kurzfassung ist also: Die automatische Beurteilung von Programmcode (was ist egal - ob Korrektheit, Effizienz, ...) ist so lange nicht realisierbar, bis jemand das Halteproblem entscheidbar macht.

    Und die "kürzeste" Fassung ist: Hör auf, darüber nachzudenken. Wenn du wissen willst, warum das Zeitverschwendung ist, studiere Informatik :)
    Gruß
    hal2000
    Alles klar @hal2000 xD

    Mich interessiert es weniger aus dieser Idee eine Anwendung zu erstellen, sondern mehr eure Ansichten, wie man Code-Qualität beurteilen kann.
    Es ist auch sehr interessant, wie die verschiedenen Antworten auf andere Schwerpunkte fixiert ist und wie ihr das begründet.

    Ich lasse das ganze erstmal offen, da mich eure Meinungen und euer Augenmerk beim Programmieren neugierig gemacht hat.
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:

    Acr0most schrieb:

    wie man Code-Qualität beurteilen kann

    Das ist allerdings was anderes als die Beurteilung der Effizienz, weil die Codequalität nicht von einer bestimmten Eingabe abhängt (tatsächlich ist jetzt der Code selbst die Eingabe). Natürlich schwingt auch hier wieder der Korrektheitsbeweis mit, aber die Entwicklergemeinde hat bestimmte Muster entworfen, auf die man Code überprüfen kann. Beispiel: Keinen toten Code schreiben. Das wird auch "Codeabdeckungsanalyse" genannt und ist in Visual Studio bereits integriert (bei den Unit-Tests). Diese Muster sind aus genanntem Grund nie vollständig, zeigen aber mit hoher Wahrscheinlichkeit Probleme auf, die die Codequalität mindern. Die Muster spiegeln Erfahrungswerte vieler Softwareentwickler wieder und helfen so, einmal gemachte Fehler in Zukunft zu vermeiden. "Software-Tester" ist übrigens ein eigener Berufszweig unter Informatikabsolventen.
    Gruß
    hal2000
    guggemol CleanCode-Developer
    Das ist mit Abstand das Beste zum Thema, was mir je untergekommen ist.
    In gewissem Sinne vlt. auch das Einzige - zumindest ists das Einzige mir bekannte, wo die verschiedenen Dimensionen aufgedröselt und miteinander in Beziehung gesetzt werden.

    Hat übrigens auch sowas wie "Referenz-Status", also in der Profi-Szene sind die CCD-FachBegriffe bekannt, und wird viel mit umgegangen, wenn Code-Qualität betrachtet wird.