Ciao, e benvenuto nella quarta puntata della ventitreesima stagione. Nelle scorse puntate abbiamo parlato di semplicità e leggibilità. Oggi affrontiamo un'altra ossessione di Go, una di quelle che sembrano dettagli tecnici ma che in realtà cambiano profondamente il modo di lavorare e persino il piacere di programmare: la velocità di compilazione. Go compila in un lampo, e voglio farti capire perché questa cosa, che a prima vista sembra minore, sia stata invece una delle ragioni del suo successo, e come sia legata a un tema che abbiamo già incontrato.
Partiamo dal ricordare cos'è la compilazione, dalla stagione sui linguaggi. Ricordi che i linguaggi ad alto livello devono essere tradotti nella lingua della macchina prima di poter girare? Questo lavoro di traduzione si chiama compilazione, e la fa un traduttore, il compilatore. Ora, ecco il punto: questa traduzione richiede tempo. E per certi linguaggi, su programmi grandi, richiede moltissimo tempo: minuti, a volte molti minuti, ogni volta che vuoi tradurre il tuo programma per provarlo. Chi ha lavorato con questi linguaggi conosce bene l'attesa: fai una modifica, avvii la compilazione, e aspetti, e aspetti, prima di poter vedere il risultato.
Voglio farti sentire quanto sia frustrante e dannosa questa attesa, perché è più grave di quanto sembri. Immagina di lavorare così: scrivi un pezzo di codice, vuoi provarlo, avvii la traduzione, e devi aspettare minuti prima di vedere se funziona. In quei minuti, il tuo filo di pensiero si spezza, ti distrai, perdi la concentrazione. E siccome ogni prova costa cara in attesa, tendi a provare meno spesso, accumulando più modifiche prima di testare, il che rende poi più difficile capire cosa è andato storto. L'attesa lunga avvelena tutto il ritmo del lavoro, spezza la concentrazione, scoraggia la sperimentazione frequente. È un attrito costante che logora la produttività e il piacere di programmare.
Go ha fatto della velocità di compilazione un obiettivo primario, fin dalla nascita, e voglio che tu apprezzi quanto sia stato importante. Gli autori di Go venivano proprio dal dolore delle compilazioni lentissime, e hanno progettato il linguaggio, fin dalle fondamenta, perché fosse velocissimo da tradurre. Molte scelte di design di Go, anche alcune di quelle che lo rendono semplice e a volte spartano, sono state fatte anche per permettere una compilazione fulminea. Con Go, tradurre il programma richiede tipicamente pochi secondi, spesso una frazione di secondo, anche per programmi grandi. Quell'attesa di minuti che avvelenava il lavoro semplicemente scompare: premi, e quasi subito hai il risultato.
Voglio farti capire perché questa velocità cambi tutto, e qui c'è un legame bellissimo con la stagione sull'Agile. Ricordi il ciclo di feedback, il costruire qualcosa, provarlo, imparare dal risultato, e correggere, e come tutto funzioni meglio quando questo ciclo è veloce e frequente? La compilazione fulminea di Go rende questo ciclo di feedback velocissimo anche a livello del singolo programmatore che scrive codice: fai una modifica, e in un attimo la provi e vedi il risultato, fai un'altra modifica, e la provi subito. Questo ciclo rapidissimo, scrivi, prova, vedi, correggi, ripeti, in continuazione, senza attese, cambia radicalmente l'esperienza. Puoi sperimentare di continuo, correggere in fretta, restare nel flusso. La velocità di compilazione è, in fondo, velocità del ciclo di feedback, e sappiamo quanto conti.
C'è un secondo dono di Go, legato al primo e altrettanto pratico, che riprende la stagione su Docker: la semplicità di distribuzione. Quando compili un programma Go, ottieni tipicamente un unico file eseguibile, autosufficiente, che contiene tutto ciò che serve per girare. Non devi installare un ambiente speciale sulla macchina di destinazione, non devi portarti dietro un mucchio di dipendenze: un solo file, che copi dove vuoi e lanci. Ricordi quanto abbiamo parlato della fatica di far girare il software su macchine diverse, del non funziona sul mio computer? Go la riduce moltissimo: quel singolo file autosufficiente gira ovunque, senza sorprese. Distribuire un programma Go è semplice come copiare un file, ed è una comodità enorme.
Voglio unire questi due doni in un quadro, perché insieme raccontano la filosofia pragmatica di Go. Da un lato, la compilazione fulminea rende veloce e piacevole il ciclo di sviluppo, lo scrivere e provare. Dall'altro, il singolo file autosufficiente rende semplice la distribuzione, il portare il programma in produzione. Sviluppo veloce e distribuzione semplice: Go ha ottimizzato l'intero percorso, dallo scrivere il codice al farlo girare in produzione, per essere il più fluido e privo di attriti possibile. Non è la ricerca dell'eleganza teorica, ma del pragmatismo concreto: rendere piacevole e produttivo il lavoro reale di ogni giorno. È semplicità messa al servizio della praticità.
Per oggi ci fermiamo qui. Go ha fatto della velocità di compilazione un'ossessione, perché l'attesa lunga per tradurre il programma avvelena il ritmo del lavoro, spezza la concentrazione e scoraggia la sperimentazione. Con Go, la traduzione richiede pochi secondi o meno, il che rende fulmineo il ciclo di feedback del programmatore, scrivi, prova, vedi, correggi, ripeti, con lo stesso spirito dell'Agile applicato al singolo che scrive codice. E in più, Go produce un unico file eseguibile autosufficiente, semplicissimo da distribuire ovunque, riducendo il vecchio problema del non funziona sul mio computer. Sviluppo veloce e distribuzione semplice: pragmatismo concreto al servizio del lavoro reale. Nella prossima puntata affrontiamo il superpotere di Go: la concorrenza resa semplice. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.