Befindet sich Delphi noch auf der Höhe der Zeit?

[SMO]

Zitat von Delphi-Laie:

Mit "lokalen (Block)Variablen" konnte aber auch ich nichts anfangen, aber da diese ja als fehlend moniert werden und ich nur Delphi näher kenne...was man nicht weiß, macht einen eben nicht heiß.

Ein Block ist ganz einfach ein Stück Code, dass in "begin ... end" geklammert ist, oder in C entsprechend in "{ ... }".
In C und verwandten Programmiersprachen kann man in jedem Block lokale Variablen deklarieren. Ursprünglich in C nur am Anfang des Blocks, später dann auch überall.
In Pascal/Delphi sähe das ungefähr so aus:

Delphi-Quellcode:

if SomeFunc() then
begin
  var s: string;
  var n: Integer;
  s := 'foo';
  n := 10;
  for var i: Integer := 0 to 9 do
  begin
    var sum: Integer;
    sum := n + i;
    WriteLn(s + IntToStr(sum));
  end;
end;

Schrecklich, oder? Pascal/Delphi hat eben seit jeher Variablen im "var" Abschnitt deklariert und nicht mitten im Code. Wer denkt, das wäre ein großes Problem, der ist nicht mehr auf der Höhe der Zeit, denn die Delphi-IDE hat schon länger Live Templates. Einfach mal irgendwo mitten im Code "var" eingeben, gefolgt von Tab (oder Strg+J).
Außerdem gibt es auch "Declare Variable" - man schreibe z.B. "foo := 'bar'", setze den Cursor auf das "foo" und drücke Strg+Shift+V.

[Delphi-Laie]

Zitat von SMO:

Schrecklich, oder?

Naja, Ansichts- und Gewohnheitssache, aber im Vergleich zu der anderen Kritik - wie berechtigt oder auch nicht die immer sein mag - wohl eher ein Nebenkriegsschauplatz.

[Hansa]

Zitat von Bernhard Geyer:

Man muss ja nicht jede Delphi-Version mitmachen. Für D6 habe ich z.B. (für uns wichtige Fixes) aus D200x rückportiert.

Du bist ja noch schlauer als gedacht.

Und die Blockvariablen sind tatsächlich das von mir vermutete ? Entsetzlich. Ich würde mal sagen : GW-Basic von 1980 lässt langsam grüssen. Aber warum nicht ? Win8 erinnert mich auch eher standardmässig an DOS als an WIN7.

[BUG]

Zitat von SMO:

Schrecklich, oder? Pascal/Delphi hat eben seit jeher Variablen im "var" Abschnitt deklariert und nicht mitten im Code. Wer denkt, das wäre ein großes Problem, der ist nicht mehr auf der Höhe der Zeit, denn die Delphi-IDE hat schon länger Code Templates.

Wer denkt, das wäre ein großes Problem, der schreibt zu lange Funktionen...

Zitat von Hansa:

Und die Blockvariablen sind tatsächlich das von mir vermutete ? Entsetzlich.

Nicht übertreiben. In for-Schleifen und für benannte Zwischenergebnisse sind die nicht so übel:

Code:

for (auto& car : pool) {
  auto& engine = car.getEngine();
  if (car.manufacturer() == VW && engine.type() == DIESEL) {
    service.schedule(car);
  }
}

Meine persönliche Einschätzung: Für Entwickler von CRUD-Anwendungen gibt es mittlerweile viele bequeme Alternativen (GC, Reflection, größeres Ökosystem, ...); ansonsten ist modernes C++ sehr benutzbar und bietet mächtige Abstraktionen mit wenig Overhead (z.B. RAII). Was bleibt ist die Sprache selbst und VLC/FMX sowie die bestehender Code und Komponenten: Delphi-Language/Object-Pascal ist angenehm, aber nicht so gut durch-standardisiert/dokumentiert wie andere Sprachen. Die VCL ist für Windows super, aber halt nicht wirklich portabel; FMX hebt sich für mich nicht sonderlich von anderen modernen Frameworks ab.
Ich würde mich nicht sonderlich sträuben, Delphi-Entwickler zu werden; aber es muss auch nicht sein.

tl;dr: Meh.

[Sir Rufo]

Nun ja, mit ein bisschen Generics und Closures bekommt man so etwas hin

Delphi-Quellcode:

  &With.Block<string, Integer>(
    'foo',
    10,
    procedure( const s: string; const n: Integer )
    var
      i: Integer;
      sum: Integer;
    begin
      for i := 0 to 9 do
        begin
          sum := n + i;
          WriteLn( s + IntToStr( sum ) );
        end;
    end );

oder

Delphi-Quellcode:

TArray.ForEach<TCar>( 
  pool,
  procedure ( const car: TCar )
  begin
    &With.Block<TEngine>( 
      car.GetEngine,
      procedure ( const engine: TEngine )
      begin
        if (car.Manufacturer = TManufacturer.VW) and (engine.&Type = TEngineType.DIESEL ) then
          service.Schedule( car );
      end );
  end );

[BUG]

Zitat von Sir Rufo:

Nun ja, mit ein bisschen Generics und Closures bekommt man so etwas hin

Muss man ja auch nicht
Ich wollte eigentlich demonstrieren, dass man Blockvariablen durchaus einsetzen kann, um die Lesbarkeit zu verbessern (imho). Es wäre ja es nicht sonderlich schlimm gewesen die Variablen im Funktionskopf zu deklarieren, aber einen sinnvollen Wert haben die Variablen im Beispiel eh nur innerhalb des Blocks.

[Sir Rufo]

Zitat von BUG:

Zitat von Sir Rufo:

Nun ja, mit ein bisschen Generics und Closures bekommt man so etwas hin

Muss man ja auch nicht

Nein, natürlich nicht ... aber wenn man einem Feature X hinterherweint, dann muss man wohl wechseln oder sich mit dem arrangieren/vertraut machen was möglich ist.

Ich bin allerdings faul, und möchte auch nicht ständig irgendwo Variablen deklarieren nur weil ich durch ein Array laufen muss. Dann schreibe ich mir eben einen TArray.ForEach<T>(Action:TAction<T>) und kann mir diese Hilfsvariablen sparen.

[Sherlock]

Ich bin voll auf Hansas Schiene: Bugfixing! Bugfixing! Bugfixing! Das ist es was Delphi fehlt.
Diese Features, mit denen man die paar halbwegs wechselwilligen Java oder C# Coder versucht anzulocken, braucht keine Sau. Ehrlich. Dann lieber auf die zwei Leute verzichten und endlich mal Stabilität in die Sprache bringen, und mal ausnahmsweise versuchen eben nicht ein Release zu verkaufen, das nichtmal zuverlässigen 64Bit Code erzeugt. Das ist doch sowas von peinlich. Wenn man dann noch bedenkt, daß da vermutlich einer stundenlang drüber gebrütet hat, ob man dieses Bugfix allen oder nur den Subscribern zur Verfügung stellt, müssen einem doch die Haare zu Berge stehen.

Sherlock

[Stevie]

Zitat von Sir Rufo:

Dann schreibe ich mir eben einen TArray.ForEach<T>(Action:TAction<T>) und kann mir diese Hilfsvariablen sparen.

Und hast dafür zigmal langsameren Code, GE-ZETT!

[Sir Rufo]

Zitat von Stevie:

Zitat von Sir Rufo:

Dann schreibe ich mir eben einen TArray.ForEach<T>(Action:TAction<T>) und kann mir diese Hilfsvariablen sparen.

Und hast dafür zigmal langsameren Code, GE-ZETT!

Für 1.000.000 fette Records in einem Array benötigen die Aufrufe (von allen Records) 8ms - soviel Zeit habe ich so gerade noch
Mit mehr habe ich es nicht getestet, weil die Records so fett waren, dass der verfügbare Speicher nicht mehr ausreichte

Aber mit einem for in habe ich das auch getestet - das hat mir aber zu lange gedauert (>>1 Sekunde)