Stagioni
Stagione 1: Iniziare a programmare per il Web
La stagione d'apertura: orientarsi nel mestiere di sviluppatore web. Dai profili professionali del settore al prepararsi al lavoro già durante gli studi e ai colloqui, fino alle fondamenta che nessun linguaggio insegna — scegliere un linguaggio oltre le mode, leggere il codice degli altri, scriverne di leggibile, collaborare con Git e, soprattutto, imparare a imparare.
Stagione 2: La psicologia applicata al lavoro come sviluppatore
Il lato umano del mestiere, complemento della prima stagione tecnica: come funzionano la mente, le relazioni e le dinamiche quotidiane quando si scrive software insieme agli altri.
Stagione 3: I colloqui di lavoro come web developer
L'intero percorso di una selezione, dalla candidatura all'offerta e oltre, affrontato fase per fase: come ci si prepara, cosa aspettarsi a ogni tappa, come si gestiscono la prova tecnica e la trattativa.
Stagione 4: I percorsi di assunzione nelle Big Tech
Il processo di selezione delle grandi aziende tecnologiche: lungo, standardizzato ed esigente, molto diverso da quello di un'azienda normale. Uno sguardo realistico e non celebrativo alla loro macchina specifica.
Stagione 5: Il valore dei progetti Open Source per il curriculum
Perché e come i contributi open source valorizzano curriculum e carriera: un asset che si costruisce nel tempo, tra portfolio, code review e reputazione. Con un taglio onesto, lontano dal mito del "contribuisci e verrai assunto".
Stagione 6: Le carriere nell'ambito cloud
Cosa significa costruire una carriera nel cloud: ruoli, competenze, percorsi e realtà quotidiana del mestiere. Concetti e archetipi durevoli, non prezzi o nomi di servizi destinati a invecchiare.
Stagione 7: Il manuale tecnico: come si costruisce un'app web
Un attraversamento dell'intero stack, dal frontend al database: il "come si fa" tecnico. Non insegna a programmare in dieci puntate, ma costruisce la mappa mentale di come tutti i pezzi di un'applicazione web si incastrano.
Stagione 8: Uno sguardo storico ai CSS
La storia del CSS, dall'esperimento fragile degli inizi alla progettazione sistematica di oggi: dalla sperimentazione selvaggia alla standardizzazione del design. Il racconto di come ci siamo arrivati.
Stagione 9: Storia ed evoluzione dello sviluppo frontend
L'evoluzione dell'intera disciplina frontend — linguaggi, paradigmi, strumenti e mestiere — seguendo un filo: come sempre più intelligenza si è spostata dentro il browser, e come il frontendista sia passato dal disprezzo al rispetto.
Stagione 10: Storia ed evoluzione dello sviluppo backend
L'evoluzione del backend, dal server che consegnava file ai sistemi distribuiti su scala planetaria. Speculare alla storia del frontend: qui il filo è il server che impara a reggere la scala restando la fonte della verità.
Stagione 11: Storia dei browser e degli standard
Il browser come software e la lunga impresa collettiva degli standard del Web: dai primi anni ai motori di rendering, dalle guerre dei browser alla nascita degli standard, fino all'era mobile. Il filo conduttore è la tensione tra competizione e standard, e il valore del Web aperto.
Stagione 12: Docker
Docker dal problema che risolve fino al flusso di lavoro completo, presentato come l'implementazione popolare dell'idea di container. Un problema per puntata, con i compromessi onesti e il monito a usarlo dove serve davvero.
Stagione 13: Kubernetes
Kubernetes dal problema che risolve fino alla domanda onesta "ne ho davvero bisogno?". Seguito diretto di Docker: dà per acquisiti i container e costruisce sopra l'orchestrazione, con al centro l'idea di stato desiderato e il ciclo di riconciliazione.
Stagione 14: Git in profondità
Git spiegato costruendone il modello mentale, non elencandone i comandi: istantanee, un grafo di commit, etichette mobili, copie complete che si sincronizzano. Capire come Git pensa, così che i comandi smettano di essere magia.
Stagione 15: CI/CD e le pipeline
L'integrazione e distribuzione continua, dal problema che risolve alla cultura che la sostiene. Culminazione della trilogia pratica: unisce Git, Docker e Kubernetes in un unico flusso automatico dal commit alla produzione, con la cultura del "piccolo, spesso, senza paura".
Stagione 16: Linux e la riga di comando per sviluppatori
Linux e la riga di comando spiegati costruendone il modello mentale e la filosofia, non l'elenco dei comandi. La fondazione sotto tutto ciò che le stagioni pratiche esplorano: container, orchestratori, Git, pipeline.
Stagione 17: Storia della rete e dei protocolli
Come i computer sono passati dall'essere isole isolate al sistema nervoso connesso del mondo, costruendo lungo il percorso una comprensione reale di come funziona internet. Sta, in un certo senso, sotto la storia del Web.
Stagione 18: Storia della sicurezza sul Web
Come il Web, nato aperto e fiducioso, sia diventato uno scrigno conteso, e come — fronte dopo fronte — si sia costruita la sicurezza su un sistema nato senza. Complemento naturale della storia della rete.
Stagione 19: Basi di dati in profondità
Le basi di dati spiegate costruendone il modello mentale — perché una base di dati "pensa" come pensa — non elencandone la sintassi SQL. Dai fondamenti dei dati alle garanzie su cui poggia tutto.
Stagione 20: Storia dei linguaggi di programmazione
La lunga scalata dai numeri grezzi della macchina fino a un modo di esprimersi sempre più vicino al pensiero umano. Un piccolo traguardo — la ventesima stagione — salutato in apertura e in chiusura.
Stagione 21: L'intelligenza artificiale spiegata bene
L'intelligenza artificiale raccontata in modo onesto: senza fantascienza né hype, con chiarezza su cosa sa fare e su dove sbaglia e perché. Un'idea per puntata, per capire il modello sotto la magia.
Stagione 22: La metodologia Agile
Come lavorano i team che costruiscono software: non una tecnologia, ma un modo di organizzare il lavoro. Registro concreto e onesto, cugino della stagione su CI/CD e di quelle su carriera e team.
Stagione 23: Go
Il linguaggio Go spiegato costruendone la filosofia e il modello mentale — perché fa, e non fa, certe scelte — non elencandone la sintassi. Apre il ciclo dei linguaggi, ciascuno raccontato attraverso i suoi valori.
Stagione 24: Node.js
Node.js spiegato costruendone il modello e la filosofia — perché funziona così — non la sintassi. Dal modo di programmare guidato dagli eventi fino all'ecosistema che gli è cresciuto attorno.
Stagione 25: PHP
PHP spiegato costruendone modello, filosofia e storia — perché funziona così e perché ha la reputazione che ha. Anche il racconto di una riabilitazione: da linguaggio bistrattato a fondamenta di una parte enorme del web.
Stagione 26: Python
Python spiegato costruendone la filosofia e il carattere — perché è fatto così e perché è finito ovunque. La leggibilità come valore, e l'ampiezza di un linguaggio arrivato in ogni campo.
Stagione 27: Java
Java spiegato costruendone modello, valori e storia — perché è fatto così e perché ha la reputazione che ha. Robustezza, portabilità e la solidità di una piattaforma che ha retto il software serio per decenni.
Stagione 28: C#
C# spiegato costruendone carattere, valori e storia — perché è fatto così e perché ha avuto la traiettoria che ha. Da linguaggio di una sola casa a piattaforma aperta e multipiattaforma.
Stagione 29: CSS
Il CSS spiegato costruendone il modello e la filosofia — perché funziona così — non la sintassi. L'idea di descrivere l'aspetto invece di comandarlo, e la separazione tra contenuto e presentazione.
Stagione 30: SVG
SVG spiegato costruendone il modello e la filosofia: descrivere il disegno, non memorizzare i punti. La grafica come descrizione, coppia naturale del CSS — si dichiara cosa mostrare e si lascia alla macchina il come disegnarlo.
Stagione 31: Laravel
Laravel spiegato costruendone il modello e la filosofia — perché è fatto così e perché è amato. Il primo sguardo a cosa sia un framework: non reinventare la ruota, e mettere al centro la felicità di chi programma.
Stagione 32: Spring Boot (Java)
Spring e Spring Boot spiegati costruendone modello, valori e storia: salvare il software serio dalla complessità, con l'iniezione delle dipendenze al centro. In coppia e in contrasto con Laravel — i framework ereditano l'anima del linguaggio.
Stagione 33: WordPress
WordPress spiegato costruendone modello, missione e valori — perché è fatto così e perché è ovunque. Non un framework ma un CMS, con una missione dichiarata: dare il web alle persone, democratizzare la pubblicazione.
Stagione 34: DNS
Il DNS, il sistema dei nomi di dominio: il meccanismo invisibile che dà a internet dei nomi umani. Decentralizzazione tramite delega e cache, la fondazione sotto le fondazioni — e i temi della fiducia, degli inganni e del controllo.
Stagione 35: nginx
nginx (si pronuncia enginex), web server e reverse proxy: la porta d'ingresso efficiente del web. Dal problema delle diecimila connessioni all'architettura a eventi, fino al ruolo moderno di porta d'ingresso davanti alle applicazioni.
Stagione 36: Apache
L'Apache HTTP Server: il cavallo da soma flessibile che ha fatto girare il web, e la comunità che l'ha costruito. Modularità, flessibilità e configurazione distribuita, ma soprattutto una storia di collaborazione aperta e la fondazione che ne è nata.
Stagione 37: LiteSpeed Web Server
LiteSpeed Web Server, il web server commerciale ad alte prestazioni: il conciliatore che ha unito la compatibilità di Apache all'efficienza di nginx. E' un rimpiazzo trasparente di Apache (ne legge la configurazione) ma gira su un motore a eventi, e aggiunge tratti suoi votati alla velocita': la cache incorporata e intelligente, il ponte veloce verso il linguaggio, la prontezza sui protocolli piu' nuovi. Prodotto commerciale, regna nella nicchia dell'ospitalita' dei siti dinamici. Chiude la trilogia dei web server (nginx, Apache, LiteSpeed).
Stagione 38: cPanel
cPanel, il piu' diffuso pannello di controllo dell'ospitalita' web: il cruscotto grafico da cui si amministra un server senza digitare comandi. Poggia su due grandi idee — nascondere la complessita' (l'astrazione) e democratizzare l'amministrazione, aprendola a chi non e' esperto. E' un integratore che da' un volto unico a tanti servizi (web server, posta, DNS, base di dati, linguaggio, certificati), si divide in due livelli (l'utente e il fornitore) e ha industrializzato l'ospitalita' condivisa. Prodotto commerciale, la sua storia insegna il rischio del lock-in; e la comodita' ha un prezzo onesto: cio' che ci permette di non imparare. La faccia umana posata sopra la macchina.
Stagione 39: Plesk
Plesk, il grande rivale di cPanel tra i pannelli di controllo dell'ospitalita' web: stesso mestiere, filosofia diversa. Le sue quattro scelte distintive: vive in due mondi (non solo Linux ma anche Windows, il mondo delle tecnologie Microsoft e del C#/.NET), offre un cruscotto unificato invece di due facce separate, guarda agli sviluppatori (Git integrato, contenitori, flussi moderni) ed e' una piattaforma estensibile invece di una cassetta chiusa. Include uno strumento dedicato per gestire WordPress su scala (con le copie di prova) e la sicurezza attiva di default. Con un fatto onesto: oggi cPanel e Plesk hanno lo stesso proprietario — una lezione sulla consolidazione del mercato e sul chiedersi chi possiede le proprie opzioni. Insieme a cPanel forma un dittico: non esiste il pannello migliore in assoluto, solo quello giusto per te.
Stagione 40: DirectAdmin
DirectAdmin, il terzo grande pannello di controllo dell'ospitalita' web: il leggero, l'economico, l'indipendente. Dove cPanel e' lo standard ricco e Plesk il camaleonte versatile, DirectAdmin fa la scommessa opposta: meno e' meglio. Consuma pochissime risorse ed e' veloce (la filosofia della leggerezza); costa poco, con un prezzo semplice che apre la porta a chi ha meno mezzi (democratizzazione per accessibilita'); e' robusto proprio perche' semplice (poche parti, pochi guasti); copre l'essenziale e lascia l'abbondanza ai giganti; ti lascia scegliere il web server sotto. Ma il suo valore piu' grande e' l'indipendenza: con un proprietario diverso da quello dei due giganti, e' l'antidoto al duopolio, e tiene onesto il mercato anche per chi non lo usa. Con lui i pannelli diventano una trilogia: non esiste il migliore in assoluto, solo quello giusto per te.
Stagione 41: Redis
Redis, la memoria velocissima del web: un archivio che tiene i dati nella memoria di lavoro invece che sul disco, ed e' per questo fulmineo. Organizza tutto con il modello piu' semplice — chiave e valore — ma il suo vero superpotere e' che i valori possono essere strutture ricche (liste, insiemi, insiemi ordinati, schede): per questo si chiama server di strutture di dati. Da velocita' e strutture nascono i suoi mestieri, che ne fanno il coltellino svizzero del backend: fare da cache davanti alle basi di dati, ricordare le sessioni con dati che scadono da soli, tenere classifiche e contatori in tempo reale, far parlare le parti di un sistema con messaggi e code. Con la persistenza per salvare su disco, e la vicenda attuale della licenza e del fork Valkey — chi possiede un bene comune. Nato da uno sviluppatore italiano.
Stagione 42: Apache Kafka
Apache Kafka, la piattaforma di flussi di eventi costruita su un'unica idea potente: il registro (log) ordinato, immutabile, su cui si scrive solo aggiungendo in fondo. Non una coda che si svuota, ma un diario di eventi che si legge senza consumare e si puo' rileggere. Da quel seme nasce tutto: produttori che scrivono e consumatori che leggono, ognuno col proprio segnalibro (offset) per essere indipendente e riavvolgere la storia; argomenti e partizioni per crescere oltre una singola macchina; un gruppo di macchine con copie replicate per essere durevole e affidabile. E soprattutto un modo diverso di pensare, dallo stato alla storia, che fa di Kafka il sistema nervoso dei dati di un'organizzazione, un hub centrale che sostituisce il groviglio dei collegamenti diretti. Con l'onestà sul suo peso: magnifico per i problemi grandi, sproporzionato per quelli piccoli. Nato in LinkedIn, oggi progetto aperto della fondazione Apache. Accanto a Redis, forma una coppia complementare: la memoria fugace e il registro durevole.
Stagione 43: API REST
Le API REST, il modo più diffuso sul web di far parlare i programmi tra loro. L'idea geniale: far parlare i programmi usando il web stesso, la stessa macchina che muove i browser. REST modella ogni cosa come una risorsa, un sostantivo, e le da' un indirizzo come le pagine del web; agisce su di essa con pochissimi verbi universali, gli stessi per tutte (leggere, creare, modificare, cancellare): l'interfaccia uniforme. Tiene ogni richiesta completa in se', senza memoria sul server, cosi' qualunque macchina puo' servirti; risponde con un linguaggio condiviso di codici di stato; e scambia rappresentazioni, fotografie delle cose, quasi sempre scritte nel formato di testo comune, il JSON. Un'API ben fatta e' un prodotto, progettato con empatia per chi la userà: coerente, prevedibile, stabile come una promessa. Con l'onestà sui suoi limiti (dare troppo o troppo poco) e sulle alternative (GraphQL, gRPC): nessuno strumento è il migliore in assoluto. Le API sono il tessuto connettivo che fa di tanti sistemi separati un ecosistema. Chiude l'arco del codice accanto a Redis e Kafka.
Stagione 44: GraphQL
GraphQL, lo stile con cui e' il cliente a chiedere esattamente i dati che vuole. Nato per curare un dolore reale di REST (ricevere troppo o troppo poco, con tanti viaggi), ribalta chi tiene la penna: non e' piu' il server a decidere la forma della risposta, ma il cliente, che la descrive e la riceve su misura, in una sola richiesta. Il nome indica il cuore dell'idea: i dati sono un grafo, una rete di cose connesse (un utente ai suoi articoli, un articolo ai commenti, un commento al suo autore) che percorri seguendo i fili. Tutto e' garantito da uno schema tipizzato e auto-descrittivo, insieme menu' e contratto; si passa da una sola porta, dove e' la richiesta a portare il significato; e ci sono operazioni chiare per leggere, cambiare e restare in ascolto dei dati dal vivo. Dietro le quinte non e' un magazzino, ma uno strato che unifica tante fonti diverse in un unico grafo pulito. Con l'onestà sui suoi costi (il caching piu' difficile, le richieste rovinosamente costose da recintare, l'eccesso sui problemi semplici) e sulla bussola di sempre: nessuno strumento e' il migliore in assoluto, e spesso GraphQL e REST convivono. Accanto a REST, forma una coppia complementare: il server che decide la forma, e il cliente che la decide.
Stagione 45: JavaScript
Il linguaggio che non doveva contare, e ha conquistato il mondo. Colma un vuoto del catalogo: dopo la stagione su Node.js (il runtime), questa è dedicata al linguaggio in sé — al suo carattere e alle sue poche idee peculiari, il modello sotto la magia. Dieci puntate: l'origine e il monopolio del browser; il ciclo degli eventi e il lavoratore che non aspetta mai; le funzioni come valori e le chiusure; l'evoluzione gentile del tempo (dal richiamo alla promessa); gli oggetti fatti di oggetti (i prototipi); la morbidezza dei tipi come dono e tranello; lo standard vivente che cresce e non rompe; l'episodio onesto sui limiti e su TypeScript; e la sintesi finale — vince chi c'è, e chi cresce con te.
Stagione 46: TypeScript
Uno strato di pensiero steso sopra JavaScript, che esiste solo mentre scrivi. Continuazione naturale della stagione su JavaScript: dopo il linguaggio che gira, lo strato di controllo che lo accompagna e poi svanisce. Dieci puntate sul carattere e sulle idee di TypeScript, non sulla sintassi: i tipi che spariscono prima di girare; il correttore che nell'editor ti fa da partner; il giudizio per forma e non per nome (la tipizzazione strutturale); l'inferenza che rende la sicurezza a buon mercato; il vuoto reso esplicito; il cursore della severità che regoli tu; il sistema utile-non-perfetto che mente apposta; il linguaggio dentro il linguaggio dei tipi che calcolano; i limiti onesti (svanisce a runtime, è un allarme non una garanzia); e la sintesi finale: TypeScript ha vinto non per la macchina, ma per le persone che si passano il codice nel tempo.
Stagione 47: gRPC
La terza e ultima risposta all'arco 'come parlano i programmi', dopo API REST e GraphQL: gRPC, la chiamata di procedura remota moderna. Dieci puntate sul carattere e sulle idee, non sulle API: cancellare la distanza (far sembrare locale una chiamata remota); il contratto scritto prima di tutto, da cui si genera il codice in ogni linguaggio; il binario compatto invece del testo leggibile; il canale sempre aperto e le quattro forme di conversazione; il poliglottismo che nasce da una fonte comune; l'evolvere senza rompere coi numeri dei campi; lo specialista che conosce la sua corsia (gRPC dietro le quinte, REST alla porta); la verità profonda che la distanza non sparisce mai davvero (gli errori del calcolo distribuito); i costi onesti; e la sintesi che chiude l'arco: risorse, grafo e funzioni chiamate sono tutte, alla radice, contratti tra programmi, perché il software è costruito su accordi.
Stagione 48: Next.js
Il framework che sposta il confine tra server e client. Naturale seguito di JavaScript e TypeScript sul versante frontend, e chiusura ideale dell'arco su come i programmi si parlano: le azioni sul server di Next sono la chiamata di procedura remota rinata nel frontend. Dieci puntate sul carattere e sulle idee, non sulle API: il vuoto che React lascia e il framework che lo riempie di opinioni; la domanda centrale su dove gira ogni pezzo (server o browser); il momento in cui si costruisce la pagina come scelta pagina per pagina; il mostrare-prima-animare-dopo e l'idratazione; la cartella che diventa la mappa (convenzione al posto della configurazione); il pendolo del web che torna al server, più saggio; il confine cancellato di nuovo dalle azioni sul server; e i prezzi onesti — l'opacità della magia (la cache) e la domanda se il framework serva davvero. In fondo, una sola idea: la fine del muro tra frontend e backend, un solo programma che vive in due posti — perché i confini sono scelte, non leggi di natura, e ogni comodità che fa sparire una distanza ne nasconde una che c'è ancora.
Stagione 49: Vue.js
Il framework che ti viene incontro. Seguito naturale della catena del frontend (JavaScript, TypeScript, Next.js), ma con un temperamento opposto a quello della stagione scorsa: dove Next decide tutto per te, Vue punta su due pilastri suoi — la reattività (l'interfaccia che si tiene in accordo con i dati da sola) e l'avvicinabilità (lo usi un pochino o del tutto, partendo da ciò che già sai). Dieci puntate sul carattere e sulle idee, non sulle API: la reattività come cuore, l'interfaccia vista come un foglio di calcolo che si ricalcola da solo; la gradualità del framework progressivo (da libreria in un angolo a framework completo, su un pendio dolce); il componente in un solo file (co-locazione: metti insieme ciò che cambia insieme); il template che parte dall'HTML e lo arricchisce, fino al legame a doppio senso; il dialogo tra i pezzi, dati in giù ed eventi in su; i due modi di scriverlo, per categoria e per funzionalità, e perché ne è cresciuto un secondo; e i prezzi onesti — il lato in ombra della sua stessa magia (quando la reattività sorprende) e il suo posto tra le alternative (ecosistema, comunità, governance indipendente). In fondo, il framework gentile: in un campo che premia la potenza, ha scommesso sull'avvicinabilità e sull'eleganza — perché l'avvicinabilità è una virtù vera e sottovalutata, e lo scopo di tutta questa macchina è lasciarti smettere di pensare alla macchina.
Stagione 50: Il lavoro del team
Un traguardo: la cinquantesima stagione. Dopo quarantanove stagioni sulle macchine — linguaggi, strumenti, infrastrutture, protocolli, framework — la lente gira sull'altra macchina, quella di cui non parliamo mai abbastanza: il gruppo di persone che scrive il software. È il pensiero verso cui il podcast si è affacciato tre volte di fila, chiudendo le stagioni scorse: dietro ogni sistema ci sono le persone che lo costruiscono, e i loro accordi. La lente: la macchina più difficile da tenere in accordo non è il computer, sono le teste di chi costruisce insieme — e tutto ciò che un team fa (revisione, scrittura, disaccordo, fiducia, coordinamento) è un meccanismo per tenere allineata la comprensione umana. Non consigli da manuale, ma le idee di fondo di un sistema fatto di persone, con le sue leggi e i suoi modi di rompersi: il vero collo di bottiglia (capirsi, coi modelli mentali che derivano); la revisione come conoscenza che si diffonde; lo scrivere per far viaggiare la comprensione tra le persone e nel tempo; il disaccordo sano (idea contro persona, dissentire e poi remare insieme); la fiducia che permette di dire "ho sbagliato" (l'analisi del guasto senza colpa); l'eroe come rischio e la conoscenza da spargere (il punto singolo di rottura umano); il costo del coordinamento (perché più persone spesso rallenta); e la chiave di volta, la legge di Conway: il software rispecchia il gruppo che lo costruisce, le interfacce sono gli accordi tra le persone — l'idea che lega le quarantanove stagioni tecniche a questa umana. In fondo, la verità di tutto il podcast: il software è un artefatto umano, non lo capisci senza capire le persone, perché è la loro comprensione condivisa resa eseguibile — e le abilità umane sono le abilità profonde.
Stagione 51: La carriera del developer
Prosegue il versante umano aperto dalla stagione precedente, ma sposta il fuoco dal gruppo nel presente all'individuo nel tempo: l'arco lungo di una vita di lavoro. Non di come si entra — colloqui, prime assunzioni, primi passi, di cui parlammo agli inizi — ma di cosa succede dopo, negli anni e nei decenni. L'immagine comune è la scala (stessi gradini, solo più in alto); la verità è che una carriera è una serie di lavori diversi che per caso condividono lo stesso nome — chi comincia risolve il compito, chi è esperto sceglie quale compito valga la pena, chi guida fa lavorare bene un gruppo. La lente: una carriera non è salire più in alto nello stesso lavoro, è scoprire di continuo che il tuo lavoro è diventato un altro, e la meta-abilità che decide chi cresce e chi si ferma è accorgersene e re-imparare il mestiere. Dieci puntate come la forma di un sistema che è la tua vita di lavoro, con le sue fasi, le sue trappole e i suoi modi di andare storta: la prima trasformazione (dall'esecuzione al giudizio); la trappola dell'esperto che ha smesso di imparare (l'esperto principiante); il bivio tra restare tecnici e guidare (un cambio di mestiere, non un premio); il moltiplicatore (dal fare al far fare, la leva oltre le proprie mani); come restare aggiornati ordinando la superficie che cambia e i fondamentali che durano; il costo nascosto del logoramento e la sostenibilità della partita lunga; la reputazione che ti precede in un mondo piccolo; e la domanda più difficile, cosa vuol dire davvero riuscire (il successo come corrispondenza ai propri valori, non come grado). In fondo, un pensiero solo: una carriera non è qualcosa che ti capita, è qualcosa che scrivi — non sei la tua produzione né il tuo titolo, sei una persona che vive una vita di lavoro, e sei tu a scriverla, una scelta alla volta.
Stagione 52: Sicurezza delle API
Ritorno alla macchina dopo le due stagioni sulle persone: la sicurezza degli accordi con cui i programmi si parlano, le interfacce, quelle che chiamiamo comunemente le API. È lo sviluppo di due fili già aperti: la storia della sicurezza del Web e l'arco su come parlano i programmi (le interfacce come contratti tra software). Un'interfaccia è una porta che apri di proposito nel muro del tuo sistema, e ogni porta per le persone giuste è anche una porta per quelle sbagliate; fuori da quella porta non controlli niente e non conosci nessuno. La tesi che tiene insieme dieci puntate è una sola: il server non deve mai fidarsi del client. Tutto ciò che arriva da fuori (la richiesta, i dati, l'identità dichiarata) è un'affermazione, non un fatto, e va verificato a ogni passaggio; quasi ogni falla, quando la smonti, è un momento in cui il server si è fidato di qualcosa di cui non doveva. Dieci difese, che sono la stessa idea applicata in posti diversi: il confine di fiducia; l'autenticazione (chi sei) e l'autorizzazione (cosa puoi fare, col buco più comune di tutti, quello per cui basta cambiare un numero nella richiesta per vedere i dati altrui); le iniezioni, dove i dati si travestono da comandi; la cifratura del canale, contro chi ascolta la conversazione allo scoperto; il limitare le richieste, perché anche il solo volume è un attacco e l'accesso illimitato è di per sé una vulnerabilità; il non dire troppo, contro i dati che trapelano; la custodia dei segreti, le chiavi del regno; e la difesa a strati, che dà per scontato di essere violati e punta a contenere il danno. Il filo che le unisce: verificare, invece di presumere. Perché la sicurezza non è un prodotto che compri o una funzione che aggiungi alla fine: è una postura, un modo di stare mantenuto in ogni richiesta e in ogni decisione, come l'igiene. E, come le stagioni precedenti insegnano, fallisce quasi sempre per ragioni umane, la fretta e l'eccesso di fiducia, il che la rende anche una disciplina di squadra e di carriera; non puoi mettere in sicurezza ciò che non capisci.
Stagione 53: PostgreSQL
Il carattere di una base di dati: fiducia ed estensibilità. Non la sintassi, ma il modello sotto la magia — transazioni, versioni multiple, pianificatore, indici, registro di scrittura, integrità — e perché Postgres, open source e noioso, ha vinto sulla distanza.
Stagione 54: MySQL
Il carattere del database che ha costruito il web: pragmatismo, ubiquità e modularità. Non la sintassi, ma il modello sotto la magia — l'architettura a motori, i due motori storici, transazioni e blocchi, la replica, gli indici, la permissività e la storia di Oracle e MariaDB. Il dittico si chiude con Postgres: il delfino e l'elefante.
Stagione 55: MongoDB
Il carattere del grande database a documenti: il modello a documenti, la flessibilità e la scalabilità orizzontale. Non la sintassi, ma il modello sotto la magia — tenere insieme ciò che si usa insieme, duplicare o collegare, la pipeline di aggregazione, le repliche e lo spezzettamento, il compromesso tra velocità e garanzia, e la storia della licenza tra open source e cloud. Trattato con equanimità, chiude la trilogia dei dati con Postgres e MySQL: non c'è una sola forma giusta.
Stagione 56: ScyllaDB
Il quarto movimento dell'arco sui database: non una nuova forma di dati, ma una nuova ossessione per la velocità e la scala. ScyllaDB è la riscrittura di Apache Cassandra vicina al metallo, con l'architettura senza condivisione (un nucleo per ogni lavoratore) e la distribuzione senza padrone. Dieci puntate su efficienza sull'hardware, modello a colonne larghe, chiave di partizione, progettazione a partire dalle domande, distribuzione tra pari, consistenza regolabile, strategia della compatibilità e, in chiusura, la lezione del rispetto per la macchina.
Stagione 57: ORM
Dopo l'arco sui database, l'ORM: il ponte tra gli oggetti del codice e le tabelle del database. Dall'incastro imperfetto ad Active Record e Data Mapper, dalla sessione invisibile al flagello N+1, da caricamento pigro e impaziente alle migrazioni e alla portabilità, fino alla sintesi matura del mappatore-e-linguaggio-del-database. Il caso più puro della tesi del podcast: non puoi usare bene la magia senza capire la macchina sotto.
Stagione 58: Nuxt.js
Il meta-framework di Vue. Dopo la libreria (Vue) e il fratello di React (Next), Nuxt: l'impalcatura completa costruita attorno a Vue. Dal rendering universale all'idratazione, dalle convenzioni al motore server full-stack, dai dati nel posto giusto a visibilità e prestazioni, fino a quando serve davvero. La tesi del podcast spostata sul frontend: il framework è la magia, la piattaforma web è la macchina.
Stagione 59: Psicologia cognitiva e lavoro in team
La stagione che gira la lente verso l'interno. Dopo aver studiato la macchina sotto il software, studiamo la macchina sotto lo sviluppatore: la mente, individuale e collettiva. Dal carico cognitivo all'attenzione, dai modelli mentali ai bias, dal terreno comune alla cognizione distribuita, dalle decisioni di gruppo al processo. La tesi del podcast nella sua versione più personale: la magia è pensare senza sforzo, la macchina è la mente che devi imparare a conoscere.
Stagione 60: WebAssembly
La stagione del traguardo tondo, dedicata a una tecnologia che è, letteralmente, una macchina. WebAssembly non è un linguaggio ma un bersaglio di compilazione: una macchina astratta universale, veloce, portabile e sicura insieme, che disaccoppia il linguaggio che scrivi dal luogo dove il codice gira. Dalla sua nascita come corsia veloce accanto a JavaScript nel browser fino alla sua fuga verso server e margini della rete, con il recinto di sicurezza che porta sempre con sé. La tesi del podcast, capire la macchina sotto la magia, qui diventa reale: sotto la magia c'è un processore vero, progettato per essere capito fino in fondo.
Stagione 61: Caching
La stagione dedicata a uno dei trucchi più potenti e universali dell'informatica: tenere una copia veloce a portata di mano. Non uno strumento, ma un principio che compare a ogni livello, dal cuore del processore ai depositi sparsi per il pianeta. Poggia su due pilastri: perché la cache funziona, cioè la ripetizione del mondo (le stesse cose tornano richieste); e perché la cache è difficile, cioè la divergenza delle copie dall'originale, da cui i due grandi problemi dell'invalidazione e dello sfratto. Sotto la magia della velocità c'è sempre lo stesso baratto silenzioso: rinunciare a un po' di spazio e di freschezza in cambio di rapidità.
Stagione 62: La legge di Amdahl
Una delle idee più semplici e spietate dell’informatica: perché “basta aggiungere risorse” smette di funzionare. La legge di Amdahl e le sue conseguenze — il soffitto posto dalla parte seriale, i rendimenti calanti, il collo di bottiglia che comanda, il prezzo del coordinamento, la legge tra le persone, i computer di oggi, le vie di fuga e la risposta di chi fa crescere il problema. Una stagione su dove esistono i limiti e su dove conviene davvero concentrare lo sforzo.
Stagione 63: Concorrenza e parallelismo
Concorrenza e parallelismo sembrano sinonimi, ma sono due idee diverse: la concorrenza è come organizzi il lavoro in attività indipendenti, il parallelismo è farle davvero nello stesso istante. In dieci puntate esploriamo la distinzione tra struttura ed esecuzione, l'illusione della simultaneità, il ruolo dell'attesa, e il grande pericolo dello stato condiviso, con le sue cure: i lucchetti e lo scambio di messaggi. Fino alla domanda pratica: quale modello scegliere, attese o calcolo?
Stagione 64: Assembly
La macchina nuda sotto ogni programma. La magia e' il codice comodo e umano che scrivi, fatto di cicli, funzioni e nomi; la macchina sotto e' una sequenza di istruzioni elementari e ottuse che spostano numeri tra registri e memoria, una alla volta. Dieci puntate per capire come pensa davvero un processore: perche' e' stupido (e perche' questo e' il suo segreto), dove vivono i numeri, come nascono cicli e funzioni dai soli salti, cos'e' la pila, chi traduce il codice in numeri, perche' i processori parlano dialetti diversi, e se convenga ancora imparare l'assembly. Un legame diretto con lo studio del C++ e con WebAssembly.
Stagione 65: Pair programming con l'IA
Programmare in coppia con l'intelligenza artificiale. La magia e' avere accanto un partner che sembra un genio: chiedi, e il codice appare. La macchina sotto e' una verita' a due facce: cos'e' davvero lo strumento (un motore che prevede testo plausibile, senza capire e senza responsabilita') e chi resti tu (l'ingegnere, l'unico responsabile). Dieci puntate su come chiedere, verificare, scegliere i compiti e non smettere di capire. L'IA e' la magia; l'ingegneria sei ancora tu.
Stagione 66: Analisi della sicurezza di un'applicazione web con l'IA
Usare l'IA per analizzare la sicurezza di un'applicazione web, senza illusioni. La magia e' avere un guardiano automatico che trova i buchi per te; la macchina sotto e' che la sicurezza e' un modo di pensare avversariale e un processo continuo, e un sembra sicuro dell'IA e' la rassicurazione piu' pericolosa, perche' una falla e' invisibile finche' qualcuno non la sfrutta. Dieci puntate difensive tra il pensare come un attaccante, le vulnerabilita' classiche, l'IA come revisore, la spada a doppio taglio e la sicurezza come processo: perche' lo strumento sta nella tua cintura, ma il guardiano sei tu.
Stagione 67: Compilatori
Come il codice che scrivi diventa un programma che gira. Il compilatore raccontato come un traduttore che lavora per fasi comprensibili: legge, capisce, ottimizza, produce. Traduttore non fotocopiatore, la regola del come se, front-end e back-end, l'onesta' del compilatore che obbedisce senza capire, lo spettro tra compilare e interpretare, la catena di build e, in fondo, nessuna magia: solo strati di traduzione, ingegneria fino in fondo.
Stagione 68: Semantica operazionale
Cos'e' il significato di un programma? La semantica operazionale lo definisce descrivendo come viene eseguito, passo per passo: stato e passo, le regole del gioco, gli esiti di un'esecuzione, i tipi come promessa. Seguito diretto della stagione sui compilatori: se il compilatore preserva il significato, qui scopriamo cos'e' il significato. Capire e' eseguire.
Stagione 69: Testing
Testing: cosa dimostra davvero un test, e cosa non potra' mai dimostrare. Un test e' un esperimento che raccoglie prove, non una dimostrazione. Dall'anatomia del test alla piramide, dalle controfigure allo sviluppo guidato dai test, dai test basati sulle proprieta' alla domanda su quanto testare. La tesi: il testing e' dubbio sistematico, e fidarsi del proprio codice vuol dire averlo messo alla prova.
Stagione 70: Internals dei sistemi operativi
La settantesima stagione scende sotto la magia piu' grande di tutte: il sistema operativo. Dieci puntate per capire come un programma speciale gestisce una macchina scarsa e condivisa e crea, per ogni programma, l'illusione di possederla tutta - processi, scheduling, memoria virtuale, filesystem, dispositivi - e per imparare a vedere la macchina sotto la magia, con i suoi costi, i suoi limiti e i suoi compromessi.
Stagione 71: Sistemi distribuiti
Dieci puntate per capire i sistemi distribuiti senza illusioni: perche' mettere insieme tanti computer non li rende un unico super-computer infallibile, ma un arcipelago di macchine separate che si parlano su una rete inaffidabile. Dalla rete-avversario al tempo che si frantuma, dai guasti ambigui alla replica, dal consenso al teorema CAP, fino agli schemi per scalare e ai conti onesti su quanto tutto questo costa. La rete e' un avversario, il guasto e' il clima: si sceglie con gli occhi aperti, dato per dato.
Stagione 72: Osservabilita' e monitoring
Osservabilita' e monitoring: imparare a vedere dentro i sistemi che costruiamo. Un sistema e' muto e opaco per natura, e ogni cosa che vedi l'hai costruita tu, potendo rispondere solo alle domande che avevi previsto. Metriche, registri e tracing; allarmi che chiamano all'azione; livelli di servizio e budget di errore; gestione degli incidenti senza colpe; e i costi onesti del vedere. Dalla magia del cruscotto verde al mestiere umile di costruire la visibilita' giusta.
Stagione 73: DevOps
La stagione che chiude l'arco operativo (sistemi operativi, sistemi distribuiti, osservabilita') risalendo dagli strumenti alla cultura. DevOps non e' un insieme di strumenti da comprare ne' un reparto a cui delegare: e' la scelta culturale di abbattere il muro tra chi costruisce e chi manda in produzione, cosi' che le stesse persone possiedano una cosa dall'idea alla produzione e ne sentano le conseguenze. Dieci puntate su flusso, infrastruttura come codice, automazione, qualita' costruita dentro, velocita' e stabilita', la pratica del rilascio e i limiti onesti della disciplina. Metafora portante: la fabbrica e la catena di produzione.
Stagione 74: Il web design tra standard e omologazione
Perche' il web di oggi tende a somigliare a se stesso, e come distinguere gli standard (interoperabilita', accessibilita', durata: l'essere capiti) dall'omologazione (il sembrare identici). Dagli standard come grammatica non stile alle cause reali della somiglianza, dai costi alla dose giusta dei kit di componenti, fino a ritrovare una voce: conformarsi dove serve l'umano, esprimersi dove serve il significato.
Stagione 75: Architettura event-driven
L'architettura event-driven raccontata con la metafora della redazione e del giornale: un evento e' un fatto, non un comando, e il disaccoppiamento non scompare, cambia forma. Dieci puntate dal mondo a domanda e risposta fino al pubblicare e sottoscrivere, l'archivio dei fatti, il flusso continuo, il progetto degli eventi e la misura di quando gli eventi convengono davvero. Magia e macchina tenute insieme: gli eventi disaccoppiano, scalano e durano, ma ogni vantaggio e' un baratto di cui conoscere il prezzo.
Stagione 76: Database internals
I database internals raccontati con la metafora della biblioteca: il banco e il magazzino, lo schedario e il registro scritto prima di essere vero. Un database e' l'arte di fingere che il disco sia veloce come la memoria e che la corrente non vada mai via, e ogni interno combatte uno di due nemici: il disco lento o il crollo improvviso. Dieci puntate dalla pagina al buffer pool, dagli indici ai due modi di tenere l'ordine, dal registro alle transazioni, dalla concorrenza al pianificatore delle query. Il ritornello di tutta la stagione: veloce in lettura, veloce in scrittura, o compatto, puoi sceglierne due.
Stagione 77: L'implementazione di un rendering engine
Come un browser trasforma HTML e CSS in pixel, raccontato con la metafora del teatro: il copione messo in scena e tenuto vivo, un fotogramma alla volta. Una pagina non e' un disegno, e' il risultato di una catena di trasformazioni da una descrizione a dei pixel, e ogni modifica rientra nella catena a un'altezza che e' il suo prezzo. Dieci puntate dal testo all'albero, dalla cascata al layout, dal disegno al compositing, fino al ritmo dei fotogrammi e all'arte di non ricalcolare cio' che non e' cambiato. Magia e macchina insieme: il browser non disegna la pagina, la ricalcola.
Stagione 78: Server-side rendering (SSR)
Il rendering lato server raccontato con la metafora della cucina e della sala: una pagina e' un piatto, e costruirla e' cucinarlo, in cucina o al tavolo, in anticipo o su ordinazione. Il rendering non e' se, ma dove e quando, e lo stesso lavoro non sparisce: lo sposti, e a volte lo paghi due volte. Dieci puntate dal confronto tra cucina e tavolo all'idratazione e al suo costo, dai dati allo streaming, dalla cache e i bordi alle isole di interattivita'. Magia e macchina insieme: il meglio dei due mondi non e' gratis, e' un menu di compromessi su dove e quando avviene il cucinare.
Stagione 79: Networking in Kubernetes
Il networking di Kubernetes raccontato con la metafora del grande palazzo di uffici: reparti, centralino, rubrica e reception. E' l'arte di dare un indirizzo stabile a cose che non lo sono, perche' non chiami mai una persona ma un reparto, e dietro ogni nome stabile un ciclo aggiorna di continuo chi risponde. Dieci puntate dalla rete piatta ai Service, dalla scoperta dei servizi al funzionamento vero del centralino, dall'Ingress alle regole di accesso, dai plugin di rete al service mesh. Magia e macchina insieme: non una rete che sa dove sono le cose, ma una pila di illusioni tenute vive da cicli che riscrivono regole.
Stagione 80: Parallelismo
Il parallelismo raccontato con la metafora del trasloco: tante braccia, una casa. La velocita' non si compra a mani, si compra a indipendenza, perche' il parallelismo non e' fare molte cose insieme, ma fare insieme solo cio' che non dipende da altro. Dieci puntate dalle dipendenze al tetto di Amdahl, dalla crescita di Gustafson al costo del coordinamento, dallo stato condiviso alle forme per dividere, dalla scala dell'hardware a quando non parallelizzare affatto. Stagione milestone, l'ottantesima: magia e macchina insieme, piu' braccia aiutano solo il lavoro indipendente, e certe cose vanno comunque un passo alla volta.