cosa è typescript?

typescript.txt

vedo che c'è parecchia confusione su typescript, a partire da cosa sia.
cercherò di fare chiarezza su cosa sia, a cosa serva e quali sono pro/contra di utilizzarlo:
typescript, come flow, nasce come type system INCREMENTALE per javascript, il che significa aggiungere dei metadati nel codice che possano essere consumati da qualcuno (tsc per ts e babel via plugin per flow) in modo da rendere fortemente tipato un linguaggio che lo è solo debolmente, senza però obbligare lo sviluppatore a tipare tutta la codebase prima di utilizzarlo ma favorendo anche un ingresso graduale in progetti pre-esistenti.

cosa è un tipo? semplicissimo:

- "stringa" -> string
- 42 -> number

un po' meno semplice:

- { a: 'a' } -> { a: string }

ancora meno semplice:

- (a, b) => a + b -> (a: number, b: number) => number
- (a, b) => a + b -> (a: string, b: string) => string

perché javascript è considerato debolmente tipato? perché è tipato solo a runtime, ovvero in fase di scrittura del codice le dichiarazioni di variabili, parametri e valore di ritorno di funzioni non dichiarano il proprio tipo, ovvero sono dichiarazioni opache rispetto al tipo.

perché typescript è un linguaggio fortemente tipato? perché il type system è in grado di utilizzare dei metadati aggiunti dallo sviluppatore per colmare la mancanza di informazione sui tipi ed è inoltre in grado di dedurre tipi banali (ma anche non così banali)

perché typescript e flow sono considerati dei type system incrementali? perché non obbligano lo sviluppatore ad avere al giorno 0 tutta al codebase tipata per cominciare ad utilizzarli. javascript è a tutti gli effetti typescript valido nella modalità più rilassata di tsc, inoltre è possibile disattivare selettivamente il type checking per alcune porzioni di codice attraverso il tipo speciale "any")

quali sono le differenze tra flow e typescript? poche. notate anche solo il fatto di come due aziende diverse siano arrivate alla stessa soluzione, ovvero fornire strumenti per tipizzare in modo forte la codebase. le differenze tra i due sistemi sono che typescript è una soluzione chiavi in mano per tutte le situazioni ed è un linguaggio vivo con un proprio ecosistema dedicato. flow invece è solo un sistema di annotazioni (live code oppure via comment syntax) che gestiscono solo il type-checking, quindi nessuna fase di traspilazione o polyfilling ed è richiesto un plugin di babel per strippare le annotazioni e produrre js valido in caso non abbiate utilizzato la comment syntax

- const str = 'stringa' // typescript sa che la variabile str ha come tipo "string"
- const _42 = () => Promise.resolve(42) // typescript sa che _42 è una funzione che ritorna Promise<number>
- mistery(a, b) { return a + b } // typescript non può dedurre cosa ritornerà questa funzione senza i metadati dei parametri

se guardiamo attentamente l'esempio "ancora meno semplice" ovvero la funzione "mistery" qui sopra possiamo vedere come una stessa funzione possa in realtà essere intesa in due modi differenti, ovvero come somma oppure come concatenazione di stringhe, in quanto la sintassi è la stessa per le due operazioni e i due parametri non possiedono l'informazione per capire quale sia delle due.

tra i benefici principali di utilizzare un linguaggio fortemente tipato vs uno debolmente tipato troviamo:
1 - scrittura di codice type-safe, il che significa che se la funzione per la somma o la concatenazione di stringhe può essere utilizzata solo come intesa
2 - intellisense deterministico e proporzionalmente completo al grado di coperatura della type coverage della codebase
3 - fare refactoring diventa molto semplice e safe perché ogni cambiamento si riflette in real time sul resto del codice e typescript può dirci con precisione cosa non va più bene dopo delle modifiche
4 - possibile avere statistiche tipo codelens in modo preciso, senza dover fare delle grep da terminale
5 - backporting di codice da altri progetti diventa semplice e safe perché typescript è in grado di segnalare quali punti siano da modificare
6 - generazione delle definizioni automatica per le api pubbliche, che permettono a chiunque di interagire con le api pubbliche di una vostra libreria in maniera type-safe senza dover scrivere a mano jsdoc per ogni funzione oppure di generare semplicemente una documentazione

oltre ai tipi, cosa aggiunge typescript?
- traspilazione e polyfill comuni in caso settiate come target una versione di js che non sia esnext (con esnext vengono disattivati tutte le traspilazioni + polyfill)
- visibilità sulle proprietà e metodi delle classi, quindi è possibile dichiarare una proprietà come private per segnalare allo sviluppatore che sta usando una proprietà che è stata considerata privata da chi ha implementato la classe stessa, molto utile per rispettare open/closed principle ("open to extension, closed to modification")

cosa non è typescript:
- un layer di complessità: la curva d'apprendimento di typescript è veramente bassa (e corta) in quanto è javascript con dei metadati aggiunti, inoltre la configurazione iniziale è talmente rilassata che js è considerato completamente valido. l'unico problema con cui vi scontrerete sarà dichiarare le dovute interfaccie, union, intersection type e type guards in caso di tipi complessi (ovviamente se avete abilitato la modalità strict + noImplicitAny e non volete usare any esplicitamente)
- inventato dalle multinazionali per gli sviluppatori java: fortunatamente, non è così. sfido chiunque ad insegnare typescript ad uno sviluppatore java senza passare da javascript stesso. impresa impossibile in partenza date le infinite differenze tra i due linguaggi di programmazione e rispettive vm)
- "tipizzare Javascript fa perdere il 90% della potenza di questo linguaggio": mi verrebbe da dire `la potenza ${'di introdurre bugs e typos'} di questo linguaggio` in quanto tutto ciò che puoi fare in js puoi farlo anche in ts, ma con la garanzia che sia type-safe

per finire con un concetto molto importante: considerate imparare typescript come un investimento con una ROI sul breve periodo poiché dopo le 3-4 situazioni in cui vi scontrerete ed imparerete a gestirle, per il resto non sarà cambiato nulla rispetto a quello che facevate prima ma vi ritroverete ad essere più produttivi tanto quanto la codebase su cui state lavorando è grande e da quante persone diverse ci hanno lavorato.