Voir le flux RSS

Blog de Gilles Vasseur - Pascal et compagnie

Delphi 10.3 Rio - Abandon d'ARC et variables inline

Noter ce billet
par , 30/10/2018 à 20h38 (232 Affichages)
Contrairement aux habitudes, Embarcadero a décidé de faire jouer le teasing pour le lancement de la nouvelle version de Delphi 10.3 prévue d’ici la fin de l’année et c’est Marco Cantù qui a été commis à cet exercice à travers deux publications récentes sur son blog. L’exercice n’est cependant pas toujours facile quand les décisions peuvent surprendre...

Gestion de la mémoire ARC

Le 26 octobre dernier, Marco Cantù abordait les problèmes relatifs au modèle ARC pour la gestion mémoire. Ce modèle qui paraissait idéal sur le papier a produit des effets indésirables, spécialement pour les projets complexes fortement ralentis, à tel point qu’il a paru nécessaire de faire un retour en arrière d’importance en l’abandonnant tout simplement ! En particulier, le pas pour intégrer ARC au développement sous Windows a été considéré comme plus important que celui du passage à l’Unicode qui avait traumatisé plus d’un développeur à l’époque et sans présenter d’avantages décisifs sur d’autres techniques éprouvées. Après une étude des retours des utilisateurs et une âpre discussion interne, il a paru préférable de s’en tenir au principe fondateur du Delphi d’aujourd’hui : « une seul source pour des plates-formes multiples ». L’avenir de Delphi se fera donc sans ARC !

Le premier compilateur touché sera Linux 64 bits, mais les autres devraient suivre à plus ou moins long terme : celui annoncé pour macOS 64 bits ignorera ce modèle, ainsi que ceux pour les plates-formes mobiles qui l’abandonneront dès la prochaine version majeure.

S’il s’agit toujours de conserver un mécanisme de décompte par référence, il devrait prendre appui sur celui déjà utilisé pour les interfaces et les chaînes de caractères. Des améliorations du langage devraient en effet renforcer les outils déjà à la disposition du programmeur : après les références d’interfaces weak et unsafe, Delphi 10.3 introduira les enregistrements gérés, première étape vers « une gestion de la durée de vie (et de la gestion de la mémoire) des objets locaux à vie courte à travers des références de pile », une possibilité encore à l’état de projet.

Variables inline

La seconde annonce a un contenu nettement moins polémique et devrait répondre à une attente réitérée ces dernières années par de nombreux développeurs : Delphi intégrera enfin les variables inline. Marco Cantù fournit quelques exemples de cette nouvelle possibilité dont la suivante :

Code :
1
2
3
4
5
6
7
8

procedure Test1; // multiple inline declarations (symbols declared when used)
begin
var I: Integer := 22;
var J: Integer := 22 + I;
var K: Integer := I + J;
ShowMessage (K.ToString);
end;


Ces déclarations pourront de même intervenir dans des boucles for...to ou for...in.

Ce qui pourrait n’être qu’une modification mineure cache de changements non négligeables. Ces variables locales auront ainsi une portée qui ne dépassera pas le bloc dans lequel elles figureront. De plus, leur type pourra être inféré suivant le code utilisé : dans de nombreux cas, il deviendra par conséquent inutile de préciser le type de la variable, ce qui constituera une révolution en Pascal ! Marco Cantù fait remarquer que cette nouvelle écriture sera aussi très utile pour des écritures complexes mettant en jeu des instances de types génériques. La même amélioration est annoncée pour les constantes typées ou non.

Les deux annonces devraient fournir la matière à des discussions pour tous ceux qui utilisent Delphi : alors, n'hésitez pas à donner votre avis ou vos impressions sur ces premières annonces !

Source : blog de Marco Cantù

Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Viadeo Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Twitter Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Google Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Facebook Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Digg Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Delicious Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog MySpace Envoyer le billet « Delphi 10.3 Rio - Abandon d'ARC et variables inline » dans le blog Yahoo

Catégories
Delphi , Divers

Commentaires

  1. Avatar de circular17
    • |
    • permalink
    Intéressant. Je ne connaissais pas ce ARC, et à y regarder, c'est vrai que ça parait un peu surprenant. J'imagine que l'idée est de faire comme avec les langages managés. C'est vrai qu'appeler Free tout le temps avec des try est un peu pénible.

    Je trouve que ce serait assez simple et peu problématique d'avoir une instruction "using":
    Code delphi : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    var
      a: TMyNiceClass; //cette déclaration pourrait être optionnelle avec l'inférence de type
    begin
      using a := TMyNiceClass.Create do
      begin
         a.somethingToDo();
      end;
    end;

    Alors certes, cela ne s'appliquerait que localement mais ce serait déjà pas mal.

    Sinon, ARC n'est-il pas un peu la même chose que les interfaces ?
  2. Avatar de gvasseur58
    • |
    • permalink
    Bonjour,

    ARC (Automatic Reference Counting) a surtout été repris par Apple à la place du Garbage collector, supprimant les variables devenues inutiles : comme tu le signales, l'idée est très proche de celle des interfaces, mais elle ne s'appliquait qu'aux plates-formes Android et iOS. Comme l'objectif de Delphi est de proposer un unique code quelle que soit la plate-forme, la logique aurait voulu qu'ARC soit utilisable sous Windows, ce qui ne se fera pas.

    Les performances d'ARC sont mauvaises dès que le projet prend un peu d'ampleur, avec des mélanges dangereux (ARC/interfaces/composants avec leur propre système), un véritable casse-tête pour les développeurs. Bref, paix à son âme !
    Petite remarque cependant : en 2013, le même Marco Cantù vantait dans son blog les mérites de cette technique, y voyant une avancée pour rendre Delphi plus moderne !

    [Comme cette nouvelle intéressait beaucoup de monde, elle est passée en actualité ici.]
  3. Avatar de circular17
    • |
    • permalink
    Je comprends l'idée de compatibilité avec les mobiles.

    Ce n'était pas une mauvaise idée dans le principe, mais avec le Pascal, pas si évident.

    Le langage Rust utilise un principe de propriétaire d'une valeur, cela dit, il n'est pas applicable tel quel au Pascal. Cela changerait trop la grammaire du code existant.

    Cependant, l'idée de propriétaire me semble pas mal. De fait, c'est ce qu'on fait quand on passe des objets, on passe aussi un booléen AOwner. On pourrait sans doute inclure cela dans le langage Pascal d'une façon ou d'une autre, afin qu'on ait pas à chaque fois à déclarer deux variables (l'objet et la propriété de l'objet).

    Par exemple on pourrait avoir un truc du genre :
    Code pascal : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    var a,b,c: TObject with ownership;
    begin
      a := TObject.Create; //a prend l'objet (un constructeur ne possède pas l'objet)
      b := a;              //b ne possède pas l'objet (il est déjà la propriété de a)
      c := give a;         //c prend l'objet et a ne le possède plus
    end;
    //c est automatiquement libéré
    give ne s'appliquerait qu'à une variable "with ownership"

    Si vraiment il n'y a pas de propriétaire et que l'objet passe d'un endroit à l'autre, le plus simple est d'utiliser une interface. C'est pas très efficace, mais ça n'est pas utilisé souvent non plus.