Delphi/FPC

Quando usare le dichiarazioni inline in Delphi?

La possibilità di dichiarare variabili e costanti in qualsiasi parte del codice, introdotta nella versione 10.3 di Delphi ha diviso le comunità di sviluppatori. Da un lato c’è chi si dichiara entusiasta, dall’altro chi rifiuta categoricamente la novità. Passato l’entusiasmo dei primi tempi, ci chiediamo: quando vale la pena di usare le dichiarazioni inline in Delphi?

La versione 10.3 di Delphi introduce importanti novità nel linguaggio. Una di queste, la possibilità di dichiarare una variabile in qualsiasi parte del codice, è considerata una modifica sostanziale del Pascal, più che una sua naturale evoluzione, e come tale ha diviso la comunità dei programmatori. La dichiarazione inline, infatti, è molto usata in altri popolari linguaggi, da Java a C#, ma rappresenta una novità assoluta per il Pascal.

Nota: nel seguito, ci riferiremo alla dichiarazione delle variabili; in generale, il contenuto si applica anche alla dichiarazione delle costanti.

Com’è noto, la dichiarazione delle variabili è tradizionalmente eseguita nella sezione var di una unit o di un metodo:

procedure SayHello(AName: string);
var
  username: string;
begin
  username:= 'world';
  if AName <> '' then
    username:= AName;
  ShowMessage ('Hello, ' + username);
end;

Da Delphi 10.3 è possibile compattare il codice richiesto; per esempio:

procedure SayHello(AName: string);
begin
  var username:= 'world'; 
 if AName <> '' then
    username:= AName;
  ShowMessage ('Hello, ' + username);
end;

dove abbiamo usato altre due importanti novità che accompagnano la dichiarazione inline: le possibilità di inferire il tipo di una variabile (è stata omessa la dichiarazione esplicita string) e di inizializzare una variabile all’atto della sua dichiarazione.

Perché usare le dichiarazioni inline in Delphi

Le dichiarazioni in linea sono state accolte con molto entusiasmo nel mondo degli sviluppatori in Delphi, che non hanno mancato di sottolinearne alcuni vantaggi:

Miglioramento delle performance
Minore scrittura di codice
Limitazione dello scope delle variabili, per esempio all’interno di loop e di strutture di controllo
Modernizzazione del linguaggio

Perché non usare le dichiarazioni inline in Delphi

Alcuni sviluppatori, in particolare quelli che fanno riferimento a Free Pascal Compiler (FPC), hanno invece rifiutato di introdurre questa caratteristica nel proprio compilatore, per una serie di altrettanto buone ragioni:

Il miglioramento delle performance dipende soprattutto dalla bontà del compilatore
A un codice più compatto, corrisponde spesso un codice più confuso
La dichiarazione in linea allontana il Pascal dal concetto type-safe del suo ideatore, Niklaus Wirth

La discussione, come potete intuire, è stata molto più complessa, ma i suoi punti principali sono quelli sopra riportati e seguendo i link precedenti potrete farvene un’idea più completa.

Sul campo

Da quando è uscito Delphi 10.3, non ho mai usato questa feature, per diversi motivi:

FPC non intende implementarla in un futuro prevedibile, mentre le mie specifiche interne prevedono che il codice prodotto sia quanto più possibile CCLS (Cross Compiler, Library, System).
La leggibilità del codice non migliora in modo significativo: spesso cercare la definizione del tipo di una variabile è più agevole quando si trova in una sezione del codice dedicata
Per la maggior parte delle applicazioni, il miglioramento dell’efficienza del codice compilato è trascurabile
Non sono ancora pienamente supportate da tool nativi, come refactoring, code insight, code completion, e di terze parti

Nella maggior parte dei casi, a mio avviso, i motivi portati a loro favore non sono decisivi e risultati simili possono essere raggiunti seguendo buone pratiche di programmazione. Le dichiarazioni inline, però, potrebbero essere usate con profitto per produrre codice più compatto, leggibile e manutenibile in casi molto specifici. Un buon esempio sono le compilazioni condizionali che agiscano sulla definizione di tipi di variabile, a patto che la portabilità del codice verso precedenti versioni di Delphi e/o FPC non sia richiesta.

Affidabilità

Al 31 dicembre 2019, nella pagina del sito di Embarcadero dedicata ai bachi risultano aperte almeno una dozzina segnalazioni relative alle dichiarazioni in linea, di gravità variabile dal mancato funzionamento della formattazione automatica del codice agli errori a runtime.

Un discorso a parte merita l’inizializzazione delle variabili. Riprendendo l’esempio precedente, in FPC avremmo questa sintassi:

procedure SayHello(AName: string);
var
  username: string = 'world';
begin
 if AName <> '' then
    username:= AName;
  ShowMessage ('Hello, ' + username);
end;

nella quale l’operatore di assegnazione è ‘=’. Compilare questo codice con Delphi genera l’errore E2195 Cannot initialize local variables, perché l’inizializzazione a questo livello non è possibile (lo è, invece, a livello di unit). Pare che non si tratti di una questione tecnica, ma del fatto che nessuno avrebbe implementato questa possibilità. Nemmeno in questo caso, quindi, è possibile usare questa caratteristica dei linguaggi per avere codice più compatto.

Il verdetto

Siamo giunti al momento in cui bisogna rispondere alla domanda: quando usare le dichiarazioni inline in Delphi?

La dichiarazione in linea di variabili e costanti non era il miglioramento più urgente che mi sarei aspettato da Delphi. I problemi dell’IDE – legati soprattutto a Code Insight e Code Completion – sono lamentati da molti utenti e la loro soluzione, probabilmente, permetterebbe di fluidificare il lavoro più di qualche riga di dichiarazione risparmiata. Tuttavia, è stata implementata e vale la pena di valutarne a fondo pro e contro non solo in termini teorici, ma in rapporto ai propri target di sviluppo.

A livello teorico non c’è una chiara preferenza pro o contro il loro uso. A livello pratico, l’implementazione della versione 10.3.2 sembra ancora troppo immatura per essere seriamente presa in considerazione.

Anche quando i bachi saranno risolti, non mi sentirò in obbligo né di consigliare, né di usare le dichiarazioni inline di Delphi. Al momento, i vantaggi sono marginali rispetto alla perdita di compatibilità. Occorrerà saper individuare, però, quei pochi casi in cui dichiarare variabili in linea fornisce un valido aiuto alla scrittura di codice migliore e l’esperienza personale diventerà, come spesso accade, il fattore determinante della scelta caso per caso.

Articoli più recenti

Paolo Morandotti

Professionista nel campo del software con trent'anni di esperienza, ama studiare le ricadute sociali delle tecnologie sulle quali ha realizzato vari programmi radiofonici.