Chi si affida a ChatGPT per la creazione automatica di contenuti rischia di rimanere indietro. La SEO richiede strategie complesse e non basta fare un copia e incolla, necessita di creatività e di contenuti pensati e scritti per il lettore. Gli articoli scritti interamente da ChatGPT presentano sempre queste caratteristiche:

• Sono in linea con la media
• Non introducono esperienza reale
• Non risolvono un problema meglio di altri
• Sono facilmente riconoscibili anche senza l’utilizzo di un detector AI
• Non tengono conto delle esigenze dell’utente.

Proprio sull’ultimo punto vale la pena soffermarci per un secondo.

AI per la scrittura di articoli: scrivere pensando alle persone, non alla SEO

Ti sembrerà assurdo ma gli algoritmi dei motori di ricerca tendono a preferire contenuti originali e di valore che risultino utili e interessanti per l’utente finale. Questo è ciò che posiziona meglio un sito web o un articolo nei risultati di ricerca. Abbiamo affrontato questo argomento anche in questo articolo: come scrivere un articolo di blog.

WriterFlow e l’AI per la scrittura di articoli non si sostituiscono all’umano

Il plugin si avvale di un’intelligenza artificiale dedicata alla SEO, pensata come AI per la scrittura di articoli, capace di generare contenuti ottimizzati in base al ragionamento dell’utente, fornendo opzioni diverse, sinonimi e suggerimenti per migliorare la qualità della scrittura, rimanendo un semplice supporto alla stesura dell’idea e non sostituendosi all’autore.

Ad esempio potrei scrivere:
“WriterFlow è un plugin AI per WordPress che ti dà una mano a scrivere gli articoli”

Richiedendo un’alternativa, quello che ottengo grazie a WriterFlow è questo:

“WriterFlow è un plugin per WordPress che utilizza l’intelligenza artificiale per supportare gli autori nella scrittura di articoli.“

AI per la scrittura di articoli e selezione di titoli efficaci

Per far crescere il proprio sito è indispensabile nutrirlo continuamente di nuovi contenuti. Google non fornisce un numero esatto di articoli da pubblicare ogni giorno, non c’è un vademecum ma è possibile affermare con buona probabilità che la frequenza di pubblicazione dipenda fortemente dal tipo di sito web.

Un piccolo/medio blog dovrebbe pubblicare non più di 2/3 articoli a settimana, un sito di News è chiaro che ne debba pubblicare molti di più. Ma per un blog aziendale o per un blog personale le idee si esauriscono velocemente.

Con WriterFlow trovare il titolo perfetto è facile. Basta specificare categoria e tag, poi lasciare che WriterFlow generi 10 idee per titoli in linea con l’argomento selezionato.

Tanto tempo risparmiato e contenuti sempre di qualità.

Dalla scelta all’azione

Basta un click sul titolo prescelto e viene automaticamente inserito. WriterFlow si integra perfettamente con il tuo workflow WordPress, semplificando la creazione di contenuti ottimizzati per la SEO.

Basta perdere tempo con la ricerca del titolo perfetto. È sufficiente fornire l’argomento e WriterFlow proporrà diverse opzioni. Se non trovate quello che cercate, basta cliccare un tasto per rigenerare nuove idee.

Scrittura assistita: un uso consapevole dell’AI per la scrittura di articoli

Nei suggerimenti di testo hai due modalità. Questo approccio rende l’AI per la scrittura di articoli uno strumento discreto e realmente utile. Accettare il testo proposto, oppure iniziare a scrivere per poi variare il contenuto con nuove idee che ti vengono in mente.

Accettazione del testo proposto

Nei blocchi di paragrafo di Gutenberg ti basta cliccare sul suggerimento per inserire tutta la frase suggerita. Oppure premere semplicemente il tasto “TAB”.

Frasi alternative

Non sei soddisfatto di come hai scritto una frase e la vorresti riformulata in modo più professionale e aderente al resto dell’articolo? Nulla di più semplice.
Con WriterFlow attivo è sufficiente selezionare la frase che vuoi riformulare e verranno generate immediatamente delle alternative. Ti basta premere l’alternativa che preferisci oppure generare nuove alternative se quelle proposte non ti soddisfano.

Scegli la parola perfetta

Stai cercando un sinonimo che non ti viene? WriterFlow ti velocizza anche in questo, mostrando il lato più pratico dell’AI per la scrittura di articoli. Fai doppio click sulla parola di cui vuoi cercare un sinonimo in modo che sia evidenziata e ti verranno consigliati 5 sinonimi. Se i sinonimi proposti non ti convincono, puoi cliccare su “rigenera” per ottenere 5 nuove opzioni. Scegli il sinonimo che preferisci e verrà inserito al posto della parola originale.

Modalità automatica o manuale?

In modalità automatica puoi impostare un tempo di inattività per ricevere suggerimenti

La modalità automatica è molto comoda quando si vuole ricevere il suggerimento dopo un certo periodo di inattività. La durata del tempo di inattività è configurabile tramite le impostazioni di WriterFlow.

Con un tempo di 5 secondi, come illustrato nell’esempio, il suggerimento si attiverà dopo 5 secondi di stop alla scrittura.

In modalità manuale sei tu a scegliere quando vuoi ricevere un suggerimento

Nella modalità manuale, dopo tre secondi di stop alla scrittura comparirà il tasto suggerisci a destra del cursore. Ti basterà cliccare sul pulsante per ricevere i suggerimenti di scrittura. Nella modalità manuale, le funzioni di generazione alternative e di suggerimento sinonimico saranno ancora disponibili. Come nel caso della modalità automatica dovrai solamente selezionare la frase o la parola per ottenere rispettivamente il testo alternativo o il sinonimo desiderato.

Con WriterFlow paghi solo quello che usi

Nel menu a destra dell’editor dell’articolo hai sempre modo di controllare il credito residuo. Ad ogni interazione il credito verrà aggiornato in modo automatico. Niente sorprese.

Inoltre i nuovi iscritti possono godere di un credito gratuito di 5 euro per testare le funzionalità di WriterFlow. I 5 euro di credito ti basteranno per almeno 15 articoli di media lunghezza.

Iscrizione e ricarica sono operazioni semplicissime. La registrazione e la creazione di una chiave API sono operazioni che avvengono in modo automatico direttamente dalla tua area amministrativa di WordPress. La ricarica richiede invece l’accesso al portale di RunAI e potrai ricaricare il tuo credito con un minimo di 5 euro.

RunAI utilizza transazioni sicure tramite l’introduzione dei gateway di pagamento PayPal e Stripe. È necessaria una carta di credito. Non ci sono costi ricorrenti, non ci sono piani in abbonamento. Ricarichi il tuo credito e utilizzi WriterFlow. Nulla di più semplice.

Puoi usare lo stesso account WriterFlow anche su più siti WordPress e il credito non ha scadenza. Se un mese sei in ferie e non stai lavorando non dovrai continuare a pagare per un servizio che non utilizzi. I costi sono puramente a consumo.

Privacy e data retention

La privacy è garantita da RunAI, la nostra piattaforma di intelligenza artificiale con nodi di inferenza Apple Silicon criptati end-to-end. Nessun contenuto viene salvato, i dati vengono elaborati solo durante l’utilizzo del servizio e cancellati un microsecondo dopo averti fornito il suggerimento nel rispetto delle normative GDPR in modo trasparente e sicuro per gli utenti.

Conclusione

WriterFlow è lo strumento innovativo che rivoluziona il modo di scrivere online, offrendo un uso consapevole dell’AI per la scrittura di articoli.

Scarica WriterFlow e inizia ad usarlo con il credito gratuito. Diventerà il tuo compagno di scrittura e ti aiuterà a creare contenuti di qualità.

L'articolo AI per la scrittura di articoli: scrivere senza delegare il pensiero proviene da RENOR & Partners S.r.l..

composer require vendor/package

e tenere aggiornamenti, versioni e dipendenze sotto controllo. Per seguire la guida abbiamo bisogno di:

• Git versione maggiore o uguale alla 2.0 installata e configurata
• Un account GitHub e token con permesso repo
• Composer con versione maggiore o uguale alla 2.5 in $PATH
• Account gratuito su Packagist.org (che si registra tramite GitHub via OAuth)

Rifacendoci all’articolo in cui avevamo visto come sviluppare una libreria di Statistica descrittiva la struttura della repository era la seguente:

descriptive-statistics-php/
├─ composer.json
├─ composer.lock
├─ phpunit.xml
├─ examples/
│  └─ geometric_mean_demo.php
│  └─ harmonic_mean_demo.php
│  └─ iqr_demo.php
│  └─ mad_demo.php
│  └─ mean_demo.php
│  └─ median_demo.php
│  └─ min_max_demo.php
│  └─ mode_demo.php
│  └─ percentile_demo.php
│  └─ range_demo.php
│  └─ standard_deviation_demo.php
│  └─ trimmed_mean_demo.php
│  └─ variance_demo.php
├─ src/
│  └─ DescriptiveStats.php
├─ tests/
│  └─ DescriptiveStatsTest.php
└─ vendor/
    └─ autoload.php

Nel terminale, all’interno della cartella del progetto digitiamo il comando:

composer init

Composer ci chiederà alcune informazioni partendo dal Package name che viene espresso come vendor/package-name. Nel mio caso essendo il mio account denominato “thesimon82” il nome del pacchetto sarà thesimon82/descriptive-statistics. Confermiamo con invio.

Ora ci viene chiesta la descrizione, per questo progetto inseriamo: Lightweight PHP class for descriptive statistics.

L’autore e ci viene restituito l’autore di default se l’avevamo già impostato, altrimenti inseriamo il nostro nome e cognome.

Minimum stability, se è una versione stabile inseriamo “stable”.

Per Package Type inseriamo: “library”

In license: MIT

Ci viene chiesto se vogliamo inserire, uno per uno, i pacchetti di produzione (require) che la libreria necessita per funzionare. In questo caso la classe è stand-alone (usa solo funzioni native di PHP), quindi non abbiamo altre dipendenze oltre alle versione minima di PHP pertanto possiamo anche dichiarare “no”. Se stai pensando a PHPUnit per i test sui metodi della classe, ti ricordo che PHPUnit è stato settato solo per la fase di sviluppo e test pertanto va inserito in require-dev e non in require. In questo modo chi installerà il pacchetto in produzione non si troverà PHPUnit tra le dipendenze di runtime.

La domanda successiva infatti richiede proprio se ho intenzione di definire le mie dipendenze dev in modo interattivo (require-dev), qui digitiamo “yes” e ci chiederà di inserire il nome del pacchetto. Digitiamo ora phpunit/phpunit. Ci darà una lista di pacchetti trovati e selezioniamo phpunit/phpunit con il numero corrispondente. Confermiamo con invio e ci viene chiesto quale versione intendiamo includere. Confermiamo semplicemente con invio per installare l’ultima versione.

Ci chiederà ora se vogliamo installare altri pacchetti di dipendenze, ma non ne abbiamo altri quindi premiamo semplicemente invio.
Ora ci chiederà se intendiamo aggiungere un mapping PSR-4 per l’autoload delle classi chiedendoci di mappare il namespace Thesimon82DescriptiveStatistics ma nel progetto avevamo utilizzato Renor\Statistics quindi digitiamo n per skippare la proposta.

Finalmente otteniamo un resoconto dei dati inseriti:

{
    "name": "thesimon82/descriptive-statistics",
    "description": "Lightweight PHP class for descriptive statistics",
    "type": "library",
    "require-dev": {
        "phpunit/phpunit": "^12.1"
    },
    "license": "MIT",
    "authors": [
        {
            "name": "Simone Renzi",
            "email": "info@simonerenzi.com"
        }
    ],
    "minimum-stability": "stable",
    "require": {},
    "autoload": {
        "psr-4": {
            "Renor\Statistics\": "src/"
        }
    }
}

Do you confirm generation [yes]? 

Qui controlliamo i dati e se tutto è giusto confermiamo con “yes” e installiamo le dipendenze.

Al termine digitiamo il comando:

composer dump-autoload per rigenerare l’autoloader delle classi.

È arrivato il momento di fare il commit con questa serie di comandi:

git add .
git commit -m "feat: first stable release"
git tag v1.0.0
git push origin main v1.0.0

Ora ci muoviamo su GitHub e dovremmo vedere la nostra repo con l’ultimo commit, nel mio caso thesimon82 feat: first stable release.

Copiamo l’URL in alto sulla barra degli indirizzi e ci spostiamo su packagist.

Clicchiamo in alto su “Submit” e incolliamo nel campo di testo il link di GitHub che abbiamo copiato. Poi premiamo il pulsante Check. A questo punto Packagist analizzerà il composer.json e mostrerà subito la scheda del pacchetto. Cliccando sul pulsante in basso “Submit” viene creato il Package.

Abbiamo terminato, ora è il momento di testare il funzionamento.

Creiamo una nuova cartella “Stats Test” poi andiamo su terminale ed entriamo all’interno della cartella.
Qui digitiamo:

composer require thesimon82/descriptive-statistics

Ora importiamo questa cartella all’interno del nostro ambiente di sviluppo e creiamo un nuovo file nella root: test.php

<?php
require_once 'vendor/autoload.php';
use RenorStatisticsDescriptiveStats;

$stats = new DescriptiveStats([1, 2, 3, 4, 5,6.22]);
echo $stats->mean();

Come possiamo vedere, stiamo includendo l’autoloader generato da Composer in cui tutti le classi mappate con PSR-4 diventano disponibili senza ulteriori require.

Definiamo il namespace utilizzato nella classe DescriptiveStats e istanziamo un nuovo oggetto con un dataset numerico. Ti ricorderai che il costruttore della classe filtrava automaticamente eventuali valori non numerici, riallineava le chiavi dell’array e lanciava un’eccezione se l’insieme fosse risultato vuoto. Viene quindi richiamato il metodo mean() che esegue la media e lo visualizza a schermo.

Se adesso dal terminale lanci il comando php test.php se hai fatto tutto correttamente dovresti avere come risultato 3.5366666666667 che è proprio la media approssimata dei valori che abbiamo passato al costruttore della classe.

Conclusioni

Abbiamo visto come trasformare una semplice classe PHP in un pacchetto Composer distribuito su Packagist. Ora la libreria può essere installata con un unico comando, beneficia di versionamento semantico, integrazione continua e di un’automazione che aggiorna automaticamente la scheda su Packagist a ogni nuovo tag.

Da questo momento il ciclo di vita è lineare: implementi una funazionalità, esegui i test, incrementi la versione, crei il tag e fa il push su GitHub. Packagist e Composer faranno il resto!

[starbox]

L'articolo Da Zero a Packagist: pubblicare una libreria PHP su Composer proviene da RENOR & Partners S.r.l..

L’intelligenza artificiale è ormai interpretata da molti imprenditori come una moda ma andrebbe utilizzata solo laddove è veramente un valore aggiunto. Parlando di efficienza, utilizzare l’intelligenza artificiale per calcolare una media, una mediana, una moda non è solamente come sparare con un bazooka per uccidere un paio di mosche ma può rivelarsi anche più lenta, dal momento che bisogna calcolare i tempi di inferenza, rispetto ad un algoritmo a stati finiti.

Anche in contesti non strettamente scientifici o accademici, conoscere i fondamenti della statistica descrittiva, può rivelarsi estremamente utile: dalla generazione di report automatizzati, al monitoraggio delle performance di un’applicazione, fino alla costruzione di dashboard o strumenti analitici.

In questo articolo realizzeremo una classe PHP che calcola i principali indicatori statistici descrittivi, come media, mediana, moda, varianza, deviazione standard, quartili, ecc., partendo da zero, senza librerie esterne. Il codice sarà pulito, riutilizzabile e pronto per essere trasfromato in un pacchetto Composer su cui verrà realizzato un altro articolo.

Progettare una classe semplice ma estensibile

Per costruire una classe di statistica descrittiva utile e facilmente integrabile in altri progetti, adotteremo una struttura ad oggetti aderente ai principi SOLID, evitando dipendenze esterne e garantendo la possibilità di estensoine futura (es. supporto a dataset associativi o lettura da file CSV).

La classe sarà progettata per lavorare su array di valori numerici, e calcolare in modo efficiente i principali indici statistici. L’obiettivo è offrire un’interfaccia semplice.

Per prima cosa andiamo a creare una nuova repo su GitHub, la trovate al link:
https://github.com/thesimon82/descriptive-statistics-php

Iniziamo ad implementare i metodi.

La struttura del progetto dovrà avere questa forma:

descriptive-statistics-php/
├─ composer.json
├─ composer.lock
├─ phpunit.xml
├─ examples/
│  └─ geometric_mean_demo.php
│  └─ harmonic_mean_demo.php
│  └─ iqr_demo.php
│  └─ mad_demo.php
│  └─ mean_demo.php
│  └─ median_demo.php
│  └─ min_max_demo.php
│  └─ mode_demo.php
│  └─ percentile_demo.php
│  └─ range_demo.php
│  └─ standard_deviation_demo.php
│  └─ trimmed_mean_demo.php
│  └─ variance_demo.php
├─ src/
│  └─ DescriptiveStats.php
├─ tests/
│  └─ DescriptiveStatsTest.php
└─ vendor/
    └─ autoload.php

Come puoi notare ho previsto anche una cartella per l’inserimento dei test sui metodi della classe (opzionale) con phpunit. Il file phpunit.xml definisce la cartella dei test ed i sorgenti di phpunit che deve essere installato tramite composer alla repo packagist phpunit/phpunit inserendolo come dipendenza di sviluppo tramite il comando composer require --dev phpunit/phpunit ^10.

Media

La media aritmetica (o valore medio) di un insieme di osservazioni numeriche si ottiene sommando tutti i valori e dividendo il risultato per il numero totale di osservazioni. Formalmente si scrive:

dove rappresenta la media aritmetica, è la cardinalità del campione e indica la somma di tutte le osservazioni. Questa misura fornisce un’indicazione sintetica della tendenza centrale dei dati, pur essendo sensibile alla presenza di valori anomali (outlier) che possono farla divergere significativamente dal “centro” reale della distribuzione.

Implementiamo questo metodo nella nostra classe DescriptiveStats.php

<?php

declare(strict_types=1);

namespace RenorStatistics;

/**
 * Class DescriptiveStats
 *
 * A lightweight class to perform basic descriptive statistics on numeric datasets.
 */
class DescriptiveStats
{
    /**
     * @var float[] Filtered and normalized numeric dataset.
     */
    private array $data;

    /**
     * Main constructor.
     *
     * @param array $data An array containing the numeric values to be analyzed.
     * @throws InvalidArgumentException If the array is empty or contains no numeric values.
     */
    public function __construct(array $data)
    {
        // Filter only numeric values (int or float) and reset array keys
        $filtered = array_filter($data, 'is_numeric');
        $this->data = array_values($filtered);

        if (count($this->data) === 0) {
            throw new InvalidArgumentException('The dataset must contain at least one numeric value.');
        }
    }

    /**
     * Calculates the arithmetic mean of the dataset.
     *
     * @return float The arithmetic mean.
     */
    public function mean(): float
    {
        return array_sum($this->data) / count($this->data);
    }
}

Come puoi notare abbiamo dichiarato lo strict_types. Questa opzione impone a PHP di non effettuare il cast automatico del valori. Questo è necessario per avere il pieno controllo del tipo di dato.

Dal momento che accetteremo i dati come un array di valori dichiariamo una proprietà privata della classe private array $data.

Nel costruttore della classe ci occupiamo di recuperare i dati che vengono passati quando andremo ad istanziare la classe per creare un nuovo oggetto, verificando che il contenuto dell’array $data sia di tipo numerico, ed andiamo a posizionare i valori all’interno della proprietà $this->data.

Nel metodo mean() andiamo a implementare la formula matematica della media: sommiamo tutti gli elementi dell’array passato e dividiamo per il numero di elementi ritornando il risultato.

Mediana

La mediana rappresenta il valore centrale di un insieme ordinato di osservazioni e suddivide il campione in due metà di egual numerosità. Data una serie di valori tali che :

• Se è dispari, la mediana è semplicemente l’elemento in posizione :
  
• Se è pari, la mediana è la media aritmetica dei due elementi centrali:
  

A differenza della media aritmetica, la mediana è robusta rispetto agli outlier, poiché dipende solo dall’ordinamento dei dati e non dalla loro ampiezza.

 /**
     * Calculates the median (50th percentile) of the dataset.
     *
     * @return float The median value.
     */
    public function median(): float
    {
        // Clone and sort the dataset to avoid mutating the original array
        $sorted = $this->data;
        sort($sorted, SORT_NUMERIC);

        $count = count($sorted);
        $mid   = intdiv($count, 2);

        // If the count is odd, return the middle value
        if ($count % 2 === 1) {
            return (float) $sorted[$mid];
        }

        // If even, return the average of the two central values
        return ($sorted[$mid - 1] + $sorted[$mid]) / 2.0;
    }

In questo metodo recupero i dati e li ordino. Otteniamo la dimensione e ricarivamo l’indice centrale con la divisione intera. Ad esempio se abbiamo 7 elementi, intdiv(7,2) restituisce 3, che corrisponde alla quarta posizione (ricorda che gli array in PHP sono zero-based!). Se il numero di valori è dispari, esiste un unico elemento perfettamente centrale e lo restituisce. In caso di numerosità pari, invece non c’è un solo valore centrale, ce ne sono due, quello in posizione $mid - 1 e quello in posizione $mid. La mediana per definizione è la media aritmetica di questi due valori. Sommiamo quindi i centrali e dividiamo per 2.0 (con la notazione decimale per forzare la divisione in virgola mobile) ottenendo a sua volta un risultato float. In questo modo il metodo restituisce il cinquantesimo percentile del campione senza modificare il dataset originario e rispettando la definizione statistica sia per serie di lunghezza dispari che pari.

Moda

Dopo media e mediana, il terzo indicatore classicamente più utilizzato della statistica descrittiva è la moda, ossia il valore, o i valori, che ricorrono più spesso all’interno di un insieme di osservazioni. se denotiamo con la frequenza assoluta di un valore nel campione, la moda si ottiene come

.

Possiamo distinguere per la serie di valori in ingresso:

• Serie unimodale quando un solo valore ha la frequenza massima
• Serie multimodale quando due o più valori condividono la frequenza massima
• Serie senza moda quanto tutti i valori della serie compaiono all’interno della stessa una sola volta

La moda è particolarmente utile quando i dati sono categorici o quando si vuole evidenziare la concentrazione attorno a determinati valori interi. A differenza di media e mediana non misura la posizione centrale ma il valore o i valori che si ripetono maggiormente nella serie. Non a caso quando un capo d’abbigliamento è di moda è perché questo, rispetto ad altri capi d’abbigliamento in una serie di vendite, risulta quello più venduto e quindi “quello che va più di moda”.

Aggiungiamo quindi il metodo alla nostra classe:

/**
 * Returns the mode(s) of the dataset.
 *
 * If the dataset is multimodal, an array with all modal values is returned.
 * If every value occurs only once, an empty array is returned (no mode).
 *
 * @return float[] list of modal values
 */
public function mode(): array
{
    // Build a frequency table: value => occurrences
    $frequencies = array_count_values($this->data);

    // Determine the highest frequency
    $maxFrequency = max($frequencies);

    // If every value appears only once, there is no mode
    if ($maxFrequency === 1) {
        return [];
    }

    // Collect all values that share the highest frequency
    $modes = [];
    foreach ($frequencies as $value => $count) {
        if ($count === $maxFrequency) {
            // Cast to float so that return type is consistent
            $modes[] = (float) $value;
        }
    }

    sort($modes, SORT_NUMERIC); // return modes in ascending order
    return $modes;
}

array_count_values() scorre l’intero dataset e restituisce un array associativo in cui la chiave è il valore osservato e il valore è quante volte ricorre. È un modo rapido per calcolare per ogni .
Con max($frequencies) otteniamo il numero di occorrenze più alto presente nella tabella; è il valore di nella definizione matematica.
Se la frequenza massima è 1, significa che ogni osservazione è unica. In tal caso il metodo restituisce un array vuoto per indicare che non esiste alcun valore modale.
Si itera sulla tabella delle frequenze: per ogni chiave il cui conteggio eguaglia la frequenza massima, si aggiunge quel valore (cast a float) all’array $modes. In questo modo vengono inclusi tutti i valori modali in caso di multimodalità.
Prima di restituire il risultato, sort($modes, SORT_NUMERIC) assicura che le mode siano ordinate in senso crescente, rendendo più prevedibile l’output.

In questo modo abbiamo coperto tutti i possibili scenari: unimodali, multimodali e senza moda.

Media geometrica

La media geometrica è la misura di tendenza centrale più adatta quando i dati rappresentano tassi di crescita o rapporti (per esempio rendimenti percentuali, indici di variazione, scale logaritmiche).

Data una serie di valori tutti strettamente positivi , la media geometrica si definisce come:

oppure in forma logaritmica più stabile numericamente

.

Questa quantità corrisponde al fattore di crescita “medio” che, applicato n volte in sequenza, produce lo stesso risultato del prodotto reale dei valori.

/**
 * Calculates the geometric mean of the dataset.
 *
 * @throws DomainException If any value is zero or negative.
 * @return float The geometric mean.
 */
public function geometricMean(): float
{
    // The geometric mean is defined only for strictly positive numbers.
    foreach ($this->data as $value) {
        if ($value <= 0) {
            throw new DomainException('Geometric mean requires all values to be greater than zero.');
        }
    }

    // Use logarithms for numerical stability: exp( (1/n) * sum(log(x_i)) )
    $logSum = array_sum(array_map('log', $this->data));
    return exp($logSum / count($this->data));
}

Poiché la media geometrica è definita solo per numeri positivi, il metodo scorre il dataset e lancia una DomainException se trova valori ≤ 0. Questo previene risultati matematicamente scorretti (o complessi).
Invece di calcolare direttamente il prodotto (che potrebbe facilmente andare in overflow), convertiamo ogni valore con log(), sommiamo i logaritmi e dividiamo per . In base alle proprietà dei logaritmi:


Applicando exp() al valore medio dei logaritmi otteniamo la media geometrica.

Media armonica

La media armonica è la misura di tendenza centrale più indicata quando i dati rappresentano velocità, rapporti o frazioni: per esempio km / h percorsi a diversi ritmi, costo medio per unità o rendimento medio di investimenti calcolato come “quote per euro”.

Data una serie di valori positivi (nessun valore può essere zero, perché apparirebbe al denominatore), la media armonica si definisce come:

In altre parole si calcola l’inverso della media aritmetica degli inversi. Rispetto alla media aritmetica, la media armonica pesa di più i valori piccoli: è quindi preziosa quando si desidera penalizzare fortemente le prestazioni peggiori (es.: il tempo medio per percorrere un chilometro su più tratte di diversa velocità).

/**
 * Calculates the harmonic mean of the dataset.
 *
 * @throws DomainException If any value is zero or negative.
 * @return float The harmonic mean.
 */
public function harmonicMean(): float
{
    // Harmonic mean is defined only for strictly positive numbers.
    foreach ($this->data as $value) {
        if ($value <= 0) {
            throw new DomainException('Harmonic mean requires all values to be greater than zero.');
        }
    }

    $inverseSum = array_sum(array_map(
        static fn (float $v): float => 1.0 / $v,
        $this->data
    ));

    return count($this->data) / $inverseSum;
}

Per prima cosa si effettua un controllo di dominio, qualunque valore maggiore o uguale a zero genera una DomainException, altrimenti il risultato non sarebbe definitivo o diverrebbe infinito. Poi si effettua una somma degli inversi: array_map() calcola l’inverso di ogni elemento, array_sum() li somma.
La formula diretta divide il numero di osservazioni per la somma ottenuta, secondo la definizione matematica.

Troncamento della media (o media troncata)

Quando un campione contiene outlier estremi che rischiano di distorcere la media aritmetica, una soluzione elegante è la media troncata (o trimmed mean).

Si sceglie una percentuale % (tipicamente 5 % oppure 10 %), si ordina il campione e si scartano le prime osservazioni più piccole e le ultime più grandi, dove

.

In questo modo si ottiene una misura di tendenza centrale più robusta della media aritmetica ma meno drastica della mediana.

/**
 * Calculates the trimmed mean of the dataset.
 *
 * @param float $percent Percentage (0–50) of data to trim at each tail.
 * @throws DomainException If $percent is out of range or removes all data.
 * @return float The trimmed mean.
 */
public function trimmedMean(float $percent): float
{
    if ($percent < 0.0 || $percent >= 50.0) {
        throw new DomainException('Percent must be in the range 0 <= p < 50.');
    }

    $count = count($this->data);
    if ($count < 3) {
        // Too few values to trim meaningfully; fall back to arithmetic mean
        return $this->mean();
    }

    // Clone and sort to preserve original order
    $sorted = $this->data;
    sort($sorted, SORT_NUMERIC);

    // Number of elements to trim from each end
    $k = (int) floor($count * $percent / 100.0);

    // Ensure at least one value remains
    if ($k * 2 >= $count) {
        throw new DomainException('Trim percentage removes all data.');
    }

    $trimmed = array_slice($sorted, $k, $count - 2 * $k);

    return array_sum($trimmed) / count($trimmed);
}

Il metodo inizia verificando che la percentuale scelta per il taglio sia sensata: deve essere maggiore o uguale a zero e strettamente minore di cinquanta, altrimenti si solleva un’eccezione; se chiedessimo, ad esempio, di eliminare il 60 % di dati a ciascuna coda non rimarrebbe nulla da mediare.

Se il campione contiene meno di tre osservazioni, la funzione considera il taglio privo di significato e restituisce semplicemente la media aritmetica: con due valori, infatti eliminare anche solo un elemento farebbe sparire metà dei dati, mentre con uno solo non esiste nulla da troncare.

Si procede poi a clonare l’array originale e a ordinarlo in senso crescente; la clonazione preserva l’ordine in cui i dati erano stati forniti all’oggetto, mentre l’ordinamento è indispensabile perché il troncamento viene applicato partendo dagli estremi della distribuzione.

Il numero di elementi da scartare in ciascuna coda, indicato con , si ottiene moltiplicando la dimensione del campione per la percentuale richiesta e arrotondando verso il basso; se ad esempio abbiamo dieci valori e vogliamo una trimmed mean al 10 %, toglieremo un elemento all’inizio e uno alla fine.

Prima di procedere, il metodo controlla che ‟due volte ” non sia pari o superiore alla lunghezza dell’array: se così fosse, il taglio eliminerebbe tutti i dati e la media non avrebbe più senso; in tal caso viene lanciata un’ulteriore eccezione.

Superata questa verifica, array_slice() preleva la porzione centrale che rimane dopo aver scartato i valori minori e i maggiori; su tale sottoinsieme si calcola infine la media aritmetica, che è proprio la media troncata desiderata.

La funzione restituisce così un indicatore di tendenza centrale più robusto della media classica: gli outlier, rimossi prima del calcolo, non possono più trascinare il risultato verso valori estremi.

Range

Il range è la misura di dispersione più semplice: indica l’ampiezza totale dei valori osservati, ossia la distanza fra l’estremo minimo e quello massimo del campione. Se chiamiamo

,

allora il range si definisce come

.

Pur essendo sensibile agli outlier (lo stesso valore che condiziona il massimo o il minimo condiziona anche il range), questa misura offre un’indicazione immediata della larghezza della distribuzione e viene spesso riportata accanto a medie o mediana per dare un colpo d’occhio sulla dispersione complessiva.

/**
 * Calculates the range (max – min) of the dataset.
 *
 * @return float The range of the data.
 */
public function range(): float
{
    // min() e max() sono O(n) ma il dataset è già in memoria: soluzione lineare
    return max($this->data) - min($this->data);
}

Il metodo come è possibile vedere è molto essenziale. Si invocano le funzioni PHP native max() e min()che eseguono una sola scansione lineare dell’array per individuare rispettivamente il valore più grande e quello più piccolo. Sottraendo il minimo dal massimo si ottiene l’ampiezza totale del campione; il risultato è restituito come float, coerente con gli altri metodi della classe.

Quartili e intervallo quartile (IQR)

Per descrivere la dispersione di un campione in modo più robusto rispetto al semplice range, si ricorre ai quartili:

• – 25° percentile (primo quartile)
• – 50° percentile (mediana)
• – 75° percentile (terzo quartile)

L’intervallo interquartile si definisce come e rappresenta l’ampiezza della metà centrale dei dati. È poco sensibile agli outlier perché si basa solo sui valori compresi fra il 25% e il 75% della distribuzione.

Un uso classico dell’IQR è il rilevamento degli outlier col metodo di Tukey  (valori minori di o maggiori di )

/**
 * Returns an array with the first, second (median) and third quartile.
 *
 * Method: "Tukey hinges".
 *  - Sort the dataset.
 *  - For Q1 and Q3, exclude the median when the sample size is odd.
 *
 * @return float[] [Q1, Q2, Q3] in ascending order.
 */
 public function quartiles(): array
    {
        $sorted = $this->data;
        sort($sorted, SORT_NUMERIC);

        $n = count($sorted);
        if ($n === 1) {
            return [$sorted[0], $sorted[0], $sorted[0]];
        }
        $mid = intdiv($n, 2);

        // Median (Q2)
        $q2 = ($n % 2 === 0)
            ? ($sorted[$mid - 1] + $sorted[$mid]) / 2.0
            : (float) $sorted[$mid];

        // Lower half (exclude median if n is odd)
        $lower = array_slice($sorted, 0, $mid);
        // Upper half (exclude median if n is odd)
        $upper = array_slice($sorted, ($n % 2 === 0) ? $mid : $mid + 1);

        // Q1 and Q3 are medians of the two halves
        $q1 = $this->medianOfArray($lower);
        $q3 = $this->medianOfArray($upper);

        return [$q1, $q2, $q3];
    }

/**
 * Calculates the interquartile range (Q3 – Q1).
 *
 * @return float The interquartile range.
 */
public function iqr(): float
{
    [$q1, , $q3] = $this->quartiles();
    return $q3 - $q1;
}

/* ---------- Helper ---------- */
/**
 * Median of a pre-sorted array (helper for quartiles).
 *
 * @param float[] $arr Sorted numeric array.
 * @return float Median value.
 */
private function medianOfArray(array $arr): float
{
    $count = count($arr);
    if ($count === 0) {
        throw new LogicException('Cannot compute median of an empty array.');
    }

    $mid = intdiv($count, 2);

    return ($count % 2 === 0)
        ? ($arr[$mid - 1] + $arr[$mid]) / 2.0
        : (float) $arr[$mid];
}

Quando il metodo quartiles() viene invocato, la prima cosa che fa è creare una copia dei dati interni e ordinarla in senso crescente; questa copia protegge l’ordine originale fornito dall’utente e consente di lavorare con un vettore monotonicamente ordinato, prerequisito indispensabile per individuare i quartili. Subito dopo, la variabile $n memorizza la lunghezza del campione e $mid rappresenta l’indice centrale calcolato tramite divisione intera. Con queste due informazioni si procede a determinare la mediana dell’intero campione, che diventa il secondo quartile ; se il numero di osservazioni è pari, la mediana è la media aritmetica dei due valori centrali, mentre nel caso dispari coincide con il valore in posizione centrale.

Una volta noto , l’array ordinato viene spezzato in due metà. Se la numerosità è dispari la mediana non va inclusa né nella parte inferiore né in quella superiore, perciò la funzione array_slice la esclude esplicitamente; se è pari la suddivisione avviene esattamente a metà. A questo punto entrano in gioco i quartili estremi: per calcolare e non si crea alcun nuovo oggetto, bensì si invoca l’helper privato medianOfArray sulle due metà già ordinate. Questa piccola routine riceve un vettore, ne conta gli elementi, determina l’indice centrale e restituisce la mediana con la stessa logica adottata in precedenza; il tutto resta confinato all’interno della classe, così l’interfaccia pubblica rimane pulita e ogni duplicazione di codice è evitata.

Il metodo quartiles() restituisce infine un array con i tre valori in ordine crescente. Il fratello iqr() si limita a scompattare quell’array, sottrae da e ritorna l’intervallo interquartile, fornendo in un’unica chiamata la misura di dispersione più robusta della classe.

In questo assetto la logica della mediana resta centralizzata dentro l’helper privato, viene riutilizzata sia per i quartili sia, in modo implicito, per qualsiasi eventuale altra funzionalità interna che avesse bisogno di calcolare una mediana su un sottoinsieme ordinato, mentre l’API pubblica continua ad offrire metodi autodidattici e facili da comprendere per chi integrerà la tua libreria.

Varianza

Per misurare quanto i valori si discostino dalla loro tendenza centrale si introduce la varianza, che calcola la media dei quadrati degli scarti dalla media aritmetica. Date osservazioni con media , la varianza della popolazione si definisce

Se invece i dati rappresentano un campione estratto da una popolazione più ampia, lo stimatore corretto (varianza campionaria) divide per :

La varianza restituisce un valore quadratico: è sempre non negativa e cresce rapidamente quando gli scarti aumentano, perciò un suo uso frequente è passare alla radice quadrata (deviazione standard) per tornare alle stesse unità di misura dei dati.

/**
 * Calculates the variance of the dataset.
 *
 * @param bool $sample If true, uses (n-1) in the denominator (sample variance).
 *                     If false, uses n (population variance).
 * @return float The variance value.
 */
public function variance(bool $sample = false): float
{
    $n = count($this->data);

    // For a single value, population variance is 0, sample variance is undefined
    if ($n < 2 && $sample) {
        throw new DomainException('Sample variance requires at least two observations.');
    }
    if ($n === 1) {
        return 0.0;
    }

    $mean = $this->mean();
    $sumSquares = 0.0;

    foreach ($this->data as $v) {
        $diff        = $v - $mean;
        $sumSquares += $diff * $diff;
    }

    $denominator = $sample ? ($n - 1) : $n;
    return $sumSquares / $denominator;
}

Il metodo riceve un flag che indica se calcolare la varianza della popolazione o lo stimatore campionario. Inizia valutando la numerosità del dataset: con un solo valore la varianza di popolazione è per definizione zero, mentre quella campionaria non esiste e viene sollevata un’eccezione. Una volta nota la media, il ciclo attraversa ogni osservazione, sottrae la media, eleva lo scarto al quadrato e lo accumula. Terminata la sommatoria, la divisione avviene per o a seconda del contesto specificato, restituendo così la misura di dispersione desiderata.

Deviazione standard

La deviazione standard non è altro che la radice quadrata della varianza: serve a riportare la misura di dispersione alle stesse unità dei dati originali. Se la varianza indica “quanti quadrati di unità” si distanziano in media le osservazioni dalla loro media, la deviazione standard esprime quello scarto in unità lineari, dunque risulta molto più intuitiva per un lettore non specialista. Per la popolazione la si ottiene come , mentre nel caso campionario si usa . Valori di deviazione standard piccoli raccontano una distribuzione raccolta intorno alla media; valori grandi parlano di dati molto dispersi.

/**
 * Calculates the standard deviation of the dataset.
 *
 * @param bool $sample If true, returns the sample standard deviation (n-1 in the denominator).
 *                     If false, returns the population standard deviation.
 * @return float The standard deviation.
 */
public function standardDeviation(bool $sample = false): float
{
    return sqrt($this->variance($sample));
}

Il metodo non contiene logica aggiuntiva: richiama semplicemente variance() con lo stesso flag e ne restituisce la radice quadrata, delegando all’algoritmo già collaudato tutta la parte di calcolo e di controlli di dominio.

Errore standard della media

Quando dalla popolazione osserviamo soltanto un campione, la media campionaria è una stima soggetta a fluttuazioni: più il campione è piccolo, più la stima può variare da un campione all’altro. L’errore standard della media (in inglese Standard Error of the Mean, SEM) quantifica esattamente questa variabilità prevista. Se s è la deviazione standard campionaria e n è la numerosità del campione, l’errore standard si calcola con

.

Un SEM contenuto indica che la media calcolata su quel campione è verosimilmente vicina alla media vera della popolazione; un SEM ampio suggerisce un’incertezza maggiore. Il SEM è inoltre la base per costruire gli intervalli di confidenza della media.

/**
 * Calculates the standard error of the mean (SEM) of the dataset.
 *
 * SEM = sample standard deviation / sqrt(n)
 * Requires at least two observations.
 *
 * @throws DomainException If the dataset size is less than 2.
 * @return float The standard error of the mean.
 */
public function standardError(): float
{
    $n = count($this->data);

    if ($n < 2) {
        throw new DomainException('Standard error requires at least two observations.');
    }

    return $this->standardDeviation(true) / sqrt($n);
}

Il metodo prende innanzitutto la dimensione del campione; se c’è un solo valore non ha senso parlare di errore standard, perciò viene sollevata un’eccezione di dominio. In tutti gli altri casi richiama la deviazione standard campionaria già implementata, ottenendo . Dividendo per la radice quadrata di n ricava il SEM secondo la definizione statistica canonica e restituisce il risultato come valore in virgola mobile. In questo modo tutta la logica numerica rimane coerente con le altre misure di dispersione: la funzione si appoggia a metodi collaudati, non replica calcoli già presenti e garantisce un contratto d’uso molto semplice.

Scarto assoluto medio

Per misurare la dispersione in modo intuitivo, senza amplificare gli scarti con il quadrato come fa la varianza, si utilizza lo scarto assoluto medio. L’idea è semplice: si calcola la distanza assoluta fra ogni osservazione e la media aritmetica, poi si fa la media di quelle distanze. Se il campione è composto dai valori e la loro media è , lo scarto assoluto medio si ottiene con

.

Lo scarto assoluto medio mantiene le stesse unità di misura dei dati, è meno sensibile agli outlier rispetto alla deviazione standard e offre un’interpretazione immediata: indica di quante unità, in media, ogni valore si discosta dal centro della distribuzione.

/**
 * Calculates the mean absolute deviation (MAD) of the dataset.
 *
 * @return float The mean absolute deviation.
 */
public function meanAbsoluteDeviation(): float
{
    $mean = $this->mean();
    $sumAbs = 0.0;

    foreach ($this->data as $v) {
        $sumAbs += abs($v - $mean);
    }

    return $sumAbs / count($this->data);
}

Il metodo ricava innanzitutto la media aritmetica del campione tramite la funzione già esistente mean(). Con questa informazione scorre ogni osservazione, sottrae la media, prende il valore assoluto dello scarto e lo accumula in $sumAbs. Una volta terminato il ciclo divide la somma degli scarti assoluti per la numerosità del campione, restituendo il risultato in virgola mobile. La logica rimane lineare e senza rami condizionali perché la formula del MAD non richiede distinzioni tra popolazione e campione: vale sempre la divisione per .

Percentili

Per localizzare un valore qualsiasi lungo la distribuzione si utilizzano i percentili: il percentile individua il punto sotto il quale ricade esattamente la percentuale dei dati ordinati. Il 50° percentile coincide con la mediana, il 25° e il 75° formano i quartili già implementati e, in generale, conoscere più percentili permette di descrivere la forma della distribuzione in maniera molto dettagliata. Poiché il campione è finito, la posizione del percentile raramente coincide con un indice intero: occorre dunque interpolare fra gli elementi adiacenti. Una convenzione ampiamente adottata (Excel e NumPy “linear” method) consiste nel calcolare

dove è la numerosità: se r cade fra gli indici e , il percentile è la combinazione lineare dei due valori con peso uguale alla parte frazionaria di .

/**
 * Returns the p-th percentile of the dataset (linear interpolation).
 *
 * @param float $p Percentile in the closed range [0, 100].
 * @throws DomainException If $p is outside 0–100.
 * @return float The requested percentile.
 */
public function percentile(float $p): float
{
    if ($p < 0.0 || $p > 100.0) {
        throw new DomainException('Percentile must be between 0 and 100.');
    }

    $sorted = $this->data;
    sort($sorted, SORT_NUMERIC);
    $n = count($sorted);

    // Edge cases: 0th and 100th percentile
    if ($p === 0.0)   { return (float) $sorted[0]; }
    if ($p === 100.0) { return (float) $sorted[$n - 1]; }

    // Linear-interpolated rank
    $rank        = ($p / 100.0) * ($n - 1);
    $lowerIndex  = (int) floor($rank);
    $upperIndex  = (int) ceil($rank);
    $weightUpper = $rank - $lowerIndex;

    // If rank is an integer, no interpolation is needed
    if ($lowerIndex === $upperIndex) {
        return (float) $sorted[$lowerIndex];
    }

    $lowerValue = $sorted[$lowerIndex];
    $upperValue = $sorted[$upperIndex];

    return (1.0 - $weightUpper) * $lowerValue + $weightUpper * $upperValue;
}

Il metodo convalida innanzitutto che il percentile richiesto sia compreso fra 0 e 100 inclusi, garantendo così coerenza con la definizione statistica. Subito dopo crea una copia ordinata dei dati, perché qualsiasi localizzazione percentuale richiede il vettore monotònicamente crescente. Gli estremi 0 e 100 vengono gestiti esplicitamente restituendo rispettivamente il minimo e il massimo del campione. Per tutti gli altri valori si calcola il rango reale , che può cadere fra due indici interi; l’indice inferiore e quello superiore delimitano l’intervallo che contiene la posizione frazionaria. Se è già intero non serve interpolazione e il metodo restituisce direttamente l’elemento corrispondente. In caso contrario si combinano linearmente il valore inferiore e quello superiore con un peso uguale alla parte decimale di , producendo un risultato continuo che scorre uniformemente fra gli elementi del campione.

Minimo e Massimo

Per completare il quadro delle misure descrittive è utile poter recuperare rapidamente l’estremo inferiore e quello superiore della distribuzione. Il valore minimo indica l’osservazione più piccola registrata nel campione; il valore massimo segnala la più grande. Queste due grandezze, pur estremamente semplici, sono indispensabili sia per dare il contesto ai dati (sapere dove inizia e dove finisce l’intervallo effettivamente osservato) sia come ingrediente di altre statistiche, ad esempio il range che hai già implementato. Poiché il dataset è interamente in memoria, individuare minimo e massimo richiede una sola scansione lineare e il costo computazionale è trascurabile.

/**
 * Returns the minimum value of the dataset.
 *
 * @return float The smallest observation.
 */
public function minValue(): float
{
    return (float) min($this->data);
}

/**
 * Returns the maximum value of the dataset.
 *
 * @return float The largest observation.
 */
public function maxValue(): float
{
    return (float) max($this->data);
}

Le funzioni PHP min() e max() attraversano l’array una sola volta; il cast garantisce che il tipo restituito sia float, uniforme con il resto dell’API.

Conclusioni

Con questo ultimo metodo abbiamo completato la nostra Classe DescriptiveStats che ora racchiude in un unico componente i più importanti strumenti di statistica descrittiva: dalle misure di posizione (media aritmetica, mediana, moda, percentili) alle misure di dispersione (range, varianza, deviazione standard, IQR, MAD), passando per indicatori di robustezza (media troncata) e incertezza (errore standard). Ogni funzione è autonoma, tipizzata e corredata di test automatici con PHPUnit che non abbiamo riportato per non allungare ulteriormente questo articolo già abbastanza pregno di nozioni.

Grazie a questa libreria, un progetto PHP può analizzare rapidamente piccoli dataset senza dipendenze esterne e senza dover utilizzare l’intelligenza artificiale solo per “moda”, integrare calcoli statistici in report, dashboard o API, estendere la classe con ulteriori indicatori sfruttando un’architettura chiara e coerente.

Nel prossimo articolo vedremo come trasformare il codice in un pacchetto Composer: creeremo la struttura definitiva della repository, vedremo come modificare il file composer.json, configureremo la CI per eseguire i test e pubblicheremo la libreria su Packagist, rendendola installabile con un semplice:

composer require thesimon82/descriptive-statistics

In questo modo potrai distribuire la tua soluzione open-source, ricevere contributi dalla community e riutilizzarla in qualsiasi progetto con la massima semplicità.

[starbox]

L'articolo Una Classe di Statistica descrittiva in PHP proviene da RENOR & Partners S.r.l..

Pubblicare fotografie online è diventato indispensabile per fotografi, e-commerce e blogger, ma secondo gli studi più recenti sul furto d’immagini, oltre il 70% dei contenuti visivi viene ricondiviso senza credito o autorizzazione. Una filigrana visibile protegge certamente l’autore, ma per renderla effettivamente valida ai fini del furto della proprietà intellettuale, spesso rovina l’estetica dello scatto con una “pecetta” tutt’altro che piacevole!

Al contrario, un watermark “invisibile” inscritto nei coefficienti della Trasformata Coseno Discreta (DCT), su cui si basa il formato JPEG, preserva la qualità percepita e può resistere a ridimensionamenti o compressioni leggere.

Codificando l’informazione nel segno di specifici coefficienti a bassa frequenza, è possibile garantire un compromesso efficace tra invisibilità e robustezza.

In questo progetto open-source, disponibile nella mia repository GitHub: https://github.com/thesimon82/php-dct-invisible-watermark, scritto in PHP 8.3 e basato su GD/Imagick per la manipolazione dei pixel, mostreremo passo passo come incorporare una firma testuale nei coefficienti a bassa frequenza (AC) di ciascun blocco 8×8, come recuperarne l’impronta e perché il segno del coefficiente rappresenta una strategia robusta contro le comuni compressioni JPEG, anche a qualità 80% o inferiore.

L’obiettivo non è solo didattico: il micro-servizio risultante può essere clonato dal repository e integrato, via CLI o API, in qualunque workflow di pubblicazione immagini.

I fondamenti tecnici

Prima di scrivere una sola riga di codice conviene chiarire come l’algoritmo di compressione JPEG agisce sulle immagini che deve comprimere.

Il formato JPEG divide l’immagine in una griglia di blocchi 8×8 pixel; ciascun blocco viene trasformato tramite la Discrete Cosine Transform (DCT), che scompone l’informazione visiva in 64 coefficienti ordinati dalla frequenza più bassa (l’angolo in alto a sinistra, responsabile dell’intensità media) a quella più alta (i dettagli più fini).

I coefficienti a media-bassa frequenza sono il punto ideale per il nostro watermark: toccare il coefficiente a frequenza zero (DC) produrrebbe aloni visibili, mentre alterare solo le frequenze più alte porterebbe a una loro eliminazione già alla prima compressione JPEG.

Intervenendo invece su coefficienti intermedi possiamo codificare singoli bit modificando il segno del coefficiente (positivo = 0, negativo = 1), ottenendo così un marcatore invisibile all’occhio ma sufficientemente robusto da sopravvivere a ridimensionamenti e compressioni JPEG fino a qualità 80.

Questo principio matematico guiderà l’intera implementazione.

Leggeremo ogni blocco 8×8, calcoleremo la DCT tramite una funzione nativa in PHP, modificheremo il segno di uno o più coefficienti scelti e salveremo il nuovo JPEG tramite GD o Imagick.

In altre parole, il watermark sarà nascosto proprio nei coefficienti che l’algoritmo di compressione JPEG tende a preservare: sarà invisibile all’occhio ma difficile da rimuovere, anche in presenza di ricompressioni leggere.

La matematica che rende invisibile il watermark

Ogni blocco di intensità (dove ) viene convertito in 64 coefficienti (con ) tramite:

[

C_{u,v}= frac{1}{4},alpha(u),alpha(v)!

sum_{x=0}^{7},sum_{y=0}^{7}

f_{x,y};

cos!Bigl[frac{(2x+1)upi}{16}Bigr],

cos!Bigl[frac{(2y+1)vpi}{16}Bigr]

tag{1}

]

dove

[

alpha(k)=

begin{cases}

dfrac1{sqrt{2}}, & k=0,\[6pt]

1, & kge 1.

end{cases}

]

(coefficiente DC) è la media luminosa del blocco. I coefficientiAC descrivono contenuti sempre più fini man mano che o crescono.

Esempio numerico semplificato

Supponiamo un blocco che abbia tutto un valore di 128, un grigio medio. Allora:

, mentre per perché non ci sono variazioni di frequenza.

L’immagine compressa conserva i coefficienti più bassi, quelli più alti sono quantizzati in modo aggressivo, spesso fino a 0.

Quantizzazione e scelta delle frequenze sicure

Prima di essere salvati in JPEG, i coefficienti DCT vengono divisi per una matrice di quantizzazione , specifica per ogni frequenza:

[

tilde{C}{u,v}= operatorname{round}!Bigl(frac{C{u,v}}{Q_{u,v}}right)Big).

tag{2}

]

Più alto è il valore di , maggiore sarà la perdita di precisione, con la possibilità che i coefficienti vengano ridotti a zero.
Per questo motivo, nel nostro algoritmo operiamo su un sottoinsieme a bassa frequenza dei coefficienti AC, in posizioni dove la quantizzazione è moderata e i valori sopravvivono meglio alla compressione.
Evitiamo inoltre i coefficienti troppo bassi (DC incluso), che potrebbero introdurre artefatti visibili se modificati.

Codifica di un bit nel coefficiente

Per garantire la sopravvivenza del bit dopo la compressione JPEG, invece di usare la parità, imponiamo il segno del coefficiente in base al bit da scrivere:

[

operatorname{embed}(c, b) =

begin{cases}

+text{minAmp} + text{boost}, & b = 0 \\

-text{minAmp} – text{boost}, & b = 1

end{cases}

tag{3’}

]

Dove:
• garantisce un valore sufficientemente lontano da zero (tipicamente ≥ 80),
• (es. 64) aumenta la distanza dal centro per evitare l’annullamento in fase di quantizzazione.

In questo modo, anche dopo trasformazioni lossy, il segno resta inalterato e il bit può essere recuperato in lettura.

Se successivamente desideriamo leggere il bit, ci basterà valutare il segno del coefficiente DCT quantizzato:

[

b =

begin{cases}

0, & tilde{C}{u,v} ge 0 \\

1, & tilde{C}{u,v} < 0

end{cases}

tag{4’}

]

In altre parole, un coefficiente positivo indica bit 0, uno negativo indica bit 1.

Questo metodo è più robusto, perché il segno di un coefficiente sopravvive a molte trasformazioni lossy, a differenza del singolo bit meno significativo.

Ricostruzione (Inverse DCT)

Dopo aver modificato i coefficienti, invertiamo la trasformazione per ottenere il blocco d’immagine marcato: 

[

f_{x,y}= frac{1}{4}!

sum_{u=0}^{7}sum_{v=0}^{7}

alpha(u),alpha(v),

tilde{C}_{u,v},

cos!Bigl[frac{(2x+1)upi}{16}Bigr],

cos!Bigl[frac{(2y+1)vpi}{16}Bigr].

tag{5}

]

L’errore massimo introdotto da una variazione di ±1 su un coefficiente di media frequenza è inferiore a 1 quantum in luminanza, sotto la soglia di percezione umano-visiva per fotografie reali.

Ridondanza ciclica per indurre robustezza

Per fronteggiare compressioni o ritagli, codifichiamo il messaggio M duplicando ciascun bit k volte e applicando un voto di maggioranza in lettura. Con k=3:

[

M = b_1b_2dots b_n

;longrightarrow;

b_1b_1b_1,b_2b_2b_2dots b_nb_nb_n

tag{6}

]

Il recupero corretto è garantito finché almeno due copie su tre sopravvivono.

Dalle formule al codice: la classe DCT

Ora che abbiamo formalizzato l’intero impianto matematico, possiamo tradurre l’equazione (1) e la sua inversa direttamente in PHP.

Per mantenere il progetto in puro PHP, senza estensioni native né dipendenze esterne, implementiamo la DCT manualmente su blocchi 8×8.

Questo approccio è sufficientemente veloce per immagini fino a qualche megapixel e, soprattutto, è trasparente e facile da comprendere e modificare.

Il progetto è organizzato con Composer e autoload PSR-4, ma la classe Dct è completamente autonoma e non richiede librerie esterne.

Se in futuro vorrai estendere il sistema con analisi matriciali (es. box counting o misure di distorsione), potrai integrare MathPHP, ma non è necessaria per la DCT.

composer.json

{
    "name": "renornad/php-dct-invisible-watermark",
    "description": "Pure-PHP DCT watermarking library for JPEG images.",
    "type": "project",
    "license": "MIT",
    "require": {
      "php": ">=8.3"
    },
    "autoload": {
      "psr-4": {
        "Renor\Watermark\": "src/"
      }
    }
  }

Dopo aver definito il nostro file composer.json procediamo all’installazione. Andiamo su terminale e digitiamo il comando:

composer install

A questo punto composer creerà il file composer.lock e la cartella vendor che però non installerà pacchetti da Packagist perché non stiamo includendo dipendenze.

src/Dct.php

Ora possiamo finalmente scrivere la classe Dct. Ricordo che è preferibile inserire i commenti al codice, come standard in inglese:

<?php

declare(strict_types=1);

namespace RenorWatermark;

/**
 * 2-D Discrete Cosine Transform (DCT) and its inverse (IDCT) for 8x8 blocks.
 */
final class Dct
{
    private const N = 8;
    private const SQRT_2_INV = 0.7071067811865476; // 1 / sqrt(2)

    /**
     * Performs the forward DCT on an 8x8 block of pixel intensities (0-255).
     */
    public static function forward(array $block): array
    {
        self::assertBlock($block);
        $C = [];

        for ($u = 0; $u < self::N; ++$u) {
            $alphaU = ($u === 0) ? self::SQRT_2_INV : 1.0;
            for ($v = 0; $v < self::N; ++$v) {
                $alphaV = ($v === 0) ? self::SQRT_2_INV : 1.0;
                $sum = 0.0;
                for ($x = 0; $x < self::N; ++$x) {
                    for ($y = 0; $y < self::N; ++$y) {
                        $cosX = cos((2 * $x + 1) * $u * M_PI / (2 * self::N));
                        $cosY = cos((2 * $y + 1) * $v * M_PI / (2 * self::N));
                        $sum += $block[$x][$y] * $cosX * $cosY;
                    }
                }
                // The DCT formula includes a factor of 1/4
                $C[$u][$v] = 0.25 * $alphaU * $alphaV * $sum;
            }
        }
        return $C;
    }

    /**
     * Performs the inverse DCT on an 8x8 block of coefficients, 
     * returning pixel values in the range [0..255].
     */
    public static function inverse(array $coeff): array
    {
        self::assertBlock($coeff);
        $f = [];

        for ($x = 0; $x < self::N; ++$x) {
            for ($y = 0; $y < self::N; ++$y) {
                $sum = 0.0;
                for ($u = 0; $u < self::N; ++$u) {
                    $alphaU = ($u === 0) ? self::SQRT_2_INV : 1.0;
                    for ($v = 0; $v < self::N; ++$v) {
                        $alphaV = ($v === 0) ? self::SQRT_2_INV : 1.0;
                        $cosX = cos((2 * $x + 1) * $u * M_PI / (2 * self::N));
                        $cosY = cos((2 * $y + 1) * $v * M_PI / (2 * self::N));
                        $sum += $alphaU * $alphaV * $coeff[$u][$v] * $cosX * $cosY;
                    }
                }
                $pixel = (int) round(0.25 * $sum);
                $f[$x][$y] = max(0, min(255, $pixel));
            }
        }
        return $f;
    }

    /**
     * Checks that the array is exactly 8x8.
     */
    private static function assertBlock(array $block): void
    {
        if (count($block) !== self::N) {
            throw new InvalidArgumentException('Block must have 8 rows.');
        }
        foreach ($block as $row) {
            if (count($row) !== self::N) {
                throw new InvalidArgumentException('Each row must have 8 columns.');
            }
        }
    }

    /**
     * Disallow instantiation.
     */
    private function __construct()
    {
    }
}

Questa classe è il cuore del progetto. Racchiude l’algoritmo della Trasformata Coseno Discreta bidimensionale applicata a blocchi 8×8 pixel, lo stesso schema impiegato dallo standard JPEG. All’avvio del metodo forward, la classe controlla che l’array ricevuto contenga esattamente otto righe e otto colonne; in caso contrario, lancia un’eccezione per evitare che un errore di dimensionamento si propaghi silenziosamente.

Una volta verificata la forma, per ogni coppia di indici di frequenza , calcola la doppia somma definita dalla formula canonica della DCT: prende ciascun valore di luminosità , lo moltiplica per due coseni — uno in funzione di e della coordinata , l’altro in funzione di e della coordinata — e accumula il risultato. Terminata la scansione del blocco, applica il fattore di normalizzazione , dove e per , così che il coefficiente conservi la media luminosa e tutti gli altri rappresentino, con la corretta scala, le componenti di dettaglio via via più fini. Il metodo restituisce quindi una matrice 8×8 di coefficienti in virgola mobile: è su questa rappresentazione in frequenza che più avanti incideremo i bit del watermark.

Il percorso inverso è affidato al metodo inverse. Anche qui, prima di qualsiasi elaborazione, la classe impone la verifica della forma del blocco. Per ogni coppia di coordinate di pixel , ricostruisce la luminanza sommando le 64 frequenze, ciascuna ponderata dal prodotto dei coseni e dai fattori di normalizzazione . Il valore finale viene moltiplicato per , arrotondato all’intero più vicino e limitato all’intervallo 0–255, così da evitare che eventuali errori numerici facciano uscire il risultato dallo spazio colore.

L’implementazione segue fedelmente la definizione matematica, senza ricorrere ad accelerazioni FFT o SIMD, privilegiando la chiarezza didattica rispetto alle prestazioni. Il costruttore è privato, la classe non può essere istanziata, e tutti i metodi sono statici e privi di stato interno: in questo modo la DCT si comporta come una funzione pura, facilmente testabile e riutilizzabile. Quando, nei prossimi paragrafi, la useremo per incastonare un bit modificando il segno di un coefficiente a bassa frequenza, potremo essere certi che la trasformazione diretta e inversa siano numericamente coerenti e che l’alterazione resti confinata ai valori che intendiamo manipolare.

src/Watermarker.php

La classe Watermarker è la regista che orchestra la fase più delicata dell’intero progetto. Riceve in ingresso o in uscita una sequenza di blocchi 8×8 di coefficienti DCT già calcolati dalla classe Dct e, senza occuparsi della lettura fisica del file JPEG, si limita a manipolare quei numeri per nascondere o recuperare un testo ASCII.

<?php

declare(strict_types=1);

namespace RenorWatermark;

/**
 * Watermarker class
 *
 * Embeds/extracts a short ASCII message (max 10 characters + terminator)
 * into low-frequency DCT coefficients. Instead of relying on the single
 * parity bit – too fragile after rounding and quantization – here
 * we encode the information into the **sign** of the coefficient:
 *
 *   bit 0  → positive coefficient
 *   bit 1  → negative coefficient
 *
 * The sign is never affected during:
 *   1. IDCT → integer rounding,
 *   2. division by JPEG quantization tables,
 *   3. further rounding or transformations.
 */
final class Watermarker
{
    /** Low-frequency coordinates (survive even at q≈90–100). */
    private const EMBED_COORDS = [
        [0, 1], [1, 0], [1, 1], [0, 2],
        [2, 0], [1, 2], [2, 1], [2, 2]
    ];

    /** Redundancy: each bit is repeated 25 times. */
    private const REDUNDANCY = 25;

    private const TERMINATOR = "";

    /* ------------------------------------------------------------------
       Public API
    -------------------------------------------------------------------*/

    public static function embed(array &$blocks, string $msg): void
    {
        if (strlen($msg) > 10) {
            throw new RuntimeException('Message too long (max 10).');
        }

        $bits   = self::stringToBitStream($msg . self::TERMINATOR);
        $cursor = 0;

        foreach ($blocks as &$block) {
            foreach (self::EMBED_COORDS as [$u, $v]) {
                if ($cursor >= count($bits)) {
                    return;
                }
                $bit           = $bits[$cursor++];
                $block[$u][$v] = self::forceSign($block[$u][$v], $bit);
            }
        }
        if ($cursor < count($bits)) {
            throw new RuntimeException('Image too small for the message.');
        }
    }

    public static function extract(array $blocks): string
    {
        $bits = [];
        foreach ($blocks as $block) {
            foreach (self::EMBED_COORDS as [$u, $v]) {
                $bits[] = ( (int) round($block[$u][$v]) < 0 ) ? 1 : 0;
            }
        }

        $filtered   = self::majority($bits, self::REDUNDANCY);
        $byteChunks = array_chunk($filtered, 8);

        $out = '';
        foreach ($byteChunks as $chunk) {
            if (count($chunk) < 8) break;
            $ch = chr(self::bitsToInt($chunk));
            if ($ch === self::TERMINATOR) break;
            $out .= $ch;
        }
        return $out;
    }

    /* ------------------------------------------------------------------
       Private helpers
    -------------------------------------------------------------------*/

    private static function stringToBitStream(string $s): array
    {
        $bits = [];
        foreach (str_split($s) as $c) {
            $byte = ord($c);
            for ($i = 7; $i >= 0; --$i) {
                $bit = ($byte >> $i) & 1;
                $bits = array_merge($bits, array_fill(0, self::REDUNDANCY, $bit));
            }
        }
        return $bits;
    }

    private static function majority(array $bits, int $group): array
    {
        $out = [];
        foreach (array_chunk($bits, $group) as $chunk) {
            $out[] = (array_sum($chunk) > $group / 2) ? 1 : 0;
        }
        return $out;
    }

    private static function bitsToInt(array $bits): int
    {
        return array_reduce($bits, fn($v, $b) => ($v << 1) | $b, 0);
    }

    /**
     * Forces the sign of the coefficient:
     *   bit 0 → positive   (>= +minAmp)
     *   bit 1 → negative   (<= -minAmp)
     * so the quantizer cannot flip it.
     */
    private static function forceSign(
        float $coeff,
        int   $bit,
        int   $minAmp = 80,   // safe amplitude > luminance quantization divisors
        int   $boost  = 64    // further offset to move away from zero
    ): float {
        $rounded = (int) round($coeff);

        // Enforce minimum amplitude
        if (abs($rounded) < $minAmp) {
            $rounded = ($rounded >= 0) ? $minAmp : -$minAmp;
        }

        // Set the sign according to the bit
        if ($bit === 0 && $rounded < 0) $rounded = abs($rounded);
        if ($bit === 1 && $rounded > 0) $rounded = -$rounded;

        // Push further from zero: +/-boost (preserving the sign)
        $rounded += ($rounded > 0) ? $boost : -$boost;

        return (float) $rounded;
    }

    private function __construct() {}
}

Quando viene invocato il metodo embed, il chiamante le passa l’array dei blocchi DCT e il messaggio da inserire. Il metodo trasforma ogni carattere in 8 bit, e ciascun bit viene replicato 25 volte (come specificato dalla costante REDUNDANCY), così da poter essere letto con un voto di maggioranza e resistere ad alterazioni dovute alla compressione JPEG. Il flusso così ridondato scorre blocco dopo blocco e si appoggia su 8 coordinate a bassa frequenza, definite nell’array costante EMBED_COORDS. Queste posizioni sono state scelte perché non intaccano la percezione visiva ma tendono a sopravvivere anche a compressioni JPEG moderate (qualità 60–80).

Per ogni coefficiente selezionato, la funzione privata forceSign() impone un segno al coefficiente: positivo per rappresentare 0, negativo per rappresentare 1. Questo approccio, più robusto rispetto all’uso della parità, garantisce che l’informazione rimanga leggibile anche dopo un passaggio di quantizzazione JPEG. Se l’immagine non contiene abbastanza blocchi per rappresentare l’intero messaggio, viene lanciata un’eccezione con un messaggio esplicito.

Il percorso inverso è affidato al metodo extract. Anche qui, la classe legge il segno degli stessi 8 coefficienti in ogni blocco, ricostruendo un lungo vettore di zeri e uno. I bit vengono poi raggruppati secondo la ridondanza e passano attraverso una funzione di voto di maggioranza (majority()), che recupera il singolo bit originario. Ogni gruppo di 8 bit restituisce un carattere, fino a incontrare il terminatore NUL che segnala la fine del messaggio. L’insieme dei caratteri così ottenuti forma il messaggio originale.

Le funzioni di supporto stringToBitStream, bitsToInt e majority incapsulano i dettagli binari, lasciando i metodi pubblici brevi e leggibili. Come la classe Dct, anche Watermarker è priva di stato interno e non può essere istanziata: tutti i metodi sono statici. Questo approccio funzionale facilita i test automatici e l’uso in ambienti concorrenti. In sintesi, la classe Watermarker realizza concretamente i principi matematici descritti in precedenza: ridondanza ciclica, codifica del bit tramite segno, terminazione esplicita del messaggio, in un flusso compatto e robusto pensato per sopravvivere alle trasformazioni tipiche delle immagini pubblicate online.

ImageIO: dall’immagine ai blocchi DCT e ritorno

La classe ImageIO è il ponte tra la teoria matematica e il file JPEG concreto.

<?php

declare(strict_types=1);

namespace RenorWatermark;

use GdImage;

/**
 * Class ImageIO
 *
 * - Loads a JPEG image.
 * - Converts RGB to the Y (luminance) channel.
 * - Splits it into 8x8 blocks and applies DCT/IDCT.
 * - Overwrites the Y channel with the embedded watermark, merging with the original CbCr.
 * - Saves the final image as JPEG with a specified quality.
 */
final class ImageIO
{
    private const BLOCK_SIZE = 8;
    private const MIN_WIDTH = 200;
    private const MIN_HEIGHT = 200;

    /**
     * Embed a watermark in a JPEG image and save the result.
     *
     * @param string $src      Path to the original JPEG
     * @param string $dest     Output path for the watermarked image
     * @param string $message  ASCII watermark (up to 10 chars)
     * @param int    $quality  JPEG quality in [0..100], default 90
     */
    public static function embed(
        string $src,
        string $dest,
        string $message,
        int $quality = 90
    ): void {
        $im = self::loadJpeg($src);
        $w = imagesx($im);
        $h = imagesy($im);

        // Ensure a minimum image size
        if ($w < self::MIN_WIDTH || $h < self::MIN_HEIGHT) {
            imagedestroy($im);
            throw new RuntimeException("Image must be at least 200x200 for robust embedding.");
        }

        // Convert RGB → Y
        $Y = self::rgbToY($im);

        // Split into 8x8 blocks, apply forward DCT
        $blocks = self::forwardBlocks($Y, $w, $h);

        // Embed the message into the DCT coefficients
        Watermarker::embed($blocks, $message);

        // Reconstruct the Y channel from the inverse DCT
        $Ywm = self::inverseBlocks($blocks, $w, $h);

        // Merge the modified Y channel and save as JPEG
        self::mergeAndSave($im, $Ywm, $dest, $quality);

        imagedestroy($im);
    }

    /**
     * Extract the watermark from a JPEG image.
     *
     * @param string $src Path to the watermarked JPEG
     * @return string     The recovered ASCII message
     */
    public static function extract(string $src): string
    {
        $im = self::loadJpeg($src);
        $w = imagesx($im);
        $h = imagesy($im);

        if ($w < self::MIN_WIDTH || $h < self::MIN_HEIGHT) {
            imagedestroy($im);
            throw new RuntimeException("Image is too small (<200x200). It may not contain a robust watermark.");
        }

        // Convert to Y
        $Y = self::rgbToY($im);

        // Apply DCT on 8x8 blocks
        $blocks = self::forwardBlocks($Y, $w, $h);

        // Extract the message from the DCT blocks
        $msg = Watermarker::extract($blocks);

        imagedestroy($im);
        return $msg;
    }

    /* -------------------------------------------------------------------------
       INTERNAL METHODS
    -------------------------------------------------------------------------- */

    /**
     * Loads a JPEG image from disk or throws an exception if invalid.
     */
    public static function loadJpeg(string $path): GdImage
    {
        if (!is_file($path)) {
            throw new RuntimeException("File not found: $path");
        }
        $im = @imagecreatefromjpeg($path);
        if (!$im) {
            throw new RuntimeException("Invalid JPEG: $path");
        }

        return $im;
    }

    /**
     * Converts an RGB image to a 2D Y (luminance) matrix.
     */
    public static function rgbToY(GdImage $im): array
    {
        $w = imagesx($im);
        $h = imagesy($im);
        $Y = array_fill(0, $h, array_fill(0, $w, 0));

        for ($y = 0; $y < $h; $y++) {
            for ($x = 0; $x < $w; $x++) {
                $rgb = imagecolorat($im, $x, $y);
                $r = ($rgb >> 16) & 0xFF;
                $g = ($rgb >> 8) & 0xFF;
                $b = $rgb & 0xFF;
                // ITU-R BT.601 luma formula
                $luma = (int) round(0.299 * $r + 0.587 * $g + 0.114 * $b);
                $Y[$y][$x] = max(0, min(255, $luma));
            }
        }

        return $Y;
    }

    /**
     * Splits the Y matrix into 8x8 blocks and applies forward DCT.
     */
    public static function forwardBlocks(array $Y, int $w, int $h): array
    {
        $blocks = [];
        for ($by = 0; $by < $h; $by += self::BLOCK_SIZE) {
            for ($bx = 0; $bx < $w; $bx += self::BLOCK_SIZE) {
                $block = [];
                for ($i = 0; $i < self::BLOCK_SIZE; $i++) {
                    $row = [];
                    $srcY = min($by + $i, $h - 1);
                    for ($j = 0; $j < self::BLOCK_SIZE; $j++) {
                        $srcX = min($bx + $j, $w - 1);
                        $row[] = $Y[$srcY][$srcX];
                    }
                    $block[] = $row;
                }
                $blocks[] = Dct::forward($block);
            }
        }
        return $blocks;
    }

    /**
     * Applies inverse DCT to each 8x8 block and rebuilds the Y matrix.
     */
    private static function inverseBlocks(array $blocks, int $w, int $h): array
    {
        $Y = array_fill(0, $h, array_fill(0, $w, 0));
        $idx = 0;

        for ($by = 0; $by < $h; $by += self::BLOCK_SIZE) {
            for ($bx = 0; $bx < $w; $bx += self::BLOCK_SIZE) {
                $coeffBlock = $blocks[$idx++];
                $pixBlock = Dct::inverse($coeffBlock);

                for ($i = 0; $i < self::BLOCK_SIZE; $i++) {
                    $dstY = $by + $i;
                    if ($dstY >= $h) break;
                    for ($j = 0; $j < self::BLOCK_SIZE; $j++) {
                        $dstX = $bx + $j;
                        if ($dstX >= $w) break;
                        $Y[$dstY][$dstX] = $pixBlock[$i][$j];
                    }
                }
            }
        }

        return $Y;
    }

    /**
     * Merges the watermarked Y channel with the original CbCr, then saves the final JPEG.
     */
    private static function mergeAndSave(GdImage $orig, array $Ywm, string $dest, int $quality): void
    {
        $w = imagesx($orig);
        $h = imagesy($orig);

        // 1) Overwrite the RGB pixels of the GDImage using the new Y
        for ($y = 0; $y < $h; $y++) {
            for ($x = 0; $x < $w; $x++) {
                $rgb = imagecolorat($orig, $x, $y);
                $r = ($rgb >> 16) & 0xFF;
                $g = ($rgb >> 8) & 0xFF;
                $b = $rgb & 0xFF;

                $cb = -0.169 * $r - 0.331 * $g + 0.5 * $b + 128;
                $cr = 0.5 * $r - 0.419 * $g - 0.081 * $b + 128;

                $Yval = $Ywm[$y][$x];

                $R = $Yval + 1.402 * ($cr - 128);
                $G = $Yval - 0.344136 * ($cb - 128) - 0.714136 * ($cr - 128);
                $B = $Yval + 1.772 * ($cb - 128);

                $R = max(0, min(255, (int) round($R)));
                $G = max(0, min(255, (int) round($G)));
                $B = max(0, min(255, (int) round($B)));

                $color = imagecolorallocate($orig, $R, $G, $B);
                imagesetpixel($orig, $x, $y, $color);
            }
        }

        // 2) Convert GDImage to a PNG blob in memory (lossless)
        ob_start();
        imagepng($orig);
        $pngData = ob_get_clean();

        // 3) Create an Imagick object from the PNG blob
        $imagick = new Imagick();
        $imagick->readImageBlob($pngData);

        // 4) Set desired JPEG parameters
        $imagick->setOption('jpeg:sampling-factor', '1x1'); // disable chroma subsampling
        $imagick->setImageCompressionQuality($quality);
        $imagick->setImageCompression(Imagick::COMPRESSION_JPEG);
        $imagick->setImageFormat('jpeg');

        // 5) Save the file
        $imagick->writeImage($dest);

        // 6) Cleanup
        $imagick->destroy();
    }

    /**
     * Prevents instantiation.
     */
    private function __construct()
    {
    }
}

Quando si invoca il metodo statico embed, il codice apre l’immagine con l’estensione GD e ricava la componente Y di luminanza — l’unica coinvolta nel watermarking — lasciando invariati i canali cromatici Cb e Cr per garantire che la firma resti invisibile all’occhio umano. La matrice Y viene poi suddivisa, riga per riga, in una griglia di blocchi 8×8. Ciascun blocco viene trasformato in frequenza con Dct::forward, così da permettere alla classe Watermarker di incidere i bit del messaggio forzando il segno di 8 coefficienti a bassa frequenza scelti appositamente.

Terminata l’incisione, ImageIO riconverte ogni blocco in pixel con Dct::inverse, ricostruendo una nuova matrice Y marcata. A questo punto la classe ricalcola i valori RGB combinando la luminanza modificata con le crominanze originali: per ogni pixel applica le formule inverse dello spazio colore secondo lo standard ITU-R BT.601, assicurandosi che i risultati restino nell’intervallo 0–255.

Il bitmap completo viene infine salvato in JPEG alla qualità desiderata, utilizzando Imagick per disattivare il subsampling cromatico e massimizzare la fedeltà. Il risultato è un file visivamente identico all’originale ma contenente, nei suoi coefficienti DCT, una firma testuale invisibile ma resistente.

Il percorso inverso, affidato al metodo extract, compie l’operazione opposta: ricarica l’immagine, isola la luminanza, la suddivide in blocchi, calcola la DCT di ciascuno e passa la sequenza di coefficienti a Watermarker::extract. Questo metodo legge il segno dei coefficienti, applica il voto di maggioranza tra le ripetizioni di ciascun bit, e ricostruisce la stringa originaria fino al carattere NUL di terminazione.

Tutta la logica di I/O, apertura dei file, conversione colore e salvataggio JPEG è confinata nella classe ImageIO, mentre Dct e Watermarker restano funzioni matematiche pure. Questa divisione chiara delle responsabilità favorisce la modularità del codice, la testabilità e l’integrazione in qualunque pipeline di elaborazione immagini.

Test in CLI

/embed.php

Inserimento di un watermark in un’immagine

#!/usr/bin/env php
<?php

// Set memory limit to 1GB
ini_set('memory_limit', '1024M');
require __DIR__ . '/vendor/autoload.php';

use RenorWatermarkImageIO;

/**
 * This command-line script embeds a watermark (up to 10 characters)
 * into a JPEG and saves the result. By default, it uses quality=90.
 *
 * Example usage:
 *   php embed.php --src=original.jpg --out=watermarked.jpg --msg="HELLO" --q=95
 *
 * Or simply:
 *   php embed.php --src=original.jpg --out=watermarked.jpg
 *   (defaults to msg="DEFAULT" and quality=90)
 */

$options = getopt('', ['src:', 'out:', 'msg::', 'q::']);
$src = $options['src'] ?? null;
$out = $options['out'] ?? null;
$msg = $options['msg'] ?? 'DEFAULT';
$q   = isset($options['q']) ? (int) $options['q'] : 90;

if (!$src || !$out) {
    fwrite(STDERR, "Usage: embed --src=INPUT.jpg --out=OUTPUT.jpg [--msg=STRING] [--q=90]n");
    exit(1);
}

try {
    ImageIO::embed($src, $out, $msg, $q);
    echo "Watermark "$msg" embedded successfully into $out at quality $qn";
} catch (Exception $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . "n");
    exit(1);
}

In questo script CLI (embed.php) definiamo, attraverso l’opzione –msg, il messaggio da imprimere nell’immagine e invochiamo il metodo statico ImageIO::embed() della classe ImageIO. Lo script accetta i seguenti parametri:

–q (facoltativo): la qualità JPEG per il salvataggio (default: 90).

–src: il percorso dell’immagine JPEG sorgente (es. original.jpg);

–out: il percorso del file JPEG di destinazione che conterrà il watermark;

–msg (facoltativo): il testo ASCII da inserire (max 10 caratteri);

php embed.php --src=original.jpg --out=watermarked.jpg --msg="RENOR" --q=95

ci tornerà:

Watermark "RENOR" embedded successfully into watermarked.jpg at quality 95

/extract.php

Da qui estraiamo il testo del Watermark contenuto nell’immagine watermarked.jpg appena creata da embed.php

#!/usr/bin/env php
<?php

// Set memory limit to 1GB
ini_set('memory_limit', '1024M');
require __DIR__ . '/vendor/autoload.php';

use RenorWatermarkImageIO;

/**
 * This command-line script extracts a watermark from a JPEG.
 *
 * Usage:
 *   php extract.php --src=watermarked.jpg
 */

$options = getopt('', ['src:']);
$src = $options['src'] ?? null;

if (!$src) {
    fwrite(STDERR, "Usage: extract --src=IMAGE.jpgn");
    exit(1);
}

try {
    $msg = ImageIO::extract($src);
    echo "Recovered message: "$msg"n";
} catch (Exception $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . "n");
    exit(1);
}

Lo script extract.php completa il ciclo di utilizzo del watermark invisibile permettendo l’estrazione del messaggio precedentemente incorporato. Si tratta di un semplice script da linea di comando che, dato un file JPEG marcato, ne legge il contenuto nascosto decodificando il segno di specifici coefficienti DCT modificati. Il messaggio, recuperato in modo robusto anche dopo compressioni JPEG con qualità medio-alta, viene ricostruito tramite voto di maggioranza sui bit ripetuti. Basta eseguire il comando con l’opzione –src per indicare l’immagine da analizzare, e lo script restituirà a terminale la stringa originariamente incorporata.

Possiamo landiare il comando:

php extract.php --src=watermarked.jpg  

otterremo:

Recovered message: "RENOR"

Vale il caso anche di analizzare le fotografie:

A sinistra l’immagine originale, a destra quella watermarked.

Possiamo notare che effettivamente, come abbiamo ampiamente descritto non ci sono elementi visibili ad occhi nudo e riconducibili all’applicazione di un Watermark che resta tuttavia ancora decifrabile utilizzando l’extract.

Chiaramente il progetto è puramente dimostrativo ed utilizzarlo a livello enterprise o per progetti in produzione richiederebbe ulteriore raffinamento.

[starbox] 

L'articolo Watermark Invisibile in JPEG con PHP 8 proviene da RENOR & Partners S.r.l..

Partiamo dalla tipica domanda che si pongono ingegneri IT e sviluppatori quando leggono alcune offerte di lavoro: “Ma le aziende credono che sviluppatori e/o ingegneri in ambito IT siano tutti dei cretini? Oppure tutto questo è dovuto al fatto che hanno personale ignorante come le capre, per usare un eufemismo alla Vittorio Sgarbi, tale per cui chi gli fa la selezione del personale non conosce la differenza tra un backend developer e un frontend developer?

Onestamente credo che la motivazione vada ricercata in altro… Perché poi la RAL offerta da pieno senso al ragionamento. E come dargli torto?

Annunci assurdi

Prendo un annuncio a caso fresco fresco ma vi garantisco che basta girare un po’ per trovarne migliaia…

Titolo dell’annuncio: Sviluppatore PHP back-end

REQUISITI RICHIESTI

• Conoscenza dei principi dello sviluppo orientato agli oggetti
• Esperienza nello sviluppo con il linguaggio PHP
• Conoscenza dei principali framework
• Conoscenza dei modelli e tool di versioning del software (GIT/SVN)
• Conoscenza del linguaggio SQL
• Conoscenza del web e dei suoi protocolli
• Conoscenza di sistemi operativi quali Windows e Linux
• Conoscenza di HTML, CSS, Javascript
• Buona conoscenza della lingua inglese sia parlata che scritta
• Comprovate capacità di problem solving relative al raggiungimento del risultato

REQUISITI PREFERENZIALI

• Conoscenza dei principali CMS web: Drupal / WordPress / Magento /Adobe Commerce
• Conoscenza ed esperienza nello sviluppo (full stack) di web applications
• Certificazioni ottenute su prodotti enterprise. Esempio: Adobe Commerce
• Esperienza in implementazione di pagamenti online e/o soluzioni e-commerce

Confusione, ignoranza o paraculismo?

Ora, anche un cieco qui vedrebbe che non stanno cercando uno sviluppatore Back-end, come suggerisce inequivocabilmente il titolo dell’annuncio… Qui si sta cercando un Full Stack e la cosa bella è che nei requisiti preferenziali lo asseriscono pure senza mezze misure!! “Conoscenza ed esperienza nello sviluppo (full stack) di Web Applications”. Oltre al fatto che in bella vista nei requisiti richiesti spunta chiara come l’acqua la conoscenza di HTML, CSS e JavaScript.

Personalmente non mi candiderei mai ad un annuncio del genere, perché lo ritengo un insulto alla mia intelligenza ma soprattutto a tutta la categoria.

Con tutto il rispetto possibile, queste non sono posizioni per cui si apre la ricerca a gente completamente ignorante dove puoi dargli a bere che gli asini volano. Queste sono posizioni dove chi si candida è una persona allenata ad utilizzare bene il cervello e non puoi pensare, con il fine ultimo di pagare una Ferrari 10 euro, di prendere in giro uno sviluppatore che al contrario di questi ciarlatani sa benissimo quali conoscenze comporti lo sviluppo front-end e quali il back-end; e cercare di mascherare il tutto facendo passare la ricerca di un Full Stack per un Back-end o di un Front-end per pagarlo di meno… Questo è un inganno ridicolo nel quale non cadrebbe neanche un bambino di 10 anni che deve finire!

Sarebbe più apprezzabile e onesto scrivere: “Cerchiamo uno sviluppatore Full Stack, offriamo questo compenso”.

In questo modo chiunque saprebbe quale figura cercano e, compatibilmente con l’offerta, potrebbe decidere se candidarsi oppure no, senza stare a perdere del tempo prezioso. In molti casi l’azienda non riceverebbe candidature, a quel punto forse, si renderebbe conto che è il caso di alzare il compenso!

Offerte di lavoro di cui vergognarsi

Per non parlare poi di tutte quelle offerte di lavoro dove richiedono competenze assurde che neanche chi lavora in NASA possiede a RAL ridicole… Ho letto annunci di aziende che cercavano competenze in ambito Back-end PHP, .net, JAVA, Python, sistemi di controllo del versioning (GIT, SVN, DevOps), sistemi di orchestrazione dei container (Kubernets, Docker), REST API e SOAP, vari framework PHP tra cui Symphony/Laravel, conoscenza degli ecosistemi e integrazione API dei servizi AWS, Google Cloud e Microsoft Azure. Per il front-end HTML, CSS, JavaScript, jQuery, React, Vue.js, Angular con requisito preferenziale nello sviluppo di App Ibride in Cordova, Flutter o Ionic… Il tutto per la modica cifra di 1200 euro signore e signori! Ma dico… Non vi vergognate neanche un po’? Mi viene da ridere ma qui ci sarebbe da piangere!

Non mi ci voglio mettere io di mezzo, che comunque in ambito IT non mi ritengo l’ultima ruota del carro, probabilmente la penultima ma non l’ultima, ma conosco personalmente delle figure con cui ho collaborato e collaboro, di altissimo livello in ambito informatico che forse arrivano con fatica ad avere neanche la metà di queste conoscenze… E per quali stipendi poi? 1200 euro al mese ????????????????????????

Siete ridicoli!!! A tutti questi furbetti del quartierino, sfruttatori di persone in difficoltà dedico un sincero vaf@@@@lo.

Le responsabilità degli imprenditori

Io credo gli imprenditori debbano fermarsi a riflettere con grande senso autocritico ed entrare in un’ottica che ha a che fare con semplicissime leggi di mercato…

Ho un cugino che ha avuto il coraggio di abbandonare l’Italia ed è andato a lavorare in Francia. Cercavano una figura Front End: HTML, CSS, JavaScript, React.js e su Node.js se non lo conosci non c’è problema, investiamo noi sulla formazione… Fine! C’è da aggiungere altro? Ogni volta che lo sento mi fa sentire un idiota ad ostinarmi nel credere che anche qui in Italia si possano cambiare le cose e non fa altro che ripetermi: “una figura come la tua qui in Francia guadagnerebbe cifre da capogiro”.
Stipendio mensile: 3800 euro al mese + bonus e che Dio glieli accresca. L’azienda offre formazione e aggiornamenti continui. È chiaro che in Francia gli imprenditori abbiano compreso che investire sul capitale umano, sui propri dipendenti, è cruciale per affrontare con successo le sfide del domani e continuare a crescere ed essere competitivi.

Se non si cambia registro il fallimento è a un passo

Veniamo in Italia…

Ci capita di fare appuntamenti con imprenditori “vecchio stampo”… Quando gli parli di automazione dei processi aziendali (cosa che gli farebbe risparmiare anche il 90% del loro attuale costo del lavoro perché devono sopportare costi assurdi per dipendenti che stanno tutto il giorno davanti a file excel e fanno in un giorno quello che un software farebbe in qualche decimo di secondo) ti guardano come se stessi venendo da Marte, perché di tutto quello che gli hai spiegato non ci hanno capito un fico secco, ma sono troppo pieni di sé per ammetterlo e per comprendere che se non si muoveranno in questo senso adesso, la strada futura potrà essere solo una: il fallimento!

Sì, parlo di fallimento, e lo urlo a tutti, senza temuta di smentita, conscio che non sto in alcun modo esasperando il discorso, perché ci capita di fare appuntamenti con imprenditori giovani che invece comprendono pienamente le potenzialità dell’automazione dei processi, comprendono che possono risparmiare tantissimo sul costo del lavoro e pertanto possono abbassare i costi dei loro servizi essendo più appetibili sul mercato e fanno numeri a colori, ed è qui che scatta la domanda di rito: “Un consumatore che trova un prodotto a 20€ e lo stesso identico prodotto, probabilmente anche con qualche difettuccio visto che tutto è frutto di “elaborazioni a mano” a 40€, secondo voi, ma quale caspita di prodotto dovrebbe comprare tra i due?“

e come corollario ne scaturisce una seconda di domanda…

“Le persone che fino ad oggi hanno comprato il prodotto a 40€, quando si accorgono che un’altra azienda ne fornisce uno migliore a 20€, continueranno a comprare quello da 40?“. Sarebbe come credere che se domani uscisse una marca di TV Oled che producesse TV di qualità pari o addirittura migliore di quelli prodotti da marche blasonate, questi continuerebbero a comprare quelli che costano il doppio… Totalmente illogico!

Ecco come si va inesorabilmente verso il fallimento… La nuova generazione imprenditoriale sarà in grado di aggredire il mercato con prezzi più bassi perché riuscirà ad essere più performante avendo meno costi. E tutti i clienti delle old-company, quando vedranno che è possibile risparmiare tanto, avendo prodotti nati da processi automatizzati e quindi sicuramente più affidabili in termini di “errore umano” e di velocità di produzione, non ci metteranno molto a chiudere contratti da una parte e aprirli dall’altra; e questo discorso è tanto più valido quanto più è grande l’azienda. Su grandi imprese, se una rondella la trovo a 2 centesimi in meno con la stessa qualità di quella che ho utilizzato fino ad oggi, a fine anno potrei trovarmi con qualche milione di euro in più di liquidità.

Idee obsolete e culto della persona

È veramente molto difficile far capire a una persona che ha costruito la sua ricchezza nel 1980 seguendo una metodologia totalmente analogica, che non siamo più nel 1980. C’è chi, in modo intelligente si pone delle domande, si guarda intorno, comprende che il mondo è cambiato. Comprende che nel 1980 quello spray eccezionale per pulire i vetri che non lasciava aloni lo trovavi solo se prendevi la macchina e ti facevi 20km per andare in quel negozio dove eri certo di trovarlo, ora vai su amazon e il giorno dopo te lo trovi fuori al cancello di casa… Ma lui invece imperterrito continua a farsi 20km per uscire di casa spendendo benzina, sprecando tempo e magari esasperandosi in mezzo al traffico. C’è chi ha compreso che viviamo in un mondo molto diverso da quello c’era nel 1980. Questi sono i soggetti che si salvano e che anzi non faranno altro che veder salire i fatturati. Ma da qui a 5 anni, aziende che non si saranno mosse con l’informatizzazione dei processi e che si mettono ancora lì a scrivere con carta e penna o nel migliore dei casi con i fogli excel, faranno una bruttissima fine.

Molti lettori potranno dire: “Ok, ma così non hai più bisogno di tante persone, ne licenzieranno la metà”. Non è detto… Ma continuiamo invece a portare avanti un modello di business che tra un paio di anni farà il botto, almeno a casa ci andranno proprio tutti! Fermo restando che puoi comunque mantenere il livello occupazionale decidendo di investire delle risorse umane su altri comparti aziendali come ad esempio quello marketing in modo che aumenti il tuo livello di business, visto che ormai sul lato di elaborazione puoi scalare virtualmente all’infinito avendo investito in automazione.

Il mondo evolve e, specie nelle aziende private che sono il motore economico del sistema Italia, devi essere in grado di adattarti ai tempi e alle richieste del mercato. Solo in questo modo potrai avere una società solida. L’economia non funziona solo con la quantità di moneta che circola, è molto più importante la velocità con cui questa moneta passa di mano in mano e se l’andazzo sarà questo, presto avremo sempre meno aziende attive sul mercato e la ricchezza si concentrerà solo su pochi, perché quando gli altri si muoveranno sarà ormai troppo tardi.

L’importanza di certe figure ed il loro riconoscimento

Cominciamo con il dare valore alle persone… Uno sviluppatore Full Stack che ti risolve dei problemi nella tua impresa e ti fa risparmiare un milione di euro l’anno non puoi pagarlo 800 euro al mese. Imprenditore!?!?!? Sii coerente prima con te stesso e poi con gli altri!!! Ma come puoi presentarti con una briciola di pane da uno che ti ha fatto mantenere nella credenza 5000 pagnotte?

Uno che si è fatto un mazzo così a studiare libri su libri, fare nottate per preparare gli esami all’università, informarsi costantemente su ultime tecnologie (e ne escono un paio nuove ogni due mesi) mentre gli altri suoi coetanei erano a farsi le canne sul muretto della piazza del paese non esiste che venga a lavorare da te per farti guadagnare un milione di euro all’anno in cambio di 800 euro al mese, ovvero quello che prendono quelli che si facevano le canne; ma gliela vogliamo riconoscere una differenza o no?? E se pensi di essere intelligente a proporre offerte di lavoro di cui ci sarebbe solo da vergognarsi a pubblicarle, forse è il caso che ritorni sui tuoi passi… Perché se applichi questo ragionamento probabilmente non sei così intelligente.

[starbox] 

L'articolo Cosa diavolo cerchi? Un backend o un frontend? proviene da RENOR & Partners S.r.l..

Alcune motivazioni

Nonostante siano chiari i punti di forza di questo CMS, ci sono molte cose che l’utente medio non può conoscere non essendo un addetto ai lavori.

C’è modo e modo di sviluppare siti web

Quanti di voi sono caduti nella tentazione di farsi sviluppare un sito a 300 euro tutto incluso? Bene, vi do una notizia… Avete buttato i vostri soldi!

Sviluppare un sito solo per dire “Hey amico! Ho fatto il sito”, è perfettamente inutile. Da che mondo è mondo, quando si decide di comprare un prodotto lo si fa perché deve essere utile a qualcosa. Un sito sviluppato con 300 euro è un sito inutile. C’è poco da girarci attorno. Con 300€ è impossibile mettere in atto tutte quelle pratiche virtuose dello sviluppo, necessarie a rendere il sito piacevole ai motori di ricerca.

La velocità di caricamento

Siti tirati su al costo di 300€ integrano sicuramente un plugin WYSIWYG (What You See Is What You Get – Quello che vedi è quello che ottieni). Questi plugin sono notoriamente molto pesanti, utilizzano tantissimo JavaScript e una miriade di CSS che per lo più non viene neanche utilizzato. Diciamolo: vengono usati principalmente da chi non sa sviluppare e vuole farsi un “sitarello per conto suo senza troppe pretese” o da chi, consapevole delle implicazioni sulla SEO, se ne sbatte solo per consegnare un lavoro prima e fare cassa.

Banco alle ciance! Numeri alla mano… In ambo i casi, il risultato sarà questo:

Un sito del genere sarà fortunato a comparire nella centesima pagina del motore di ricerca, a meno di non aver fatto un lavoro certosino sulla SEO studiando contenuti per parole chiave composte e più facilmente posizionabili, oppure avere un numero di articoli e contenuti che integrino tutta la conoscenza umana, allora si, si può chiudere un occhio sulla velocità di caricamento, ma se si è scesi a questi compromessi figuriamoci concentrare tutte queste attenzioni sulla SEO e i contenuti!

Pertanto: spesa inutile!

Ottimizzazione delle immagini

Un sito ben fatto ha avuto dietro il lavoro di un webmaster che ha dedicato molto tempo all’ottimizzazione delle immagini per il Web.
Oggi ci sono formati pensati per favorire la velocità di caricamento del sito, formati che offrono una dimensione contenuta pur mantenendo una discreta qualità dell’immagine.

Oltretutto le immagini andrebbero ridimensionate per l’uso che se ne deve fare. Se necessito di riempire una piccola area di 300 x 200 pixel con un’immagine, è una bad-practice caricare un’immagine di 2400 x 1600 pixel.

A 300€ a sito questa cura non può esistere perché richiede tempo, pertanto si preferisce prendere e caricare l’immagine così com’è e ridimensionarla tramite CSS aggiungendo un paio di attributi al tag (operazione molto più veloce):

[html]
<img src="./images/img01.jpg" width="300px" height="200px" alt="" title="" longdesc="" />
[/html]

Peccato che l’immagine pesi 4 Megabyte! In sostanza solo il caricamento di questa immagine, da mobile richiederebbe dai 4 ai 5 secondi con copertura 4G, contro i 20 Kb della stessa immagine ottimizzata, che verrebbe caricata in una 30ina di millisecondi.

Nella riga di codice suesposta spiccano anche tre attributi utili per la SEO e lasciati volutamente non compilati: ogni immagine dovrebbe avere un testo alternativo, un titolo e una descrizione lunga. Il motore di ricerca fa caso a questi dettagli perché sono utili ai non vedenti per interpretare il contenuto dell’immagine. Pertanto oltre a rappresentare delle ulteriori parole da catalogare ai fini SEO i motori tendono a premiare chi pensa anche ai meno fortunati. Naturalmente anche la compilazione di questi campi richiede del tempo e dubito che siti da 300€ abbiano fatto una preventiva ricerca delle parole chiave con cui potersi posizionare e si siano dati da fare per fornire descrizioni di tutte le immagini che inseriscono.

Tanto per darvi un’idea dei tempi, su questo blog esce un articolo al giorno… La motivazione non è dovuta alla scarsa voglia di scrivere o alla mancanza di fantasia: abbiamo centinaia di titoli di articoli da scrivere nel nostro piano editoriale, il problema è che tra analisi SEO e stesura, un articolo richiede mezza giornata di tempo per essere redatto… E vogliamo ancora perdere tempo a parlare di un sito a 300€?

Rimandare CSS e JS che bloccano la visualizzazione

Il browser quando riceve i dati del sito richiesti elabora CSS e JavaScript nell’ordine in cui sono scritti e blocca la visualizzazione della pagina fin tanto che tali file non siano stati completamente caricati. Questo allunga ulteriormente i tempi di interazione con il sito. Alcuni di questi file potrebbero non essere necessari nell’immediato e possono essere rimandati. In sostanza si deve semplicemente comunicare al browser che quei file possono essere caricati dopo il caricamento dei contenuti della pagina. Questa pratica da modo all’utente che sta aprendo il sito di poterlo visualizzare e poterci interagire molto prima. Tale pratica abbassa quella che i motori di ricerca chiamano frequenza di rimbalzo. In sostanza se un sito impiega 20 secondi per caricarsi a 6 secondi se ne sono già andati l’80% dei visitatori.

Eliminare frammenti CSS e JavaScript non utilizzati

Operazione sicuramente difficile da compiere su progetti che utilizzano framework CSS-JS! Lo sviluppatore dovrebbe accedere ai file CSS e JS del framework alla ricerca di tutte quelle classi (per il CSS) e di tutte le funzioni (per i JavaScript) che non vengono richiamate all’interno delle pagine del sito ed eliminarle. In condizioni normali non sarebbe la fine del mondo, ma non è facile trovare ciò che serve dentro un file dove il nome più user friendly per nominare una variabile è “var k”.

La pratica di sostituzione dei nomi delle variabili user friendly con variabili corte è messa in atto dagli sviluppatori del framework per ridurre la dimensione del file che il browser dovrà caricare, ma rende praticamente illegibile il codice JavaScript scritto al suo interno. In sostanza è una pratica non attuabile.

Un’operazione che sicuramente può essere fatta, riguarda la minificazione di tutti i CSS e i JS. Tutto il file viene scritto in un’unica riga eliminando le informazioni sugli “a capo” e gli spazi al suo interno. Questo permette di risparmiare una quantità di spazio che può andare mediamente dal 20 al 40% del peso originale. Tutto ciò si traduce in un tempo di caricamento inferiore a parità della velocità di download.

Siti Web visivamente tutti uguali

Quando si utilizzano queste scorciatoie si nota immediatamente una somiglianza tra tutti i siti. Vuoi o non vuoi, le classi CSS sempre quelle sono! Per quanto si possa poi personalizzare resta sempre un’impronta visiva molto simile tra siti che sono stati sviluppati utilizzando Plugin WYSIWYG o Framework.

Stiamo dunque dicendo che WordPress è un CMS da evitare?

Assolutamente no! WordPress è un ottimo CMS per creare siti web con blog e eCommerce, a patto che si sviluppino temi alla regola dell’arte, senza utilizzare questo genere di scorciatoie che rendono assolutamente inutile l’investimento fatto per avere un sito web online.

Anche questo sito è stato sviluppato con WordPress, ma non in mezza giornata… In un paio di mesi. Possiede uno stile che sarà impossibile trovare su Siti sviluppati con le scorciatoie di cui abbiamo parlato, ha immagini ottimizzate, SEO ottimizzata, Sitemap aggiornata in tempo reale e sicuramente il costo di sviluppo non è stato di 300€ a meno che non troviate uno sviluppatore che lavori per voi a 150 euro al mese!

Del resto l’Audit parla da solo…

Come avrete capito non si tratta di scegliere WordPress si o WordPress no; si tratta. come sempre, di valutare come si lavora su WordPress e fare tutte le valutazioni del caso se non si vogliono buttare via soldi.

Ahimé la maggior parte dei siti online vengono proprio sviluppati da “fantomatiche agenzie web” proprio in questo modo, cercando di andare sulla velocità di sviluppo e sul numero di clienti intrappolati nella rete al pari dei pesci pescati in mare, rifilandogli dei siti web pagati poco, sviluppati tanto per far vedere il sito online al cliente e che risultano però essere completamente inutili ai fini per cui un sito web dovrebbe essere costruito: attirare nuovi clienti.

In Italia già da qualche anno si respira un’aria di “eccessiva faciloneria”. Si pensa che tutti possano fare tutto con poco sforzo. Mi dispiace, ma non è così! È giusto che qualcuno prima o poi si prenda la responsabilità di dire che se fai il Cuoco sarai bravissimo a fare il tuo lavoro ma non puoi sviluppare siti web.

I contro di WordPress

Essendo il CMS più gettonato al mondo è anche quello maggiormente preso d’assalto dalla comunità Hacker. Più di 16 milioni di siti online sono stati sviluppati utilizzando WordPress, il passo è breve: trovo una falla in WordPress e posso estenderla a 16 milioni di siti.

La community di WordPress è sempre al lavoro per migliorare il core del CMS, tanto è vero che di tanto in tanto vengono rilasciati aggiornamenti del Core, ma attenzione, ci sono anche i Plugin che sono spesso sviluppati da agenzie di terze parti,  e che potrebbero aver chiuso i battenti,  pertanto non rilasceranno più aggiornamenti e qualcuno prima o poi troverà una falla.

La maggior parte degli attacchi a WordPress proviene infatti proprio da falle nei plugin e nei temi (che non fanno eccezione). Sviluppare il proprio tema da zero permette di limitare gli attacchi sul fronte dei temi proprio in funzione del fatto che se il tema è vostro sarà univoco e non c’è Hacker al mondo disposto a trovare falle di sistema su un tema utilizzato da un singolo sito, a meno che non vi chiamiate INPS o Agenzia delle Entrate.

In buona sostanza dovete orientarvi preferibilmente su plugin che contino milioni di installazioni e che garantiscano che la Software House che li ha sviluppati resti in vita per garantire aggiornamenti del loro plugin nel tempo.

WordPress per essere sicuro necessita di essere aggiornato continuamente, non appena è disponibile un aggiornamento.

Dalle ultime versioni è possibile anche impostare gli aggiornamenti automatici, tanto per il core WordPress quanto per i plugin.

Quando non è consigliabile utilizzare WordPress

Non c’è una regola, ci si limita ad utilizzare il buon senso… Personalmente non utilizzerei WordPress per fini per cui non è stato concepito. Ricordiamoci che WordPress nasce come CMS per l’integrazione di Blog, per qualsiasi altro progetto ci penserei prima di utilizzare WordPress.

Non utilizzerei WordPress nel caso in cui la parola chiave del lavoro da svolgere fosse: performance. Non perché WordPress in sé sia lento ma perché, lo ricordo, per poter funzionare effettua chiamate che per alcuni progetti potrebbero essere totalmente superflue.

Strutturare un progetto Custom implica che si scriva solo ed esclusivamente il codice che serve ai fini per cui il sito o l’applicazione web è stata progettata. Allo stesso modo utilizzerei soluzioni Custom per non preoccuparmi di dover aggiornare temi e plugin, specie quando alcuni plugin non sono stati ancora aggiornati per il corretto funzionamento su un nuovo core di WordPress. Questo potrebbe generare problemi di utilizzo del sito.

In buona sostanza quando il budget lo permette sono sempre per l’implementazione di soluzioni custom: più affidabili, più performanti, più sicure… Naturalmente a patto di non pagarle 300€.

[starbox] 

L'articolo WordPress o soluzione custom? proviene da RENOR & Partners S.r.l..

Un mio carissimo Professore universitario, il Prof. Carlo Gaibisso, nelle sue lezioni di “Programmazione strutturata” in linguaggio C diceva sempre questa frase: “Si scrivono prima i commenti e poi il codice”.

Come dargli torto?

Nonostante quella dei programmatori sia una classe di “animali da palcoscenico” nel mondo dell’informatica, e nonostante la preparazione che uno sviluppatore possa avere, è un dato di fatto che sia sempre più facile e immediato leggere qualcosa che appartenga al nostro comune modo di comunicare. È molto più semplice leggere in Italiano di cosa si occupa un algoritmo piuttosto di comprendere cosa faccia un algoritmo scritto in codice; diviene tanto più complesso comprenderlo quanto più è complesso l’algoritmo.

Anche la programmazione orientata agli oggetti congloba la programmazione procedurale. All’interno dei metodi di una classe si programma in modo procedurale.

La programmazione procedurale è così chiamata perché il codice viene eseguito secondo una procedura. Posso scrivere procedure per qualsiasi cosa… Ad esempio se devo calcolare la successione di Fibonacci so che per calcolare il numero al passo n devo prendere il numero precedente e sommarlo a quello ancora precedente.
Pertanto la procedura sarà: partendo da S = 1 1,  f₃ -> Prendo f₂ lo sommo a f₁, e ottengo

S = 1 1 2

Prendo f₃ = 2 lo sommo a f₂ = 1 e ottengo

S = 1 1 2 3

Prendo f₄ = 3 lo sommo a f₂ = 2 e ottengo

S = 1 1 2 3 5

Comprenderete che è molto più facile capire istantaneamente la definizione: “Per calcolare il numero ennesimo della successione di Fibonacci sommo i due precedenti” rispetto a f_n = f_n-1 + f_n-2 specie se questa formula è scritta con variabili e cicli all’interno di un algoritmo informatico!

esempio in PHP per il calcolo della serie di Fibonacci senza commenti

[php]<br /> &lt;?php<br /> class Fibonacci<br /> {<br /> public static function calcolaSuccessione($n)<br /> {<br /> $n = $n – 2;<br /> $a = 1;<br /> $b = 1;<br /> echo $a . &#039;&lt;br&gt;&#039;;<br /> echo $b . &#039;&lt;br&gt;&#039;;<br /> for ($i = 0; $i &lt; $n; $i++) {<br /> $c = $a + $b;<br /> echo $c . &#039;&lt;br&gt;&#039;;<br /> $a = $b;<br /> $b = $c;<br /> }<br /> }<br /> }</p> <p>Fibonacci::calcolaSuccessione(1000);<br /> [/php]

esempio in PHP con i commenti

[php]<br /> &lt;?php</p> <p>/**<br /> * Fibonacci è una classe per il calcolo della successione di Fibonacci<br /> * e la sua verifica<br /> *<br /> * Fibonacci è una classe per il calcolo della successione di Fibonacci<br /> * la verifica del rapporto aureo attraverso il rapporto tra termini successivi<br /> * la verifica tramite il triangolo di tartaglia e la verifica tramite<br /> * le uguaglianze di Cassini, Catalani e D&#039;Ocagne<br /> *<br /> * @author Simone Renzi<br /> * @version 1.0<br /> * @access public<br /> * @see http://renor.it<br /> *<br /> **/<br /> class Fibonacci<br /> {<br /> /**<br /> * @method calcolaSuccessione – Metodo statico per calcolare la successione<br /> * di Fibonacci per $n termini<br /> * @param int $n – Il numero di iterazioni<br /> * @return void non ha valori di ritorno, stampa solamente a schermo i valori<br /> * della serie ad ogni iterazione<br /> * @access public<br /> **/</p> <p> public static function calcolaSuccessione($n)<br /> {<br /> //Avendo due parametri fissi li rimuovo dalle iterazioni<br /> $n = $n – 2;<br /> $a = 1;<br /> $b = 1;<br /> //Stampo i due parametri di partenza<br /> echo $a . &#039;&lt;br&gt;&#039;;<br /> echo $b . &#039;&lt;br&gt;&#039;;<br /> //Ciclo per $n<br /> for ($i = 0; $i &lt; $n; $i++) {<br /> //Calcolo il valore della successione al passo $n<br /> $c = $a + $b;<br /> //Stampo a schermo il valore<br /> echo $c . &#039;&lt;br&gt;&#039;;<br /> //sposto i valori delle variabili<br /> //f2 diventa f1<br /> $a = $b;<br /> //f3 diventa f2, nella prossima iterazione verrà calcolato il nuovo f3<br /> $b = $c;<br /> }<br /> }<br /> }</p> <p>Fibonacci::calcolaSuccessione(1000);<br /> [/php]

Posso continuare ad applicare la procedura di prendere i due numeri precedenti all’infinito. Ovviamente calcolare una serie infinita di numeri richiede un tempo infinito quindi si opta per trovare la successione al termine n dove n è il numero di iterazioni per cui l’algoritmo dovrà eseguire la procedura.

Dalle immagini si nota che scrivere codice commentato in modo virtuoso richiede molte più righe e quindi più tempo ma in caso di manutenzione diventerà tutto estremamente più facile e veloce. Investiamo una piccola parte  del nostro tempo prima per non dover perdere intere giornate dopo.

Procedure

Posso applicare una procedura in qualsiasi contesto, anche per cucinare. Una ricetta altro non è che una procedura: prendere un pentolino, mettere 2 cucchiai di olio extravergine di oliva, aggiungere uno spicchio di aglio, un peperoncino piccante, accendere il fornello e cuocere a fuoco lento, ecc.

Le procedure sono insite all’interno delle funzioni e possono essere combinate tra loro per risolvere problemi più grandi. Tornando all’esempio di Fibonacci, un altro algoritmo potrebbe verificare che il rapporto tra due numeri consecutivi della serie di fibonacci approssima al crescere di n sempre di più il rapporto aureo. Una ulteriore funzione potrebbe verificare che la successione ottenuta di n termini considerando la dei termini presenti su ciascuna diagonale del triangolo di tartaglia corrisponde alla successione di Fibonacci, ecc.

Al pari potrei dire che la procedura precedente utile per la preparazione del soffritto deve essere portata avanti al pari della procedure per cuocere la pasta.

Come avrete compreso una procedura si comprende meglio e in modo più veloce se ci sono commenti che ne descrivono i passi.

Si è soliti inserire prima i commenti e poi il codice perché questa pratica ci permette di scrivere codice molto velocemente senza dimenticarci nulla e lasciando agli altri programmatori che dovranno integrare altre funzioni di comprendere velocemente il famoso “cosa serve a cosa”. 

[starbox] 

L'articolo Prima i commenti, poi il codice proviene da RENOR & Partners S.r.l..

Effettivamente, quasi tutti i libri di testo che ho letto nella vita sul paradigma OOP complicano un concetto che io definirei come la naturale evoluzione della programmazione procedurale e funzionale.

Perché renderla complicata?

Perché a mio avviso, tutti i libri e tutti i corsi vogliono per forza portare degli esempi paragonando la programmazione a oggetti alla vita reale. In realtà, chi ha imparato a programmare in modo procedurale, fino a quel momento ha visto unicamente esempi nel mondo dello sviluppo: cos’è una variabile, cos’è un array, come si cicla un array, come scrivere una condizione, come fare un diagramma di flusso, come scrivere una funzione; pertanto non ritengo siano abituati a cogliere degli esempi nel mondo reale in questa fase, ma dopo aver compreso cosa implica il paradigma a oggetti in ambito informatico. È un metodo di pensare al codice che diviene quasi necessario quando si passa dal piccolo progetto ad un progetto più grande o che dovrà essere manutenuto ed esteso nel futuro. Solo quando si avranno chiare queste basi, sarà possibile portare degli esempi nella vita reale.

Complicare scoraggia

Complicando in questo modo le cose i nuovi “adepti” del mondo della programmazione si scoraggiano. Il risultato è che alcuni di loro abbandonano l’interesse per la programmazione, altri restano fermi alla programmazione procedurale o funzionale senza sapere che da quella funzionale all’OOP il passo è veramente cortissimo.

Chi sviluppa progetti procedurali può creare grattacapi a chi dovrà rimettere mano sul codice

Il paradigma a oggetti non è solo un “diverso modo di organizzare il codice” ma fornisce delle regole e un modus operandi tale per cui chi dovrà mettere mano su codice sviluppato da qualcun altro lo potrà fare senza spaccarsi per troppo tempo la testa alla ricerca di “cosa fa cosa”.

Inoltre nella programmazione a oggetti non bisognerebbe mai sottovalutare la potenza dell’UML.

In sostanza la programmazione a oggetti fornisce tutte le best practice che un buon sviluppatore dovrebbe mettere in atto per rendere il codice facilmente leggibile, strutturato come si deve, facilmente manutenibile e scalabile.

Parlando di scalabilità

Non solo il paradigma ad oggetti incanala lo sviluppatore in un’ottica di sviluppo virtuosa, ma permette anche di usufruire di tutta una serie di strumenti già pronti e facilmente integrabili. Git Hub pullula di Classi già implementate e facilmente integrabili, per lo più tramite Composer, che danno modo di risparmiare tantissimo tempo in fase di sviluppo. Esistono classi praticamente per qualsiasi cosa: la generazione di un PDF, l’invio delle eMail, l’integrazione con le API di eBay e Amazon per l’automazione di progetti eCommerce, la generazione di QR Code e Bar Code, il confronto tra immagini, il ridimensionamento di immagini, la compressione, ecc. ecc.

Questi strumenti sono sempre scritti con paradigma orientato agli oggetti e per sfruttarli e, in taluni casi, riadattarli alle nostre necessità, è necessario conoscere questa filosofia di scrittura del codice.

Quando è difficile scalare?

Svariate volte mi è capitato di rimettere mano su progetti scritti in ottica procedurale… Ho dovuto perdere letteralmente giorni solo per capire in che modo fosse organizzato il codice, dovendo leggermi file di decine di migliaia di righe di codice. Diviene molto difficile modificare anche una banalissima funzione perché è necessario andare alla ricerca, nelle migliaia di righe, di quella porzione di codice che si occupa di mettere in atto quell’azione, stare lì ore a debuggare… Un inferno.

In progetti orientati agli oggetti la cosa sarebbe stata di una banalità disarmante!

Come funziona la programmazione a oggetti?

Sono minuti che giriamo intorno all’argomento ma ancora non ne abbiamo dato una definizione che sia facilmente comprensibile.

Per imparare a programmare a oggetti non c’è altra strada che imparare prima la programmazione procedurale, poi quella funzionale ed in fine quella ad oggetti, perché una è la naturale evoluzione dell’altra.
Programmare significa saper analizzare un grosso problema, scomporlo in problemi più piccoli e trovare delle soluzioni a ciascuno di questi piccoli problemi per poi ricomporne i pezzi e risolvere il problema principale. Per fare questo ci si avvale di funzioni.
Il passaggio dalla programmazione procedurale alla funzionale è abbastanza semplice: le funzioni sono dei raccoglitori di codice procedurale specializzate nella risoluzione di un piccolo problema. Es. scrivere un programma che si occupi di cercare una stringa all’interno di un’altra stringa; se la trova restituire esito positivo altrimenti negativo. Questo programma posso scriverlo all’interno di una funzione. Le funzioni nella programmazione sono esattamente come le funzioni matematiche: si passano una o più variabili in ingresso dopodiché la funzione le elabora e restituisce un risultato, o se vogliamo dirlo in un modo più correttamente matematico. Data una funzione per ogni elemento del dominio della funzione ne corrisponde uno nel codominio. Nella programmazione le funzioni hanno dei parametri di ingresso che vengono elaborati e viene restituito un valore di uscita.

In questo modo si risolve un piccolo problema derivato dal problema principale e posso continuare a risolvere piccoli problemi con altre funzioni per poi metterle assieme e risolvere il problema principale.

All’atto in cui ho finito di preparare tutte queste funzioni, posso valutare quali siano risolutive di una classe di problemi. Poniamo ad esempio di dover calcolare il totale di n fatture ancora non pagate di un’azienda e di dover successivamente inviare questo totale tramite mail al cliente che ce le deve pagare.

Primo problema: prendere tutti i dati da un database

Secondo problema: esaminare le fatture

Terzo problema: sommare le fatture non pagate

Quarto problema: inviare il totale tramite email al cliente per il pagamento

Come lo risolveremmo con la programmazione funzionale?

Primo problema:

• scrivo una funzione che effettui la connessione al database
• scrivo una funzione che faccia una query di SELECT nel database per recuperarne i dati
• li inserisco in un array

Secondo problema:

• scrivo una funzione che mi cicli l’array
• scrivo una funzione che mi scarichi tutte le fatture
• scrivo una funzione che inserisca le fatture non pagate in un altro array

Terzo problema:

• scrivo una funzione che mi cicli l’array e mi sommi il totale delle fatture in una variabile di ritorno

Quarto problema:

• scrivo una funzione che invii una mail al cliente passandogli il valore della variabile contenente il totale fattura
• verifico il corretto invio della mail

Come è possibile vedere abbiamo risolto il problema principale “Calcolare il totale di n fatture ancora non pagate di un’azienda e inviare il totale tramite mail al cliente per il pagamento” utilizzando delle funzioni che risolvono delle sottocategorie del problema principale semplicemente mettendole assieme in modo ordinato.

Come portare tutto questo in un’ottica OOP?

Si devono scindere gli attori in gioco per comprendere a quali Classi di problemi questi appartengano… Ad esempio la Connessione al database è una Classe di problemi che differisce da quella delle fatture, pertanto fatture potrebbe essere un’altra classe di problemi, così come l’invio della Mail è ulteriormente un’altra Classe di problema rispetto alla connessione al database e all’invio delle Mail.

Abbiamo quindi identificato delle Classi che altro non sono che raccoglitori di funzioni, le quali, al loro interno, assumono il nome di “Metodi”.

Per questo problema avremo la Classe Connection per la connessione al database, la Classe Fatture per tutte le funzioni che soddisfano il requisito di risolvere i sottoproblemi relativi alle fatture e la Classe Mail che contiene i metodi relativi all’invio della posta elettronica. Ogni classe raccoglie i metodi (o se vogliamo ancora utilizzare il termine “funzioni”) relativi alla loro classe risolutiva di problemi.

L’oggetto che viene istanziato (creato) dalla Classe, altro non è che un contenitore dei metodi che implementa la Classe (e di proprietà che altro non sono che le variabili in gioco all’interno della Classe)  che possono essere utilizzati per risolvere il problema principale.

Naturalmente questo è uno degli approcci, ma ognuno potrebbe trarre le sue conclusioni sugli attori come meglio crede che sia giusto e non ci sarebbe una versione corretta e una errata. Ad esempio uno sviluppatore avrebbe potuto integrare i metodi per l’invio delle Mail all’interno della Classe delle fatture visto che si riferiscono all’invio di posta elettronica contenente dati di fatturazione. Sarebbe stato un ragionamento che io non condivido ma non scorretto.

Perché usando il paradigma ad oggetti il codice è più facilmente manutenibile?

Semplice! Perché se domani mi chiedessero di integrare anche la media del totale delle fatture, tutto quello che dovrò fare sarà aggiungere un metodo alla Classe Fatture che si occupi di calcolare il valore medio delle fatture di quel Cliente, senza dover stare a ricercare in un file unico la parte di codice che si occupa della fattura.

La cosa importante da fare quando si programma a oggetti è dunque quella di capire quali sono i problemi in gioco, strutturare un diagramma che si chiama UML e raccogliere dentro ogni classe tutti i metodi risolutivi dei microproblemi adibiti a quella Classe di problemi. Una volta che il discorso filerà liscio su carta si potrà iniziare a scrivere i commenti (una best practice che puoi leggere in questo articolo) e per ultimo stendere il codice. L’operazione diventerà veramente banale perché il grosso del lavoro è stato fatto prima con carta e penna.

Naturalmente questo non è un corso di programmazione OOP, le regole della programmazione a oggetti sono molte e vanno comprese integralmente: ereditarietà di una classe figlia, classi astratte, interfacce, traits, ecc., ma una volta entrati nell’ottica di “Cosa è una Classe” e “Perché passare alla programmazione a oggetti” si tratterà solo di studiare queste regole ed applicarle programmando e continuando a programmare sempre di più. Ti accorgerai, una volta compresa, della facilità concettuale e di come torni veramente utile per organizzare il codice secondo regole facilmente interpretabili anche da un’altra persona che dovrà rimettere mano al tuo codice.

Come hai visto la programmazione a oggetti è molto più semplice di quello che si dice, non è assolutamente un concetto astratto e terribile che crea blocchi a chi vuole imparare a programmare… Tutto sta a prenderla nel modo giusto senza stare lì a parlare di Case, Automobili e Moto (questo è l’esempio più citato), Palazzi, Ricette e chi più ne ha più ne metta.

[starbox] 

L'articolo Programmazione: da procedurale verso l’OOP proviene da RENOR & Partners S.r.l..