Tutte le lezioni

Distinguere bug, limitazione, richiesta di funzionalità e malinteso d'uso; capire perché la stessa parola non può coprire tutto.

Output: Tassonomia personale con criteri di classificazione.

Capire perché alcuni errori fermano il programma prima di partire, altri durante l'esecuzione, altri ancora restano nascosti pur producendo un risultato sbagliato.

Output: Schema con esempio per ciascuna famiglia.

Installare e configurare browser aggiornato con DevTools, editor con linter integrato, terminale e runtime locale.

Output: Postazione pronta e screenshot di verifica.

Costruire un vocabolario minimo: runtime, stack, heap, payload, fixture, regressione, throttling, source map, snapshot, postmortem.

Output: Glossario personale del corso.

Distinguere descrizioni emotive, sintomi tecnici, passaggi riproducibili e ipotesi non verificate, usando un template canonico (titolo, ambiente, passi, atteso, osservato, evidenze, severità).

Output: Template bug report compilato.

Classificare un difetto in modo che prossimo passo, severità e responsabile siano deducibili dalla categoria.

Output: Matrice categoria/severità/priorità.

Capire quali informazioni rendono un errore confrontabile tra computer, browser, account e ramo di codice diversi.

Output: Scheda ambiente minima.

Ridurre un problema senza cancellare proprio la condizione che lo fa comparire; conoscere acronimi MCVE/MRE come pratica condivisa.

Output: Caso minimo e passaggi numerati.

Separare cosa dovrebbe accadere, cosa accade davvero e quanto spesso accade, e iniziare a registrare la sessione in un taccuino strutturato (ipotesi, prove, esiti, link).

Output: Mappa dei sintomi più taccuino della sessione.

Leggere tipo, messaggio, file, riga e contesto distinguendo Error, TypeError, RangeError, SyntaxError e usando name, message, cause senza fermarsi alla prima parola spaventosa.

Output: Glossario degli errori frequenti.

Seguire la catena delle chiamate distinguendo punto in cui esplode e punto in cui nasce la causa, comprendendo l'ordine LIFO dello stack.

Output: Mappa dello stack.

Riconoscere lo stesso schema sotto messaggi diversi: NullPointerException (Java/Kotlin), nil (Swift), KeyError e TypeError (Python), Segmentation fault (C/C++), panic (Go, Rust).

Output: Tabella linguaggio/errore/equivalente JS.

Capire perché non tutti gli errori parlano nello stesso modo e alcuni non generano eccezioni; introdurre il concetto di assert.

Output: Tabella sintomo/categoria.

Leggere 400, 401, 403, 404, 409, 422, 429, 500, 502, 503, 504 come segnali su input, permessi, conflitti, rate limit, server e gateway; usare curl o httpie oltre al pannello Network.

Output: Checklist per errori API.

Scrivere log che rispondono a una domanda precisa, usare console.group/table/time/assert per dare struttura e rimuoverli o trasformarli dopo la diagnosi.

Output: Traccia di log leggibile.

Fermare il programma nel punto giusto con breakpoint condizionati e logpoint, osservare variabili e impostare exception breakpoint senza modificare il codice.

Output: Sequenza commentata di osservazioni.

Capire se il difetto vive nel client, nella richiesta, nel server o nei dati ricevuti; usare filtro per tipo, throttling e replay della richiesta.

Output: Scheda richiesta/risposta.

Distinguere localStorage, sessionStorage, cookies, IndexedDB e cache del Service Worker; sapere quando il dato persiste e quando no.

Output: Mappa dato sorgente/dato persistito/dato renderizzato.

Confrontare stato applicativo, DOM renderizzato e props/store del framework con estensioni dedicate (React DevTools, Vue DevTools, Svelte Inspector, Redux DevTools).

Output: Confronto stato/DOM annotato.

Impostare prove che confermano o smentiscono una sola spiegazione possibile e usare la tecnica del rubber duck per esplicitare assunzioni nascoste.

Output: Registro ipotesi/prova/esito.

Spegnere parti del sistema con feature flag o commenti chirurgici senza introdurre nuovi bug e senza perdere il sintomo.

Output: Percorso di riduzione documentato.

Tagliare lo spazio di ricerca con confronti a metà, diff e cronologia Git; usare git bisect interattivo e git bisect run con uno script di verifica.

Output: Commit sospetto motivato e script di bisect.

Capire il principio del delta debugging: ridurre input o codice in modo automatico fino al minimo che fa fallire il programma.

Output: Input minimo conservato come fixture.

Riconoscere input incompleti, duplicati, ordinamenti inattesi, valori limite, NaN, null, stringhe vuote, encoding misti; collegare al testing classico (boundary value, equivalence partitioning).

Output: Set di dati di prova classificato.

Separare la correzione necessaria da refactor e pulizie che rischiano di confondere la verifica, anche quando il codice toccato fa prudere le mani.

Output: Diff annotato.

Trasformare il bug trovato in una verifica automatica o E2E (Playwright/Cypress, snapshot, asserzioni mirate) che fallisce prima del fix e passa dopo.

Output: Test o procedura di regressione.

Controllare il caso principale, un caso vicino, un caso limite e un caso che non deve cambiare prima di dichiarare chiuso il bug.

Output: Checklist post-fix.

Decidere consapevolmente tra correggere in avanti, fare git revert, usare git reset locale o aprire un branch hotfix, valutando rischio e urgenza.

Output: Albero decisionale fix-forward/revert.

Rendere comprensibile nel tempo cosa è stato corretto, perché e come è stato verificato, usando Conventional Commits e la regola 50/72 per oggetto e corpo.

Output: Commit message e nota di release breve.

Formulare una richiesta che include contesto, prove già fatte e punto esatto in cui si è bloccati, prendendo spunto dalla tradizione How To Ask Questions The Smart Way.

Output: Messaggio di handoff e link di riproduzione.

Classificare un ticket per impatto, urgenza, proprietario e scadenza così che la coda non diventi caos.

Output: Matrice di triage compilata.

Dividere ruoli tra chi guida, chi osserva, chi prende note e chi verifica, alternandoli con timer.

Output: Registro di sessione.

Valutare una correzione guardando diff, test, casi limite, retro-compatibilità, side effect e rischio di regressione, usando una checklist canonica di review.

Output: Commenti di review strutturati.

Convertire un errore risolto in una regola, un test, una checklist o una decisione di progetto, usando il formato blameless postmortem.

Output: Scheda lezione appresa.

Capire perché codice scritto in una sequenza può produrre effetti in un ordine diverso durante l'esecuzione, distinguendo task, microtask (Promise, queueMicrotask) e rendering frame.

Output: Timeline asincrona commentata.

Riconoscere promise non attese, catch mancanti, stati pendenti, unhandled rejection e fallimenti che non arrivano in console.

Output: Mappa promessa/stato/esito.

Riconoscere e prevenire race condition (doppio submit, stale closure, setState dopo unmount) e usare AbortController per cancellare fetch e listener.

Output: Pattern di cancellazione documentato.

Individuare listener duplicati, eventi non rimossi, propagazione inattesa, stato UI non sincronizzato e bug specifici del framework (stale closure React, reactivity Vue, store leak Svelte).

Output: Registro evento/stato/render.

Diagnosticare bug provocati da cache di Service Worker o CDN, collegare codice sorgente, bundle e componente renderizzato attraverso le source map.

Output: Traccia sorgente/bundle/componente.

Controllare se richiesta, risposta e modello dati concordano su nomi, tipi, valori mancanti, formati e versione dell'API.

Output: Diff contratto/API/interfaccia.

Distinguere errori di identità, permessi, cookie (SameSite, Secure, HttpOnly), token JWT (firma, scadenza, audience), CORS preflight OPTIONS e scadenza sessione.

Output: Tabella causa/segnale/verifica.

Riconoscere bug causati da ordinamenti, join, vincoli mancanti, migrazioni incomplete e record incoerenti.

Output: Fixture dati e query verificata.

Riconoscere bug che dipendono da fuso orario, salvataggio in UTC vs locale, encoding misto (UTF-8 vs Latin-1), formattazione numerica e date.

Output: Checklist locale/encoding/timezone.

Capire come retry mal progettati creano duplicati, perché serve idempotency-key, quando un messaggio finisce in dead letter queue e come confrontarsi con servizi esterni instabili.

Output: Schema integrazione con strategia di retry.

Trovare differenze tra locale, preview e produzione dovute a env, versioni, cache, build, lock file o servizi collegati.

Output: Matrice ambiente/configurazione.

Misurare prima di ottimizzare, distinguendo CPU, layout, rendering, caricamento asset e tempi di risposta; leggere LCP, INP, CLS e TTFB come segnali utente, usando User Timing API (performance.mark e performance.measure).

Output: Profilo prestazionale annotato con metriche.

Riconoscere crescita anomala della memoria, listener rimasti attivi, timer pendenti, sottoscrizioni store e riferimenti trattenuti che impediscono la garbage collection.

Output: Confronto heap prima/dopo.

Profilare un servizio backend (Node, Python, Java) e leggere flamegraph generati con perf, py-spy o async-profiler per individuare hot path.

Output: Hot path annotato con piano di verifica.

Costruire segnali utili in produzione (log JSON con livello e correlation id, metriche RED/USE, trace distribuiti) senza esporre dati sensibili e senza affogare l'indagine nel rumore; introdurre SLI, SLO ed error budget.

Output: Traccia end-to-end con SLO discusso.

Gestire un difetto già rilasciato: contenere l'impatto, aggiornare gli utenti via status page, coordinare la war room, scegliere rollback o fix-forward in coordinamento con il Modulo 5, poi documentare la causa.

Output: Postmortem tecnico breve.

Aprire il caso del capstone, leggere la segnalazione iniziale, costruire caso minimo riproducibile e pianificare le sessioni successive.

Output: Bug report e piano di indagine.

Applicare osservazione, isolamento e delta debugging per arrivare a una causa verificata, mantenendo il taccuino.

Output: Taccuino di indagine con causa radice.

Applicare fix minimo, scrivere test di regressione, eseguire matrice di verifica e preparare commit e branch.

Output: Pull request capstone pronta per la review.

Presentare il caso a un compagno o docente in massimo dieci minuti, ricevere review, scrivere retrospettiva blameless e lezioni apprese.

Output: Presentazione e postmortem definitivi.