Ciao, e benvenuto nella seconda puntata della quarantasettesima stagione. Nella scorsa puntata abbiamo visto l'idea di gRPC: chiamare una funzione su un altro computer. Oggi vediamo la sua pratica più distintiva, quella che lo separa nettamente dal modo che pensa in risorse: con gRPC, prima di scrivere qualunque codice, scrivi il contratto. E poi, cosa quasi magica, dal contratto si genera il codice, in ogni linguaggio. Oggi capiamo: il contratto prima di tutto, definire e poi generare.
Partiamo da cos'è questo contratto, perché è il cuore di tutto. Prima ancora di programmare, scrivi una descrizione formale, in un linguaggio neutro, che non è né quello del server né quello del client. In questa descrizione dici: ecco quali funzioni esistono, ecco cosa prende ciascuna, ed ecco cosa restituisce. Questo file è l'unica fonte di verità. Non un commento, non una pagina di documentazione: il documento ufficiale, preciso, da cui tutto discende. È l'accordo scritto nero su bianco, prima che chiunque scriva una riga di programma vero.
Voglio darti la parte magica, perché è ciò che cambia tutto. Ed ecco la magia: da quell'unico contratto, uno strumento genera automaticamente il codice, sia per il client sia per il server, in qualunque linguaggio ciascun lato usi. Definisci una volta, e generi ovunque. Il server in un linguaggio, il client in un altro, ma entrambi nati dallo stesso contratto, con i tipi giusti, già pronti. Non scrivi tu la parte noiosa del far combaciare le due parti: la scrive la macchina, partendo dalla verità condivisa. Tu ti occupi solo di cosa fanno davvero le funzioni.
Voglio farti sentire il contrasto, perché è netto. Pensa a come funziona nel modo che pensa in risorse, quello di due stagioni fa. Lì, il contratto spesso è solo documentazione: pagine di prosa, una speranza che le due parti siano d'accordo. Informale, e facilissimo che le due parti, col tempo, divergano senza accorgersene: il server cambia qualcosa, la pagina di documentazione resta vecchia, e il client si rompe. Con gRPC, il contratto non è una speranza: è un documento da cui si compila. Non puoi divergere, perché entrambe le parti nascono dalla stessa fonte, ciascuna nella propria lingua, con i propri tipi.
Voglio dirti perché questo conta davvero, perché elimina un'intera classe di guai. Ecco il beneficio concreto: sparisce un'intera categoria di errori, quelli del tipo il client e il server non sono d'accordo sulla forma delle cose. Sono tra i bug più comuni e frustranti dei sistemi fatti di pezzi che parlano: uno si aspetta un campo che l'altro non manda più, uno chiama una funzione che è cambiata. Con il contratto che genera entrambi i lati, questo disaccordo diventa impossibile per costruzione: non che sia raro, proprio non può accadere, perché tutti e due vengono dalla stessa verità.
Voglio darti l'immagine che rende chiara questa idea, perché è precisa. Pensa a un trattato scritto in una lingua neutra, che nessuna nazione usa come propria. Da quel testo, ogni nazione riceve una traduzione ufficiale nella sua lingua. Nessuno litiga su cosa è stato concordato, perché tutte le versioni derivano dall'unico testo originale. Se il trattato cambia, cambiano tutte le traduzioni insieme, dalla stessa fonte. Nessuno può leggere una cosa diversa da un altro: la verità è una sola, e tutte le copie ne discendono fedelmente. Il contratto di gRPC è quel trattato, e le lingue dei programmi sono le traduzioni.
Voglio trarre la lezione generale, perché va oltre gRPC. La lezione è questa: quando due parti devono mettersi d'accordo, scrivere l'accordo prima, in modo formale, e far derivare da lì la copia di ciascuno, elimina la possibilità stessa del malinteso. Il contratto non come documentazione da tenere aggiornata a mano, sperando, ma come generatore: la fonte da cui nasce, automaticamente e sempre allineato, il codice di tutti. È una differenza filosofica: l'accordo non descrive ciò che hai costruito, l'accordo costruisce. Mettere la verità al primo posto, e derivare tutto da essa, è un modo potente di togliere di mezzo l'errore prima ancora che nasca.
Per oggi ci fermiamo qui. Abbiamo visto la pratica più distintiva di gRPC: il contratto prima di tutto. Prima di programmare, scrivi una descrizione formale, in un linguaggio neutro, di quali funzioni esistono, cosa prendono e cosa restituiscono: l'unica fonte di verità. E da quel contratto si genera automaticamente il codice, per client e server, in ogni linguaggio: definisci una volta, generi ovunque. A differenza del modo che pensa in risorse, dove il contratto è spesso solo documentazione da cui si può divergere, qui non puoi divergere: entrambe le parti nascono dalla stessa fonte. Così sparisce l'intera categoria di errori del client e server non d'accordo. Come un trattato in lingua neutra da cui ogni nazione riceve la sua traduzione ufficiale. La lezione: scrivere l'accordo prima, e derivarne tutto, elimina il malinteso. Nella prossima puntata vediamo come parla, in binario. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.