Premiera Delphi 13

I mamy premierę Delphi 13 za sobą. Na webinarze startowym wszyscy wychwalają jakie to przełomowe wydarzenie i jakie wspaniałe. W rzeczywistości chyba średnio, wręcz mi się wydaje, że gorzej niż 12.3.

• W składni języka jest dodany w zasadzie tylko conditional ternary operator (jak to się u licha tłumaczy??? warunkowy operator trójargumentowy?). Fajne, ale z kategorii inspektor gadżet: ShowMessage (if Left < 100 then 'Small' else 'Big'). Rzeczy potrzebnych ani widu ani słuchu. Zapytałem się "A co z case i stringami?", na co Cantu oczywiście nie odpowiedział. O procedurach generycznych (poza klasami) można tylko pomarzyć.
• Chwalą się, że teraz domyślnym środowiskiem jest IDE 64 bit I...GetIt oczywiście w nim nadal działa read only (super). Zrobili fajną rzecz bo GetIt teraz może trzymać różne wersje pakietów i ogólnie jakoś szybciej działa, ale za to... Bookmark i Navigator znikł. Zwolnił się David Millington i był jakiś nowy człowiek w to miejsce. Zapytano go też o to i podobno ma to być dalej dostępne jak Millington zrobi (co obiecał), ale póki co w Delphi 13 to ja tego nie widzę. Czyli teraz lepiej wygląda Lazarus 4
• W samym IDE jest jedna naprawdę przydatna rzecz, komunikaty można pogrupować hinty, błędy itd. - to fajnie wygląda. Jest też wyszukiwanie w innych okienkach niż inspektor obiektów (np. structure), też naprawdę ok. Ale jak myślicie, że szuka zagnieżdżonych właściwości w Inspektorze Obiektów to nie tym razem.
• Uaktualnili pakiety SDK, ale z dziwnych rzeczy teraz instalator ostrzega, że nie ma Windows SDK, ale go nie pobiera. W sumie irytujące, ale pewnie wynika z jakiejś durnej polityki MS. Nie ma IOS 26 póki co, Win ARM też nie ma (podobno ma być później).
• Jest trochę poprawek VCL, też raczej z cyklu inspektor gadżet Title Bar ma nowe możliwości i o dziwo pracują dalej na MDI. Są też poprawki w FMX, wygląda, że parę optymalizacji wydajnościowych zrobili. Z Linuxem się przyznali, że na razie nie mają o czym mówić, bo odzyskali prawa do pakietu bardzo niedawno. Dopiero badają co z tym dalej, ale strasznie chcą to rozwijać (co podkreślali)
• Więcej jest dla tych co mają Architect, bo sporo zrobili z WebStencil i uaktualnili WebBorkera (nie mam, to nie będę się wypowiadał o szczegółach). Ale na prezentacji pokazali fajne demo.

Tak z grubsza to... wszystko. No prawie... Nie to forum, ale trudno nie zauważyć, że C++ leży. Niby jest nowy CLANG, ale uwaga! Nie działa Mac. To brzmi jak żart Jak wspominałem Millington się zwolnił.
Jakoś to takie nieprzekonywujące było. A na koniec... Oczywiście Zeos się nie skompilował w Delphi 13. Chyba trzeba pisać na forum.
Podsumowując na razie ciekawostka, ale da się ją zainstalować obok wersji 12.3 do testów. Potwierdzam, że oba środowiska działają - przynajmniej mnie.

Dodali np. operatory 'is not' oraz 'not in'

I oczywiście możliwość użycia/integracji z AI wszelkiej maści

Uaktualnienie. Wydany dzisiaj Snapshot ZeosLib r8400 się kompiluje. Problemem spowodowany był przez: "changes to support ftLargeUint as introduced with Delphi 13".

KKuba napisał(a):

• W składni języka jest dodany w zasadzie tylko conditional ternary operator (jak to się u licha tłumaczy??? warunkowy operator trójargumentowy?).

Najczęściej operator warunkowy.
Gratuluję programisom delphi że w końcu w 2025 będą mogli go używać Co prawda ostatnim trendem jest raczej udoskanalanie pattern matchingu ale to spory krok naprzód.

Dodali po 2 latach to o czym pisałem

Usprawnienia języka Delphi w nowych środowiskach Embarcadero

Może Ci co używają Delphi nie potrzebują żadnych nowości ?
Średnia wieku użytkowników pewnie >40 wiec mniej otwarci są zmiany i stawiają na stabilność :D

Mi w mailach mignęła wzmianka o nowej wersji ale nawet nie chciało mi się znaglać bo pewnie tak jak zawsze nie za wiele tych nowości
Z miłą chęcią wziął bym udział w jakimś nie dużym projekcie w Delphi aby sprawdzić czy nadal podoba się język jak mam parę lat przerwy :D

Współczesne Delphi całkiem nieźle się prezentuje, szczególnie po wdrożeniu inline variable declaration — składnia nadal przyjemna i czytelna, ale lepsze możliwości kontroli widoczności zmiennych. Jest wszystko czego trzeba — kogo obchodzi jakiś gówniany cukier składniowy aka pattern matching. Lmao.

Prezentuje się jak przestarzały język sprzed 30 lat

I bardzo dobrze — w przeciwnym razie stałby się takim składniowym koszmarkiem jak C++, Rust czy Zig.

Wraz z wiekiem obniża się poziom percepcji więc nie da się ukryć że jakieś zalety taki archaizm ma.

KKuba napisał(a):

"A co z case i stringami?",

Rozwiniesz myśl? Od tego chyba sprawdza się pętla for-in w połączeniu z tablicą.

Dokumentacja wyjaśnia, że blok case of wspiera jedynie typy policzalne — ciągi znaków nie są wspierane. Tak więc jeśli chodzi o ten aspekt, to takie rzeczy są dostępne we Free Pascalu, w Delphi na razie nie.

flowCRANE napisał(a):

Dokumentacja wyjaśnia, że blok case of wspiera jedynie typy policzalne — ciągi znaków nie są wspierane. Tak więc jeśli chodzi o ten aspekt, to takie rzeczy są dostępne we Free Pascalu, w Delphi na razie nie.

Ale przecież ja to dokładanie napisałem i dokładnie o to pytałem Cantu. Embarcadero w ankiecie do użytkowników zadało pytanie o brakujące funkcjonalności języka i było tam właśnie case ze stringami. Pewnie nie zauważyłeś ankiety, ale dlatego było moje pytanie na webinarze. Z kolei procedury/funkcje generyczne również są dostępne tylko w Free Pascalu od wersji 3.2x, ale tak jak pisałem w Delphi można o tym pomarzyć. To ostatnie mnie akurat przeszkadza w pisaniu bibliotek w Delphi, wiec tak sobie przy okazji narzekam...

@KKuba: to z blokiem case of to była odpowiedź dla @Opi, żebyś nie musiał ”rozwijać myśli”.

Myślę, że też nie ma co zazdrościć Free Pascalowi bloku case of, bo używanie go w połączeniu ze stringami jest rzadkością. Bardziej smuciłby mnie fakt braku wsparcia funkcji/procedur generycznych, bo to już jak najbardziej przydatna rzecz. Free Pascal idzie o jeszcze jeden krok dalej — specjalizacja będzie mogła być niejawna, bez wszędobylskiego specialize i pokazywania kompilatorowi palcem o jaki typ danych chodzi (przykład). Niestety nadal nie ma tego w wersji stabilnej.

Pozwolę się nie zgodzić z jedną rzeczą. Case ze stringami jest przeze mnie nagminnie używane przy pracy z polami tekstowymi w SQL.
Jak się zorientowałem , że tego nie ma w Delphi (a w Free Pascalu jest od ponad 10 lat) to rwałem sobie włosy z głowy. To znaczy dalej je rwie...
Takie rzeczy strasznie przeszkadzają gdy używasz obu środowisk i przenosisz kod źródłowy w obie strony.

Tutaj chociaż tyle dobrze, że case of ze stringami można łatwo zamienić na łańcuszek if then else if then else. Braku funkcji generycznych w Delphi już nijak nie zastąpi.

KKuba napisał(a):

Ale przecież ja to dokładanie napisałem i dokładnie o to pytałem Cantu. Emabracedro w ankiecie do użytkowników zadało pytanie o brakujące funkcjonalności języka

Ciekaw jestem, czy był poruszany punkt 2. Specjalnie zapytałem AI o brakujące elementy języka Delphi i w jednym z punktów był właśnie ten ciekawy temat.

Dla tych, którzy nie wiedzą o czym rozmawiamy (w tym ja, gdyż jestem ciekaw jak miałoby to wyglądać z punktu pisania kodu), poniżej przykłady i rozwiązania:

1. Obsługa string w case..of

Co zyskujemy?

• Lepszą czytelność, zwięzłość i mniejsze ryzyko pomyłek w zagnieżdżonych konstrukcji if..else if..else.

Obecnie w Delphi:

• Musimy używać długich i mało czytelnych konstrukcji if..else if..else.

teraz:

var Command: string := 'ADD';

if Command = 'ADD' then DoAdd
else
if Command = 'DELETE' then DoDelete
else
if Command = 'UPDATE' then DoUpdate
else ShowMessage('Unknown command');

w przyszłości:

var Command: string := 'ADD';

case Command of
        'ADD': DoAdd;
  'DELETE': DoDelete;
  'UPDATE': DoUpdate;
  else ShowMessage('Unknown command');
end;

1. Operatory bezpiecznej nawigacji (?.) i koalescencji (??)

Co zyskujemy?

• Drastyczne uproszczenie kodu i wbudowane bezpieczeństwo przed błędami odwołania do nil.
• Operatory pozwalają skrócić ten kod do jednej, bezpiecznej linii.
  ?. (operator bezpiecznego dostępu): jeśli obiekt po lewej jest nil, całe wyrażenie zwraca nil i nie wykonuje dalszych odwołań.
  ?? (operator koalescencji): jeśli wyrażenie po lewej jest nil, zwraca wartość po prawej stronie.

Obecnie w Delphi:

• Musimy ręcznie sprawdzać, czy obiekt nie jest nil przed każdym odwołaniem.

teraz:

var Street: string;
//...
if Assigned(Customer) then
  if Assigned(Customer.Address) then Street := Customer.Address.Street
  else Street := 'Brak adresu'
else Street := 'Brak adresu';

w przyszłości:

var Street: string;
//...
Street := Customer?.Address?.Street ?? 'Brak adresu';

1. Procedury i funkcje generyczne

Co zyskujemy:

• Redukcja powielania kodu (DRY - Don't Repeat Yourself): Tworzymy jedną implementację, która działa dla wielu typów danych, zamiast pisać osobne funkcje SwapInteger, SwapString itd.
• Większe bezpieczeństwo typów: Wszystkie operacje są sprawdzane na etapie kompilacji. Unikamy błędów, które mogłyby wystąpić przy użyciu wariantów (Variant) lub wskaźników.
• Czystość i prostota kodu: Kod staje się bardziej ekspresyjny i łatwiejszy do zrozumienia oraz utrzymania.

Obecnie w Delphi:

• Aby osiągnąć ten sam cel, musimy zadeklarować generyczny rekord, a w nim statyczną procedurę.

teraz

type
  TGenericUtils = record
  public
    class procedure Swap<T>(var Left, Right: T); static;
  end;

class procedure TGenericUtils.Swap<T>(var Left, Right: T);
begin
 var Temp: T := Left;

 Left := Right;
 Right := Temp;
end;

//użycie
begin
 var A: Integer := 10;
 var B: Integer := 20;

 TGenericUtils.Swap<Integer>(A, B); // Konieczność jawnego podania typu
 // lub z inferencją, ale składnia nadal jest długa:
 TGenericUtils.Swap(A, B);
 ShowMessage(Format('A: %d, B: %d', [A, B]));

 var S1: string := 'Hello';
 var S2: string := 'World';
 TGenericUtils.Swap(S1, S2);
 ShowMessage(Format('S1: %s, S2: %s', [S1, S2]));
end;

w przyszłości:

procedure Swap<T>(var Left, Right: T);
begin
 var Temp: T := Left;

 Left := Right;
Right := Temp;
end;

//użycie
begin
 var A: Integer := 10;
 var B: Integer := 20;
 Swap<Integer>(A, B); // Jawne określenie typu (opcjonalne)
 // lub prościej, z automatyczną inferencją typów:
 Swap(A, B);
 ShowMessage(Format('A: %d, B: %d', [A, B])); // Wyświetli: A: 20, B: 10

 var S1: string := 'Hello';
 var S2: string := 'World';
 Swap(S1, S2);
 ShowMessage(Format('S1: %s, S2: %s', [S1, S2])); // Wyświetli: S1: World, S2: Hello

 var D1: Double := 1.23;
 var D2: Double := 4.56;
 Swap(D1, D2);
 ShowMessage(Format('D1: %f, D2: %f', [D1, D2])); // Wyświetli: D1: 4.560000, D2: 1.230000
end;

1. Pattern Matching (Rozpoznawanie Wzorców)

Co zyskujemy?

• Ogromny wzrost czytelności i bezpieczeństwa. Koniec z wielokrotnym is i as. Kod staje się bardziej deklaratywny ("co ma się stać dla danego typu") niż imperatywny ("sprawdź, potem rzutuj, potem wykonaj").

Obecnie w Delphi:

• Sprawdzanie typu obiektu i rzutowanie go wymaga kilku kroków i zagnieżdżonych warunków.

teraz

var Shape: TShape;
//...
if Shape is TCircle then
  begin
   var Circle := Shape as TCircle;

   Canvas.DrawCircle(Circle.Center, Circle.Radius);
  end
else
if Shape is TRectangle then
  begin
   var Rect := Shape as TRectangle;

   Canvas.DrawRectangle(Rect.Bounds);
  end;

w przyszłości:

var Shape: TShape;
//...
case Shape of
      // 'c' jest już typu TCircle
   c: TCircle: Canvas.DrawCircle(c.Center, c.Radius); 
      // 'r' jest już typu TRectangle
   r: TRectangle: Canvas.DrawRectangle(r.Bounds);     
      // Można nawet dodawać warunki!
   p: TPolygon where p.Points.Count > 10:  ShowMessage('Complex polygon');                 
 else ShowMessage('Unsupported shape');
end;

1. Krotki (Tuples) i Dekonstrukcja

Co zyskujemy?

• Czystszy i bardziej funkcjonalny sposób przekazywania danych. Koniec z mylącymi parametrami out. Kod staje się bardziej ekspresyjny.

Obecnie w Delphi:

• Używamy parametrów out lub var, albo definiujemy specjalny rekord/klasę do przechowywania wyniku.

function TryParsePoint(S: string; out X, Y: Integer): Boolean;
// ...
var a, b: Integer;
if TryParsePoint('(10, 20)', a, b) then ...

w przyszłości:

// Definicja funkcji zwracającej krotkę
function TryParsePoint(S: string): (Success: Boolean; X: Integer; Y: Integer);
// ...

// Użycie z dekonstrukcją
var (ok, a, b) := TryParsePoint('(10, 20)');
if ok then ShowMessage(Format('X: %d, Y: %d', [a, b]));