Ciao, e benvenuto nella seconda puntata della ventitreesima stagione. Nella scorsa puntata abbiamo visto che Go è nato scommettendo sulla semplicità radicale. Oggi entriamo nel cuore di questa filosofia, e affrontiamo l'idea più controintuitiva e più profonda di tutto il linguaggio: meno è meglio. L'idea che, per un linguaggio di programmazione, avere meno funzionalità possa essere un vantaggio enorme invece che una limitazione. È un'idea che va contro l'istinto comune, e capirla bene è la chiave per capire tutto Go. Oggi parliamo della filosofia del linguaggio piccolo.
Partiamo dal fatto sorprendente che voglio farti apprezzare: Go è deliberatamente un linguaggio piccolo. Ha poche parole chiave, poche funzionalità, poche costruzioni. Puoi impararlo per intero in tempi brevi, cosa quasi impossibile con linguaggi più ricchi, che sono così vasti che quasi nessuno li conosce davvero tutti. E questa piccolezza non è un caso, non è che gli autori non abbiano fatto in tempo ad aggiungere altro: è una scelta precisa, difesa con fermezza. Ogni volta che qualcuno proponeva di aggiungere una funzionalità, la domanda non era serve, ma serve abbastanza da valere la complessità che aggiunge? E molto spesso la risposta era no. La piccolezza di Go è coltivata con disciplina.
Ora, la domanda naturale è: perché? Perché rinunciare volontariamente a funzionalità, a potenza espressiva? Cosa ci guadagni a essere piccoli? La risposta è profonda e riprende un tema che ci accompagnerà: un linguaggio piccolo è un linguaggio in cui c'è, di solito, un modo solo, o pochi modi, per fare una certa cosa. E questo, controintuitivamente, è un enorme vantaggio, soprattutto quando tante persone lavorano insieme. Perché se c'è un modo solo di fare le cose, allora il codice scritto da una persona assomiglia a quello scritto da un'altra, ed è facile da leggere e capire per tutti. La piccolezza porta uniformità, e l'uniformità porta leggibilità.
Voglio farti sentire il contrasto con i linguaggi ricchi, perché chiarisce tutto. In un linguaggio molto ricco ed espressivo, ci sono dieci modi diversi ed eleganti di fare la stessa cosa, e ogni programmatore sceglie il suo preferito. Il risultato è che il codice scritto da persone diverse appare diversissimo, ciascuno con il suo stile, le sue costruzioni furbe, i suoi trucchi. Bello per chi scrive, che può esprimersi; faticoso per chi legge, che deve decifrare lo stile altrui ogni volta. In un linguaggio piccolo come Go, invece, c'è meno spazio per lo stile personale e la furbizia: tutti scrivono in modo simile, e il codice, per quanto meno brillante, è immediatamente leggibile da chiunque. Go sacrifica l'espressività individuale in cambio della leggibilità collettiva.
Voglio evidenziare un cambio di priorità fondamentale che sta dietro tutto questo, perché è illuminante. La maggior parte dei linguaggi ottimizza, consapevolmente o no, per chi scrive il codice: cerca di rendere piacevole, potente, espressivo l'atto di scrivere. Go ottimizza per chi legge il codice. Perché? Perché il codice viene letto molte più volte di quanto venga scritto: lo scrivi una volta, ma poi tu e altri lo rileggete decine di volte per capirlo, correggerlo, modificarlo, per anni. Ottimizzare per la lettura, anche a costo di rendere la scrittura un po' meno brillante, è quindi la scelta giusta per il software che deve vivere a lungo ed essere curato da tanti. Go mette al primo posto il lettore, non lo scrittore.
C'è una conseguenza di questa filosofia che a volte spiazza chi arriva a Go, e voglio prepararti: Go può sembrare, a volte, un po' noioso, un po' verboso, meno elegante di altri linguaggi. E in un certo senso è vero, ma è voluto. Go non vuole essere brillante o astuto: vuole essere chiaro, prevedibile, senza sorprese. Preferisce che tu scriva qualche riga in più, ma cristalline, piuttosto che una riga furba e densa che poi nessuno capisce. Questa noiosità, questa mancanza di magia, è in realtà una virtù nascosta: il codice noioso e prevedibile è codice che si capisce a colpo d'occhio, che non nasconde trappole, che chiunque può mantenere. In Go, noioso è un complimento.
Voglio collegare questa filosofia a un tema che percorre tutto il podcast, perché è la stessa saggezza in un nuovo campo. Ricordi la filosofia dei piccoli strumenti di Linux, che fanno una cosa sola ma bene, e la potenza che nasce dal combinarli? O l'idea che dominare la complessità significa tenere le cose semplici e chiare? Go applica questa saggezza al design di un linguaggio: resta piccolo, fai poche cose ma bene, privilegia la chiarezza. È un altro esempio del fatto che, spesso, la vera eleganza non sta nell'aggiungere, ma nel togliere; non nella ricchezza, ma nell'essenzialità. Go è, in un certo senso, l'incarnazione del meno è più applicata a un linguaggio di programmazione.
Per oggi ci fermiamo qui. L'idea più profonda e controintuitiva di Go è che meno è meglio: essere un linguaggio piccolo, con poche funzionalità, è un vantaggio, non un limite. Perché la piccolezza porta un modo solo di fare le cose, e questo porta uniformità e leggibilità, cruciali quando tanti lavorano insieme. Go ottimizza per chi legge il codice, non per chi lo scrive, perché il codice si legge molte più volte di quanto si scriva. Per questo può sembrare noioso e verboso, ma è voluto: il codice noioso e prevedibile è quello che chiunque può capire e mantenere. È il meno è più applicato a un linguaggio. Nella prossima puntata approfondiamo la leggibilità e le convenzioni: fatto per essere letto. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.