Eure besten Quellcode Kommentare...

[silver-moon-2000]

Zitat von Furtbichler:

Zitat von silver-moon-2000:

FuzzFactor ? einfach genial

Das mag ja für dich ein lustiger Name sein, aber eigentlich ist das nicht nur irgendwie komisch, sondern exakt das, was gemeint ist.
[...]
Es handelt sich also um einen Faktor, der die letzten Stellen der einzelnen Datentypen 'verwischt', sodaß man zwei Werte auf 'Gleichheit' (unscharf!) prüfen kann.
[...]

Das ist mir schon klar, worum es mir aber geht, ist Folgendes: Warum geben Sie die Resolution so "genau" an, nur um dann alle(!) so definierten Werte mit dem FuzzFactor zu multiplizieren?
Was ich sagen will: Warum definieren sie die Werte (z.B. 1E-19 ) so präzise, nur um sie im gleichen Schritt wieder zu "verwischen"? Warum definieren sie die Werte nicht gleich um 1E+3 unschärfer?
Als ich das gelesen habe, hat es im ersten Augenblick auf mich gewirkt wie:

Zitat:

<Programmierer1>: Verdammt, der Vergleich funktioniert nicht. Warum???
<Programmierer 2>: [nach 15min heftigem Kopfkratzen] Ich glaube, wir haben damals(TM) die Vergleichsschwellen zu gering gesetzt... Was sollen wir nur machen...
<Programmierer 1>: Ich hab's: Wir setzen einfach die Werte rauf, dann wird's schon klappen!
<Programmierer 2>: Schon, aber wenn sich irgendwann(TM) wieder was ändert, dann müssen wir wieder alle Werte anpacken...
<Programmierer 1>: Stimmt, hhhhhhhhmmmmmmmm...
<Programmierer 3>: Dann macht's doch einfach so: Nehmt 'ne Konstante und multipliziert alle Schwellen damit. Dann könnt Ihr später einfach diese Konstante anpassen.
<Programmierer 1 + 2>: Geniale Idee, danke <Programmierer3>. Aber, wie groß sollen wir die Konstante machen? 10?
<Programmierer 3> Ach, iwo! Nehmt's doch gleich 1000.
<Programmierer 1+2> Aber ist 1000 nicht irgendwie ein bischen groß?
<Programmierer 3>Merkt doch eh' keiner und dann wird's scho' funktionieren... und hey, wenn später ein Update rauskommt, machen wir den Wert einfach kleiner und tun so, als ob wir durch unendliche Schlauheit plötzlich unseren Compiler um den Faktor 10 besser gemacht hätten.

Disclaimer: Dass es in Wahrheit anders abgelaufen ist, ist mir klar, aber dieser Gedankengang hat sich mir eben in diesem Moment aufgedrängt. Ich will den Leuten bei Emba(undVorläufern) nichts unterstellen


Also nochmal zusammenfassend: Ich finde die Bezeichnung nach wie vor genial; aber auch die Tatsache, dass ein genauerer Wert vorgegeben und gleich darauf verwischt wird, entzieht sich meiner Meinung nach nicht einer gewissen Komik.

[Furtbichler]

Zitat von silver-moon-2000:

Zitat von Furtbichler:

Zitat von silver-moon-2000:

FuzzFactor ? einfach genial

Das mag ja für dich ein lustiger Name sein, aber eigentlich ist das nicht nur irgendwie komisch, sondern exakt das, was gemeint ist.
[...]
Es handelt sich also um einen Faktor, der die letzten Stellen der einzelnen Datentypen 'verwischt', sodaß man zwei Werte auf 'Gleichheit' (unscharf!) prüfen kann.
[...]

Das ist mir schon klar, worum es mir aber geht, ist Folgendes: Warum geben Sie die Resolution so "genau" an, nur um dann alle(!) so definierten Werte mit dem FuzzFactor zu multiplizieren?

Das nennt sich selbsterklärender Code. So ist klar, das die Genauigkeit der einzelnen Datentypen als Grundlage genommen wird. Wenn Du gleich die 10E-16 als Konstante nimmst, weiß doch keiner, wieso? Das müsstest Du dann dazuschreiben. Toll. Aber warum nicht gleich so programmieren, das man gar keine Kommentare benötigt? Das ist ein Programmierparadigma ('Clean Code').

Zitat:

<Programmierer1>: Verdammt, der Vergleich funktioniert nicht. Warum???

Wir sich als 'Programmierer' diese Frage nicht sofort selbst beantworten kann, ist keiner und gehört wieder in die Schule/Ausbildung/Bücherecke.

Der Name ist aber mal selten zutreffend, das stimmt schon.

[Uwe Raabe]

Zitat von silver-moon-2000:

aber auch die Tatsache, dass ein genauerer Wert vorgegeben und gleich darauf verwischt wird, entzieht sich meiner Meinung nach nicht einer gewissen Komik.

Die Zahlen 1E-19, 1E-15 und 1E-7 geben genau den Wert eines Extended, Double oder Single an, der, wenn man ihn von dem Wert 1.0 abzieht, noch ein von 1.0 unterscheidbares Ergebnis liefert. Insofern korrespondieren die Zahlen 19, 15 und 7 mit der Angabe der signifikanten Stellen für die drei Float-Typen in der Delphi Hilfe (abgesehen von dem einem Tippfehler bei Extended 32-Bit, da muss es 19-20 statt 10-20 heißen). Ich finde das schon wesentlich nachvollziehbarer als wenn man gleich die sich durch die Multiplikation ergebenden Werte hinschreiben würde.

Nebenbei wäre es auch wesentlich einfacher und auch sofort nachvollziehbar, wenn man einen anderen FuzzFactor verwenden wollte. Dann würde man nämlich genau diese Konstante ändern und nicht die für jeden einzelnen Float-Typ.

[TForm1]

Ist der schon bei Euch aufgetaucht?

HTML-Code:

             _.-~-.
           7''  Q..\
        _7         (_
      _7  _/    _q.  /
    _7 . ___  /VVvv-'_                                            .
   7/ / /~- \_\\      '-._     .-'                      /       //
  ./ ( /-~-/||'=.__  '::. '-~'' {             ___   /  //     ./{
 V   V-~-~| ||   __''_   ':::.   ''~-~.___.-'' _/  // / {_   /  {  /
  VV/-~-~-|/ \ .'__'. '.    '::                     _ _ _        ''.
  / /~~~~||VVV/ /  \ )  \        _ __ ___   ___ ___(_) | | __ _   .::'
 / (~-~-~\\.-' /    \'   \::::. | '_ ` _ \ / _ \_  / | | |/ _` | :::'
/..\    /..\__/      '     '::: | | | | | | (_) / /| | | | (_| | ::'
vVVv    vVVv                 ': |_| |_| |_|\___/___|_|_|_|\__,_| ''

Hi there, nice to meet you!

Habe ich gerade im HTML-Text auf der Seite von Firefox gesehen.

[TiGü]

Delphi-Quellcode:

//------------------------------------------------------------------------------
{*Erzeugt analog zur Echtzeitversion für einen Tastendruck auf der
Tastatur in der DEMO-Version eine Massage an das aufrufende
Programm.
@param BoxNr  Boxennummer
@param eSensor Ereignis}
procedure DemoSensor(BoxNr,eSensor:Integer);
...

Gemeint war eine Windows-Message!

[Luckie]

Ich halte mir dann das Tablet mal auf meinen verspannten Rücken.

[TiGü]

XE7 - System.Threading - Zeile 3005

Delphi-Quellcode:

procedure TThreadPool.TQueueWorkerThread.ExecuteWorkItem(var Item: IThreadPoolWorkItem);
begin
  try
    try
      Item.ExecuteWork;
    finally
      Item := nil;
    end;
  except
    // ???figure out error handling and exception passing system???
  end;
end;

[Sherlock]

In XE8 ist das ja bestimmt behoben worden...kostet halt extra.

Sherlock

[Der schöne Günther]

unit Soap.OPToSOAPDomConv;

Delphi-Quellcode:

begin
    { Old -D6- Header processing logic - left here simply because....}
    AbortRequest := False;
    HeaderProcessor := FindHeaderProcessor(HeaderNamespace, HeaderName, '');
    if HeaderProcessor <> nil then
      HeaderProcessor.ProcessHeader(HeaderNode, HeaderHandled, AbortRequest)
    else
    begin
      UnhandledNode(Format('%s:%s', [HeaderNamespace, HeaderName]), HeaderNode.XML);
      DefaultProcessHeader(HeaderNode, HeaderHandled, AbortRequest);
    end;
    if AbortRequest then
      raise ESOAPDomConvertError.CreateFmt(SHeaderError, [HeaderNamespace, HeaderName]);
  end;