blaise: progetto per un nuovo compilatore pascal

[DragoRosso]

Le potenzialità sono molte però, rovescio della medaglia, gestirle non è semplice (parlo solo di fpc).
Sviluppare con un solo target in mente è una cosa, ma voler fare qualcosa tipo "write once, compile everywhere" non è affatto facile.
Per questo affidarsi a QBE e LLVM può essere una svolta.
Per quanto riguarda GC la pensiamo ugualmente mi pare ma, per ARC, la pensiamo in modo differente. 

Delphi è multipiattaforma, e nella stragrande maggioranza del codice troverai $IFDEF riferito alle vaire piattaforme. Ma sostanzialmente si limita qua. Poi i pacchetti di terze parti hanno tutta una serie di $IFDEF legati alle peculiartità passate delle vecchie versioni di Delphi (le definizioni si trovano normalmente nei classici file INC presenti anche in FPC).
E' anche vero che Embarcadero ha puntato molto sulla filosofia multipiattaforma e di fatto è riuscita a gestire con FMX un framework che rende molto più semplice la scrittura del codice da parte dell'utente, e in una buona parte del codice questo funziona senza $IFDEF nella stragrande maggioranza dei casi in tutte le piattaforme.
LLVM è lo strumento usato da sempre in Delphi per le versione "mobile".

ARC, non sò se l'hai mai provato ... io si ... ma avremo modo di vedere, è inutile che ti porti esempi adesso. Comunque, credimi che la differenza è veramente minima in termini di scrittura di codice, ma è massima in termini di uso.

Dai ... ti faccio un esempio banale:

Codice Seleziona Espandi

var MiaClasse: TMiaClassa;
begin
  MiaClasse := TMiaClasse.Create('WEB');
  .....
  .....
  .....
  MiaClasse.Free;
  MiaClasse := TMiaClasse.Create('LOCAL');
  .....
  .....
  .....
  MiaClasse.Free;
end;


Quello sopra è un codice, magari non proprio tipicissimo, ma che si fà ed è comuqnue lecito.
Quando devi riusare la stessa variabile, non potrai mai essere sicuro di quello che fai. Questo è il problema di ARC.
Il free non libera alcunchè (*). E in quel codice non è assolutamente detto che il reference count sia a zero, per una serie di motivi.
Ed è quindi soggetto con una altissima probabilità a LEAK.

L'ARC è stato pensato per linguaggi stile JAVA dove tutto è gestito dal runtime, non dal codice direttamente.
Non si adatta ad un linguaggio come il Pascal.
Ma questo è un mio pensiero.

(*) E neanche il nil ... mettere a nil o eseguire il free in ARC equivale alla stessa azione, ossia decrementare il reference count.

[nomorelogic]

io penso a questo

Codice Seleziona Espandi


Result := '';
try
   try
     A := TClasseA.Create;
     B  := TClasseB.Create;
     A.FaiQualcosa;
     B.FaiQualcosa;
     ...
     Result := 'Ok';
   except
     on E: Exception do
       Result := 'Ko';
   end;
finally
  A.Free;
  B.Free;
end;



che si potrebbe scrivere così

Codice Seleziona Espandi


Result := '';
try
  A := TClasseA.Create;
  B  := TClasseB.Create;
  A.FaiQualcosa;
  B.FaiQualcosa;
  ...
  Result := 'Ok';
except
  on E: Exception do
    Result := 'Ko';
end;


in un moderno linguaggio di programmazione mi aspetto questo
e credo che avvicinerebbe molto dei possibili nuovi programmatori


Edit:
il try..finally è stato concepito per forzare la liberazione delle risorse
cosa che se ci pensasse il compilatore in automatico, non servirebbe


Edit2:
del resto, il free automatico è già implementato nei .lfm (o.dfm) perché i controlli sono predefiniti a design-time.
Si tratta di fare in modo che le risorse allocate in un blocco begin/end, vengano liberate automaticamente quando escono dallo scope del blocco.

Se poi creiamo le risorse altrove e usiamo le stesse risorse in più procedure, certo che bisogna stare attenti, ma credo che programmando una classe come si deve, questo richieda una attenzione minima.

[bonmario]

Sviluppare con un solo target in mente è una cosa, ma voler fare qualcosa tipo "write once, compile everywhere" non è affatto facile.

Parlo per me, naturalmente: io sviluppo con Lazarus Uty che possono servire al lavoro o a casa. Al lavoro ho un PC Windows, a casa Linux, con Ubuntu e Windows. Devo dire che gran parte del lavoro effettivamente lo faccio una volta solo, ma solo perché nel tempo ho imparato ad usare del codice che aiuta in questo. Se ad esempio sto definendo un percorso, uso PathDelim come delimitatore, invece di mettere "\" o "/", così so già che funzionerà dappertutto senza sforzi.
Per altre cose, mi sono fatto io delle funzioncine che uso sempre. Ad esempio, quella che converte nei percorsi "C:\" in "/media/Disco_C" e viceversa quando gira sul mio PC di casa
Usando questo approccio, gran parte del codice è lo stesso. Nel mio caso, direi almeno il 90%

[DragoRosso]

@nomorelogic
Forse ti sati confondendo.
Non pensare alla "vita" della varibile ... in Delphi ad esempio questo è già implementato in diversi "oggetti".
ARC è una cosa diversa. Non è che finisci di usarle una risorsa (nei tuoi termini) e questa magicamente si libera (ti ripeto che in Delphi questo è già così).

ARC lavora tramite REFCOUNT. E' il concetto d'uso delle intercacce.
Ma per le classi o per altri oggetti complessi (... in realtà neanche tanto complessi ...) tutto ciò è più complesso.
Se parliamo di comuni variabili locali a metodi, posso anche essere d'accordo con il tuo esempio, ma se ARC (e torno a ripetermi) si riporta a tutto ... si parla di un altro mondo.

Inoltre, sei certo che un "free" automatico possa sempre funzionare ? Io mica tanto, anzi per niente a giudicare da ciò che faccio io.
Poi magari faccio "roba strana", ma senza un codice specifico di "liberazione" in molti casi non è possibile agire.

[nomorelogic]

@nomorelogic
Forse ti sati confondendo.
Non pensare alla "vita" della varibile ...
...
Non è che finisci di usarle una risorsa (nei tuoi termini) e questa magicamente si libera

Visto che non è la prima volta che in questo thread mi spieghi cos'è ARC e come funziona, do' per assunto che sono stato ambiguo nei miei post.
Non mi sto confondendo: so cos'è ARC, so cos'è RAII e la vita di una variabile e so anche che la magia non c'entra...

Ora, quando ho parlato di ARC e mi sono riferito al blocco begin/end è che, mea culpa, ho dato per scontato che potevo sotto-intendere il RefCount.
Evidentemente non è così, almeno non lo è per tutti, quindi in futuro cercherò di essere più preciso.

Ho usato impropriamente "scope" ma intendevo un RefCount dove "end" diminuisce di 1 quello che è stato incrementato di 1 dopo il "begin".
Era un esempio focalizzato sulla semplificazione del codice in un blocco begin/end. Punto.
Lo so che sono in conflitto di interessi, ma la vedo come una leggerezza comprensibile (e intuibile).

Disclaimer preventivo:
Non voglio approfondire né ARC e neanche che nel corpo del begin/end ci potrebbero essere incrementi e/o decrementi arbitrari a carico di altre procedure che altererebbero il RefCounting.

Per il resto non sto io a fare un trattato sul reference counting e non mi interessa neanche che qualcuno ci abbia provato ma poi abbia fatto un passo indietro: non è un buon motivo per stroncare il progetto di un nuovo compilatore che ha queste ambizioni.

Detto questo se qualcosa non torna in un post altrui, visto che è un forum pubblico ed è doveroso disambiguare, si possono chiedere chiarimenti.

[DragoRosso]

Non era mia intenzione ne accusare ne incolpare chichessia.
Per me topic chiuso.