Sprechende Variablennamen vs. Schreibarbeit

M

menace

Well-Known Member
Hallo,
ich wollte mal fragen, wie ihr das mit VariablenNamen haltet. Es gibt ja die Moeglichkeit, alles sehr kurz zu halten, und das spart etwas Schreibarbeit. Allerdings muss man sich viel mehr merken, damit man diese nicht falsch verwendet, und wirklich leserlich ist der Code auch nicht.

Wenn man allerdings andererseits sprechende Variablen namen wie BinTreeWorkingCopy verwendet oder x_counter wird die Zeilenlaenge sehr lang (selbst wenn man die inoffizielle Regel, -dass es bloss 3 Einrueckungen gibt, fuer mehr macht man eine neue Funktion-, einhaelt) und man muss auch einiges mehr tippen.

Wo/Wie macht ihr den TradeOff? ParameterNamen lang, Hilfsvariablen kurz? Verwendet ihr eine (Ab-)art der ungarischen Notation? Schreibt ihr einfach a, b, c, d, e? "Unterstuetzt" euch evtl eine "IDE" bei Variablen-AutoCompletion?

Ich bitte um Meinungen, bzw. Erfahrungen. Egal ob jetzt in C, Perl, Java oder in Shellscripts :-)
 
Ich würde mich an die Empfehlungen in diesem Buch halten:
Perl - Best Practices von Damian Conway

Also ein konsistentes Namensystem konsequent durchhalten.

'a', 'b', etc. als Variablennamen ist idiotisch, um es sanft auszudrücken.

Es besteht eine gewisse Chance, dass der Code der von dir geschrieben wird
in einem gewissen Zeitabstand gewartet werden muss,
wenn du ihn dann nicht mehr verstehst ...
 
Ich investiere grundsätzlich Zeit, Sorgfalt und Schreibarbeit in die Codequalität. Auch wenn ich den Code die nächsten drei Wochen noch nachvollziehen kann, nach Jahren wirds kompliziert und vor allem nervig, den alten Code wieder aufzuarbeiten.
 
lars schrieb:
Es besteht eine gewisse Chance, dass der Code der von dir geschrieben wird in einem gewissen Zeitabstand gewartet werden muss, wenn du ihn dann nicht mehr verstehst ...
Zum Vergrößern anklicken....
Irgendeine Studie (jaja, allerdings stimmt das mit meiner eigenen Erfahrung durchaus überein) kam zu dem Ergebnis, daß Programmierer nur 10% ihrer Zeit damit verbringen, neue Programme zu entwickeln. Der Großteil der Zeit werde darauf verwendet, bestehende Programme zu warten bzw. zu erweitern. Oftmals ist das dann auch nicht der eigene Code, der da gewartet werden soll, sondern der wurde vor Jahren von jemandem geschrieben, der vielleicht schon gar nicht mehr in der Firma ist.

Man sollte also immer sprechende Variablennamen verwenden. Was interessieren die paar Anschläge mehr schon groß. Kurze Variablennamen (ganz extrem einbuchstabige) verursachen einen riesigen Wartungsaufwand. Stell dir mal vor, du sollst Code warten, der vor Jahren von irgendwem geschrieben wurde, und überall finden sich einbuchstabige Variablennamen. Viel Spaß. :ugly:

Bewährt hat es sich übrigens auch, hinter Variablendeklarationen noch einen Kommentar zu setzen, wie etwa:
Code: 
unsigned int pricePerUnit;   // Stückpreis in Cent.
unsigned int vat;            // Mehrwertsteuersatz in Prozent.
Oftmals vermisse ich solche Kommentare. Dann geht die Raterei los: In welcher Währung wird "pricePerUnit" geführt? Steht in "vat" der Mehrwertsteuersatz oder der -betrag? Die Einheiten sind wichtig und sollten deshalb immer klar erkennbar sein, sonst hat man eigentlich schon gleich verloren.

In Ausnahmefällen, z.B. für die Hilfsvariable einer for-Schleife, kann man auch mal auf "i" o.ä. zurückgreifen, aber auch nur, wenn dadurch der Schleifenrumpf weiterhin klar verständlich bleibt.
 
Auf jeden Fall sind klare Variablen Namen besser als kurze. Es ist gar nicht so einfach einen Variablennamen zu formulieren. Das zwingt dich darüber nachzudenken wie dein Programm überhaupt funktioniert.
 
Hallo menace,

Variablen-/Typnamen sind bei mir meist selbsterklärend.
Typdeklarationen und Konstanten schreibe ich grundsätzlich groß, Variablen enthalten den Typ in Kurzform, Modulname und schließlich den eigentlichen Namen. Schleifenzähler innerhalb der Funktion heißen bei mir meist i, j, k. Beispiele:
Code: 
typedef char CHAR64[64];
typedef char* PCHAR;
typedef unsigned long int ULONG;
typedef long int LONG;
PCHAR p_main_str;

Funktionen erhalten bei mir auch immer einen klaren Namen bestehend aus Modulname und Tätigkeit der Funktion:
Code: 
LONG sqlfkt_sql_insert_name(CHAR64 name) {
   LONG ret_l_error;

   ret_l_error = SQLParseCode(...)
   return ret_l_error;
}
Da kann auch auch nach längerer Zeit wieder in den Code einsteigen ohne auszusteigen.

Viele Grüße

Jürgen
 
Zuletzt bearbeitet von einem Moderator:
wenn ich irgendwas programmiere, sinnt die variablen namen auch meistens sinnvoll. wenn ich jedoch in der schule bin, und wieder irgendein programm im informatik unterricht fuer meinen ach so faehigen info lehrer schreiben soll, dann nenne ich die variablen a, b, c oder sonstwie, hauptsache er hat spass beim lesen :rolleyes:

EDIT:
in schleifen nenne ich die variablen allerdings i oder k oder so, da habe ich keine lust dauernd irgendeinen langen namen rein zu schreiben :-D

MfG
 
Also für Integerzählvariablen/Iteratoren o.ä. immer i und dann in einer evtl. vorkommenden inneren Schleife j.
Für alles andere Sprechende Varaiblenname, z.B. x_koord, y_koord, dof (für degree of freedom),......
 
Ich halte es so wie chaos.

Allerdings breche ich - wie -ec- - mit dieser "Tradition", wenn ich im Informatik-Unterricht Programme schreibe/schreiben soll. Ich mach mir damit zwar etwas mehr Arbeit diese kurzen, nichtssagenden Variablen erst zu kommentieren (damit *ich* den Code versteh) und die Kommentare vor dem Abliefern rauszuschmeissen (damit der Lehrer weniger versteht ;)) - der Spass ist es mir aber wert :D
 
wieso schreibarbeit?

ich persoenlich nenne meine variablen erstmal aaa,bbb,ccc etc.

sobald dann das grundgeruest meiner funktion steht lasse ich ein :10,20s/aaa/indexCounter/g drueberlaufen und ich kanns spater auch wieder lesen.

gut, wenns nur 10 zeilen sind dann reicht auch schonmal I fuer input und O fuer output.

aber eigentlich bekommt es deinem code ganz gut wenn du dir nochmal 5 sekunden mehr gedanken da drueber machst was der tun soll.
 
Ich benutze lange Namen für alles (außer plausible Index-Variablen) und Ctrl+P im vim. Habt Ihr vergessen, dass es automatische Ergänzung gibt?
 
Meinereiner schreibt immer Romane statt Programme.
Ich tipp lieber mal mehr bei einem Variablennamen und kann's danach noch lesen - und andere auch.

Für Zähl/Indexvariablen in Schleifen benutz ich auch mal i,j,k etc. aber das ist ok, finde ich.
Ansonsten denke ich ist außer den Variablennamen ein einheitlicher Coding-Styleguide wichtig, das nervt zwar mitunter, weil man's selbst lieber anders hätte, aber dauerhaft - insbesondere, wenn man nicht allein arbeitet - hilft das sehr.

Das IMHO beste Kompliment, das man als Programmierer bekommen kann, ist wenn ein Jahr nach dem Ausscheiden aus einer Firma die alten Kollegen einem erzählen, daß der damals geschaffene Quellcode immer noch gut lesbar und gut verständlich ist ;-)

Gruss...

Der Indy
 
lol.
das geht auch andersrum: nach einer STUNDE im softwarepraktikum musste ich mal den quellcode von nem mathematikdoktoranden verbessern...
das war krank!

delta war halt die variable fuer einen winkel. okay.
gammai war eine imaginaerzahl
gammar der realteil.

soweit noch alles okay. aber dann:

was ist a_? jupp, genau: a[i-1].
und was ist a__? das war a[i+1].
und dann gab es auch noch b___... hiiiiiiiimmmel!
 
Du musst dich einloggen oder registrieren, um hier zu antworten.
Zurück
Oben