Ciao, e benvenuto nella decima e ultima puntata della quarantasettesima stagione. Oggi tiriamo le somme su gRPC, ma non solo: chiudiamo un arco lungo tre stagioni, sulla domanda più profonda del software fatto di pezzi che parlano tra loro. Come fanno i programmi a parlarsi? Rimettiamo in fila gRPC, e poi allarghiamo lo sguardo su tutto l'arco, e sulla verità che tiene insieme le tre risposte.
Ripercorriamo la stagione, perché il ritratto ora si compone. Abbiamo cominciato dall'idea di cancellare la distanza, far sembrare una chiamata remota una chiamata di funzione. Poi il contratto scritto prima di tutto, da cui si genera il codice. Il parlare in binario, compatto invece che leggibile. Il canale sempre aperto, la conversazione invece della domanda secca. Il poliglottismo, tante lingue che si capiscono grazie a una fonte comune. L'evolvere senza rompere, coi numeri dei campi. Lo specialista che conosce la sua corsia. La verità profonda che la distanza non sparisce mai. E i costi onesti, e il posto di gRPC accanto agli altri due.
Voglio allargare lo sguardo su tutto l'arco, perché è la parte grande. Fermiamoci sulle tre stagioni insieme, perché formano un ritratto solo. Tre risposte alla stessa domanda: come parlano i programmi. La prima pensa in risorse, cose con un indirizzo, testo universale. La seconda pensa in un grafo, e lascia al client la libertà di chiedere esattamente ciò che gli serve. La terza pensa in funzioni chiamate, veloci e rigorose, tra macchine che controlli. Tre filosofie diverse, ognuna che ottimizza una cosa diversa: l'universalità e la semplicità, la libertà di chi chiede, la velocità e il rigore tra i tuoi. E badi bene: nessuna ha reso vecchie le altre. Sono nate e cresciute in parallelo, e convivono, perché rispondono a bisogni diversi che esistono tutti insieme, nello stesso sistema, nello stesso momento.
Voglio darti la verità che le unisce, perché è il cuore di tutto. E sotto tutte e tre, la stessa idea profonda, quella attorno a cui gira l'intero podcast: ognuna di queste è, in fondo, un contratto tra programmi. Un accordo su cosa si può chiedere e cosa verrà risposto. Cambiano in cosa ottimizzano, ma sono tutte, alla radice, dei patti. Il software è costruito su accordi: contratti, promesse sulla forma e sul comportamento delle cose. E azzeccare quegli accordi, sceglierli formali o sciolti, leggibili o veloci, rigidi o flessibili, è gran parte del mestiere. Non è la tecnologia il cuore: sono i patti che tiene. Cambia lo stile del contratto, ma non il fatto che ci sia un contratto: che due programmi, per collaborare, debbano prima essersi promessi qualcosa su cosa aspettarsi l'uno dall'altro. Tolta quella promessa, non c'è dialogo, ma solo rumore.
Voglio darti le due idee da portare via, perché vanno oltre gRPC. La prima: come parlano due cose non è mai una domanda con una sola risposta, ma una famiglia di baratti, e conoscere i baratti ti fa scegliere bene. Non cercare il vincitore: impara i compromessi, e scegli. La seconda, più profonda: sotto le risorse, i grafi e le funzioni chiamate, è tutto contratti. E la salute di un sistema fatto di molte parti è, in gran parte, la salute degli accordi tra quelle parti. Se i patti sono chiari e onesti, il sistema regge; se sono confusi o traditi, crolla, per quanto belli siano i pezzi presi da soli.
Voglio dirti dove ci lascia questo arco, perché il filo continua. Con queste tre stagioni abbiamo guardato come i pezzi di un sistema si parlano: il linguaggio dei loro accordi. Ma dietro ogni contratto ci sono i programmi veri che lo onorano, e le persone che li scrivono e che devono, anche loro, mettersi d'accordo. Forse è lì che guarderemo, prima o poi: dai patti tra i programmi ai patti tra chi li costruisce. Perché, a pensarci, è sempre la stessa storia: che si tratti di macchine o di persone, tutto sta nella qualità degli accordi.
Per oggi, e per questa quarantasettesima stagione, ci fermiamo qui. Abbiamo raccontato gRPC per intero: cancellare la distanza, il contratto che genera il codice, il binario, il canale aperto, il poliglottismo, l'evoluzione coi numeri, lo specialista, la distanza che non sparisce, i costi onesti. E abbiamo chiuso un arco di tre stagioni sul come parlano i programmi: risorse, grafo, funzioni chiamate, tre risposte, tre baratti. Sotto tutte, la stessa verità: sono tutte contratti tra programmi, e il software è costruito su accordi. Le due idee grandi: non cercare il vincitore ma impara i baratti, e la salute di un sistema è la salute dei patti tra le sue parti. Se una cosa spero ti resti da tutto l'arco, è questa: guarda sempre i confini tra i pezzi, non solo i pezzi. Lì, negli accordi, vive o muore un sistema. Grazie di cuore per avermi accompagnato in queste dieci puntate, e in tutto questo arco. Prenditi cura di te, e del codice che scrivi. A rileggerci presto, nella prossima stagione.