Was nervt euch so, während der Programmierung oder so allgemein

[himitsu]

Also, was nun echt mal nicht geht:

Delphi hat ein Jahr 2000-Umstellungsproblem :shock:


OK, eigentlich ist es nur ein Sommer-/Winterzeitumstellungsproblem.
Schön daß da die einzige Lösung darin besteht Delphi neu zu Starten, denn alles zu speichern/überschreiben half auch nix. :evil:

Denn als es grade den Eingabefokus zurückbekam, machte es das, was bei einer externen Änderung passiert ... es meckert "Da wurde was verändert. Soll ich es neu laden"?
Das ist ja eigentlich nicht schlimm, aber daß macht es grade bei allen geöffneten Dateien (sind schon ein paar) und natürlich auch bei denen, welche eigentlich nicht verändert wurden.
Und ganz besonders besch*** ist, daß es das nun jedes Mal macht wenn es den Fokus zurückbekommt, da es sich das [Nein] nicht merkt, bei der noch nicht gespeicherten Projektgruppendatei (groupproj).



Und weil Delphi so intelligent ist, merkt es nicht, daß schon soein (hier sogar das Gleiche) modales Fenster auf ist ... eine Alt-Tab-Orgie und man muß erstmal tausende "soll ich laden"-Fenster zumachen. :wall:

[jaenicke]

Zitat:

Zitat von himitsu (Beitrag 1133444)

Zumindestens hatte man in XE schon eine abfrage "Wollen sie wirklich formatieren?" eingebaut, was mein aktuelles 2010 noch nicht kennt. :cry:

Bist du sicher? Hast du bei dir nicht zufällig aus Versehen die Checkbox aktiviert "nicht mehr nachfragen"? Das kannst du in den Optionen sehen, wenn es das da schon gab sollte das dort so oder ähnlich aussehen:

Anhang 35459

Zitat:

Zitat von himitsu (Beitrag 1133444)

Was auf jeden Fall nervt, ist die Tlanungsphase zu einem Programm/Code ... da geht soooo viel sinnlose Zeit drauf, bevor man mit dem Proggen endlich anfangen kann :?

Noch nerviger ist es aber ohne Plan heranzugehen und nach ein paar Wochen zu merken, dass das Konzept so doch nicht so gut funktioniert. :mrgreen:

[himitsu]

Jupp, das war eines der zwei Megafeatures, weswegen man unbedingt auf XE upgraden mußte. (abgesehn von SVN und Co.)
Anhang 35460

Es war scheinbar noch genug anderen passiert, daß sie bei Strg+D das D manchmal verfehlten.
Das Ding ist ja nur so von oftgenutzten Tasten umgeben > Strg+E Strg+R Strg+F Strg+G Strg+V Strg+C Strg+X Strg+S ...

[himitsu]

..., daß ich jetzt noch ganz schnell die letzen "sicheren" Delphi-Tage-Pfefferminz-Dinger loswerden muß.

Ich wußte ja nicht daß die ein Verfallsdtum haben, aber ich sah jetzt grade noch, daß diese morgen früh verfallen werden :shock:


PS: Warum haben wir keinen Witzethread?

Zwei Männer gehen von einer Halloweenparty nach Hause und beschließen, die Abkürzung über den Friedhof zu nehmen, schließlich passt das gerade richtig in die Stimmung. Mitten zwischen den Gräbern hören sie plötzlich ein Geräusch aus dem Dunklen kommen: Tock-tock-tock, tock-tock-tock... Zitternd vor Furcht schleichen sie weiter und finden schliesslich einen alten Mann, der mit Hammer und Meißel einen Grabstein bearbeitet. Nachdem der erste sich wieder leicht erholt hat, fragt er den Mann: "Alter Mann, Sie haben uns fast zu Tode erschreckt... wir dachten schon, Sie wären ein Geist! Was arbeiten Sie denn hier mitten in der Nacht?"
"Diese Idioten!" murmelt der alte Mann, "die haben meinen Namen falsch geschrieben...".

Mit der ganzen Totenstimmung hier, die letzte Zeit über, vergeht einem ja fast der Appetit beim Leichenschmaus.

[mquadrat]

Feature-Creap ohne dazu passende Anpassung von Budget und Termin :x

[himitsu]

Extrem nerven tut es, daß _AddRef und _Release nie als virtual deklariert sind. (QueryInterface ist es allerdings fast immer)

Wie soll man denn da nachträglich eine Referenzzählung implementieren, wo es vorher keine gab (diese Funktionen machen nichts), bzw. wie soll man da das Verhalten ändern können.
:cry:

TComponent-Nachfahren wollte ich mit einer Referenzzählung ordentlichen versehnen, welche VCL-Object-Verwaltung und Interface-Referenzzählung kombiniert.
Die einzige Lösung ist da umständlich(er) ein weiteres Interface (IVCLComObject) dahinter zu schalten.


Ach ja und es kotzt uch an, wenn man an fertige (fast passende) Implementationen nicht rann kommt, da der gewünschte Typ irgenwo in einem Implementation-Teil versteckt deklariert ist. :wall:

[Stevie]

Zitat:

Zitat von himitsu (Beitrag 1134042)

Extrem nerven tut es, daß _AddRef und _Release nie als virtual deklariert sind. (QueryInterface ist es allerdings fast immer)

Wie soll man denn da nachträglich eine Referenzzählung implementieren, wo es vorher keine gab (diese Funktionen machen nichts), bzw. wie soll man da das Verhalten ändern können.

Überschreib die Methoden und setz in die Klassendefinition nochmals IInterface. Dann werden die 3 Methoden aus dieser Klasse benutzt.

[Meflin]

Digital River. Nie wieder!

[himitsu]

Hi Stevie,

seit man aber Interfaces wieder in Objekte zurückcasten kann (IInterfaceComponentReference sei Dank ... die haben mir meine Idee geklaut :cry:),
ist dieses nicht mehr sicher, denn wenn man dann auf das ältere Klasse castet und dann wieder in ein Interface, dann wird das Interface des Vorfahren und nicht das Neue verwendet.

Und IInterfaceComponentReference zu überschreiben hatte keinerlei Wirkung, sonst hätt' ich da einfach NIL zurückgegeben. :twisted:

Delphi-Quellcode:

type
  TMyClass1 = class(TObject, IInterface)
    function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

  TMyClass2 = class(TMyClass1, IInterface)
    function QueryInterface(const IID: TGUID; out Obj): HResult; override; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

procedure TForm1.FormCreate(Sender: TObject);
var
  i1, i2, i3, i4, i5, i6: IInterface;
  o5: TMyClass1;
  o6: TMyClass2;
begin
  Memo1.Lines.Add('');
  Memo1.Lines.Add('o6 := TMyClass2.Create / i6 := TMyClass2(o6) as IInterface');
  o6 := TMyClass2.Create;
  i6 := o6 as IInterface;
  i6._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('o5 := TMyClass2.Create; / i5 := TMyClass1(o5) as IInterface;');
  o5 := TMyClass2.Create;
  i5 := o5 as IInterface;
  i5._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i1 := TMyClass1.Create;');
  i1 := TMyClass1.Create;
  i1._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i2 := TMyClass2.Create;');
  i2 := TMyClass2.Create;
  i2._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i3 := TMyClass2(i2) as TMyClass2;');
  i3 := i2 as TMyClass2;
  i3._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i4 := TMyClass2(i2) as TMyClass1;');
  i4 := i2 as TMyClass1;
  i4._AddRef;

  Memo1.Lines.Add('');
end;

{ TMyClass1 }

function TMyClass1.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  Form1.Memo1.Lines.Add('TMyClass1.QueryInterface');
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TMyClass1._AddRef: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass1._AddRef');
end;

function TMyClass1._Release: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass1._Release');
end;

{ TMyClass2 }

function TMyClass2.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  Form1.Memo1.Lines.Add('TMyClass2.QueryInterface');
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TMyClass2._AddRef: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass2._AddRef');
end;

function TMyClass2._Release: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass2._Release');
end;

end.




o6 := TMyClass2.Create / i6 := TMyClass2(o6) as IInterface
TMyClass2.QueryInterface
TMyClass2._AddRef
TMyClass2._AddRef

o5 := TMyClass2.Create; / i5 := TMyClass1(o5) as IInterface;
TMyClass1.QueryInterface    // ist QueryInterface nicht virtual kommt hier TMyClass1.QueryInterface rause
TMyClass2._AddRef
TMyClass2._AddRef

i1 := TMyClass1.Create;
TMyClass1._AddRef
TMyClass1._AddRef

i2 := TMyClass2.Create;
TMyClass2._AddRef
TMyClass2._AddRef

i3 := TMyClass2(i2) as TMyClass2;
TMyClass2.QueryInterface
TMyClass2._AddRef
TMyClass2._AddRef

i4 := TMyClass2(i2) as TMyClass1;
TMyClass2.QueryInterface
TMyClass1._AddRef
TMyClass1._AddRef

TMyClass2._Release
TMyClass2._Release
TMyClass1._Release
TMyClass2._Release
TMyClass2._Release
TMyClass1._Release

[haentschman]

@himi...

wenn wir hier einen Counter hätten, würdest du den genervten Record halten... :stupid: Paß auf deine Gesundheit auf, damit nicht in ein paar Jahren ein Bypaß dich verschönert :zwinker: Man muß sich nicht über alles aufregen. Manchmal einfach nur akzeptieren... :thumb:

[Stevie]

Zitat:

Zitat von himitsu (Beitrag 1134125)

seit man aber Interfaces wieder in Objekte zurückcasten kann (IInterfaceComponentReference sei Dank ... die haben mir meine Idee geklaut :cry:),
ist dieses nicht mehr sicher, denn wenn man dann auf das ältere Klasse castet und dann wieder in ein Interface, dann wird das Interface des Vorfahren und nicht das Neue verwendet.

So ne Schei... macht man ja auch nicht! Oder man schaltet sein Hirn an bevor man wirres Zeugs codet.

[himitsu]

Die Klasse ist für etwas, was hier mal veröffentlicht wird ... Und was hier für Irre rumlaufen, kann ich mir jetzt noch garnicht ausdenken. :stupid:
Allerdings könnte man sich über diese Lib die Delphi-IDE lahmlegen und das wollte ich minimieren.

[Stevie]

Dass man non ref counted interfaces haben will, ist ja noch plausibel, aber dass man TComponent Derivate mit Refcounting ausstatten will, kann ich nicht ganz verstehen, denn genau damit kannst du ganz böse Überraschungen erleben. Das TComponent livetime management wird nunmal über den Owner geregelt und nicht über das Interface. Beides zu mischen wird über kurz oder lang in die Hose gehen.

[himitsu]

Deswegen hab ich mir ja ein entsprechendes Verhalten ausgedacht, welches den Referenzzähler und die Objektreferenz beachtet ... erst wenn Beides freigeben ist, wird alles aufgeräumt. :stupid:

Denn es ist vorgesehn diese Klassen gleichzeitig in der VCL und als Interface zu nutzen und ich wollte mir eben doppelte Arbeit ersparen, das als Interface zu machen und dann nochmal 'ne Containerklasse für die VCL bereitzustellen. :oops:

[Namenloser]

Zitat:

Zitat von himitsu (Beitrag 1134149)

Deswegen hab ich mir ja ein entsprechendes Verhalten ausgedacht, welches den Referenzzähler und die Objektreferenz beachtet ... erst wenn Beides freigeben ist, wird alles aufgeräumt. :stupid:

Das klingt ziemlich kompliziert und fehleranfällig, aber wenn es funktioniert, ist es cool.

[himitsu]

Eigentlich nicht ... jedenfalls nicht, wenn ich _AddRef hätte überreiben können :cry:

Aber ich hab jetzt die Basisklase (abgeleitet von TComponent) und eine Helperklasse, welche ich als VCLInterface in TComponent einbeschmuggelt hab. :D

Nja, statt 3 Zeilen Code jetzt 10 sinnlose Funktionen, welche einfach nur wieder zurück zur Basisklasse umleiten.
*ich haß das*


So, als Rache und weil heute nich mehr viel passiert, entschlüssle ich jetzt das geheime Interface hinter den anonymen Methoden und veröffentliche es dann ... das hat emba jetzt davon.
An dem Objekt hinter dem Interface bin ich schon und nun nur noch die schöne neue überladene RTTI ausnutzen. :roll:

[himitsu]

Mir ist grade die krankeste Idee gekommen, für einen Code:

Delphi-Quellcode:

for i in(function:TArray<Integer>var i:Integer;begin SetLength(Result,5);for i:=0to 4do Result[i]:=i*10;end)()do
  ShowMessage(Variant(i));

Eigentlich sollte es doch nervig sein, wenn wunderschöner Delphi-Code urplötzlich wie eine C-Krankheit aussieht, oder etwa nicht?

PS: Das ist die Kurzfassung einer

Delphi-Quellcode:

for i := 0 to 40 step 10 do

-Schleife ... falls man es, aus welchen Gründen auch immer, tatsächlich nicht erkennen sollt. :angle2:

Delphi-Quellcode:

var
  i2: integer;


for i2 in (function: TArray<Integer>
           var
             i: Integer;
           begin
             SetLength(Result, 5);
             for i := 0 to 4 do
               Result[i] := i * 10;
           end)() do
  ShowMessage(IntToStr(i2));

Ich geb's zu, am Ende hab ich es dann doch noch so gelöst. :oops:

Delphi-Quellcode:

var
  i, i2: integer;

for i := 0 to 4 do begin
  i2 := i * 10;
  ShowMessage(IntToStr(i2));
end;

Oder wenigstens so :angle:

Delphi-Quellcode:

for i in TArray<Integer>.Create(0, 10, 20, 30, 40) do
  ShowMessage(IntToStr(i));

Ich hoffe jetzt wendet niemand genervt dem Delphi den Rücken zu und wanders zu QBasic ab. :?


Aber wirklich nervig ist eigentlich, daß

Delphi-Quellcode:

TArray<Integer>

und

Delphi-Quellcode:

array of Integer

nicht kompatibel sind, obwohl

Delphi-Quellcode:

TArray<T>

auch nur ein

Delphi-Quellcode:

array of T

ist :wall:

Delphi-Quellcode:

var
  G: TArray<Integer>;
  D: array of Integer;

D := G;  // [DCC Fehler] U.pas(56): E2010 Inkompatible Typen: 'TArray<System.Integer>' und 'Dynamic array'

Aber OK, man soll sich ja nicht so aufregen ... an der sonst so kranken Vererbungsreihe der Generics liegt es dieses Mal nicht direkt.

Delphi-Quellcode:

var
  X: array of Integer;
  D: array of Integer;

X := D;  // [DCC Fehler] U.pas(56): E2008 Inkompatible Typen

Denn der Witz ist, daß das sonst so typsichere/strenge Delphi durch die Generics "scheinbar" total verweichlicht wird.

Delphi-Quellcode:

var
  X: TArray<Integer>;
  D: TArray<Integer>;

X := D;  // denn das geht zumindestens ^_^

[Valle]

Mich nervt gerade tierisch, dass mein (Linux-) Rechner eben komplett abgestürzt ist. Das starten irgendwelcher Programme wurde mit I/O-Error quittiert, bereits geöffnete Programme froren ein, sobald sie auf die Festplatte zugreifen wollten. Nach dem nötigen Hard-Reset kamen Fehler beim Booten - und das obwohl der Linux Kernel über eine spezielle Tastenkombination erst alle Schreiboperationen vollendet und anschließend die Geräte ausgehängt hat. Also fast ein normaler Shutdown.

Eine Analyse des Dateisystem-Headers zeigt: alle 592 Bytes, welche die Schlüssel zur verschlüsselten Partition enthielten bestehen jetzt ausschließlich aus Nullen. Statt arbeiten ist jetzt also erstmal eine Neuinstallation und -Konfiguration des Systems angesagt. Datenverlust gab es zum Glück keinen, aber mit meiner tollen Internetanbindung mindestens 1 Tag Arbeit. Juhu.

Liebe Grüße,
Valentin

[Luckie]

Ich dachte man installiert nur Windows neu, wenn es abgestürzt ist. :mrgreen:

[Namenloser]

Mit Linux wär das nicht passiert :warn:

[BUG]

Zitat:

Zitat von Valle (Beitrag 1134382)

Eine Analyse des Dateisystem-Headers zeigt: alle 592 Bytes, welche die Schlüssel zur verschlüsselten Partition enthielten bestehen jetzt ausschließlich aus Nullen.

Fast überall wo ich über partitionsweise Verschlüsselung gelesen habe, wird empfohlen, den Header gesondert zu sichern :angel2:
Aber nur da und nur Nullen? Das sieht ja irgendwie aus wie Absicht :gruebel:

[himitsu]

Zitat:

Zitat von NamenLozer (Beitrag 1134386)

Mit Linux Windows wär das nicht passiert :warn:

:mrgreen: (den es war ja ein Linux, was da verreckte :zwinker: )

[add]
Linux soll doch soooo sicher sein?
Da gibt es ja angeblich keine Viren und Co.

[Thom]

Zitat:

Zitat von himitsu (Beitrag 1134153)

So, als Rache und weil heute nich mehr viel passiert, entschlüssle ich jetzt das geheime Interface hinter den anonymen Methoden und veröffentliche es dann ... das hat emba jetzt davon.
An dem Objekt hinter dem Interface bin ich schon und nun nur noch die schöne neue überladene RTTI ausnutzen. :roll:

Das ist doch nichts weiter als ein TInterfacedObject (Mason Wheeler: Anonymous method as TInterfacedObject). :gruebel:

[Luckie]

...wenn das Intranet zusammen gebrochen ist und man an Infos im Wiki aus dem Intranet nicht drankommt.

[Namenloser]

Zitat:

Zitat von himitsu (Beitrag 1134389)

Zitat:

Zitat von NamenLozer (Beitrag 1134386)

Mit Linux Windows wär das nicht passiert :warn:

:mrgreen: (den es war ja ein Linux, was da verreckte :zwinker: )

Das war Sarkasmus ;)

[Stevie]

Zitat:

Zitat von Thom (Beitrag 1134393)

Zitat:

Zitat von himitsu (Beitrag 1134153)

So, als Rache und weil heute nich mehr viel passiert, entschlüssle ich jetzt das geheime Interface hinter den anonymen Methoden und veröffentliche es dann ... das hat emba jetzt davon.
An dem Objekt hinter dem Interface bin ich schon und nun nur noch die schöne neue überladene RTTI ausnutzen. :roll:

Das ist doch nichts weiter als ein TInterfacedObject (Mason Wheeler: Anonymous method as TInterfacedObject). :gruebel:

Ich habs auch nicht ganz verstanden, was daran noch geheim sein soll. Nen TInterfacedObject mit Feldern für alle captured Variablen und ein Interface mit einer Invoke methode, welche der Signatur der anonymen Methode entspricht.

[himitsu]

[verschoben]
http://www.delphipraxis.net/163779-s...ml#post1134418

[Valle]

Das hat nichts mit Sicherheit zutun. Ich denke mal ein Hardwaredefekt ist schuld, weil das System auf einer SSD installiert ist war. Der Rechner hat öfter mal verschiedene Macken mit der Festplatte. Bei ca. jedem 5. Mal hängt er sich beim Booten auf, und diese "Freezes" und I/O-Errors kamen auch schon öfter vor.

Den Partition-Header werde ich in Zukunft auch nochmal gesondert aufheben. Dass es wie Absicht aussieht habe ich auch schon gedacht, schließe ich aber eigentlich aus. Heute Mittag werd' ich mal das neue Ubuntu probieren statt dem guten alten Debian.

Liebe Grüße,
Valentin

[Luckie]

Ich überlege, ob wir nicht mal einen neuen Thread aufmachen sollte: "Was nervt himitsu". :mrgreen:

[mkinzler]

Am Besten eine eigene Rubrik :mrgreen:

[Medium]

Mich nervt gerade tierisch, dass das Paint() von TGraphicControl-Nachkommen bereits ausgeführt wird, noch bevor sich dessen Parent fertig gezeichnet hat (bzw. gar sichtbar ist). Adjeu halbtransparenter Komponentenumbau :evil:

[DeddyH]

Zitat:

Zitat von Luckie (Beitrag 1134430)

Ich überlege, ob wir nicht mal einen neuen Thread aufmachen sollte: "Was nervt himitsu". :mrgreen:

Meinst Du "Was" oder eher "Wen"? :mrgreen:

[Nersgatt]

Zitat:

Zitat von DeddyH (Beitrag 1134453)

Zitat:

Zitat von Luckie (Beitrag 1134430)

Ich überlege, ob wir nicht mal einen neuen Thread aufmachen sollte: "Was nervt himitsu". :mrgreen:

Meinst Du "Was" oder eher "Wen"? :mrgreen:

Wieso, gibs doch schon: Klick :mrgreen:

(Himi: sorry, den konnt ich mir nicht verkneifen. Auf gar keinen Fall ernst nehmen!)

[Bummi]

jetzt ist aber mal wieder gut ....

[implementation]

Zitat:

Zitat von himitsu (Beitrag 1134380)

Denn der Witz ist, daß das sonst so typsichere/strenge Delphi durch die Generics "scheinbar" total verweichlicht wird.

Delphi-Quellcode:

var
  X: TArray<Integer>;
  D: TArray<Integer>;

X := D;  // denn das geht zumindestens ^_^

Das kommt aber nicht durch die Generics.
Probier das mal:

Delphi-Quellcode:

type TIntArray = array of Integer;

var
  X: TIntArray;
  D: TIntArray;

X := D;

Das Problem liegt daran, dass Delphi für jedes Vorkommen einer Arraydeklaration einen neuen Typen anlegt.

Delphi-Quellcode:

// gleicher Typ
X, D: array of Integer;

// verschiedener Typ
X: array of Integer;
D: array of Integer;

Das steht aber auch in (fast) jedem Einsteigerbuch :mrgreen:

[Delphi-Laie]

Am neuen Delphi (bzw. RAD-Studio) XE2:

Tools->Optionen->Delphi-Optionen

Geht man auf "Bibliothek" oder "Bibliothek - Übersetzt" ist immer 32-Bit-Windows als Plattform ausgewählt und nicht das, was man zuletzt aufgerufen/angewählt/eingestellt hatte. Nunja...

Noch schlimmer: Wechselt man zwischen beiden, wird die Plattform grundsätzlich auf 32-Bit-Windows zurückgesetzt. Das ist keinesfalls offensichtlich und nicht sofort zu bemerken. Man wundert sich zunächst, daß die Einstellungen, die man vornahm, manchmal "irgendwie" nicht richtig gespeichert werden.


Noch so eine Lästigkeit: Startet man das Compilat aus der IDE heraus, zoomt die IDE in den Fenster-Maximal-Modus, um nach dem Beenden des Programmes wieder seine alte Größe und Position einzunehmen.


Mir kann das alles keiner als "Features" verkaufen. Für mich sind das schlichtweg Softwareergonomiefehler.

[Medium]

Stell doch dein Debug-Layout so ein, wie du es lieber hättest ;)

[himitsu]

Wie kann man eigentltich sagen "dieses Layout ist ein Debug-Layout" ?

Kann man irgendwie sagen, dieses Debug-Layout gehört zu diesem Nicht-Debug-Layout?
Also wenn das Layout aktiv ist, soll dieses Debug-Layout genutzt werden und bei einem Anderem ein Anderes.

Bzw. kann man Delphi sagen, es soll immer das letzte Layout, welches zuletzt zum Debuggen genutzt wurde, auch das nächste Mal nutzen?

Und am Liebsten wäre es mir, wenn er sich auch die aktuellen Änderungen merken würde und man nicht jeden Scheiß erst speichern muß.

[Stevie]

Zitat:

Zitat von himitsu (Beitrag 1135722)

Wie kann man eigentltich sagen "dieses Layout ist ein Debug-Layout" ?

F6 ist dein Freund 8-)

[N1ls]

Mich nervt gerade

Delphi-Quellcode:

if false = someFunction() then
begin
  // do something
end;

extrem an.

Mal ganz abgesehen vom Vergleich auf false(den Code habe ich sinngemaess von PHP uebersetzt und da machen solche Abfragen ab und an sogar Sinn). Mit der Reihenfolge komme ich gar nicht klar. Ist IMHO einfach nur umstaendlich zu lesen, oder?

Gruesse,

N1ls