1
00:00:15,500 --> 00:00:18,300
Benvenuti ad un nuovo episodio. 
Prima di iniziare con 

2
00:00:18,300 --> 00:00:20,980
l'argomento di oggi vi invito a 
iscrivervi, attivare la 

3
00:00:20,980 --> 00:00:24,500
campanella e a lasciare una 
valutazione positiva, il vostro 

4
00:00:24,500 --> 00:00:27,820
supporto è fondamentale per far 
crescere questa comunità. e a, 

5
00:00:27,820 --> 00:00:29,940
migliorare ogni episodio se 
avete 

6
00:00:29,940 --> 00:00:37,900
dubbiosemplicementecuriositaviinvitoaiscriverviamauro.spezzaferro@gmail.com.
Grazie per la vostra attenzione 

7
00:00:37,900 --> 00:00:41,600
e buon ascolto. 
In questa puntata parleremo di 

8
00:00:41,600 --> 00:00:44,200
un tema che tutti i 
programmatori incontrano prima o

9
00:00:44,200 --> 00:00:48,160
poi, le dipendenze software. 
Ma partiamo dall'inizio, che 

10
00:00:48,160 --> 00:00:51,440
cosa sono le dipendenze? 
Le dipendenze nel mondo del 

11
00:00:51,440 --> 00:00:55,000
software sono quei componenti 
esterni, librerie o moduli che 

12
00:00:55,000 --> 00:00:56,760
un programma utilizza per 
funzionare. 

13
00:00:57,480 --> 00:01:00,680
In pratica, invece di riscrivere
da zero ogni funzione, gli 

14
00:01:00,680 --> 00:01:04,160
sviluppatori riutilizzano codice
già pronto, spesso realizzato da

15
00:01:04,160 --> 00:01:07,560
altri sviluppatori. 
Questo approccio permette di 

16
00:01:07,560 --> 00:01:10,280
velocizzare il processo di 
creazione in modo da non 

17
00:01:10,280 --> 00:01:12,640
soffermarci troppo sulla 
realizzazione di un particolare 

18
00:01:12,640 --> 00:01:15,640
componente. 
Immaginiamo per un attimo di 

19
00:01:15,640 --> 00:01:17,880
voler gestire il processo di 
acquisizione dei permessi 

20
00:01:17,880 --> 00:01:19,840
durante l'esecuzione 
dell'applicazione di Android. 

21
00:01:20,640 --> 00:01:24,360
In questo caso possiamo muoverci
su due binari, il primo di 

22
00:01:24,360 --> 00:01:27,560
utilizzare delle api standard 
che stesso il sistema operativo 

23
00:01:27,560 --> 00:01:31,400
ci mette a disposizione e quindi
gestire ogni aspetto, oppure il 

24
00:01:31,400 --> 00:01:34,480
secondo metodo. 
Utilizzare una libreria esterna 

25
00:01:34,480 --> 00:01:38,320
che ci nasconde parte del 
comportamento in questo secondo 

26
00:01:38,320 --> 00:01:41,640
caso, utilizzare una libreria 
esterna significa che qualcun 

27
00:01:41,640 --> 00:01:44,280
altro ha già scritto il codice 
necessario per gestire i 

28
00:01:44,280 --> 00:01:47,880
permessi, magari in modo più 
semplice o più elegante. 

29
00:01:48,280 --> 00:01:51,160
Noi dobbiamo solo includere 
quelle librerie e imparare a 

30
00:01:51,160 --> 00:01:54,720
usarle. 
Ed ecco il cuore del concetto di

31
00:01:54,720 --> 00:01:58,320
pendenza, affidarci a qualcosa 
che non abbiamo scritto noi? 

32
00:01:59,440 --> 00:02:02,840
Ovviamente tale aspetto porta a 
considerazioni abbastanza forti,

33
00:02:03,080 --> 00:02:06,040
perché affidarsi a una 
dipendenza non è mai una scelta 

34
00:02:06,040 --> 00:02:08,280
neutra. 
Significa incorporare nel nostro

35
00:02:08,280 --> 00:02:12,000
progetto non solo il codice, ma 
anche le decisioni, gli stili e 

36
00:02:12,000 --> 00:02:14,840
persino le filosofie di chi quel
codice lo ha scritto. 

37
00:02:15,360 --> 00:02:18,240
In altre parole, quando 
importiamo una libreria stiamo 

38
00:02:18,240 --> 00:02:21,400
accettando di fidarci della 
qualità, della sicurezza e della

39
00:02:21,400 --> 00:02:24,080
manutenzione futura di un 
progetto che non controlliamo 

40
00:02:24,080 --> 00:02:27,160
direttamente. 
È come comporre un puzzle e 

41
00:02:27,160 --> 00:02:29,760
decidere di usare un pezzo 
disegnato da qualcun altro. 

42
00:02:30,240 --> 00:02:33,160
Se quel pezzo è preciso e 
resistente, si incastra 

43
00:02:33,160 --> 00:02:36,640
perfettamente e ci permette di 
completare l'immagine, ma se è 

44
00:02:36,640 --> 00:02:40,000
difettoso o manca, rischia di 
compromettere l'armonia e la 

45
00:02:40,000 --> 00:02:43,400
solidità dell'intero quadro. 
Ed è proprio su questo aspetto 

46
00:02:43,400 --> 00:02:46,480
che vorrei soffermarmi, perché 
l'uso delle dipendenze non 

47
00:02:46,480 --> 00:02:49,720
riguarda soltanto la tecnica, ma
anche la mentalità con cui 

48
00:02:49,720 --> 00:02:53,400
affrontiamo la programmazione. 
Scrivere software non è 

49
00:02:53,400 --> 00:02:56,600
semplicemente mettere insieme 
righe di codice, è un esercizio 

50
00:02:56,600 --> 00:02:59,720
di responsabilità. 
Ogni dipendenza che scegliamo 

51
00:02:59,720 --> 00:03:01,640
rappresenta una decisione a 
lungo termine. 

52
00:03:02,000 --> 00:03:05,160
Può semplificarci la vita oggi, 
ma condizionarci domani. 

53
00:03:06,640 --> 00:03:09,400
Pensiamoci un attimo, se un 
progetto personale resta 

54
00:03:09,400 --> 00:03:12,480
bloccato perché una libreria non
viene più aggiornata, pazienza. 

55
00:03:12,960 --> 00:03:15,880
Ma se la stessa cosa accade in 
un software aziendale o 

56
00:03:15,880 --> 00:03:18,920
addirittura in un sistema 
critico, le conseguenze possono 

57
00:03:18,920 --> 00:03:22,280
essere enormi. 
Un piccolo componente trascurato

58
00:03:22,280 --> 00:03:25,200
può diventare punto di fragilità
che mette a rischio l'intero 

59
00:03:25,200 --> 00:03:28,040
programma. 
Ecco perché è importante 

60
00:03:28,040 --> 00:03:31,480
sviluppare un approccio critico,
non prendere mai una libreria 

61
00:03:31,480 --> 00:03:35,000
solo perché lo fanno tutti, 
valutare la sua affidabilità, la

62
00:03:35,000 --> 00:03:37,520
sua comunità, il ritmo con cui 
vengono rilasciati gli 

63
00:03:37,520 --> 00:03:41,120
aggiornamenti, chiedersi sempre 
se il problema che risolve non 

64
00:03:41,120 --> 00:03:43,480
possa essere affrontato 
direttamente con un po' di 

65
00:03:43,480 --> 00:03:47,080
codice scritto da noi. 
In questo senso le dipendenze 

66
00:03:47,080 --> 00:03:49,080
diventano una palestra di 
consapevolezza. 

67
00:03:49,720 --> 00:03:52,840
Ci insegnano a distinguere tra 
ciò che è davvero utile e ciò 

68
00:03:52,840 --> 00:03:55,800
che invece ci rende soltanto 
pigri o troppo dipendenti dal 

69
00:03:55,800 --> 00:03:59,280
lavoro degli altri. 
E alla fine questa è una delle 

70
00:03:59,280 --> 00:04:02,360
lezioni più importanti per ogni 
programmatore, saper scegliere, 

71
00:04:02,800 --> 00:04:05,480
scegliere se affidarsi, 
scegliendo quando essere 

72
00:04:05,480 --> 00:04:08,960
autonomi, scegliere se costruire
un equilibrio tra velocità e 

73
00:04:08,960 --> 00:04:11,560
solidità. 
Ormai siamo sempre più 

74
00:04:11,560 --> 00:04:14,480
consapevoli che esiste un 
pacchetto, una libreria, un 

75
00:04:14,480 --> 00:04:17,200
modulo che ci permetterà di 
ridurre il tempo di sviluppo. 

76
00:04:17,720 --> 00:04:20,040
Ed è proprio questa 
consapevolezza che ci porta una 

77
00:04:20,040 --> 00:04:23,200
specie di illusione, di 
sicurezza, l'idea che esista 

78
00:04:23,200 --> 00:04:26,200
sempre una soluzione pronta, già
confezionata, da prendere e 

79
00:04:26,200 --> 00:04:27,960
incollare dentro il nostro 
progetto. 

80
00:04:28,520 --> 00:04:31,440
Ma la verità è che ogni volta 
che scegliamo questa strada 

81
00:04:31,440 --> 00:04:35,440
stiamo facendo un compromesso. 
Stiamo risparmiando tempo oggi, 

82
00:04:35,560 --> 00:04:38,480
ma stiamo anche accettando di 
legare il nostro lavoro a 

83
00:04:38,480 --> 00:04:42,840
qualcosa che non controlliamo. 
E questo non è necessariamente 

84
00:04:42,840 --> 00:04:46,080
un male, anzi, spesso è la 
scelta giusta, ma richiede 

85
00:04:46,080 --> 00:04:49,520
maturità e giudizio. 
Il rischio è trasformare la 

86
00:04:49,520 --> 00:04:52,640
programmazione in un semplice 
assemblaggio di pezzi altrui, 

87
00:04:53,040 --> 00:04:55,840
perdendo di vista la capacità di
risolvere i problemi con le 

88
00:04:55,840 --> 00:04:58,640
nostre forze. 
Ed è qui che nasce il vero 

89
00:04:58,640 --> 00:05:02,040
equilibrio, usare le dipendenze 
quando davvero accelerano e 

90
00:05:02,040 --> 00:05:05,320
arricchiscono il progetto, ma 
non lasciare che diventino un 

91
00:05:05,320 --> 00:05:09,560
stampelle costanti. 
Perché se ci pensiamo, il valore

92
00:05:09,560 --> 00:05:12,360
di un buon programmatore non sta
solo nel conoscere i pacchetti 

93
00:05:12,360 --> 00:05:16,200
giusti da installare, ma anche e
soprattutto nel sapere quando 

94
00:05:16,200 --> 00:05:19,240
farne a meno. 
Ma dunque, arrivati a questa 

95
00:05:19,240 --> 00:05:22,200
parte della puntata, sorge 
spontanea una domanda, fino a 

96
00:05:22,200 --> 00:05:24,560
che punto è giusto affidarci 
alle dipendenze? 

97
00:05:25,240 --> 00:05:28,600
La verità è che non esiste una 
risposta assoluta, dipende dal 

98
00:05:28,600 --> 00:05:31,440
contesto, dall'obiettivo e anche
dalla prospettiva con cui 

99
00:05:31,440 --> 00:05:34,520
guardiamo il nostro lavoro. 
Prendiamo due scenari opposti. 

100
00:05:35,040 --> 00:05:37,640
Da un lato abbiamo lo 
sviluppatore hobbista che vuole 

101
00:05:37,640 --> 00:05:39,640
creare un progetto personale in 
poco tempo. 

102
00:05:40,080 --> 00:05:43,160
In questo caso usare molte 
librerie può avere perfettamente

103
00:05:43,160 --> 00:05:46,480
senso, riduce la complessità e 
permette di concentrarsi sul 

104
00:05:46,480 --> 00:05:49,520
risultato finale. 
Se la libreria un giorno smette 

105
00:05:49,520 --> 00:05:52,240
di funzionare non è un dramma, 
si tratterà al massimo di 

106
00:05:52,240 --> 00:05:54,040
abbandonare o rifare il 
progetto. 

107
00:05:54,560 --> 00:05:57,840
Dall'altro c'è lo sviluppatore 
professionista che lavora a un 

108
00:05:57,840 --> 00:06:00,840
software destinato a durare 
negli anni, magari in ambiente 

109
00:06:00,840 --> 00:06:03,480
aziendale o addirittura critico,
come già abbiamo detto. 

110
00:06:04,000 --> 00:06:07,240
Qui il discorso cambia, ogni 
dipendenza diventa un vincolo, 

111
00:06:07,280 --> 00:06:10,480
un nodo che Lega il futuro 
progetto a decisioni prese da 

112
00:06:10,480 --> 00:06:13,640
qualcun'altro. 
In questo contesto la leggerezza

113
00:06:13,640 --> 00:06:16,480
con cui spesso aggiungiamo 
librerie può trasformarsi in un 

114
00:06:16,480 --> 00:06:19,480
rischio enorme. 
E qui entra in gioco un concetto

115
00:06:19,480 --> 00:06:22,560
che spesso viene sottovalutato, 
il debito tecnico. 

116
00:06:23,160 --> 00:06:26,080
Ogni dipendenza che introduciamo
è come un prestito. 

117
00:06:26,480 --> 00:06:29,560
Ci dà subito qualcosa, tempo 
risparmiato, funzioni già 

118
00:06:29,560 --> 00:06:33,080
pronte, ma ci obbliga a ripagare
in futuro, quando quella 

119
00:06:33,080 --> 00:06:35,640
dipendenza dovrà essere 
aggiornata, mantenuta, 

120
00:06:35,760 --> 00:06:39,240
sostituita. 
E come tutti i debiti, anche 

121
00:06:39,240 --> 00:06:42,680
questo accumula interessi. 
Più dipendenze abbiamo, più 

122
00:06:42,680 --> 00:06:45,480
diventa complicato gestire il 
progetto sul lungo periodo, 

123
00:06:45,880 --> 00:06:48,440
perché alla fine il software non
è fatto solo di righe di codice,

124
00:06:48,440 --> 00:06:52,440
è fatto di scelte, e ogni scelta
racconta qualcosa di noi come 

125
00:06:52,440 --> 00:06:55,960
sviluppatori, del nostro modo di
affrontare i problemi e delle 

126
00:06:55,960 --> 00:06:58,080
responsabilità che siamo 
disposti a prenderci. 

127
00:06:58,720 --> 00:07:01,600
In questa parte finale della 
puntata vorrei soffermarmi su 

128
00:07:01,600 --> 00:07:04,640
alcuni esempi di cui l'utilizzo 
di un pacchetto esterno ha 

129
00:07:04,640 --> 00:07:06,440
provocato più danni che 
benefici. 

130
00:07:07,120 --> 00:07:08,800
Perché non parliamo solo di 
teoria. 

131
00:07:09,080 --> 00:07:11,960
La storia dell'informatica 
recente è piena di casi che ci 

132
00:07:11,960 --> 00:07:14,760
ricordano quanto sia delicato 
affidarsi ciecamente alle 

133
00:07:14,760 --> 00:07:17,840
dipendenze. 
Uno dei più noti è quello del 

134
00:07:17,840 --> 00:07:22,000
pacchetto left PAD, un piccolo 
modulo di javascript grande 

135
00:07:22,000 --> 00:07:25,360
appena 11 righe di codice che 
serviva a fare una cosa 

136
00:07:25,360 --> 00:07:29,080
banalissima, aggiungere degli 
spazi o dei caratteri davanti a 

137
00:07:29,080 --> 00:07:32,800
una stringa per allinearla. 
Eppure questo piccolo pacchetto 

138
00:07:32,840 --> 00:07:35,920
era diventato una dipendenza di 
centinaia e migliaia di progetti

139
00:07:35,920 --> 00:07:38,520
nel mondo. 
Quando il suo autore decise di 

140
00:07:38,520 --> 00:07:42,560
rimuoverlo da NPM, l'intero 
ecosistema javascript andò nel 

141
00:07:42,560 --> 00:07:45,200
caos. 
Build che non funzionavano più, 

142
00:07:45,320 --> 00:07:49,560
progetti bloccati, aziende in 
difficoltà, tutto per 11 righe 

143
00:07:49,560 --> 00:07:52,680
di codice che chiunque avrebbe 
potuto scrivere da solo. 

144
00:07:52,800 --> 00:07:56,160
È stato un esempio lampante di 
come la troppa fiducia nelle 

145
00:07:56,160 --> 00:07:58,640
dipendenze possa generare una 
fragilità enorme. 

146
00:07:59,560 --> 00:08:03,120
Ma ancora un'altro caso riguarda
Live in Stream dell'ex, sempre 

147
00:08:03,120 --> 00:08:06,960
nell'ecosistema javascript. 
Una libreria molto usata per 

148
00:08:06,960 --> 00:08:10,160
gestire flussi di dati, 
anch'essa inclusi in migliaia di

149
00:08:10,160 --> 00:08:12,640
progetti. 
A un certo punto lo sviluppatore

150
00:08:12,640 --> 00:08:15,200
originale, stanco di mantenere 
il pacchetto, lo affido a 

151
00:08:15,200 --> 00:08:17,800
qualcun altro. 
E questa persona cosa fece? 

152
00:08:18,000 --> 00:08:20,560
Inserire il codice malevolo 
progettato per rubare 

153
00:08:20,560 --> 00:08:24,080
criptovalute dagli utenti 
permisi il codice infetto, 

154
00:08:24,080 --> 00:08:27,920
circolò indisturbato nascosto 
dentro una libreria di cui tutti

155
00:08:27,920 --> 00:08:30,120
si fidavano. 
È un caso che ci ricorda 

156
00:08:30,120 --> 00:08:32,799
un'altra verità. 
Ogni dipendenza è una porta 

157
00:08:32,799 --> 00:08:35,840
d'ingresso e più dipendenza 
abbiamo, più porte lasciamo 

158
00:08:35,840 --> 00:08:38,559
aperte. 
E non sono casi isolati. 

159
00:08:39,120 --> 00:08:42,120
Basti pensare alle vulnerabilità
scoperte in librerie cruciali 

160
00:08:42,120 --> 00:08:45,520
come Log for J, utilizzato 
praticamente da chiunque nel 

161
00:08:45,520 --> 00:08:49,120
mondo Java. 
Nel 2021 una falla critica rese 

162
00:08:49,120 --> 00:08:51,800
invulnerabili migliaia di 
sistemi in tutto il mondo, 

163
00:08:52,120 --> 00:08:55,640
obbligando aziende e governi a 
correre al riparo in tempi 

164
00:08:55,640 --> 00:08:58,360
record. 
Questi esempi ci insegnano una 

165
00:08:58,360 --> 00:09:01,600
cosa fondamentale. 
Non è la quantità di codice che 

166
00:09:01,600 --> 00:09:04,440
conta, ma la fiducia che 
riponiamo in esso. 

167
00:09:04,920 --> 00:09:07,640
Anche un piccolo pacchetto può 
diventare il punto debole di un 

168
00:09:07,640 --> 00:09:11,240
intero ecosistema ed è per 
questo che come sviluppatori 

169
00:09:11,240 --> 00:09:12,880
dobbiamo imparare a essere 
critici. 

170
00:09:13,280 --> 00:09:16,520
Non vuol dire smettere di usare 
librerie, sarebbe impensabile 

171
00:09:16,520 --> 00:09:19,800
oggi, ma vuol dire imparare a 
porci delle domande giuste. 

172
00:09:20,160 --> 00:09:22,360
Questa libreria è davvero 
necessaria? 

173
00:09:22,360 --> 00:09:25,440
È ben mantenuta e supportata da 
una comunità attiva? 

174
00:09:25,840 --> 00:09:29,200
Potrei scrivere io la parte che 
mi serve, magari in poche righe,

175
00:09:29,200 --> 00:09:31,240
invece. 
Importare un pacchetto esterno. 

176
00:09:31,840 --> 00:09:34,880
La consapevolezza parte da qui, 
perché ogni dipendenza che 

177
00:09:34,880 --> 00:09:37,560
scegliamo, come abbiamo detto, 
non è solo un pezzo di codice in

178
00:09:37,560 --> 00:09:39,880
più, è una responsabilità che ci
assumiamo. 

179
00:09:40,240 --> 00:09:42,600
E con questa riflessione 
arriviamo alla conclusione della

180
00:09:42,600 --> 00:09:46,280
puntata, le dipendenze software 
sono strumenti potenti, ci 

181
00:09:46,280 --> 00:09:49,280
permettono di risparmiare tempo,
semplificare lo sviluppo e 

182
00:09:49,280 --> 00:09:51,400
accedere a funzionalità 
complesse e senza doverlo 

183
00:09:51,400 --> 00:09:53,960
riscrivere da zero. 
Ma come abbiamo visto dagli 

184
00:09:53,960 --> 00:09:57,880
esempi di left Padd, Heaven 
Stream e Log for J, anche un 

185
00:09:57,880 --> 00:10:00,440
piccolo pacchetto può 
trasformarsi in un rischio se 

186
00:10:00,440 --> 00:10:03,200
non siamo consapevoli di cosa 
stiamo importando nel nostro 

187
00:10:03,200 --> 00:10:06,360
progetto. 
La vera lezione è questa, non si

188
00:10:06,360 --> 00:10:09,080
tratta di smettere di usare 
librerie, ma di imparare a farlo

189
00:10:09,080 --> 00:10:11,960
con giudizio. 
Chiediamoci sempre, è davvero 

190
00:10:11,960 --> 00:10:15,240
necessaria e affidabile? 
Posso gestire io quella parte di

191
00:10:15,240 --> 00:10:17,320
codice? 
Saper rispondere a queste 

192
00:10:17,320 --> 00:10:20,720
domande non ci rende soltanto 
programmatori più efficienti ma 

193
00:10:20,720 --> 00:10:23,800
anche più responsabili, capaci 
di costruire software robusto, 

194
00:10:23,800 --> 00:10:28,040
sicuro e sostenibile nel tempo. 
Questa è la scelta che distingue

195
00:10:28,040 --> 00:10:31,120
chi programma solo per ottenere 
risultati immediati da chi 

196
00:10:31,120 --> 00:10:33,960
programma con consapevolezza, 
guardando anche al futuro del 

197
00:10:33,960 --> 00:10:36,720
proprio lavoro. 
Grazie per avermi dedicato parte

198
00:10:36,720 --> 00:10:39,120
del vostro tempo. 
Vi aspetto al prossimo episodio.