Articoli per sviluppatori

Codifica

Base64: a cosa serve la codifica e come funziona

Come Base64 trasforma dati binari in testo ASCII e quando serve davvero.

Base32: come si differenzia da Base64 e quando è più comodo

L'alfabeto di Base32, insensibile a maiuscole/minuscole, e i casi in cui è più comodo di Base64.

URL Encode/Decode: il percent-encoding nei link

Come i caratteri speciali negli indirizzi e nei parametri diventano sequenze %XX.

HTML Entities: come mostrare caratteri speciali in sicurezza

Perché i caratteri < > & vanno escapati e come questo evita di rompere il markup.

JWT: struttura del token e cosa significa "decodificare" un JWT

Header, payload e signature di un JWT, e perché decodificare non equivale a verificare la firma.

Unicode Escape: cosa significano le sequenze \uXXXX

Da dove vengono sequenze come \u0041 in JSON e nelle stringhe JS, e cosa significano.

ROT13 e il cifrario di Cesare: semplice sostituzione di caratteri

Perché uno scorrimento di 13 lettere rende ROT13 auto-inverso, e perché si usa ancora oggi.

Punycode: come funzionano i domini internazionalizzati nel DNS

Come un dominio con caratteri non latini diventa una forma ASCII con il prefisso xn--.

Il codice Morse: come il testo diventa punti e linee

Il principio di codifica delle lettere in punti e linee, e dove si usa ancora oggi il Morse.

Data URI: quando incorporare immagini direttamente nel codice

Come un Data URI incorpora il contenuto di un file direttamente in HTML o CSS, e quando conviene.

Gzip + Base64: comprimere dati per trasmetterli come testo

Perché i dati binari compressi vengono anche codificati in Base64 prima di finire in un campo di testo.

XML Entities: escapare i caratteri nei documenti XML

Le cinque entity XML obbligatorie senza le quali il documento si rompe durante il parsing.

JSON

JSON Formatter: formattazione, minificazione e validazione

Formattare per la leggibilità, minificare per la dimensione, validare per la correttezza: tre compiti diversi con JSON.

JSONPath: interrogare dati JSON senza analizzarli a mano

Come JSONPath permette di estrarre i valori necessari da un JSON grande con una sola espressione, senza scorrerlo a mano.

JSON Diff: in cosa il confronto strutturale differisce da quello testuale

Perché l'ordine delle chiavi non dovrebbe influire sul confronto tra due documenti JSON.

JSON Schema: come descrivere e validare la struttura di un JSON

Come JSON Schema permette di verificare automaticamente se i dati rispettano un contratto atteso.

JSON Flatten: trasformare una struttura annidata in una lista piatta

Come un JSON profondamente annidato diventa una lista piatta di chiavi come user.address.city.

JSON Sort Keys: perché ordinare le chiavi di un oggetto

Perché l'ordine delle chiavi JSON non è specificato, ma ordinarle resta utile nella pratica.

JSON Repair: perché il JSON si rompe e come ripararlo

Cause comuni di JSON "rotto" e cosa una riparazione automatica può o non può correggere.

Mock JSON Generator: a cosa servono i dati finti

Come i dati fittizi permettono di iniziare a costruire un'interfaccia prima che il backend sia pronto.

JSON ↔ YAML/CSV/XML/TOML: quando e perché convertire

Quali dati si perdono convertendo JSON in CSV e perché YAML e TOML sono popolari per i file di configurazione.

Testo

Case Converter: perché esistono stili di denominazione diversi

Perché in uno stesso progetto le variabili si scrivono in camelCase ma i file in kebab-case, e da dove vengono queste regole.

Text Diff: come gli algoritmi trovano la differenza tra due testi

Come un algoritmo di diff trova l'insieme minimo di modifiche tra due versioni di un testo.

Espressioni regolari: sintassi di base e pattern comuni

Come leggere un'espressione regolare e in cosa la corrispondenza greedy differisce da quella lazy.

Ordinare e deduplicare righe: a cosa serve

Perché un ordinamento numerico che mette "10" prima di "9" è un errore, e come evitarlo.

String Escape: perché lo stesso testo va escapato in modo diverso

Perché la stessa virgoletta viene escapata in modo diverso in una stringa JS, in JSON e in un comando shell.

CRLF contro LF: perché i caratteri di fine riga contano ancora

Perché un file scritto su Windows può apparire "completamente modificato" in git su Linux.

Contare caratteri e parole: perché non è sempre banale

Perché un'emoji o una lettera accentata possono contare come più caratteri contemporaneamente.

Lorem Ipsum: da dove viene il testo segnaposto e a cosa serve

Perché i designer usano deliberatamente testo "senza senso" invece di contenuti reali nei mockup.

Slugify: come trasformare un testo qualsiasi in un URL

Come un titolo come "Ciao, Mondo!" diventa una stringa compatibile con gli URL come ciao-mondo.

Markdown: perché una sintassi di testo semplice ha battuto gli editor ricchi

Perché gli sviluppatori preferiscono scrivere la documentazione in Markdown invece che in un editor di testo ricco.

Spazi e caratteri invisibili: la causa nascosta di bug strani

Perché due stringhe apparentemente identiche possono non corrispondere a causa di un carattere invisibile.

Text Reverse: perché "invertire un testo" è più difficile di quanto sembri

Perché un'inversione ingenua di una stringa può trasformare un'emoji in byte inutilizzabili.

Analisi di frequenza del testo: a cosa serve contare le ripetizioni delle parole

Come la frequenza delle lettere in un testo cifrato aiuta a violare i cifrari a sostituzione più semplici.

Hash/Crittografia

Hash Generator: in cosa differiscono MD5, SHA-1 e SHA-256

Perché MD5 viene ancora usato per verificare l'integrità dei file, ma non per le password.

Checksum Verifier: come verificare che un file non sia danneggiato

Perché un checksum corrispondente conferma l'integrità di un file, ma non chi lo ha creato.

HMAC: in cosa differisce un hash con chiave da un hash normale

Perché un semplice SHA-256 non protegge dalla manomissione di un messaggio, ma HMAC sì.

Bcrypt: perché le password vengono hashate lentamente, non velocemente

Perché un SHA-256 veloce è una cattiva scelta per le password, e un bcrypt lento è quella giusta.

UUID: come vengono generati identificatori che quasi non si ripetono mai

Perché un UUID v4 può essere generato in modo indipendente su milioni di macchine senza rischio di collisione.

Generatore di password: cosa rende davvero forte una password

Perché una password lunga fatta di parole del dizionario è più forte di una corta con simboli e numeri.

AES: come funziona la crittografia simmetrica

Perché la stessa chiave cifra e decifra i dati in AES, e come questo differisce dalla crittografia asimmetrica.

Argon2: perché questo algoritmo ha vinto il concorso sull'hashing delle password

Come Argon2 si difende meglio dagli attacchi con GPU rispetto agli algoritmi di hashing password più vecchi.

Scrypt: perché l'algoritmo ha bisogno di così tanta memoria

Perché scrypt richiede deliberatamente molta memoria per rendere più difficile il cracking su dispositivi ASIC.

TOTP: come funzionano i codici monouso nelle app di autenticazione

Perché il codice di Google Authenticator funziona senza internet e si sincronizza col server solo tramite l'ora.

PBKDF2: lo standard più vecchio per lo stretching delle chiavi

Perché il numero di iterazioni raccomandato per PBKDF2 cresce ogni anno.

X.509: cosa c'è dentro un certificato SSL

Cosa controlla esattamente il browser nel certificato di un sito prima di mostrare il lucchetto verde.

PGP: come funziona la crittografia a chiave pubblica e privata

Perché si può condividere liberamente una chiave pubblica PGP, ma mai quella privata.

Tempo/Numeri

Tempo Unix: perché i computer contano il tempo dal 1970

Perché il 1° gennaio 1970 è diventato il punto di riferimento del tempo per la maggior parte dei sistemi informatici.

Espressioni cron: come decifrare una pianificazione di attività

Come decifrare un'espressione come */15 * * * * e sapere esattamente quando verrà eseguita l'attività.

Sistemi numerici: a cosa servono binario, ottale ed esadecimale

Perché il colore #FF5733 in CSS è scritto con cifre esadecimali anziché decimali.

Operazioni bit a bit: come funzionano AND, OR e XOR a livello di bit

In cosa l'AND bit a bit differisce da quello logico, e perché operare sui singoli bit di un numero.

Differenza tra date: perché contare i giorni è più complicato di quanto sembri

Perché sottrarre date in modo ingenuo può dare un risultato sbagliato a causa degli anni bisestili.

Calcolo dell'età: perché non è una semplice sottrazione di anni

Perché sottrarre semplicemente gli anni di nascita può dare un'età superiore di uno rispetto a quella reale.

Fusi orari: perché UTC non è la stessa cosa di GMT

Perché UTC non cambia mai due volte all'anno, mentre l'ora di Londra (GMT/BST) sì.

Calcolatrice di durata: come sommare correttamente ore, minuti e secondi

Perché sommando minuti e secondi bisogna "riportare" il resto alla cifra successiva, come nella somma decimale.

ISO 8601 Duration: come scrivere una durata in formato standard

Perché PT1H30M significa «1 ora 30 minuti» e non «1 minuto 30 ore».

Numero di settimana: perché paesi diversi contano le settimane in modo diverso

Perché il 1° gennaio a volte appartiene alla settimana 52 o 53 dell'anno precedente secondo lo standard ISO 8601.

Numeri romani: come funziona un sistema senza zero né posizioni

Perché IV significa 4 e non 6, e come funziona la regola della sottrazione nei numeri romani.

IEEE 754: perché 0.1 + 0.2 non è uguale a 0.3 nel codice

Perché in quasi ogni linguaggio di programmazione 0.1 + 0.2 restituisce 0.30000000000000004.

Numero in lettere: perché trasformare cifre in parole

Perché nei documenti bancari l'importo viene scritto sia in cifre che in lettere contemporaneamente.

Rete/HTTP

Analisi degli URL: di quali parti è fatto un indirizzo web

Perché un URL ha una parte dopo il simbolo # che il server non riceve nemmeno.

Query string contro JSON: perché i parametri GET sono così limitati

Perché passare un array o un oggetto annidato tramite la query string di un URL non è semplice come con JSON.

User-Agent: perché questa stringa è un tale pasticcio

Perché Chrome, Safari ed Edge contengono tutti contemporaneamente le parole "Mozilla" e "Safari" nel loro User-Agent.

Basic Authentication: come funziona il modo più semplice per proteggere una risorsa HTTP

Perché Basic Auth richiede assolutamente HTTPS, dato che Base64 è codifica, non crittografia.

Header HTTP: cosa si nasconde in ogni richiesta e risposta

Perché l'header Content-Type determina come il browser interpreta il corpo della risposta del server.

Cookie: come un piccolo pezzo di testo mantiene lo stato di una sessione

Perché l'attributo HttpOnly protegge un cookie dal furto tramite JavaScript malevolo.

CORS: perché il browser blocca richieste "normali" verso un altro dominio

Perché un errore CORS si verifica nel browser, non lato server, e chi blocca davvero la richiesta.

Header delle email: come tracciare il percorso di un messaggio dal mittente a te

Perché bisogna leggere gli header Received dal basso verso l'alto per tracciare il percorso di un messaggio.

SEO

Meta tag: quali influenzano davvero ricerca e social media

Perché un motore di ricerca a volte ignora la tua meta description e genera uno snippet proprio dal testo della pagina.

robots.txt: come i bot di ricerca decidono cosa possono scansionare

Perché una regola Disallow in robots.txt non nasconde una pagina dai risultati di ricerca se qualcos'altro ci punta con un link.

Sitemap.xml: perché i motori di ricerca hanno bisogno di una mappa del sito

Perché comparire in sitemap.xml non garantisce che un motore di ricerca indicizzi una pagina.

Favicon: perché una sola icona richiede così tante dimensioni e formati

Perché una singola favicon.ico non basta più per essere mostrata correttamente su tutti i dispositivi.

Generare sitemap.xml: come costruire automaticamente una mappa del sito

Perché i motori di ricerca ignorano in gran parte il campo priority in sitemap.xml, pur facendo parte della specifica.