| 

.NET C# Java Javascript Exception

32
Das schwieigste was mir bisher begegnet ist war ein VB.NET Projekt das von ehemaligen VB4/VB6 Entwicklern erstellt wurde. Hier waren in der "Main Form" >25.000 Zeilen Code zu finden - sprich: Nahezu das komplette Projekt. Methoden waren teilweise über 7 Bildschirmseiten lang und die meisten Variablen "Modulglobal" definiert.

Aber am schlimmsten sind die alten "On Error goto Next" bzw.
Try
Catch (Ex as Exception)
//Hier wird absichtlich nichts gemacht nach dem Motto: Wenn man keinen Fehler sieht, ist auch keiner passiert :-(
end try

Was ist für dich der nervigste / schlimmste Programmierstil der dir bisher in deiner Karriere begegnet ist?
13.04.2011
Thomas Sczyrba 1,4k 1 2 9
Thomas Sczyrba 1,4k 1 2 9
1
Scheiße, mir sind die Bewertungen für heute ausgegangen. (max. 30 pro Tag). Auf jedenfall sehr Unterhaltsam der Thread.
Floyd 13.04.2011
Oh das ist schade. Ich freue mich immer über eine faire Bewertung. Vielleicht morgen? :-)
Thomas Sczyrba 13.04.2011
Du hast schon ;) Nur für die anderen bleibt nichts mehr übrig.
Floyd 13.04.2011
26 Antworten
12
Ich hatte mal ein ANSI C Programm mit zehtausenden Codezeilen und gut darin versteckt:
define("while","until");

Nun versucht mal das Verhalten zu verstehen, wenn dort steht:
int i = 0;
do
{
// something
i++;
}until(i < 1000);

Da waren sogar noch mehr solche Perlen drin :)
13.04.2011
DaSpors 4,1k 2 8
1
Meine Lieblingsart C zu nutzen:
define begin {;
define end };

:D
m.fuchs 13.04.2011
12
Das schlimmste für mich ist wenn ein anderer Entwickler meine Architektur zerstört. Sei es weil diese nicht verstanden ist oder weil er schlicht zu faul ist den Mehraufwand einer sauberen Architektur durchzuziehen.
Jüngstes Bsp: Das durchbrechen meiner Indirektion indem eine Assembly einfach Referenziert wird und „mal schnell“ direkt gegen die Implementierung programmiert wird.

Grmpf……aaaaarrrrrrggghhhhhh
13.04.2011
Jorgen Schumann 1,6k 1 9
DAS kenn ich +1 (lieber +10, aber geht ja nich)
DaSpors 13.04.2011
2
Das kenn ich auch. Hauptgrund für die mangelnde akzeptanz ist meistens mangelndes Verständnis. Die Frage ist nun wie man das "Verständis" am besten bei den Kollegen hervorrufen kann?! Das ist immer wieder eine schwierige Aufgabe.
Thomas Sczyrba 13.04.2011
+1 das gibts wohl überall :-)
slesa 13.04.2011
6
Erklären, vermitteln - und später reviewen. Das ist für uns Architekten halt das täglich Brot.

Oder möglicherweise auch (in diesem Fall) die Implementierung internal machen und eine Factory spendieren, die nur das Interface herausgibt.
Matthias Hlawatsch 13.04.2011
So siehts aus Matthias! +1
Florian Mätschke 13.04.2011
1
Da Müssen klare Richtlinien her, die auch als Abteilungsleiter gestützt werden müssen.
Gentlehag 15.04.2011
9
13.04.2011
Jürgen Luhr 7,1k 1 9
1
Da setz ich einen drauf: mach noch ein #ifdef DEBUG drumrum :-)
slesa 13.04.2011
Toller Link... ich glaube den werde ich in Zukunft öfters frequentieren
Thomas Sczyrba 13.04.2011
böse böse ...
nabuchodonossor 13.04.2011
8
Wo es mir immer wieder die Sicherungen haut, sind untypisierte string Vergleiche von DateTimes oder Integern.
Sowas in der Art:

if (DateTime.Now.Date.ToString() == "14.04.2011 00:00:00")
Console.WriteLine("Ich bin ein Idiot und sollte den Beruf wechseln!");

oder sowas

//(Jo ich benamse bei solch kleinen Sachen oder demonstrationen einen Integer mit z1)
int z1 = GetIntValue();

if (z1.ToString() == "3")
Console.WriteLine("Ich bin ein Idiot und sollte den Beruf wechseln!");

//Jojo, ich weiß da steht 2mal es gleiche, aber ich schreib jetzt ka extra Methode ;)
14.04.2011
Voi 216 3
9
Gehört "Ich bin ein Idiot und sollte den Beruf wechseln!" nicht in eine Konstante wenn du es mehrfach verwendest? ;)
Floyd 14.04.2011
+1 ;) Meinst jetzt ICH bin ein Idiot und sollte meinen Beruf wechseln ;)*DUMPSUP*
Voi 14.04.2011
nö, wir machen doch alle Fehler ;)
Floyd 18.04.2011
7
++++++++++
[
>+++++++>++++++++++>+++>+<<<<-
] Schleife zur Vorbereitung der Textausgabe
>++. Ausgabe von 'H'
>+. Ausgabe von 'e'
+++++++. 'l'
. 'l'
+++. 'o'
>++. Leerzeichen
<<+++++++++++++++. 'W'
>. 'o'
+++. 'r'
------. 'l'
--------. 'd'
>+. '!'
>. Zeilenvorschub
+++. Wagenrücklauf

Schlimmer Programmierstil :o)
13.04.2011
Jürgen Luhr 7,1k 1 9
2
Das ist kein schlimmer stil, das ist eine echt coole Sprache :)
DaSpors 13.04.2011
5
Nö. Cool ist das hier: http://de.wikipedia.org/wiki/Ook! (Das Ausrufezeichen gehört zum Link)
Jürgen Luhr 13.04.2011
Geiler Link! +1 von mir
Thomas Sczyrba 13.04.2011
Das geht noch besser: Programmiersprache "Whitespace": http://en.wikipedia.org/wiki/Whitespace_(programming_language)
hugoZ 13.04.2011
1
"Brainfuck" heist die Sprache udn hat genau 8 Befehle
Floyd 13.04.2011
2
Ook! ist der bisher witzigste Wikipedia Artikel den ich jemals gelesen habe :-)
Logdog82 13.04.2011
Dann kann ich nur die Bücher von Terry Pratchett empfehlen, auf die sich Ook! beziehen. Sehr lesenswert. Vor allem Gevatter Tod. Das hat jetzt aber mit Programmierung nichts mehr zu tun ;o)
Jürgen Luhr 13.04.2011
7
Sehr schön finde ich übrigens auch, wenn Variablen zwar urspünglich sprechend bezeichnet waren, sich ihre Bedeutung aber mit der Zeit ins Gegenteil verkehrt hat.
Oder eine gute Mischung aus deutschen, englischen und denglischen Bezaichnern.

Gruselig!
13.04.2011
DaSpors 4,1k 2 8
Da muss ich mich aber auch jedes mal zammreissen.
Wenn wir uns geeinigt haben deutsche Bezeichner zu verwenden und mir grad nur der englische einfällt ist die Versuchung echt groß. ;)
Maverick1st 13.04.2011
Wir nehmen jetzt zum Glück immer englische Bezeichner. Zumendest DAS konnte ich durchsetzen :)
DaSpors 14.04.2011
2
Glückwunsch! Wieviele Entwickler in Deinem Team können Lohnsteuerjahresausgleich ins Englische übersetzen? Und beim Lesen des Codes auch wieder zurück, natürlich ohne sich dabei vom eigentlichen problem ablenken zu lassen? Ich hab mir das auch schon oft gewünscht, in einer einheitlichen Sprache codieren zu können. Aber wenn die Domäne deutsch ist, dann hab ich am Ende lieber ein paar deutsche Begriffe im Code und akzeptiere den Sprachmix (komplett deutsch zu codieren hab ich noch nie durchsetzen können, und mir würde es aber auch schwer fallen).
Matthias Hlawatsch 14.04.2011
Auch ein gruseliger Gedanke: Abrechnungssoftware schreiben müssen :)
DaSpors 15.04.2011
1
"ArtikelRows" z.B. sieht gruselig aus. Das Problem ist: Bei einer so komplexen Domäne wie Warenwirtschaft fallen weder mir, noch allen anderen Beteiligten die englisch korrekten(!) Begriffe ein. Vor allem können künftige Entwickler das dann wenigsten sofort lesen.
Dodnedder 22.04.2011
Auch immer wieder schön sind Methoden- oder Variablennamen die über die ganze Bildschirmbreite gehen :)
Christoph_Wi 01.02.2012
7
Mich regt folgendes auf:

StreamWriter sw = ...;
...
sw.Flush();
sw.Close();
sw.Dispose();

Das zeigt, dass sich derjenige keine Sekunde mit der API befasst hat und zudem noch die gängige using-Pattern nicht kennt. Abhilfe ist natürlich:

using(StreamWriter sw = ...) {
...
}

Das ist auch Exception-sicher.
13.04.2011
Marvin Steppat 3,1k 4 8
Stimmt, zumindest using sollte man kennen und benutzen. Aber dass Close ein Flush impliziert und dasselbe tut wie Dispose, steht nicht sonderlich klar in der API-Doku, und ich kann auch verstehen, wenn ein Programmierer verwirrt ist, wenn es zwei Methoden für den gleichen Zweck gibt. Ein typisches Beispiel dafür, dass das "Umbenennen" einer Methode durch explizite Interface-Implementierung plus Delegation seine Schattenseiten hat - sprich: hier haben auch die Designer der StreamWriter-API ihre Aktie dran.
Matthias Hlawatsch 13.04.2011
moment: also eigentlich erwarte ich mir von einem close ein implizites flush ... flush nur wenn ich zu diesem zeitpunkt NOCH kein close machen will. gabs doch schon bei alten fileoperationen in dos zeiten schon so. kurz: schlechter code, weil sw.Flush() VÖLLIG unnötig.
nabuchodonossor 13.04.2011
Ich kläre solche Fragen meist mit Reflector. Schneller als die Doku.
Marvin Steppat 13.04.2011
7
Das beste, was ich mal gesehen hab, war Code, der von Kollegen in Fernost kam. Die sollten Code schreiben, der Straßennamen in einer Komponente verfügbar macht. Anstatt eine Textdatei mit den Namen zu bauen und die dann einzulesen, haben sie die Namen in den Code geschrieben:
List<string> streets = new List<string>();
streets.Add("Asamstraße");
streets.Add("Behamstraße");
streets.Add("Clemensstraße");
...
streets.Add("Zeppelinstraße");
13.04.2011
Pocher 71 2
7
Folgende Elemente führen aus meiner Sicht automatisch zu Programmierkatastrophen:

- "Hacken" einer API (z.B. durch Nutzung von Reflection um Zugriff auf private Member zu erhalten)
- Fehlende Granularität (Stichwort Methodenlänge, Klassenlänge)
- Verkehrte Weltvorstellung (z.B. Erde ist eine Scheibe, Wettermodell liefert falsche Ergebnisse)
- Semantische Uneindeutigkeit
- Durchlässigkeit von inkonsistenten Daten. (Führt zu Fail-Save-Operationen an jeder Stelle, wo die inkonsistenten Daten verarbeitet werden)
- Eierlegende Wollmilchsäue (Methoden saveOrUpdate, getOrCreate, save(Object))
- generische Allgemeinplätze ( Object doSomething(Object o) )
- Heisenberg'sche Unschärferelation (Getter, die Objektzustände semtisch ändern)
- "Weiterarbeiten" mit "mäßigen" Implementationen (Don't touch it-Phänomen)-
- Schlechtes Exception Handling (führt dazu, dass exceptions einfach weitergereicht werden)
- Fehlende Modularisierung (Große, nicht handlebare Moule)
fehlende Normalisierung (zig Stellen im Code müssen für eine semantische Änderungen angepasst werden)
21.06.2011
oopexpert 445 8
1
+1 allein schon für "Heisenberg'sche Unschärferelation" :-)
Thomas Sczyrba 21.06.2011
+1, wie Thomas schon sagte...
ffordermaier 09.07.2011
6
Ach ja, was mich auch noch total verrückt macht ist das explizite testen auf boolsche Werte:

public bool CheckValue(bool myValue)
{
bool myErgebnis;

if(myValue == true)
{
myErgebnis = true;
}
else
{

myErgebnis = false;
}
return myErgebnis;
}
13.04.2011
Thomas Sczyrba 1,4k 1 2 9
Find ich garnicht mal so schlimm.
Floyd 13.04.2011
2
Meinst du das explizite Ausschreiben in den if-Bededingungen? Also if(myValue == true) statt if(myValue)? Das erhöht aber die Lesbarkeit.
hugoZ 13.04.2011
5
Die Lesbarkeit erhöhen würde es vor allem, einen anderen Namen für myValue zu verwenden, der ausdrückt, was der boolsche Wert bedeutet. Also z.B.

if(dieWeltistSchön) {...}

In Fällen, wo man es mit Bezeichnern zu tun hat, die man nicht ändern kann und denen man die boolsche Natur nicht am Namen ansieht, finde ich den expliziten Vergleich allerdings tatsächlich ganz in Ordnung - vor allem, wenn negiert werden muss: das ! in C# ist nicht sonderlich auffällig, da kann ein if (myValue == false) verständlicher sein.
Matthias Hlawatsch 13.04.2011
3
Ist ein tolles Kriterium im Bewerbungsgespräch, wenn jemand sowas ohne besonderen Grund schreibt. Zeigt, dass er noch nicht drauf hingewiesen wurde und tendentiell am Anfang steht.
Marvin Steppat 13.04.2011

Lol, gibt es irgendeinen Grund warum man das so explizit testen sollte?
Aber auch wenns kein bool Wert ist finde ich den Code emens hässlich,
weil eine eigene Variable gemacht wird die dann einfach zurück gegeben wird.
Angenommen wir hätten einen String als Parameter und wollen auf irgendwas prüfen würde ich das so schreiben:
private void IsValid(string value)
{
if(value = "xyValuexy")
return true;

return false;
}
Voi 14.04.2011
Ich hoffe jetzt funktioniert die Highlightung (denglish is super) ;)

private void IsValid(string value)
{
if(value = "xyValuexy")
return true;

return false;
}
Voi 14.04.2011
4
@Voi, wobei deine Methode immer true zurückgeben wird ;)
Mallen 14.04.2011
2
oder noch besser:
[code]

private void IsValid(string value)
{
return value == "xyValuexy"
}–
[/code]

Ps: sry für den doppelpost und wer aufmerksam war, ich hab das zweite = vergessen ;)
Voi 14.04.2011
1
@Mallen Die bringt gar nix zurück ;)
Weil der Rückgabewert void is, ansonst funktioniert Sie.

Starkes Stück. 3 Zeilen Code 2 Fehler ;)
Deshalb sollte man alles mal test ;)

Aber des dient eh nur zum verstehen was ich meine *hust* ;)
Voi 14.04.2011
Das explizite Testen auf boolsche Werte ist zwar Mehraufwand, was man nicht braucht, macht den Code aus meiner Sicht weder lesbarer noch weniger lesbarer. Alles steht und fällt hier mit der Benennung der geprüfen Variable.
oopexpert 08.08.2011
6
Passend zu der if(myValue==true)-Methode gibts auch noch die Möglichkeit, den Abbruch einer Schleife zu erzwingen:

max = 10000;
for(i=1; i<max; i++)
{
if( abbruchbedingung )
i = max;
else
...
13.04.2011
slesa 212 6
Ui- das ist aber auch recht übel. In VB.NET gibt sogar noch das GOTO. Das würde deine Schleife noch fiel fieser machen.
Thomas Sczyrba 13.04.2011
2
Da habe ich bis heute nicht verstanden, welcher Teufel das VB.NET Team geritten hat GOTO wieder einzubauen. Das wäre ja nun endlich mal die Gelegenheit gewesen das loszuwerden.
m.fuchs 13.04.2011
4
Have a "break;", würde ich da dem Entwickler sagen...
Matthias Hlawatsch 13.04.2011
Dieser Spezial-"Entwickler" hat eine angeborene Abneigung gegen "break" und "continue". Name und Wohnort sind der Redaktion bekannt.
slesa 13.04.2011
das ist aber wirklich bös ...
nabuchodonossor 13.04.2011
Sowas übles wird hoffentlich vom Compiler wegoptimiert! ^^
Florian Mätschke 13.04.2011
5
Das schlimmste, was mir begegnet ist, waren Abfragen an die Datenbank, die als SQL in einer PHP-Seite standen. Das ist zwar übliche Praxis und unter Performance-Gesichtspunkten vielleicht auch verständlich, macht aber den Code absolut unlesbar, die Fehlersuche wird zur Qual. Das Schlimmste daran ist aber, dass ich den Code auch noch selbst geschrieben habe. Ist zwar schon lange her, aber man schämt sich trotzdem immer noch dafür.
13.04.2011
Camelott 51 2
6
Also ich sage immer: Die einzige Konstante in der Softwareentwicklung ist die Veränderung. Egal ob Du jetzt den Code von vor 2 Jahren anschaust oder in 2 Jahren den Code von heute - immer würdest Du sagen "Was habe ich da denn nur gemacht". Das ist ganz normal und ein gutes Zeichen da es zeigt das du Dich immer weiterentwickelst. Mir geht es nach 15 Jahren programmieren immer noch so ;-)
Thomas Sczyrba 13.04.2011
Die Grundkonzepte haben sich nicht geändert. Man will Dinge zusammen betrachten, die zusammengehören. Man will keine manuell zu pflegenden Redundanzen. Man will eine angemessene Granularität von Aufgaben.
oopexpert 08.08.2011
Wieso, SQL queries als "programminterne Textverarbeitung" zusammenzusetzen ist doch cool ... da wird es nie langweilig ...
mupan 31.01.2012
5
Ok, einen hab ich noch. Es gab mal einen Vorschlag, die Dateizugriffe im Netzwerk zu beschleunigen, in dem man ganz tief in der untersten Bibliotheksschicht hardgecoded eine Datei immer zuerst auf C:\ sucht.

Wohlgemerkt, der Quelltext lief unter Mac, Linux und das dritte System hab ich vergessen ;-)
13.04.2011
slesa 212 6
5
Meine Erfahrung ist, dass manches, was als schlechter Stil empfunden wird, nur ungewohnt ist. Z.b. fand ich die "lazy-init-pattern"

public Klasse Property
{
get { return feld ?? (feld = new Klasse()); }
}

früher dirty. Inzwischen erscheint sie mir natürlich und steigert meine Effizienz.
13.04.2011
Marvin Steppat 3,1k 4 8
4
ganz allgemein fällt mir hier auf: jeder findet den stil,

*) den er selbst vor langer zeit hatte
*) eigenheiten, die entwickler von anderen sprachen mitgenommen haben
*) alles was er nicht selber so machen würde

als schlechten stil.

ich sag jetzt dazu ganz - wahrscheinlich in oppostion zu allen anderen hier - folgendes:

da erfahrungsgemäß der "mehraufwand", der mit "gutem stil" einhergeht, nicht bezahlt wird, begegnet man immer wieder "schlechtem" stil (hauptsache, schnell und es funktioniert).

das hat mich auch jahrelang gestört (eher: jahrzehnte), aber mittlerweile auch schon bald ein jahrzehnt) ist es mir wurscht: wenn der stil schlecht ist, kostet die änderung halt jetzt mehr! oder es gibt sie nicht, wenn das zu teuer ist.

beispiel: wörtlich hat mir ein auftraggeber (der das erzeugnis an seine kunden verkauft) gesagt: wenn das geld nicht reicht, machen wir es halt mit weniger funktionalität.

muss ich da noch was dazusagen?
13.04.2011
nabuchodonossor 1,3k 4
Mit weniger Funktionalität ok, aber deswegen auf guten Stil zu verzichten...? Egal wie die Vorgaben sind, man ist immer noch selbst für den Quellcode veratnwortlich.
slesa 13.04.2011
klingt ja fast als hättest du resigniert ;)
DaSpors 13.04.2011
@daspors: ja eh - was soll ich machen? es geht - ich bin selbständig - immer um die frage: wenn der kunde nur 2 stunden bezahlt, kriegt er auch nur, was in 2:05 möglich ist ...
nabuchodonossor 13.04.2011
@slesa: weniger funktionalität: beispiel: ein kunde wollte die möglichkeit, aus seiner (bestehenden) umgebung ein pdf dokument bei einem bestimmten webservice signieren zu lassen (frag jetzt nicht wieso ... ich weiss es nicht): funktionalität heißt für mich, es geht, oder es geht eben nicht. manchmal ist die anforderung entweder komplett oder gar nicht zu erfüllen. es scheitert übrigens meist nicht an uns it leuten, sondern an den verkäufern, die unsere dienstleistung feilbieten.
nabuchodonossor 13.04.2011
4
Mittlerweile find ich auch ganz hübsch:
int reportWanted = CheckArgumentsOfProgramSomeHow();
switch(reportWanted)
{
case 0: DoDefaultReport();
case 1: DoReport1(); // Benutzer-Auswertung
case 2: DoReport2(); // Auswertung nach Bestand
..
case 115: DoReport115(); // Bericht für Kunde xyz
}

1. Vollkommen selbsterklärender Code
2. jederzeit erweiterbar... was will man mehr?
13.04.2011
slesa 212 6
ui...schön :)
DaSpors 13.04.2011
2
Ist doch prima - eine schönere Vorlage, um magic numbers, Trennung der Belange und Einsatz von Interfaces zu erklären und grundlegende Refactoringtechniken vorzustellen, kann man sich doch kaum wünschen ;-)
Matthias Hlawatsch 13.04.2011
sieh es doch so: jeder, der solchen code schreibt, sorgt doch dafür dass wir in ein paar jahren ein vermögen verdienen.
nabuchodonossor 13.04.2011
Da hat jemand OO-Design gescheut...
oopexpert 08.08.2011
4
Ich hatte mal mit Code zu tun, der HTML-Code manipuliert hat. Aus Gründen, die ich vergessen habe, gab es die Notwendigkeit, das '.'-Zeichen zu escapen. Der dafür zuständige Senior(!)-Entwickler (Architekt mag ich ihn wirklich nicht nennen) hatte dafür den genialen Einfall, einen String zu bilden aus den Anfangsbuchstaben aller 5 Entwickler im Team und deren Nachnamen, also etwa "hmuellerbschulzfmeyercschneider". Mit diesem Bandwurm wurde dann jeder einzelne Punkt im HTML-Code ersetzt!

Übrigens gab es dann gewisse Performance-Probleme... aber bei weitem nicht nur aus diesem Grund.

Der gleiche Typ hat übrigens auch sein Geburtsdatum als "expires"-Header an den Browser übermittelt, um das Cachen der Seiten zu verhindern.
13.04.2011
Matthias Hlawatsch 12,8k 3 9
4
Ich hab noch was zum Thema QBasic!
Als Anfänger sollte ich in den Jahre 2001-2002 eine QuickBasic Anwendung (von meinen Chef in den 80ger und 90ger programmiert) zur Rezeptoptimierung für "Gross-Schlachtereien" nach VB.net portieren. Mahtematisches Prinzip war die LineareOptimierung. Das Programm bestand aus einer Datei BSRezopt.bas

Kleine Kostprobe:



PS: Dann schon lieber Ook! :o)
14.04.2011
Jorgen Schumann 1,6k 1 9
Das sieht so schrecklich wie FoxPro aus.
Gentlehag 15.04.2011
"ZEHLER" ...
mupan 31.01.2012
3
Das ist mir gerade eingefallen. Ich denke mal, dass man dies als schlechten Programmierstil bezeichnen kann, aber auch in einer gewissen Weise interessant. :-)
(new Thread (delegate() { try { ((IOperator)(obj)).Run(); } catch { } })).Start();
13.04.2011
smartic 500 8
2
Der Entwickler wurde ganz offenbar nicht nach Zeilen bezahlt.
Matthias Hlawatsch 13.04.2011
1
Übrigens gibt es sogar Wettbewerbe bei denen es darum geht möglichst unleserlichen Code zu schreiben http://de.wikipedia.org/wiki/Obfuscated_Perl_Contest
Thomas Sczyrba 13.04.2011
Und ich habe noch nie ein Perl-Skript gesehen, welches kein Wettbewerbsbeitrag war ;)
m.fuchs 13.04.2011
1
ich finds cool. Nur beim Debuggen kriegt man einen Vogel.
hugoZ 13.04.2011
3
Allgmein kann ich Code nicht ausstehen, der folgender maßen aussieht:

String s;
String s1;
String s2;
String s3;

public a()
{
s1 = s2;
...

}


Sprich, wenn die Leute keine vernünftigen Bezeichner für ihre Variablen oder Methoden haben.
Wenn dann auch nicht mal darauf geachtet wird, ob vielleicht eine member-variable eine globale überlädt, dann is der Ofen endgültig aus.
Ein weiteres Highlight was ich mal betrachten durfte war folgendes:
while(something = true)
{
do something
}


Als der Verursacher dann endlich drauf gekommen zu sein schien was falsch ist hat er folgendes draus gemacht. :)
while(true)
{
if(something = false)
{
break;
}
do something
}


Fazit:
Setzen, 6.
13.04.2011
Maverick1st 322 7
Bei kurzen Codeblöcken geht das aber.
trengel 13.04.2011
ups. Ich meine bei for(int i=0; i<10; i++) ist das i schon okay oder das string s = ""; solang s nur lokal ist.
trengel 13.04.2011
1
Also ich hab mir angewöhnt so sachen wie int i; wirklich NUR in for schleifen zu verwenden. Auch in noch so kleinen Methodenblöcken verwende ich aussagekräftige Variablen. Hat den einfachen Grund, dass ich mich nicht mehr lange damit beschäftigen muss wofür ich die Variable damals eigentlich angelegt hab, wenn ich mal nach längerer Zeit wieder an den Code ran muss.
Maverick1st 13.04.2011
3
Die schlimmsten sachen die ich leider schon als ernsthaften code sah waren folgendes:

void ShowString(string value)
{
this.TextBox.Text = value.ToString();
}


und
void IEnumerable ListToIEnumerable(List<int> zahlen)
{
return (from c in zahlen select c).ToEnumerable<int>();
}
15.04.2011
Gentlehag 1,0k 2 8
3
if !(Bedingung != true) { ... }


*Facepalm*
31.01.2012
Nicolai Schönberg 2,4k 1 9
2
Hahaha der ist Geil!
Karl 31.01.2012
2
Ich hab auch mal was schönes gesehen:
if(MyValue) //Der If-Block war immer leer. Es war immer nur der else-Block gefüllt.
{
}
else
{
...DoSomething...
}
13.04.2011
phlow666 912 9
1
Ich denke mal hier handelt es doch sicher eher um unwissenheit als um schlechten Stil(?)
Thomas Sczyrba 13.04.2011
1
Natürlich ist das ein schlechter Stil. Unwissenheit hin oder her. Schlechter Stil aber allemal.
phlow666 13.04.2011
1
Das war bestimmt einer aus der Komplementärwelt zu unserer. Jeder Hiesige wird den if-Block nutzen und nicht den else-Block.
hugoZ 13.04.2011
Oh Gott, heute gesehen!
Marvin Steppat 31.01.2012
1
Ach das ist ganz einfach: Fortran mit 6 Leerzeichen vor jeder Zeile. Was für ein Bullshit.
13.04.2011
hugoZ 53 1 5
das gilt nur für SEHR alte programme ... gibt mindestens seit der 95er definition freeformat.
nabuchodonossor 13.04.2011
2
Schon seit dem 90er Standard. Früher war es echt grausig.
gfoidl 19.10.2011
Fortran war auch so? Ich dachte das war eine Eigenart von Cobol.
Procedurnamen in Spalte 8 und Code in Spalte 12.
Jaksa 31.01.2012
1
Was heute als schlechter Stil gilt, war vor Jahren noch gar nicht anders möglich (ich spiele auf das Beispiel mit der stream-Verwendung ohne using an). Vieles kann gar nicht zur Gänze nachgebessert werden und findet sich immer wieder. Ein aus VB6 nach VB.NET importiertes Projekt schleppt viele Altlasten mit. Daran sollte man immer denken, bevor man andere Entwickler als unfähig bezeichnet, ein Ton der mir nicht gefällt und nur auf wenige nur vielleicht zutrifft.

Und nun ein sehr einfaches Nachdenk-Beispiel, jeder weiß was die folgende Routine macht (nur der Name wurde von der Autorin geändert), und vor allem: Das galt als guter Programmierstil (zu der Zeit war aber auch noch keine Rede von OO, Funktionale Programmierung war das Non-Plus-Ultra).

void DoSomething (Element *Array, int Begin, int End) {
int L = Begin, R = End;
Element Temp;
keytype Pivot;
if (End - Begin > 0) {
Pivot = Array[End].key;
while (L < R) {
while (L < R && Array[L].key <= Pivot) L++;
while (L < R && Array[R].key >= Pivot) R--;
if (L < R ) {
Temp = Array[L];
Array[L] = Array[R];
Array[R] = Temp;
}
}
Temp = Array[End];
Array[End] = Array[L];
Array[L] = Temp;
DoSomething (Array, Begin, L-1);
DoSomething (Array, L+1, End);
}
}


Was ist das schlimmste, das mir persönlich im OO Bereich je begegnet ist? Ein VB6 Programm importiert nach VB.NET war dabei, Haufenweise Legacy Code, Code-Duplizierung zum Abwinken, am besten gespickt mit kleinen Abweichungen. Aber am fürchterlichsten fand ich diesen "Smell":

> 2000 Loc umrahmt von
If (false){ ... }
, ja wenn man wie damaliger Auftraggeber kein (damals) VSS hatte / wollte musste man die Codebasis halt auf "Umwegen bewahren". (Übrigenshabe ich hier auf der Seite gerade massive Performance Probleme beim Tippen) - schönen AB-END noch (man verzeihe mir das Wortspiel aus Zuse's Zeiten)
20.03.2014
Maria Simlinger 1,1k 9
0
Ist mir bei altem C Code begegnet: Print()-Routinen für irgendwelche structs, in denen aber auch Variablen gesetzt werden. Die print()-Routinen werden allerdings nur bei Setzen eines printflags ausgeführt, hauptsächlich für debug-Zwecke... ;-(
Eieiei...
19.10.2011
Eiger 1,9k 2 9

Stelle deine Allgemein-Frage jetzt!