Effektiver Code

[Magic1416]

Hallo zusammen,

ich habe eine Frage bezüglich Programmierung allgemein. Nachdem ich schon einige kleinere Sachen programmiert habe, macht man sich gedanken drüber ob bestimmte Methoden oder Code auch effektiv oder anders ausgedrückt, sauber programmiert ist. Die Hauptfrage ist, woran erkennt man guten, effektiven und sauberen code. Wobei sich Effektiv bei mir auf die CPU Zeit bezieht.

Ist ein Code automatisch schnell und effektiv, wenn ich mit möglichst wenig Zeilen sehr viel erreiche ? Oder ist ein für Menschen lesbarerer Code automatisch sauberer und effektiv ? Wie kann man eigentlich selbst feststellen, ob der neue geschriebene Code für eine Aufgabe besser ist als der alte ? Gibt es da irgendwelche Tools die die CPU Zeit oder den Speicherverbrauch während der Laufzeit messen ? Subjektiv kann man das ja leider kaum feststellen.

Gruß Magic

 

[7H3 N4C3R]

Codegeschwindigkeit ist zwar immer nett, aber nicht so wichtig.

Zuerst: Das Programm muss korrekt sein.

Zweitens: Das Programm muss die Anforderungen erfüllen. (vor allem wenn man auf "Auftrag" programmiert)

Drittens: Das Programm (und damit auch der Quellcode) sollte wartbar sein. D.h., müsstest du weil du eine kleine Änderung vorhast, Tonnen von Code wegwerfen, so wäre das Programm miserabel wartbar. Leichte Erweiterbarkeit und Fehlerbehebung zeichnen wartbaren Code aus. Genauso wie gute Lesbarkeit und Verständlichkeit. (Geh mal davon aus, du willst den Code nach einem halben Jahr wieder verstehen)

Viertens: Wähle vernünftige Algorithmen. Beispielproblem: Segmentsumme (Google/Wikipedia gibt genaueres, aber es ist hier nicht so wichtig) - eine Straight-Forward-Implementierung hat eine Komplexität von O³. Man könnte zwar den Code bis ins letzte Bisschen optimieren, allerdings kann durch geschickte Algorithmen die Segmentsumme auf eine Komplexität von 3 O gesenkt werden. Damit schlägt man die superoptimierte Version um Längen.

Fünftens: Nimm für jedes Problem nur die Algorithmen, die sinnvoll sind. Wenn du übertriebenerweise für den schnellsten Algorithmus drei Jahre implementierst, nur damit er 5 Sekunden schneller ist als etwas, was man in 2 Wochen programmiert hat, so ist das einfach sinnlos.

Sechstens: Hast du alle Punkte berücksichtigt, so kannst du den Profiler anwerfen und dir sagen lassen, WO GENAU das Programm zu langsam ist. Dann ganz gezielt dort optimieren. Niemals vorher und niemals nur auf Verdacht oder weil man meint es zu wissen.

 

[Boron]

In vielen Büchern habe ich die übereinstimmende Meinung gelesen: "Optimierungen überlässt man dem Compiler!" (Sinngemäß auf einen gemeinsamen Nenner gebracht).

Ich neige dazu dem zuzustimmen .

Der Punkt wo ein Entwickler was ändern kann ist der von meinem Vorredner angesprochene Punkt 4 und danach Punkt 6.

 

[Kampfgnom]

Ich glaube ich erkläre das ganze nochmal auf etwas konkreterer Ebene. Du gehst einfach davon aus, das manche Operationen "teurer" sind von der Laufzeit her. Dazu zählen der einfachheit halber einfach mal nur Zuweisungen und Vergleiche. Nehmen wir uns also mal folgenden Suchalgorithmus in C++:

int zuSuchen=4;
int array[n]={1,2,5,6,...,123132112}

// Hier Geht der Algorithmus los
int i=0; //zuweisung
while(i<n) //vergleich
{
if(array[i]==zuSuchen) //vergleich
break;// fertig
++i; //zuweisung
}

Du hättest also im schlechtesten Falle n*3+1 "teure" Operationen. Also Lineare Laufzeit, bzw O(n). Das ist für einen Suchalgorithmus verdammt schlecht (habs hier mal der Einfachheit halber gemacht ). Logarithmisch sollte das ganze schon ablaufen...

Ich denke du solltest erstmal auf diese Art und Weise an deine Programme drangehen. Einen Profiler halte ich in deinem Falle erstmal für eine Spielerei (auch wenns schön ist).
Im Allgemeinen kann man sagen: O(2*n) ist nicht VIEL besser als O(3*n). Dafür würde sich eine komplizierte Optimierung kaum lohnen, für O(log n) schon.

Du musst halt wissen, wie 7H3 N4C3R schon gesagt hat, was dir wichtiger ist: Einfacher Code (so wie mein Beispiel) oder doch lieber Performance. Für eine Datenbank mit 200 Einträgen würde ich nicht extra ein großartig ausgefeiltes Suchverfahren implementieren (höchtens aus Spaß) wenn ich mal eben was suchen will.

Ansonsten gilt eigentlich alles was 7H3 N4C3R gesagt hat...

mfg

EDIT: Siehe dazu auch http://de.wikipedia.org/wiki/Sortierverfahren

 

[gimmebytes]

Ich würde sagen, dass gerade wartbarer Code am wichtigsten ist. Vorallem dann, wenn man im Team arbeitet und/oder den Code nicht nur einmal verwenden will. Das die Komplexität natürlich auch nicht zu schlecht sein sollte (gerade bei größeren Programmen) ist natürlich auch klar. Insgesamt bringts 7H3 N4C3R schon aufn Punkt!