Imagemagick on Melabit

Come nascondere in modo sicuro le informazioni riservate di un file pdf

Sat, 07 Aug 2021 06:00:00 +0000

Ve la ricordate la figuraccia dell’esercito americano che aveva documentato i risultati dell’indagine sulla morte di Nicola Calipari con un PDF pieno di omissis ma che poteva essere letto integralmente con un semplice copia e incolla del testo? Beh, è successo anche a me: dovevo nascondere delle informazioni riservate da alcuni documenti richiesti dal Ministero e ho fatto lo stesso errore degli americani. Però poi ho imparato come si fa in modo corretto e lo racconto qui perché potrebbe essere utile ad altri lettori.

La burocrazia italiana è un mostro dalle mille teste e da un pezzo ho smesso di cercare di capirne le motivazioni. Questa però non è male: ogni volta che partecipo a un progetto di ricerca finanziato da un Ministero o da una Regione devo produrre i miei cedolini dello stipendio in formato PDF per tutti i mesi (o meglio anni) di durata del progetto.

Tutto ciò serve a dimostrare che il mio datore di lavoro è in regola con i contributi e con tutte le altre disposizioni di legge. Tutto bene in teoria, peccato che il mio datore di lavoro sia il CNR, un ente pubblico, che quindi deve per forza di cose essere in regola con queste disposizioni. Ma la burocrazia non guarda a questi dettagli, se c’è una norma va applicata ciecamente anche se è inutile (anzi, direi, preferibilmente se è inutile).

Ma al di là della seccatura di dover rispondere ad una richiesta chiaramente superflua, i cedolini contengono informazioni riservate che è bene nascondere: l’IBAN prima di tutto, ma poi anche l’eventuale quota sindacale, informazioni sulle tasse pagate o sui prestiti e benefici vari di cui si potrebbe usufruire, e chissà che altro che non so. Per parecchio tempo ho reso illeggibili queste informazioni utilizzando la funzione sfumino (smudge) di Pixelmator, come si può vedere qui sotto.

Usare lo sfumino però è noioso, soprattutto se si deve ripetere il processo su un gran numero di documenti diversi. E allora a un certo punto, ideona!, ho pensato bene di utilizzare Anteprima per inserire dei rettangoli neri sopra le porzioni di testo da nascondere, con il grosso vantaggio di poterli copiare ed incollare facilmente in tutti i documenti da mascherare.

Ma, proprio come nel rapporto Calipari, questo metodo consente di recuperare le informazioni riservate con un semplice copia e incolla, come potete verificare voi stessi con questo file.¹

Tutto ciò succede perché, a partire dalla versione 1.5, un file PDF può memorizzare le informazioni su più livelli diversi, più o meno come i file grafici di Photoshop (o simili). Nel caso specifico, i rettangoli aggiunti finiscono in un livello diverso da quello del cedolino originale e possono essere selezionati e modificati anche in un secondo momento con Anteprima o con Acrobat Reader.

Combinare i livelli di un file PDF è facile, basta usare il servizio “Salva come PDF…” raggiungibile dal menu File > Stampa… di Anteprima (o di qualunque altra applicazione per macOS). Questo servizio simula la stampa del file PDF originale, salvandolo invece in un nuovo documento PDF. Poiché una stampante non può gestire i livelli multipli del file originale, l’effetto finale è quello di fondere tutti i livelli in uno solo, rendendo il documento non più modificabile (come ci si può accorgere facilmente se si prova a selezionare i rettangoli neri di questo file dopo averlo stampato virtualmente come appena descritto).

Ho sempre pensato che tutto ciò bastasse a nascondere efficacemente le informazioni riservate, ma purtroppo non è così: anche se i rettangoli neri aggiunti al file PDF non possono essere più modificati, è ancora possibile selezionare e copiare il testo sottostante (provare con il file di sopra per credere).

Per fortuna il problema può essere risolto sia tramite il solito Anteprima che con il Terminale. Anteprima va benissimo se abbiamo a che fare con uno o due file PDF, mentre la potenza del Terminale viene fuori alla grande quando i file da gestire sono parecchi.

Metodo numero 1. Usare Anteprima è di gran lunga il modo più facile per nascondere in modo sicuro le informazioni riservate presenti in un file PDF, ma richiede due passaggi manuali e la creazione di un file intermedio che va poi buttato via, per cui è consigliabile solo a chi deve rendere sicuri solo pochi file PDF (oppure a chi ha molta pazienza).

Per procedere bisogna aprire con Anteprima il file PDF contenente le informazioni riservate ancora in chiaro e inserire i soliti rettangoli neri sopra le parti di testo da nascondere. Arrivati a questo punto si esporta il file PDF in un formato grafico, che può essere indifferentemente HEIC, PNG o TIFF (non JPEG, perché questo formato supporta solo documenti di una pagina). Basta ora aprire questo file grafico con Anteprima ed esportarlo di nuovo in PDF (o ancora meglio stamparlo virtualmente in PDF) per avere un file a prova di bomba, nel quale non è più possibile selezionare il testo del documento. Il file rimane sicuro anche se lo si sottopone ad un processo di riconoscimento ottico dei caratteri (OCR) con uno dei tanti software disponibili (io uso con soddisfazione una vecchia versione di PDFpenPro ma ce n’è davvero per tutti i gusti), che ora non può andare a leggere dietro le pecette nere.

Metodo numero 2. Ghostscript è probabilmente lo strumento software più diffuso per la gestione dei file PostScript e PDF dal Terminale, può fare cose complicatissime ma richiede un grosso sforzo per padroneggiarlo a dovere. Ghostscript non è presente di default in macOS ma può essere installato facilmente tramite Homebrew oppure installando MacTeX,² la distribuzione più diffusa di LaTeX per macOS.

Una volta che abbiamo Ghostscript sul Mac, possiamo usarlo per trasformare in un solo colpo il documento PDF da mascherare in un documento sicuro tramite questo comando da eseguire nel Terminale di macOS

$ gs -dPDF -dBATCH -dNOPAUSE -dNOSUBSTDEVICECOLORS -sDEVICE=pdfwrite \
-sOutputFile=documento_sicuro.pdf documento_da_mascherare.pdf

I nomi dei due file PDF presenti nell’ultima riga del comando sono autoesplicativi e vanno sostituiti con i nomi veri dei nostri documenti. Ricordo come al solito che il carattere $ indica il prompt del Terminale di macOS e non fa parte del comando vero e proprio.

Ghoscript funziona bene ma è un po’ lento e tante opzioni sono davvero oscure. Molto meglio secondo me utilizzare il prossimo metodo.

Metodo numero 3. Anche ImageMagick è un peso massimo fra gli strumenti da Terminale, specializzato nella creazione, modifica o conversione dei file grafici di praticamente qualunque formato ci venga in mente. ImageMagick mette a disposizione una marea sterminata di comandi e di opzioni fra i quali è facile perdersi, però la natura più moderna del programma lo rende più facile da usare, almeno al livello base che ci serve qui. Anche ImageMagick va installato sul Mac tramite Homebrew, e comunque richiede la presenza di Ghostscript per funzionare (che è poi il motivo principale per cui ho deciso di presentare anche il metodo numero 2).

Per convertire il documento PDF da mascherare in un documento sicuro con ImageMagick basta eseguire da Terminale il comando

$ magick convert -density 300 documento_da_mascherare.pdf documento_sicuro.pdf

eventualmente anche senza il comando iniziale magick

$ convert -density 300 documento_da_mascherare.pdf documento_sicuro.pdf

L’opzione density indica la risoluzione (in punti per pollice, dpi) del documento finale, 300 dpi vanno benissimo per i documenti stampati ma possono essere tranquillamente ridotti a 150 o anche 96 dpi se il file sicuro viene utilizzato solo sul computer (e quindi, come piace tanto dire ai nostri burocrati, è dematerializzato).

Come dicevo prima, l’utilità di usare il Terminale viene fuori soprattutto quando abbiamo un gran numero di file da rendere sicuri. Per farlo possiamo usare questo script in bash che va copiato nella cartella contenente i file PDF da processare (oppure in una cartella presente nel PATH) dandogli un nome significativo (io uso secure_pdf ma potete usare quello che preferite), lanciandolo da Terminale dopo averlo reso eseguibile con chmod (i dettagli di come si fa li trovate qui).

#!/bin/bash

OUTDIR="./secured"

if [[ ! -d $OUTDIR ]]; then
    mkdir "$OUTDIR"
fi
 
for f in *.pdf; do
    fout="$OUTDIR/$f"
    echo "Converting '$f' to '$fout'"
    convert -density 300 "$f" "$fout"
done

Lo script converte tutti i PDF che trova nella cartella dove viene eseguito, salvandoli in una nuova cartella secured con lo stesso nome del documento PDF originale. Se volete che i file sicuri abbiano un nome diversi e magari finiscano nella stessa cartella dei file originali, basta aggiungere o modificare un paio di righe ed è fatto.

#!/bin/bash

OUTDIR="."
SUFFIX="-SECURE"

if [[ ! -d $OUTDIR ]]; then
    mkdir "$OUTDIR"
fi
 
for f in *.pdf; do
    fname=`basename "$f" ".pdf"`
    fout="$OUTDIR/$fname $SUFFIX.pdf"
    echo "Converting '$f' to '$fout'"
    convert -density 300 "$f" "$fout"
done

Altri metodi. Naturalmente quelli elencato non sono gli unici metodi validi per rendere sicuro un PDF. Chi usa Acrobat Pro può fare tutto da questo programma utilizzando gli strumenti integrati di redazione del testo. Personalmente trovo inutile pagare 20 euro al mese per un editor di PDF (il migliore, è vero, ma sono sempre 240 euro all’anno), ma per chi ha già una licenza Adobe può essere l’opzione migliore.

Un’altra alternativa molto meno costosa è quella di usare uno strumento come il mai troppo apprezzato PDF Toolkit+, con il quale è possibile tramite interfaccia grafica esportare un documento PDF in vari formati grafici e a svariate risoluzioni, dove ogni pagina del PDF finisce in un file diverso, e rimontare poi le singole pagine in un unico file PDF. Niente che non si possa fare con Anteprima, ma qui abbiamo una maggiore flessibilità, ad esempio perché possiamo decidere di cambiare l’ordine delle pagine o di escluderne alcune dal documento finale. In ogni caso PDF Toolkit+ vale molto di più dei due caffè che costa, io ad esempio lo trovo perfetto per ridurre le dimensioni dei file PDF scannerizzati.

Direi che questi 5 metodi possano bastare, ma se qualche lettore ne conosce altri sarebbe bello se li descrivesse nei commenti.

Non sperate di trovare il mio IBAN, è solo la versione in PDF della prima pagina di questo post. ↩︎
Qualcuno potrà chiedersi che senso abbia installare i quasi 5 GB di MacTeX solo per avere Ghostscript. Vista così può davvero sembrare una cosa insensata, ma il valore aggiunto di avere LaTeX sul Mac è, a mio avviso, inestimabile. ↩︎

Programmare l'inutilità

Mon, 23 Nov 2015 06:00:00 +0000

Come tanti ricevo ogni giorno una o più email che mi propongono di visitare questo o quel sito. Non è sempre tempo perso, spesso si trovano delle vere e proprie gemme.

Altre volte però scopro siti o applicazioni la cui utilità è perlomeno dubbia.

img2css

La palma del programma più inutile degli ultimi mesi vorrei assegnarla a img2css, una applicazione web scritta in JavaScript che converte una immagine bitmap (in formato png, jpg o simili) in un file CSS, che può qundi essere inserito direttamente in una pagina web.

In teoria l’idea è ottima, perché permette di integrare un’immagine in una pagina web senza bisogno di collegamenti a file esterni, ma nella pratica fallisce miseramente.

Anche con immagini semplicissime il file CSS generato diventa di dimensioni abnormi, ed è molto più pesante da gestire e da trasmettere in rete rispetto all’immagine originale.

Proviamo img2css

Proviamo ad usare img2css con una immagine semplicissima composta da un quadrato di 10x10 pixel con bordo nero e interno bianco. L’immagine si può creare da Terminale tramite convert, uno dei comandi più potenti di ImageMagick, in grado non solo (come dice il nome) di convertire le immagini da un formato grafico all’altro, ma anche di generare delle immagini ex-novo in praticamente qualunque formato conosciuto.

Il comando

	$ convert -size 10x10 xc:white -fill white \
	-stroke black -draw "rectangle 0,0 9,9" square_10x10.png

produce l’immagine , che occupa esattamente 127 byte (per maggiore chiarezza l’immagine è visualizzata al doppio della dimensione originale).

Convertendo l’immagine con img2css, il codice CSS corrispondente

<div style="height:1px;width:1px;box-shadow:#000 0 0, #000 1px 0, #000 2px 0, #000 3px 0, #000 4px 0, #000 5px 0, #000 6px 0, #000 7px 0, #000 8px 0, #000 9px 0, #000 0 1px, #000 1px 1px, #000 2px 1px, #000 3px 1px, #000 4px 1px, #000 5px 1px, #000 6px 1px, #000 7px 1px, #000 8px 1px, #000 9px 1px, #000 0 2px, #000 1px 2px, #fff 2px 2px, #fff 3px 2px, #fff 4px 2px, #fff 5px 2px, #fff 6px 2px, #fff 7px 2px, #000 8px 2px, #000 9px 2px, #000 0 3px, #000 1px 3px, #fff 2px 3px, #fff 3px 3px, #fff 4px 3px, #fff 5px 3px, #fff 6px 3px, #fff 7px 3px, #000 8px 3px, #000 9px 3px, #000 0 4px, #000 1px 4px, #fff 2px 4px, #fff 3px 4px, #fff 4px 4px, #fff 5px 4px, #fff 6px 4px, #fff 7px 4px, #000 8px 4px, #000 9px 4px, #000 0 5px, #000 1px 5px, #fff 2px 5px, #fff 3px 5px, #fff 4px 5px, #fff 5px 5px, #fff 6px 5px, #fff 7px 5px, #000 8px 5px, #000 9px 5px, #000 0 6px, #000 1px 6px, #fff 2px 6px, #fff 3px 6px, #fff 4px 6px, #fff 5px 6px, #fff 6px 6px, #fff 7px 6px, #000 8px 6px, #000 9px 6px, #000 0 7px, #000 1px 7px, #fff 2px 7px, #fff 3px 7px, #fff 4px 7px, #fff 5px 7px, #fff 6px 7px, #fff 7px 7px, #000 8px 7px, #000 9px 7px, #000 0 8px, #000 1px 8px, #000 2px 8px, #000 3px 8px, #000 4px 8px, #000 5px 8px, #000 6px 8px, #000 7px 8px, #000 8px 8px, #000 9px 8px, #000 0 9px, #000 1px 9px, #000 2px 9px, #000 3px 9px, #000 4px 9px, #000 5px 9px, #000 6px 9px, #000 7px 9px, #000 8px 9px, #000 9px 9px;"></div>

occupa 1259 byte, circa 10 volte in più del file png di partenza. Le cose peggiorano rapidamente se si usano immagini più complesse. Questa immagine da 20x20 pixel , composta da alcuni rettangoli concentrici colorati e generata tramite

$ convert -size 20x20 xc:white -fill white \
-stroke black  -draw "rectangle 0,0 19,19" \
-stroke red    -draw "rectangle 2,2 17,17" \
-stroke green  -draw "rectangle 4,4 15,15" \
-stroke blue   -draw "rectangle 6,6 13,13" \
-stroke yellow -draw "rectangle 8,8 11,11" concentric_color.png

occupa solo 481 byte in formato png, che diventano ben 6.491 byte quando di converte l’immagine in CSS con img2css.

Con immagini reali a colori, o peggio ancora fotografie (ad esempio questa), le immagini CSS possono diventare anche 150-200 volte più grandi di quella originale, mettendo in ginocchio il browser (e il computer!) durante il processo di conversione o quando si copia il file CSS ottenuto in una pagina web.

Provare per credere, ma se poi il Mac si pianta non prendetevela con me.

Dentro il codice

Il programma img2css è molto semplice ed è composto poche centinaia di linee di codice JavaScript. Ma è perfino troppo lungo per quello che fa.

In fondo si tratta solo di determinare il codice RGB di ogni pixel dell’immagine, convertirlo in formato esadecimale ed associarlo alle coordinate orizzonantali e verticali del pixel considerato.

Ogni pixel viene quindi convertito nella sequenza #AAA Xpx Ypx, dove #AAA indica il colore in esadecimale (la stringa può essere composta da 3 o 6 numeri a seconda del colore RGB determinato) e Xpx Ypx indicano le coordinate orizzonantali e verticali del pixel.

Tutto questo si può fare tranquillamente da Terminale, con poche righe di codice ben piazzate.

img2css da Terminale

Per convertire un file grafico in una sequenza di colori RGB si può usare ancora convert di ImageMagick,

$ convert square_10x10.png -compress none square_10x10.ppm

ottenendo un file in formato ppm, in cui ciascun pixel dell’immagine è rappresentato da tre numeri interi decimali, corrispondenti ai tre colori RGB del pixel stesso (il formato grafico ppm è molto inefficiente, ma è utilissimo dal punto di vista didattico perché mostra chiaramente come è fatto un file grafico).

Le sequenze di tre numeri decimali sono disposte per righe orizzontali a partire dalla quarta riga del file. Le prime tre righe contengono rispettivamente il numero magico che definisce il tipo di file, le dimensioni dell’immagine in pixel e il valore massimo del colore RGB del file.

La rappresentazione in formato ppm del quadrato di 10x10 pixel con bordo nero e interno bianco mostrato sopra è

P3
10 10
255
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Sequenze di dati come questa possono essere facilmente analizzate e trasformate tramite awk, uno dei tanti potenti strumenti specifici disponibili nei sistemi operativi basati su Unix.

Basta uno script awk di poche righe per convertire le informazioni RGB decimali contenute nel file ppm in formato esadecimale

#!/usr/bin/awk -f

/^255/  { while (getline == 1)
          { for (i = 1; i <= NF; i += 3)
              printf "0x%02X%02X%02X ", $i, $(i+1), $(i+2);
              printf "\n"
          }
        }

Eseguendo lo script img2css.awk sul file ppm precedente si ottiene

$ ./img2css.awk square_10x10.ppm 
0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 
0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0xFFFFFF 0x000000 0x000000 
0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 
0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000 0x000000

Per riprodurre l’output prodotto da img2css, è sufficiente modificare leggermente il modo in cui lo script stampa i valori dei colori RGB, aggiungere la stampa della le coordinate di ciascun pixel e inserire le parti iniziali e finali del tag <div>, ottenendo

#!/usr/bin/awk -f

BEGIN   { out = sprintf("<div></div>");
          print out;
        }

che produce un output equivalente a quello di img2css

$ ./img2css_v2.awk square_10x10.ppm
<div style="height:1px;width:1px;box-shadow:#000000 0 0px, #000000 1px 0px, #000000 2px 0px, #000000 3px 0px, #000000 4px 0px, #000000 5px 0px, #000000 6px 0px, #000000 7px 0px, #000000 8px 0px, #000000 9px 0px, #000000 0 1px, #000000 1px 1px, #000000 2px 1px, #000000 3px 1px, #000000 4px 1px, #000000 5px 1px, #000000 6px 1px, #000000 7px 1px, #000000 8px 1px, #000000 9px 1px, #000000 0 2px, #000000 1px 2px, #FFFFFF 2px 2px, #FFFFFF 3px 2px, #FFFFFF 4px 2px, #FFFFFF 5px 2px, #FFFFFF 6px 2px, #FFFFFF 7px 2px, #000000 8px 2px, #000000 9px 2px, #000000 0 3px, #000000 1px 3px, #FFFFFF 2px 3px, #FFFFFF 3px 3px, #FFFFFF 4px 3px, #FFFFFF 5px 3px, #FFFFFF 6px 3px, #FFFFFF 7px 3px, #000000 8px 3px, #000000 9px 3px, #000000 0 4px, #000000 1px 4px, #FFFFFF 2px 4px, #FFFFFF 3px 4px, #FFFFFF 4px 4px, #FFFFFF 5px 4px, #FFFFFF 6px 4px, #FFFFFF 7px 4px, #000000 8px 4px, #000000 9px 4px, #000000 0 5px, #000000 1px 5px, #FFFFFF 2px 5px, #FFFFFF 3px 5px, #FFFFFF 4px 5px, #FFFFFF 5px 5px, #FFFFFF 6px 5px, #FFFFFF 7px 5px, #000000 8px 5px, #000000 9px 5px, #000000 0 6px, #000000 1px 6px, #FFFFFF 2px 6px, #FFFFFF 3px 6px, #FFFFFF 4px 6px, #FFFFFF 5px 6px, #FFFFFF 6px 6px, #FFFFFF 7px 6px, #000000 8px 6px, #000000 9px 6px, #000000 0 7px, #000000 1px 7px, #FFFFFF 2px 7px, #FFFFFF 3px 7px, #FFFFFF 4px 7px, #FFFFFF 5px 7px, #FFFFFF 6px 7px, #FFFFFF 7px 7px, #000000 8px 7px, #000000 9px 7px, #000000 0 8px, #000000 1px 8px, #000000 2px 8px, #000000 3px 8px, #000000 4px 8px, #000000 5px 8px, #000000 6px 8px, #000000 7px 8px, #000000 8px 8px, #000000 9px 8px, #000000 0 9px, #000000 1px 9px, #000000 2px 9px, #000000 3px 9px, #000000 4px 9px, #000000 5px 9px, #000000 6px 9px, #000000 7px 9px, #000000 8px 9px, #000000 9px 9px;"></div>

perfettamente funzionante, come si può verificare inserendo pari pari il tag <div> ottenuto in un documento html (come questo):

Conclusioni

È chiaro che usare convert ed awk non risolve il problema di fondo, le immagini CSS generate rimangono comunque molto più grosse di quelle originali, ma almeno sono prodotte con poche righe di codice ed usando solo degli strumenti standard di Unix.

Alcuni anni fa si parlava in senso negativo di bloatware, di quei programmi inutilmente grossi e tanto poco ottimizzati da richiedere grosse risorse hardware anche per svolgere funzioni relativamente semplici.

A volte i programmatori dimenticano due concetti fondamentali della buona programmazione, cercare la semplicità e usare lo strumento più adatto per il compito specifico, e si perdono in inutili (e stucchevoli) esercitazioni di stile. Succede a chi propone banalmente di usare file CSS enormi al posto di semplici immagini grafiche, ma succede anche in tanti altri casi ben peggiori.

A parte questo, il post è stato anche un’occasione per parlare di awk, uno strumento poco conosciuto ma molto otente, in particolare quando si tratta di analizzare e trasformare dati contenuti in file di testo.

Uno strumento che è diventato parte integrante da anni della mia routine di lavoro quotidiana. Sarebbe bello poterne riparlare.