Da una piacevole discussione nata su Twitter con il buon Matteo Capucci
@mattecapu (a proposito, per chi se lo fosse perso, mi trova su twitter all’account
@albertoarmida) è nato lo spunto per questo post, che più che un post informativo (come solito) vuole essere un post di riflessione per gli “addetti ai lavori” (ossia per i programmatori).
Attualmente siamo letteramente circondati da linguaggi di programmazione di livello più o meno alto, di impostazione prettamente top-down (programmazione sequenziale) o i più moderni linguaggi ad oggetti.
Qualsiasi linguaggio di programmazione che si rispetti consente all’utente di dichiarare variabili dove memorizzare i dati elaborati dai propri algoritmi, ed è proprio da questo concetto di variabile che è nata la discussione: meglio un linguaggio di programmazione debolmente tipizzato o un linguaggio fortemente tipizzato?
Prima di procedere oltre, chiariamo il concetto di tipizzazione: con tipizzazione si intende l’associazione tra una variabile ed un tipo di dato.
Molti linguaggi di programmazione consentono di avere quella che può essere definitiva come “tipizzazione debole” o “tipizzazione dinamica“, ossia una variabile è in grado di cambiare il proprio tipo durante l’esecuzione del programma.
In pseudocodice:
var x; // (1)
x := 5; // (2)
x := “ciao”; // (3)
In buona sostanza quindi, alla riga 2 la variabile è di tipo intero, mentre alla riga 3 assume il tipo stringa.
Con la cosiddetta “tipizzazione forte” o “tipizzazione statica” invece una variabile in fase di chiarazione viene appunto abbinata in modo statico e definitivo ad un tipo e non può essere mai cambiato durante l’esecuzione del flusso di codice.
Sempre facendo un esempio in pseudocodice:
int x; // (1)
x = 5; // (2)
x = “ciao”; // (3) → rifiutata dal compilatore
A primo acchito potrebbe venire da pensare che solo i linguaggi più antichi ed ormai superati consentano la tipizzazione debole, mentre invece i linguaggi più moderni consentono solamente la tipizzazione forte, ma non è così: PHP, ad esempio è un linguaggio debolmente tipizzato mentre invece C è fortemente tipizzato.
Non si tratta quindi di una questione legata alla vetustà o meno del linguaggio di programmazione scelto, quanto piuttosto di una vera e proprio scelta fisolofica.
I sostenitori della tipizzazione debole sostengono che le varibili debolmente tipizzate consentano una maggior flessiblità di programmazione, evitando di dover magari dichiarare un elevato numero di variabili di appoggio (per calcoli temporanei, ad esempio) per ciascun tipo.
Viceversa i sostenitori della tipizzazione forte usano questa flessibilità proprio come “arma” contro la tipizzazione debole, asserendo che il mancato controllo a priori dei tipi in fase di compilazione presta facilmente in fianco all’introduzione di bug dovuti proprio a problemi di conversione: si pensi ad esempio all’assegnazione di una variabile stringa rappresentante una data ad una variabile di tipo data piuttosto che, per un bug logico, l’utilizzo di una variabile debolmente tipizzata contenente la stringa “ciao” presupponendo che però questa contega valori numerici… il crash è assicurato.
Personalmente sono assolutamente a favore dei linguaggi fortemente tipizzati anzi, forse con una visione un po’ “talebana”, arrivo addirittura ad impostare i compilatori in modo tale da rifiutare i cast impliciti come ad esempio l’assegnazione di una variabile intero ad una variabile in virgola mobile: è fattibile, non andrà mai in crash (dato che dal punto di vista matematico, gli interi sono un sottoinsieme dei numeri in virgola mobile), ma personalmente, se questo avviene, dato che i tipi dato sono dimensionalmente diversi, a mio avviso c’è un errore nella logica dell’algoritmo.
Voi cosa ne pensate? Meglio un linguaggio “flessibile” ma forse più prono ad errori o un linguaggio più “rigido”, ma che impone quindi al programmatore un piccolo effort ulteriore in fase di programmazione, evitando però fastidiosi crash a runtime?
