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

and keeping updates, versions, and dependencies under control.
To follow the guide, we need:

• Git version 2.0 or higher installed and configured
• A GitHub account and a token with repo permission
• Composer version 2.5 or higher installed $PATH
• A free account on Packagist.org (registered via GitHub using OAuth)

Referring back to the article where we explored how to develop a descriptive statistics library, the repository structure was as follows:

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

In the terminal, inside the project folder, we type the command:

composer init

Composer will ask us for some information, starting with the package name, which is expressed as vendor/package-name. In my case, since my account is named “thesimon82”, the package name will be thesimon82/descriptive-statistics. We confirm by pressing Enter.

Now we are asked for the description—
for this project, we’ll enter: Lightweight PHP class for descriptive statistics.

Next is the author field: if we’ve already configured it previously, Composer will show a default author; otherwise, we enter our name and surname manually.

Minimum stability: if it’s a stable release, we enter “stable”.

For Package Type, we enter: “library”.

In license: MIT

We are then asked whether we want to add, one by one, the production packages (require) that the library needs in order to work. In this case, the class is stand-alone (it only uses native PHP functions), so we don’t have any dependencies other than the minimum PHP version—therefore, we can safely answer “no”.


If you’re thinking about PHPUnit for testing the class methods, remember that PHPUnit is only used during development and testing, so it should be placed in require-dev, not in require.


This way, anyone installing the package in a production environment won’t have PHPUnit among their runtime dependencies.

The next prompt, in fact, asks whether we intend to define our development dependencies interactively (require-dev). Here, we type “yes”, and Composer will then prompt us to enter the name of the package.


We now type:


phpunit/phpunit


Composer will return a list of matching packages—select phpunit/phpunit by entering the corresponding number.


Then it will ask which version to include.
We simply press Enter to install the latest available version.

It will now ask if we want to install any additional dependency packages, but since we don’t have any others, we simply press Enter.
It will now ask if we want to add a PSR-4 autoload mapping for the classes, suggesting to map the namespace Thesimon82\DescriptiveStatistics.
However, in our project we used Renor\\Statistics, so we type n to skip the proposal.

Finally, we obtain a summary of the entered data:

{
    "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]? 

Here we review the data, and if everything is correct, we confirm with “yes” and proceed to install the dependencies.

At the end, we type the command:

composer dump-autoload to regenerate the class autoloader.

It’s time to make the commit using the following series of commands:

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

Now we move to GitHub, and we should see our repository with the latest commit—
in my case: thesimon82 feat: first stable release.

We copy the URL from the address bar at the top and head over to Packagist.

Click on “Submit” at the top, then paste the GitHub link you copied into the text field. Press the Check button.
At this point, Packagist will analyze the composer.json file and immediately display the package details.
Clicking the “Submit” button at the bottom will create the package.

We’re done—now it’s time to test if everything works correctly.

Create a new folder named “Stats Test”, then open the terminal and navigate into that folder using:
Here we type:

composer require thesimon82/descriptive-statistics

Now import this folder into your development environment and create a new file in the root directory named: test.php.

<?php
require_once 'vendor/autoload.php';
use Renor\Statistics\DescriptiveStats;

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

As we can see, we’re including the Composer-generated autoloader, which makes all classes mapped via PSR-4 available automatically—without the need for additional require statements.

We define the namespace used in the DescriptiveStats class and instantiate a new object with a numeric dataset.
You’ll recall that the class constructor automatically filters out non-numeric values, reindexes the array keys, and throws an exception if the resulting dataset is empty.


Then, the method mean()is called, which computes the mean and displays it on the screen.

If you now run the command: php test.php from the terminal, and if everything was done correctly, you should see the result:
3.5366666666667,
which is precisely the approximate mean of the values we passed to the class constructor.

Conclusions

We’ve seen how to transform a simple PHP class into a Composer package distributed on Packagist.
Now the library can be installed with a single command, benefits from semantic versioning, continuous integration, and automation that updates the Packagist listing automatically with every new tag.

From this point on, the lifecycle is straightforward:
you implement a feature, run the tests, increment the version, create the tag, and push it to GitHub.
Packagist and Composer will take care of the rest!

[starbox]

L'articolo From Zero to Packagist: Publishing a PHP Library on Composer proviene da RENOR & Partners S.r.l..

Artificial intelligence is now seen by many entrepreneurs as a trend, but it should only be used where it truly adds value. Speaking of efficiency, using AI to calculate a mean, a median, or a mode is not only like using a bazooka to kill a couple of flies, but it can also turn out to be slower, considering the inference times, compared to a finite state algorithm.

Even in contexts that are not strictly scientific or academic, knowing the fundamentals of descriptive statistics can prove extremely useful: from generating automated reports, to monitoring an application’s performance, and even to building dashboards or analytical tools.

In this article, we will build a PHP class that calculates the main descriptive statistical indicators—such as mean, median, mode, variance, standard deviation, quartiles, and more—from scratch, without relying on external libraries. The code will be clean, reusable, and ready to be transformed into a Composer package, which will be the subject of a follow-up article.

Designing a simple yet extensible class

To build a useful and easily integrable descriptive statistics class, we will adopt an object-oriented structure aligned with SOLID principles, avoiding external dependencies and ensuring the possibility of future extension (e.g., support for associative datasets or reading from CSV files).

The class will be designed to operate on arrays of numerical values and efficiently compute the main statistical indicators. The goal is to provide a simple interface.

First, let’s create a new repository on GitHub, which you can find at the following link:
https://github.com/thesimon82/descriptive-statistics-php

Let’s start implementing the methods.

The project structure should be as follows:

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

As you can see, I have also included a folder for adding tests on the class methods (optional) using PHPUnit. The phpunit.xml file defines the test folder and the PHPUnit sources, which must be installed via Composer from the Packagist repository phpunit/phpunit, adding it as a development dependency using the command composer require --dev phpunit/phpunit ^10.

Mean

The arithmetic mean (or average) of a set of numerical observations is obtained by summing all the values and dividing the result by the total number of observations. Formally, it is written as:

where represents the arithmetic mean, is the sample size, and indicates the sum of all observations. This measure provides a concise indication of the central tendency of the data, although it is sensitive to the presence of outliers, which can cause it to deviate significantly from the actual “center” of the distribution.

Let’s implement this method in our class. DescriptiveStats.php

<?php

declare(strict_types=1);

namespace Renor\Statistics;

/**
 * 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);
    }
}

As you can see, we have declared strict_types. This directive enforces PHP to avoid automatic type coercion, which is essential when we want full control over data types.

Since we will accept the data as an array of values, we declare a private property of the class private array $data.

In the class constructor, we handle retrieving the data passed when instantiating the class to create a new object, verifying that the contents of the array $data are numeric, and we place the values inside the property $this->data.

In the mean() method, we implement the mathematical formula for the mean: we sum all the elements of the passed array and divide by the number of elements, returning the result.

Median

The median represents the central value of an ordered set of observations and divides the sample into two halves of equal size. Given a series of values such that :

• If is odd, the median is simply the element in position :
  
• If is even, the median is the arithmetic mean of the two central elements:
  

Unlike the arithmetic mean, the median is robust to outliers, as it depends only on the ordering of the data and not on their magnitude.

 /**
     * 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 this method, I retrieve the data and sort it. We get the size and calculate the central index using integer division. For example, if we have 7 elements, intdiv(7,2) returns 3, which corresponds to the fourth position (remember that arrays in PHP are zero-based!). If the number of values is odd, there is a single perfectly central element, and it is returned. In the case of an even number of values, however, there is not just one central value but two: the ones in positions $mid - 1 and $mid. By definition, the median is the arithmetic mean of these two values. We therefore sum the central elements and divide by 2.0 (using decimal notation to force floating-point division), which returns a float result. This way, the method returns the fiftieth percentile of the sample without modifying the original dataset and in accordance with the statistical definition for both odd and even-length series.

Mode

After the mean and the median, the third most commonly used indicator in descriptive statistics is the mode, that is, the value or values that occur most frequently within a set of observations. If we denote by the absolute frequency of a value in the sample, the mode is obtained as:

.

We can distinguish, based on the input data series:

• Unimodal series when only one value has the highest frequency
• Multimodal series when two or more values share the highest frequency
• Series without a mode when all the values in the series appear only once each

The mode is particularly useful when the data are categorical or when one wants to highlight concentration around certain integer values. Unlike the mean and the median, it does not measure central tendency but rather the value or values that occur most frequently in the series. It is no coincidence that when a clothing item is “in fashion” it is because, compared to other items in a sales series, it turns out to be the most sold and therefore “the one most in fashion.”

Let’s therefore add the method to our class:

/**
 * 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() It scans the entire dataset and returns an associative array where the key is the observed value and the value is the number of times it occurs. This is a quick way to calculate for each .
With max($frequencies), we obtain the highest number of occurrences present in the table; this corresponds to the value of in the mathematical definition.
If the maximum frequency is 1, it means that each observation is unique. In this case, the method returns an empty array to indicate that no modal value exists.
We iterate over the frequency table: for each key whose count equals the maximum frequency, we add that value (cast to float) to the array $modes. In this way, all modal values are included in the case of multimodality.
Before returning the result, sort($modes, SORT_NUMERIC) ensures that the modes are sorted in ascending order, making the output more predictable.

In this way, we have covered all possible scenarios: unimodal, multimodal, and without a mode.

Geometric mean

The geometric mean is the most appropriate measure of central tendency when the data represent growth rates or ratios (for example, percentage returns, variation indices, logarithmic scales).

Given a series of strictly positive values , the geometric mean is defined as:

or, in a numerically more stable logarithmic form:

.

This quantity corresponds to the “average” growth factor which, applied n times in sequence, yields the same result as the actual product of the values.

/**
 * 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));
}

Since the geometric mean is only defined for positive numbers, the method scans the dataset and throws a DomainException if it encounters values ≤ 0. This prevents mathematically incorrect (or complex) results.
Instead of directly calculating the product (which could easily overflow), we convert each value using log(), sum the logarithms, and divide by . Based on the properties of logarithms:


By applying exp() to the average of the logarithms, we obtain the geometric mean.

Harmonic mean

The harmonic mean is the most appropriate measure of central tendency when the data represent speeds, ratios, or fractions—for example, kilometers per hour traveled at different paces, average cost per unit, or average return on investments calculated as “units per euro.”

Given a series of positive values (no value can be zero, as it would appear in the denominator), the harmonic mean is defined as:

In other words, it is calculated as the inverse of the arithmetic mean of the reciprocals. Compared to the arithmetic mean, the harmonic mean gives more weight to smaller values: it is therefore valuable when one wishes to strongly penalize poorer performances (e.g., the average time to travel one kilometer over multiple segments at different speeds).

/**
 * 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;
}

First, a domain check is performed: any value less than or equal to zero triggers a DomainException, otherwise the result would be undefined or become infinite. Then, a sum of the reciprocals is computed: array_map() calculates the reciprocal of each element, array_sum() sums them.
The direct formula divides the number of observations by the obtained sum, according to the mathematical definition.

Truncated mean (or trimmed mean)

When a sample contains extreme outliers that risk distorting the arithmetic mean, an elegant solution is the truncated mean (or trimmed mean).

A percentage % (typically 5% or 10%) is chosen, the sample is sorted, and the first smallest and the last largest observations are discarded, where:

.

This way, a measure of central tendency is obtained that is more robust than the arithmetic mean but less drastic than the median.

/**
 * 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);
}

The method begins by verifying that the chosen trimming percentage makes sense: it must be greater than or equal to zero and strictly less than fifty, otherwise an exception is thrown; if, for example, we were to request the removal of 60% of the data from each tail, there would be nothing left to average.

If the sample contains fewer than three observations, the function considers trimming meaningless and simply returns the arithmetic mean: with two values, removing even one would eliminate half the data, while with only one there is nothing to trim.

The process then proceeds by cloning the original array and sorting it in ascending order; cloning preserves the order in which the data was provided to the object, while sorting is essential because trimming is applied starting from the extremes of the distribution.

The number of elements to discard at each tail, denoted by , is obtained by multiplying the sample size by the requested percentage and rounding down; for example, if we have ten values and want a 10% trimmed mean, we will remove one element from the beginning and one from the end.

Before proceeding, the method checks that “twice ” is not equal to or greater than the length of the array: if it were, the trimming would remove all the data and the mean would no longer make sense; in such case, an additional exception is thrown.

Once this check is passed, array_slice() extracts the central portion that remains after discarding the smallest and largest values; the arithmetic mean is then calculated on this subset, which is precisely the desired trimmed mean.

The function thus returns a measure of central tendency that is more robust than the classic mean: the outliers, removed before the calculation, can no longer pull the result toward extreme values.

Range

The range is the simplest measure of dispersion: it indicates the total spread of the observed values, that is, the distance between the minimum and maximum extremes of the sample. If we denote

,

then the range is defined as

.

Although it is sensitive to outliers (the same value that affects the maximum or minimum also affects the range), this measure provides an immediate indication of the distribution’s spread and is often reported alongside the mean or median to give a quick overview of overall dispersion.

/**
 * 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);
}

As can be seen, the method is very straightforward. It invokes the native PHP functions max() and min(), which each perform a single linear scan of the array to identify the largest and smallest values, respectively. Subtracting the minimum from the maximum yields the total spread of the sample; the result is returned as a float, consistent with the other methods in the class.

Quartiles and interquartile range (IQR)

To describe the dispersion of a sample more robustly than with the simple range, quartiles are used:

• – 25th percentile (first quartile)
• – 50th percentile (median)
• – 75th percentile (third quartile)

The interquartile range is defined as and represents the spread of the central half of the data. It is not very sensitive to outliers because it is based only on the values between the 25th and 75th percentiles of the distribution.

A classic use of the IQR is outlier detection using Tukey’s method (values less than or greater than .

/**
 * 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];
}

When the quartiles() method is called, the first thing it does is create a copy of the internal data and sort it in ascending order; this copy preserves the original order provided by the user and allows working with a monotonically ordered vector, which is a necessary prerequisite for identifying quartiles. Immediately afterward, the variable $n stores the sample size, and $mid represents the central index calculated via integer division. With these two pieces of information, the median of the entire sample is determined, which becomes the second quartile ; if the number of observations is even, the median is the arithmetic mean of the two central values, whereas in the odd case, it coincides with the value at the central position.

Once is known, the sorted array is split into two halves. If the sample size is odd, the median must not be included in either the lower or upper part, so the function array_slice explicitly excludes it; if it is even, the division occurs exactly in half. At this point, the outer quartiles come into play: to calculate and , no new object is created—rather, the private helper medianOfArray is invoked on the two already sorted halves. This small routine receives a vector, counts its elements, determines the central index, and returns the median using the same logic as before; all of this remains confined within the class, keeping the public interface clean and avoiding any code duplication.

The quartiles() method finally returns an array with the three values in ascending order. Its counterpart, iqr(), simply unpacks that array, subtracts from , and returns the interquartile range, providing in a single call the most robust measure of dispersion in the class.

In this setup, the logic for computing the median remains centralized within the private helper, and is reused both for quartiles and, implicitly, for any other internal functionality that might need to calculate a median on a sorted subset. Meanwhile, the public API continues to offer self-explanatory and easy-to-understand methods for anyone integrating your library.

Variance

To measure how much the values deviate from their central tendency, variance is introduced, which calculates the mean of the squared deviations from the arithmetic mean. Given observations with mean , the population variance is defined as:

If instead the data represent a sample drawn from a larger population, the correct estimator (sample variance) divides by :

Variance returns a quadratic value: it is always non-negative and increases rapidly as deviations grow. For this reason, it is often used in conjunction with its square root (standard deviation) to return to the same units of measurement as the data.

/**
 * 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;
}

The method receives a flag indicating whether to calculate the population variance or the sample estimator. It begins by evaluating the dataset size: with only one value, the population variance is by definition zero, whereas the sample variance does not exist and an exception is thrown. Once the mean is known, the loop traverses each observation, subtracts the mean, squares the deviation, and accumulates it. After the summation is complete, the division is performed by or depending on the specified context, thus returning the desired measure of dispersion.

Standard deviation

The standard deviation is simply the square root of the variance: it serves to bring the measure of dispersion back to the same units as the original data. If variance indicates “how many squared units” the observations deviate on average from their mean, the standard deviation expresses that deviation in linear units, making it much more intuitive for a non-specialist reader. For the population, it is obtained as while in the sample case it is . Small standard deviation values indicate a distribution concentrated around the mean; large values indicate widely dispersed data.

/**
 * 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));
}

The method contains no additional logic: it simply calls variance() with the same flag and returns its square root, delegating all calculation and domain checks to the already tested algorithm.

Standard error of the mean

When we observe only a sample from the population, the sample mean is an estimate subject to fluctuations: the smaller the sample, the more the estimate may vary from one sample to another. The standard error of the mean (SEM) precisely quantifies this expected variability. If s is the sample standard deviation and n is the sample size, the standard error is calculated as

.

A small SEM indicates that the mean calculated from that sample is likely close to the true population mean; a large SEM suggests greater uncertainty. The SEM is also the basis for constructing confidence intervals for the mean.

/**
 * 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);
}

The method first retrieves the sample size; if there is only one value, it makes no sense to speak of standard error, so a domain exception is raised. In all other cases, it calls the already implemented sample standard deviation method to obtain . By dividing by the square root of n, it computes the SEM according to the canonical statistical definition and returns the result as a floating-point value. In this way, all numerical logic remains consistent with the other measures of dispersion: the function relies on well-tested methods, does not replicate existing calculations, and guarantees a very simple usage contract.

Mean absolute deviation (MAD)

To measure dispersion in an intuitive way, without amplifying deviations by squaring them as variance does, the mean absolute deviation (MAD) is used. The idea is simple: calculate the absolute distance between each observation and the arithmetic mean, then take the average of those distances. If the sample consists of the values and their mean is , the mean absolute deviation is given by:

.

The mean absolute deviation maintains the same units of measurement as the data, is less sensitive to outliers than the standard deviation, and offers an immediate interpretation: it indicates by how many units, on average, each value deviates from the center of the distribution.

/**
 * 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);
}

The method first retrieves the arithmetic mean of the sample using the already existing mean() function. With this information, it iterates over each observation, subtracts the mean, takes the absolute value of the deviation, and accumulates it in $sumAbs. Once the loop is complete, it divides the sum of absolute deviations by the sample size, returning the result as a floating-point number. The logic remains linear and without conditional branches because the MAD formula does not require distinctions between population and sample: division by always applies.

Percentiles

To locate any given value along the distribution, percentiles are used: the percentile identifies the point below which exactly of the ordered data fall. The 50th percentile coincides with the median, the 25th and 75th form the quartiles already implemented, and in general, knowing multiple percentiles allows for a very detailed description of the distribution’s shape. Since the sample is finite, the percentile position rarely corresponds to an exact integer index: interpolation between adjacent elements is therefore required. A widely adopted convention (Excel and NumPy “linear” method) consists in calculating:

where is the sample size: if r falls between indices and , the percentile is the linear combination of the two values, weighted by the fractional part of .

/**
 * 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;
}

The method first validates that the requested percentile lies between 0 and 100 inclusive, thus ensuring consistency with the statistical definition. It then creates a sorted copy of the data, since any percentile localization requires a monotonically increasing vector. The boundary cases 0 and 100 are handled explicitly by returning the minimum and maximum of the sample, respectively. For all other values, the real rank is calculated, which may fall between two integer indices; the lower and upper indices define the interval containing the fractional position. If is already an integer, no interpolation is needed and the method returns the corresponding element directly. Otherwise, the lower and upper values are linearly combined using a weight equal to the decimal part of , yielding a continuous result that flows smoothly between the elements of the sample.

Minimum and Maximum

To complete the overview of descriptive measures, it is useful to be able to quickly retrieve the lower and upper extremes of the distribution. The minimum value indicates the smallest observation recorded in the sample; the maximum marks the largest. These two quantities, although extremely simple, are essential both for providing context to the data (knowing where the observed interval begins and ends) and as components of other statistics, such as the range you have already implemented. Since the dataset is entirely in memory, finding the minimum and maximum requires only a single linear scan, and the computational cost is negligible.

/**
 * 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);
}

The PHP functions min() and max() scan the array only once; the cast ensures that the returned type is float, consistent with the rest of the API.

Conclusions

With this final method, we have completed our DescriptiveStats class, which now encapsulates in a single component the most important tools of descriptive statistics: from measures of central tendency (arithmetic mean, median, mode, percentiles) to measures of dispersion (range, variance, standard deviation, IQR, MAD), including indicators of robustness (trimmed mean) and uncertainty (standard error).
Each function is self-contained, strongly typed, and supported by automated PHPUnit tests, which we have not included here so as not to further lengthen an article already rich in content.

Thanks to this library, a PHP project can quickly analyze small datasets without external dependencies and without having to use artificial intelligence just to compute a “mode”, integrate statistical calculations into reports, dashboards, or APIs, and extend the class with additional indicators by leveraging a clear and consistent architecture.

In the next article, we will see how to transform the code into a Composer package: we will create the final structure of the repository, review how to modify the composer.json file, configure CI to run the tests, and publish the library on Packagist, making it installable with a simple:

composer require thesimon82/descriptive-statistics

In this way, you will be able to distribute your open-source solution, receive contributions from the community, and reuse it in any project with maximum simplicity.

[starbox]

L'articolo A Descriptive Statistics Class in PHP proviene da RENOR & Partners S.r.l..

Publishing photographs online has become essential for photographers, e-commerce sites, and bloggers, but according to the latest studies on image theft, over 70% of visual content is reshared without credit or authorization. A visible watermark certainly protects the author, but to make it truly effective against intellectual property theft, it often ruins the aesthetic of the shot with an unsightly “patch”!

In contrast, an “invisible” watermark embedded in the coefficients of the Discrete Cosine Transform (DCT), on which the JPEG format is based, preserves perceived quality and can withstand resizing or light compression.

By encoding the information in the sign of specific low-frequency coefficients, it is possible to ensure an effective compromise between invisibility and robustness.

In this open-source project, available in my GitHub repository: https://github.com/thesimon82/php-dct-invisible-watermark, written in PHP 8.3 and based on GD/Imagick for pixel manipulation, we will demonstrate step by step how to embed a textual signature into the low-frequency (AC) coefficients of each 8×8 block, how to retrieve its fingerprint, and why using the coefficient’s sign represents a robust strategy against common JPEG compressions, even at 80% quality or lower.

The goal is not purely educational: the resulting microservice can be cloned from the repository and integrated, via CLI or API, into any image publishing workflow.

Technical foundations

Before writing a single line of code, it is worth clarifying how the JPEG compression algorithm processes the images it needs to compress.

The JPEG format divides the image into a grid of 8×8 pixel blocks; each block is transformed using the Discrete Cosine Transform (DCT), which decomposes the visual information into 64 coefficients ordered from the lowest frequency (the top-left corner, representing the average intensity) to the highest frequency (the finest details).

The mid-to-low frequency coefficients are the ideal spot for our watermark: altering the zero-frequency (DC) coefficient would produce visible halos, while modifying only the highest frequencies would lead to their removal during the very first JPEG compression.

By instead acting on intermediate coefficients, we can encode individual bits by modifying the sign of the coefficient (positive = 0, negative = 1), thus obtaining a marker that is invisible to the eye but robust enough to survive resizing and JPEG compressions down to 80% quality.

This mathematical principle will guide the entire implementation.

We will read each 8×8 block, compute the DCT using a native PHP function, modify the sign of one or more selected coefficients, and save the new JPEG using GD or Imagick.

In other words, the watermark will be hidden precisely in the coefficients that the JPEG compression algorithm tends to preserve: it will be invisible to the eye but difficult to remove, even in the presence of light recompressions.

The mathematics that makes the watermark invisible

Each block of intensities (where) is converted into 64 coefficients (with ) using:

\[

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)u\pi}{16}\Bigr]\,

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

\tag{1}

\]

where

\[

\alpha(k)=

\begin{cases}

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

1, & k\ge 1.

\end{cases}

\]

(the DC coefficient) represents the average luminance of the block. The AC coefficients C_{u,v} with describe increasingly fine details as either or increase.

Simplified numerical example

Let’s suppose a block where all values are 128, a medium gray. Then:

while
because there are no frequency variations.

The compressed image preserves the lower-frequency coefficients, while the higher ones are aggressively quantized—often down to 0.

Quantization and selection of safe frequencies

Before being saved in JPEG format, the DCT coefficients are divided by a quantization matrix , specific to each frequency:

\[

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

\tag{2}

\]

The higher the value of , the greater the loss of precision, with the possibility that the coefficients will be reduced to zero.
For this reason, in our algorithm we operate on a low-frequency subset of the AC coefficients, in positions where quantization is moderate and the values are more likely to survive compression.
We also avoid coefficients that are too low (including DC), as modifying them could introduce visible artifacts.

Bit encoding in the coefficient

To ensure the bit survives JPEG compression, instead of using parity, we enforce the sign of the coefficient based on the bit to be written:

If the bit is 0, we make the coefficient positive

\[

\operatorname{embed}(c, b) =

\begin{cases}

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

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

\end{cases}

\tag{3’}

\]

Where:

ensures a value sufficiently far from zero (typically ≥ 80),
(e.g., 64) increases the distance from zero to prevent nullification during quantization.

In this way, even after lossy transformations, the sign remains unchanged and the bit can be recovered during reading.

If we later wish to read the bit, we simply need to evaluate the sign of the quantized DCT coefficient:

\[

b =

\begin{cases}

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

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

\end{cases}

\tag{4’}

\]

In other words, a positive coefficient indicates bit 0, a negative coefficient indicates bit 1.

This method is more robust because the sign of a coefficient survives many lossy transformations, unlike the least significant bit.

Reconstruction (Inverse DCT)

After modifying the coefficients, we invert the transformation to obtain the watermarked image block:

\[

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)u\pi}{16}\Bigr]\,

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

\tag{5}

\]

The maximum error introduced by a ±1 variation on a mid-frequency coefficient is less than 1 quantum in luminance, which is below the human visual perception threshold for real photographs.

Cyclic redundancy to induce robustness

To withstand compression or cropping, we encode the message M by duplicating each bit k times and applying a majority vote during reading. With k = 3:

\[

M = b_1b_2\dots b_n

\;\longrightarrow\;

b_1b_1b_1\,b_2b_2b_2\dots b_nb_nb_n

\tag{6}

\]

Correct recovery is guaranteed as long as at least two out of three copies survive.

From formulas to code: the DCT class

Now that we have formalized the entire mathematical framework, we can translate equation (1) and its inverse directly into PHP.

To keep the project in pure PHP, without native extensions or external dependencies, we implement the DCT manually on 8×8 blocks.

This approach is sufficiently fast for images up to a few megapixels and, most importantly, it is transparent and easy to understand and modify.

The project is organized with Composer and PSR-4 autoloading, but the Dct class is completely self-contained and does not require any external libraries.

If in the future you wish to extend the system with matrix analyses (e.g., box counting or distortion metrics), you can integrate MathPHP, but it is not required for the 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/"
      }
    }
  }

After defining our composer.json file, we proceed with the installation. Open the terminal and type the command:

composer install

At this point, Composer will create the composer.lock file and the vendor directory, but it won’t install any packages from Packagist because we are not including any dependencies.

src/Dct.php

We can now finally write the Dct class. Remember that it is preferable to include comments in the code, following the standard in English:

<?php

declare(strict_types=1);

namespace Renor\Watermark;

/**
 * 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()
    {
    }
}

This class is the core of the project. It encapsulates the algorithm of the two-dimensional Discrete Cosine Transform applied to 8×8 pixel blocks, the same scheme used by the JPEG standard.
At the start of the forward method, the class checks that the input array contains exactly eight rows and eight columns; otherwise, it throws an exception to prevent a sizing error from propagating silently.

Once the shape has been verified, for each pair of frequency indices , it computes the double summation defined by the canonical DCT formula: it takes each luminance value , multiplies it by two cosine terms — one as a function of and coordinate , the other as a function of and coordinate — and accumulates the result. Once the entire block has been scanned, it applies the normalization factor , where and for , so that the coefficient preserves the average luminance, and all the others represent, at the correct scale, the increasingly finer detail components. The method therefore returns an 8×8 matrix of floating-point coefficients: it is on this frequency representation that we will later embed the watermark bits.

The inverse path is handled by the inverse method. Here too, before any processing, the class enforces a check on the shape of the block. For each pair of pixel coordinates , it reconstructs the luminance by summing the 64 frequency components, each weighted by the product of cosine terms and the normalization factors . The final value is then multiplied by , rounded to the nearest integer, and clamped to the 0–255 range, to prevent any numerical errors from pushing the result outside the valid color space.

The implementation closely follows the mathematical definition, without relying on FFT or SIMD accelerations, favoring educational clarity over performance. The constructor is private, the class cannot be instantiated, and all methods are static and stateless: in this way, the DCT behaves like a pure function—easily testable and reusable. When, in the following sections, we use it to embed a bit by modifying the sign of a low-frequency coefficient, we can be confident that the forward and inverse transformations are numerically consistent and that the alteration remains confined to the values we intend to manipulate.

src/Watermarker.php

The Watermarker class is the director that orchestrates the most delicate phase of the entire project. It receives as input or output a sequence of 8×8 DCT coefficient blocks already computed by the Dct class and, without dealing with the physical reading of the JPEG file, simply manipulates those numbers to hide or retrieve an ASCII text.

<?php

declare(strict_types=1);

namespace Renor\Watermark;

/**
 * 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 = "\0";

    /* ------------------------------------------------------------------
       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() {}
}

When the embed method is called, the caller provides the array of DCT blocks and the message to be embedded. The method converts each character into 8 bits, and each bit is replicated 25 times (as specified by the REDUNDANCY constant), so that it can later be read using a majority vote and withstand alterations due to JPEG compression. The resulting redundant bitstream flows block by block and relies on 8 low-frequency coordinates defined in the constant array EMBED_COORDS. These positions were chosen because they do not affect visual perception but tend to survive even moderate JPEG compressions (quality 60–80).

For each selected coefficient, the private function forceSign() enforces a specific sign: positive to represent 0, negative to represent 1. This approach—more robust than using parity—ensures that the information remains readable even after JPEG quantization.
If the image does not contain enough blocks to represent the entire message, an exception is thrown with an explicit message.

The inverse process is handled by the extract method. Here too, the class reads the sign of the same 8 coefficients in each block, reconstructing a long vector of zeros and ones. The bits are then grouped according to the redundancy factor and passed through a majority vote function (majority()), which recovers the original bit. Every group of 8 bits yields one character, until a NUL terminator is encountered, signaling the end of the message. The resulting sequence of characters forms the original message.

The helper functions stringToBitStream, bitsToInt, and majority encapsulate binary-level details, keeping the public methods short and readable. Like the Dct class, Watermarker is also stateless and cannot be instantiated: all methods are static. This functional approach facilitates automated testing and use in concurrent environments.
In summary, the Watermarker class concretely implements the mathematical principles described earlier: cyclic redundancy, bit encoding via sign, explicit message termination—all in a compact and robust flow designed to survive the typical transformations of images published online.

ImageIO: from the image to DCT blocks and back

The ImageIO class is the bridge between the mathematical theory and the actual JPEG file.

<?php

declare(strict_types=1);

namespace Renor\Watermark;

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()
    {
    }
}

When the static embed method is invoked, the code opens the image using the GD extension and extracts the Y (luminance) component— the only one involved in watermarking—while leaving the chrominance channels Cb and Cr untouched, to ensure the watermark remains invisible to the human eye.
The Y matrix is then divided, row by row, into a grid of 8×8 blocks. Each block is transformed into the frequency domain using Dct::forward, enabling the Watermarker class to embed the message bits by forcing the sign of 8 specifically chosen low-frequency coefficients.

Once the embedding is complete, ImageIO converts each block back into pixels using Dct::inverse, reconstructing a new, watermarked Y matrix. At this point, the class recalculates the RGB values by combining the modified luminance with the original chrominance components: for each pixel, it applies the inverse color space formulas according to the ITU-R BT.601 standard, ensuring that the results stay within the 0–255 range.

The complete bitmap is finally saved as a JPEG at the desired quality, using Imagick to disable chroma subsampling and maximize fidelity. The result is a file that is visually identical to the original but contains, within its DCT coefficients, an invisible yet resilient textual signature.

The inverse process, handled by the extract method, performs the opposite operation: it reloads the image, isolates the luminance channel, divides it into blocks, computes the DCT of each block, and passes the sequence of coefficients to Watermarker::extract. This method reads the sign of the coefficients, applies majority voting across the repetitions of each bit, and reconstructs the original string up to the NUL termination character.

All I/O logic—file opening, color conversion, and JPEG saving—is confined within the ImageIO class, while Dct and Watermarker remain pure mathematical functions. This clear separation of responsibilities promotes code modularity, testability, and easy integration into any image processing pipeline.

CLI test

/embed.php

Embedding a watermark in an image

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

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

use Renor\Watermark\ImageIO;

/**
 * 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 $q\n";
} catch (\Exception $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . "\n");
    exit(1);
}

In this CLI script (embed.php), we define the message to embed in the image via the –msg option and call the static method ImageIO::embed() from the ImageIO class. The script accepts the following parameters:

–q (optional): the JPEG quality for saving (default: 90).

–src: the path to the source JPEG image (e.g., original.jpg);

–out: the path to the destination JPEG file that will contain the watermark;

–msg (optional): the ASCII text to embed (max 10 characters);

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

it will return:

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

/extract.php

From here, we extract the watermark text contained in the watermarked.jpg image just created by embed.php.

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

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

use Renor\Watermark\ImageIO;

/**
 * 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.jpg\n");
    exit(1);
}

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

The extract.php script completes the invisible watermark usage cycle by allowing the extraction of the previously embedded message. It is a simple command-line script which, given a watermarked JPEG file, reads the hidden content by decoding the sign of specific modified DCT coefficients.
The message—robustly recovered even after medium-to-high quality JPEG compressions—is reconstructed using majority voting on the repeated bits.
Just run the command with the –src option to specify the image to analyze, and the script will return the originally embedded string in the terminal.

We can run the command:

php extract.php --src=watermarked.jpg  

we’ll get:

Recovered message: "RENOR"

It is also worth analyzing photographs:

On the left, the original image; on the right, the watermarked one.

We can observe that, as thoroughly described, there are indeed no elements visible to the naked eye that can be traced back to the application of a watermark, which nevertheless remains fully decodable using the extract script.

Clearly, the project is purely demonstrative, and using it at an enterprise level or in production environments would require further refinement.

[starbox]

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

Let’s start with the classic question IT engineers and developers ask themselves when reading certain job offers:
“Do companies actually think that developers and/or IT engineers are all idiots?
Or is it simply that they have people as ignorant as goats—pardon the expression, borrowing from Vittorio Sgarbi—meaning that whoever’s handling their recruitment doesn’t even know the difference between a backend developer and a frontend developer?”

Honestly, I believe the reason should be sought elsewhere… Because the offered gross annual salary (RAL) fully justifies the reasoning. And who can blame them?

Absurd ads

I take a random fresh ad, but I assure you that just looking around a bit you can find thousands of them…

Ad title: PHP Back-end Developer

REQUIRED QUALIFICATIONS

• Knowledge of object-oriented development principles
• Experience in development with the PHP language
• Knowledge of the main frameworks
• Knowledge of software versioning models and tools (GIT/SVN)
• Knowledge of the SQL language
• Knowledge of the web and its protocols
• Knowledge of operating systems such as Windows and Linux
• Knowledge of HTML, CSS, and JavaScript
• Good knowledge of the English language, both spoken and written
• Proven problem-solving skills related to achieving results

PREFERRED REQUIREMENTS

• Knowledge of the main web CMS: Drupal / WordPress / Magento / Adobe Commerce
• Knowledge and experience in (full stack) web application development
• Certifications obtained on enterprise products. Example: Adobe Commerce
• Experience in implementing online payment systems and/or e-commerce solutions

Confusion, ignorance, or opportunism?

Now, even a blind person here would see that they are not looking for a Back-end developer, as the ad title unequivocally suggests… What they are actually seeking is a Full Stack developer, and the funny thing is that in the preferred requirements they state it clearly without any half-measures!! “Knowledge and experience in (full stack) web application development.” Moreover, right there in the required qualifications, the knowledge of HTML, CSS, and JavaScript stands out as clear as day.

Personally, I would never apply to such a job posting, because I consider it an insult to my intelligence but above all to the entire profession.

Con tutto il rispetto, queste non sono posizioni per le quali si può aprire una ricerca rivolgendosi a persone completamente incompetenti, facendogli credere che gli asini volino. Sono ruoli in cui chi si candida deve essere una persona allenata a usare bene il cervello. Non puoi pensare, con l’obiettivo finale di pagare una “Ferrari” 10 euro, di prendere in giro uno sviluppatore che, al contrario di certi ciarlatani, conosce perfettamente quali competenze richiedano lo sviluppo front-end e quali il back-end; cercando di mascherare tutto facendo passare la ricerca di un Full Stack come quella di un Back-end o di un Front-end per pagarlo meno. Questo è un inganno ridicolo nel quale non cadrebbe neanche un bambino di 10 anni che deve finire!

It would definitely be more appreciated and honest to write: “We are looking for a Full Stack developer, we offer this compensation.” This way, candidates are not misled, and respect for the required professionalism is demonstrated by setting clear and transparent expectations from the very beginning.

In this way, everyone would know exactly which role is being sought and, depending on the offer, could decide whether to apply or not, without wasting precious time. In many cases, the company would not receive any applications, and at that point, perhaps, it would realize that it is necessary to increase the compensation!

Job offers to be ashamed of

Not to mention all those job offers that demand absurd skills, ones that even NASA employees might not possess, for ridiculously low salaries… I have read ads from companies looking for expertise in Back-end PHP, .NET, JAVA, Python, version control systems (GIT, SVN, DevOps), container orchestration systems (Kubernetes, Docker), REST API and SOAP, various PHP frameworks including Symfony/Laravel, knowledge of ecosystems and API integration of AWS, Google Cloud, and Microsoft Azure services. For the front-end: HTML, CSS, JavaScript, jQuery, React, Vue.js, Angular, with a preferred requirement in hybrid app development using Cordova, Flutter, or Ionic… All this for the modest sum of 1,200 euros, ladies and gentlemen! I mean… Aren’t you even a little ashamed? It makes me laugh, but honestly, this is something to cry about!

I don’t want to get in the middle of this, and although I don’t consider myself the last wheel in the IT field—probably the second to last, but not the last—I personally know very high-level professionals I have worked and still work with, who probably struggle to even reach half of these required skills… And all this for a salary of 1,200 euros per month? ????????????????????????
It’s truly unbelievable and frankly an insult both to those who work seriously and to the value of the profession itself.

You are ridiculous!!! To all these crafty little opportunists, exploiters of people in difficulty, I sincerely dedicate a big f*** off.

The responsibilities of entrepreneurs

I believe entrepreneurs should pause to reflect with a strong sense of self-criticism and adopt a perspective grounded in very simple market laws…

I have a cousin who had the courage to leave Italy and went to work in France. They were looking for a Front End developer: HTML, CSS, JavaScript, React.js — and for Node.js, if you don’t know it, no problem, we will invest in your training… Period! Is there anything else to add? Every time I hear from him, he makes me feel like an idiot for stubbornly believing that things can change here in Italy too, and he keeps repeating to me: “A professional like you would earn staggering amounts here in France.”
Monthly salary: 3,800 euros per month plus bonuses, and may God increase them. The company offers continuous training and updates. It is clear that in France entrepreneurs have understood that investing in human capital, in their own employees, is crucial to successfully face the challenges of tomorrow and to continue growing and remaining competitive.

If the approach doesn’t change, failure is just one step away.

Let’s come back to Italy…

We often meet “old-school” entrepreneurs… When you talk to them about automating business processes — which could save them up to 90% of their current labor costs, considering they have to bear outrageous expenses for employees who spend the whole day in front of Excel files doing in one day what software could do in a fraction of a second — they look at you as if you came from Mars. They don’t understand a thing of what you’ve explained, but they are too full of themselves to admit it or realize that if they don’t move in this direction now, the only path ahead will be failure!

Yes, I’m talking about failure, and I shout it to everyone, without fear of contradiction, fully aware that I am not exaggerating the matter in any way. Because we also have meetings with young entrepreneurs who fully understand the potential of process automation; they realize they can save a lot on labor costs and therefore can lower the prices of their services, making them more competitive in the market, and they achieve impressive results.

And this is where the usual question arises: “A consumer finds a product at €20 and the very same product — probably with some flaws since everything is the result of ‘manual processing’ — at €40. Which product, do you think, would they actually buy between the two?”

And as a corollary, a second question arises…

“People who, until now, have bought the product for €40 — when they realize that another company offers a better one for €20 — will they continue buying the €40 one?” It would be like believing that if tomorrow a brand of OLED TVs came out producing TVs of equal or even better quality than those made by well-known brands, people would still buy the ones that cost twice as much… Totally illogical!

This is how failure becomes inevitable… The new generation of entrepreneurs will be able to aggressively enter the market with lower prices because they will be more efficient, having lower costs. And all the customers of the old companies, when they see that it is possible to save significantly by having products born from automated processes — and therefore certainly more reliable in terms of “human error” and production speed — will not take long to close contracts on one side and open them on the other. This argument is even more valid the larger the company is. In large enterprises, if I can find a washer for 2 cents less with the same quality as the one I have used until now, at the end of the year I could have a few million euros more in liquidity.

Obsolete ideas and cult of personality

It is truly very difficult to make a person understand—someone who built their wealth in 1980 following a completely analog methodology—that we are no longer in 1980. There are those who, wisely, ask themselves questions, look around, and realize that the world has changed. They understand that in 1980, that exceptional spray for cleaning windows without leaving streaks was only available if you took your car and drove 20 km to the store where you were sure to find it. Now, you go on Amazon, and the next day it’s delivered right to your doorstep. But he, stubbornly, continues to drive 20 km, wasting gas, time, and maybe getting frustrated in traffic.

There are those who have understood that we live in a world very different from the one in 1980. These are the people who will survive and, in fact, will only see their revenues rise. But within five years, companies that have not embraced process digitalization and still rely on pen and paper, or at best Excel sheets, will meet a very bad end.

Many readers might say: “Okay, but then you won’t need so many people anymore; they’ll lay off half of them.” That’s not necessarily true… However, continuing to pursue a business model that in a couple of years will collapse — well, at least everyone will be out of a job!

That said, you can still maintain employment levels by choosing to invest human resources in other company departments, such as marketing, to increase your business scale, since on the processing side you can now virtually scale infinitely thanks to your investment in automation.

The world evolves, and especially in private companies — which are the economic engine of the Italian system — you must be able to adapt to the times and market demands. Only in this way can you have a solid company.

The economy doesn’t work solely based on the amount of money in circulation; much more important is the speed at which that money changes hands. If the current trend continues, soon we will have fewer and fewer active companies in the market, and wealth will concentrate in the hands of a few, because when others decide to move, it will already be too late.

The importance of certain roles and their recognition

Let’s start by giving value to people… A Full Stack developer who solves problems in your company and saves you a million euros a year cannot be paid 800 euros per month. Entrepreneur!?!?!? Be consistent first with yourself and then with others!!! How can you show up with a mere crumb to someone who helped you keep 5,000 loaves in the cupboard?

Someone who has worked their tail off studying book after book, pulling all-nighters to prepare for university exams, constantly keeping up with the latest technologies (and there are a couple of new ones every two months), while their peers were hanging out smoking on the village square wall, would never come to work for you—earning you a million euros a year—in exchange for 800 euros a month, which is basically what those who were smoking get.

Are we going to recognize a difference or not? And if you think you’re clever proposing job offers that should only be ashamed to be published, maybe it’s time to rethink your approach… Because if you follow this kind of logic, you’re probably not that smart after all.

[starbox]

L'articolo What the h*ll are you looking for? A backend or a frontend? proviene da RENOR & Partners S.r.l..

Some motivations

Although the strengths of this CMS are clear, there are many things that the average user may not know about not being an insider.

There is a way and a way to develop websites

How many of you have fallen to the temptation of getting a site developed for 300 euros all inclusive? Well, here’s some news for you… You have thrown your money away!

Developing a site just to say, “Hey man! I made the site,” is perfectly useless. Since time immemorial, when you decide to buy a product you do it because it has to be useful for something. A site developed with 300 euros is a useless site. There is little to go around. With 300€ it is impossible to put in place all those virtuous development practices necessary to make the site pleasing to search engines.

The speed of loading

Sites pulled up at a cost of 300€ are sure to integrate a WYSIWYG (What You See Is What You Get) plugin. These plugins are notoriously heavy, using lots of JavaScript and a myriad of CSS that is mostly not even used. Let’s face it: they are mainly used by those who don’t know how to develop and want to make their own “unpretentious little site” or by those who, aware of the SEO implications, don’t give a damn just to deliver a job sooner and make cash.

Banco alle ciance! Numbers in hand. In either case, the result will be this:

Such a site will be lucky to appear on the 100th page of the search engine, unless you have done painstaking work on SEO by studying content for compound keywords that are more likely to rank, or have a number of articles and content that integrates all human knowledge, then yes, you can turn a blind eye to the loading speed, but if you have made such compromises let alone focus all this attention on SEO and content!

Therefore: unnecessary expense!

Image optimization

A well-done site has had behind it the work of a webmaster who has spent a great deal of time optimizing images for the Web.
Today there are formats designed to aid site loading speed, formats that offer a small size while maintaining decent image quality.

In addition, images should be resized for their intended use. If I need to fill a small area of 300 x 200 pixels with an image, it is bad-practice to upload a 2400 x 1600 pixel image.

At 300€ per site this care cannot exist because it is time-consuming, so one prefers to take and upload the image as is and resize it via CSS by adding a couple of attributes to the tag (much faster operation):

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

Too bad the image weighs 4 megabytes! Basically just loading this image, from mobile would take 4 to 5 seconds with 4G coverage, compared to the 20 Kb of the same optimized image, which would load in about 30 milliseconds.

Also prominent in the above line of code are three attributes that are useful for SEO and intentionally left unfilled: each image should have an alternate text, a title, and a long description. The search engine pays attention to these details because they are useful for the blind to interpret the content of the image. Therefore, in addition to representing additional words to be categorized for SEO purposes, engines tend to reward those who also think of the less fortunate. Of course, filling out these fields also takes time, and I doubt that $300 sites have done prior research on keywords they can rank with and have gone out of their way to provide descriptions of all the images they include.

Just to give you an idea of the time frame, an article comes out on this blog every day…. The motivation is not due to a lack of desire to write or a lack of imagination: we have hundreds of article titles to write in our editorial plan, the problem is that between SEO analysis and drafting, an article takes half a day to write… And do we still want to waste time talking about a €300 site?

Postpone CSS and JS blocking the display

The browser when it receives the requested site data processes CSS and JavaScript in the order they are written and blocks the display of the page until those files have been fully loaded. This further lengthens the time it takes to interact with the site. Some of these files may not be needed immediately and can be delayed. In essence, one must simply tell the browser that those files can be loaded after the page content has loaded. This practice gives the user who is opening the site a way to view it and be able to interact with it much sooner. This practice lowers what search engines call the bounce rate. Basically if a site takes 20 seconds to load at 6 seconds 80% of visitors have already left.

Delete unused CSS and JavaScript fragments

Definitely difficult operation to perform on projects using CSS-JS frameworks! The developer would have to access the framework’s CSS and JS files looking for all those classes (for CSS) and functions (for JavaScript) that are not called within the site pages and delete them. Under normal conditions this would not be the end of the world, but it is not easy to find what you need inside a file where the most user friendly name for naming a variable is “var k.”

The practice of replacing user-friendly variable names with short variables is put in place by the framework developers to reduce the size of the file that the browser will have to load, but it makes the JavaScript code written within it virtually unreadable. In essence, it is an unworkable practice.

One operation that can certainly be done involves minification of all CSS and JS. The entire file is written in a single line by eliminating the “carriage return” information and spaces within it. This saves an amount of space that can average 20 to 40 percent of the original weight. All this results in a shorter loading time at the same download speed.

Web sites visually all the same

When using these shortcuts you immediately notice a similarity between all sites. Want it or not, the CSS classes always are! As much as you can then customize there always remains a very similar visual impression between sites that were developed using WYSIWYG Plugins or Frameworks.

Are we therefore saying that WordPress is a CMS to be avoided?

Absolutely not. WordPress is a great CMS for creating websites with blogs and eCommerce, as long as you develop themes to the rule of art, without using these kinds of shortcuts that make the investment made to have a website online absolutely useless.

This site was also developed with WordPress, but not in half a day…. In a couple of months. It possesses a style that will be impossible to find on Sites developed with the shortcuts we have talked about, it has optimized images, optimized SEO, Sitemap updated in real time and definitely the cost of development was not 300€ unless you find a developer to work for you at 150€ a month!

For that matter, the Audit speaks for itself….

As you may have guessed, it’s not a matter of choosing WordPress yes or WordPress no; it’s. as always, a matter of evaluating how you work on WordPress and making all the appropriate assessments if you don’t want to throw money away.

Alas, most online sites are precisely developed by “phantom web agencies” in precisely this way, trying to go on the speed of development and the number of clients trapped in the net like fish caught in the sea, foisting on them low-paying websites, developed just to get the client to see the site online and which turn out, however, to be completely useless for the purposes for which a website is supposed to be built: attracting new clients.

In Italy for some years now there has been an air of “excessive facilitation.”. It is thought that everyone can do everything with little effort. I am sorry, but that is not the case! It is only fair that someone sooner or later will take the responsibility to say that if you are a Cook you will be great at your job but you cannot develop websites.

The cons of WordPress

As the most popular CMS in the world, it is also the one most stormed by the Hacker community. More than 16 million online sites have been developed using WordPress, the step is short: I find a flaw in WordPress and I can extend it to 16 million sites.

The WordPress community is always working to improve the core of the CMS, so much so that updates to the Core are released from time to time, but beware, there are also Plugins that are often developed by third-party agencies, and they may have closed their doors, so they will no longer release updates and someone will sooner or later find a flaw.

In fact, most attacks on WordPress come precisely from flaws in plugins and themes (which are no exception). Developing your own theme from scratch allows you to limit attacks on the theme front precisely because of the fact that if the theme is yours it will be unique and there is no Hacker in the world willing to find systemic flaws on a theme used by a single site, unless your name is INPS or Internal Revenue Service.

Basically, you should preferably go for plugins that have millions of installations and ensure that the Software House that developed them stays alive to ensure updates to their plugin over time.

WordPress to be safe needs to be updated continuously, as soon as an update is available.

From the latest versions it is also possible to set automatic updates, both for the WordPress core and plugins.

When it is not advisable to use WordPress

There is no rule, you just use common sense…. Personally, I would not use WordPress for purposes for which it was not designed. Remember that WordPress started as a CMS for Blog integration, for any other project I would think about it before using WordPress.

I would not use WordPress in case the key word of the work to be done was: performance. Not because WordPress itself is slow but because, I remind you, in order to run it makes calls that for some projects might be totally unnecessary.

Structuring a Custom project implies that you write only and exclusively the code that serves the purposes for which the site or web application was designed. Similarly, I would use Custom solutions to avoid worrying about having to update themes and plugins, especially when some plugins have not yet been updated to work properly on a new WordPress core. This could generate problems with site usage.

Basically when the budget allows, I am always for implementing custom solutions: more reliable, better performing, safer… Of course, as long as you don’t pay 300€ for them.

[starbox]

L'articolo WordPress or custom solution? proviene da RENOR & Partners S.r.l..

A very dear university professor of mine, Prof. Carlo Gaibisso, used to say this phrase in his lectures on “Structured Programming” in the C language: “You write the comments first and then the code.”

How can you blame them?

Despite the fact that programmers are a class of “stage animals” in the world of computer science, and despite the training a developer may have, it is a fact that it is always easier and more immediate to read something that belongs to our common way of communicating. It is much easier to read in Italian what an algorithm is about than to understand what an algorithm written in code does; it becomes the more complex to understand it the more complex the algorithm.

Object-oriented programming also incorporates procedural programming. Within the methods of a class, one programs procedurally.

Procedural programming is so called because code is executed according to a procedure. I can write procedures for anything… For example if I have to calculate the Fibonacci succession I know that to calculate the number at step n I have to take the previous number and add it to the still previous number.
Therefore the procedure will be: starting with S = 1 1, f3_– > I take _f2 I add it to _f1, and I get

S = 1 1 2

I take _f3 = 2 I add it to _f2 = 1 and get

S = 1 1 2 3

I take _f4 = 3 I add it to _f2 = 2 and get

S = 1 1 2 3 5

You will understand that it is much easier to instantly understand the definition, “To calculate the nth number of the Fibonacci sequence I add the previous two” than _fn = _fn-1 + _fn-2 especially if this formula is written with variables and cycles within a computer algorithm!

PHP example for calculating Fibonacci series without comments

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

PHP example with comments

[php]<br />
<?php</p>
<p>/**<br />
* Fibonacci is a class for calculating the Fibonacci succession<br />
* and its verification<br />
*<br />
* Fibonacci is a class for calculating the Fibonacci succession<br />
* The verification of the golden ratio through the relationship between successive terms<br />
* verification by tartaglia triangle and verification by<br />
* Cassini, Catalani and D’Ocagne’s equalities<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 calculateSuccession – Static method to calculate succession<br />
* of Fibonacci for $n terms<br />
* @param int $n – The number of iterations<br />
* @return void has no return values, it just prints the values<br />
* of the series at each iteration<br />
* @access public<br />
**/</p>
<p> public static function calculateSuccession($n)<br />
{<br />
//As I have two fixed parameters I remove them from iterations<br />
$n = $n – 2;<br />
$a = 1;<br />
$b = 1;<br />
//Print the two starting parameters<br />
echo $a . “
”;<br / >
echo $b . “
”;<br / >
//Cycle for $n<br />
for ($i = 0; $i < $n; $i++) {<br />
//Calculate the value of the subsequence at step $n<br />
$c = $a + $b;<br />
//Print on screen the value<br />
echo $c . “
”;<br / >
//move variable values<br />
//f2 becomes f1<br />
$a = $b;<br />
//f3 becomes f2, the next iteration will calculate the new f3<br />
$b = $c;<br />
}<br />
}<br />
}</p>
<p>Fibonacci::calculateSuccession(1000);<br />
[/php]

I can continue to apply the procedure of taking the previous two numbers to infinity. Obviously computing an infinite set of numbers takes an infinite amount of time so we opt to find the subsequence at term n where n is the number of iterations for which the algorithm will have to perform the procedure.

From the pictures we can see that writing commented code in a virtuous way requires many more lines and therefore more time but in case of maintenance everything will become extremely easier and faster. We invest a small part of our time before so that we do not have to waste whole days afterwards.

Procedures

I can apply a procedure in any context, even for cooking. A recipe is nothing but a procedure: take a saucepan, put 2 tablespoons of extra virgin olive oil, add a clove of garlic, a hot pepper, turn on the stove and simmer, etc.

Procedures are inherent within functions and can be combined to solve larger problems. Returning to the Fibonacci example, another algorithm might verify that the ratio between two consecutive numbers in the Fibonacci series approximates as n increases more and more the golden ratio. A further function could verify that the obtained succession of n terms considering the of the terms on each diagonal of the tartaglia triangle corresponds to the Fibonacci succession, etc.

On par I could say that the previous procedure useful for preparing the soffritto should be carried out on par with the procedure for cooking the pasta.

As you may have realized, a procedure is best and most quickly understood if there are comments describing the steps.

It is usual to insert comments first and then code because this practice allows us to write code very quickly without forgetting anything and leaving other programmers who will have to integrate other functions to quickly understand the famous “what is needed for what.”

[starbox]

L'articolo First the comments, then the code proviene da RENOR & Partners S.r.l..

Indeed, almost every textbook I have read in life on the OOP paradigm complicates a concept that I would characterize as the natural evolution of procedural and functional programming.

Why make it complicated?

Because in my opinion, all books and all courses necessarily want to bring examples comparing object-oriented programming to real life. In fact, people who have learned to program procedurally up to that point have only seen examples in the development world: what is a variable, what is an array, how to cycle an array, how to write a condition, how to make a flowchart, how to write a function; therefore, I don’t think they are used to picking up examples in the real world at this stage, but after they understand what the object-oriented paradigm implies in computing. It is a method of thinking about code that becomes almost necessary when moving from a small project to a larger project or one that will need to be maintained and extended in the future. Only when you are clear about these basics will it be possible to bring examples into real life.

Complicating discourages

By complicating things in this way, new “adepts” to the programming world become discouraged. The result is that some of them drop their interest in programming, others remain stuck in procedural or functional programming without knowing that from functional programming to OOP is really a very short step.

Those who develop procedural projects can create headaches for those who will have to put their hands back on the code

The object-oriented paradigm is not just a “different way of organizing code” but provides rules and a modus operandi such that those who will have to get their hands on code developed by someone else will be able to do so without splitting their heads for too long searching for “what does what.”

Also, in object-oriented programming, one should never underestimate the power of the UML.

In essence, object-oriented programming provides all the best practices that a good developer should put in place to make code that is easily readable, structured as it should be, easily maintainable, and scalable.

Speaking of scalability

Not only does the object-oriented paradigm channel the developer into virtuous development, but it also allows the developer to take advantage of a whole host of ready-made and easily integrated tools. Git Hub is teeming with ready-implemented and easily integrated Classes, mostly through Composer, which provide a way to save so much time in development. Classes exist for just about anything: generating a PDF, sending eMail, integrating with eBay and Amazon APIs for automating eCommerce projects, generating QR Codes and Bar Codes, comparing images, resizing images, compression, etc. etc.

These tools are always written with an object-oriented paradigm, and to take advantage of them and, in some cases, readjust them to our needs, it is necessary to be familiar with this philosophy of writing code.

When is it difficult to climb?

Several times I have had to rehash projects written procedurally… I had to literally lose days just to figure out how the code was organized, having to read files of tens of thousands of lines of code. It becomes very difficult to modify even a very trivial function because you have to go searching through the thousands of lines for that portion of code that is responsible for putting that action into effect, stand there for hours debugging… Hell.

In object-oriented projects this would have been disarmingly trivial!

How does object-oriented programming work?

We have been circling the topic for minutes but still have not given a definition that is easily understood.

To learn object-oriented programming there is no other way than to learn first procedural programming, then functional programming and finally object-oriented programming, because one is the natural evolution of the other.
Programming means being able to analyze a big problem, break it down into smaller problems and find solutions to each of these smaller problems and then put the pieces back together to solve the main problem. To do this we use functions.
The transition from procedural to functional programming is quite simple: functions are binders of procedural code that specialize in solving a small problem. E.g. write a program that deals with searching for a string within another string; if it finds it return positive outcome otherwise negative. This program I can write within a function. Functions in programming are exactly like mathematical functions: you pass one or more variables as input after which the function processes them and returns a result, or if we want to say it in a more properly mathematical way. Given a function for every element in the domain of the function corresponds to one in the codomain. In programming, functions have input parameters that are processed and an output value is returned.

This solves a small problem derived from the main problem, and I can continue to solve small problems with other functions and then put them together to solve the main problem.

At the point when I have finished preparing all these functions, I can evaluate which ones are solving a class of problems. For example, let’s say we need to calculate the total of n outstanding invoices from a company and then have to email this total to the customer who owes us for them.

First problem: getting all the data from a database

Second problem: examining invoices

Third problem: adding up the unpaid bills.

Fourth problem: email the total amount to the customer for payment

How would we solve it with functional programming?

First problem:

• I write a function that makes the connection to the database
• I write a function that does a SELECT query in the database to retrieve the data
• I put them into an array

Second problem:

• I write a function that loops my array
• I write a function that downloads all the invoices to me.
• I write a function that inserts unpaid bills into another array

Third problem:

• I write a function that loops the array and sums the total invoices to me in a return variable

Fourth problem:

• I write a function that sends an email to the customer by passing them the value of the variable containing the invoice total
• I verify the correct sending of the email

As you can see, we solved the main problem “Calculate the total of n outstanding invoices of a company and email the total to the customer for payment” by using functions that solve subcategories of the main problem by simply putting them together in an orderly way.

How to bring this into an OOP perspective?

One must break down the actors involved to understand which Problem Classes these belong to…. For example, Database Connection is a Problem Class that differs from Invoices, so Invoices might be another Problem Class, just asSending Mail is further another Problem Class than Database Connection and Sending Mail.

We have therefore identified Classes that are nothing more than binders of functions, which, within them, take on the name “Methods.”

For this problem we will have the Connection Class for connecting to the database, the Invoices Classfor all the functions that satisfy the requirement to solve invoice-related subproblems, and the Mail Classthat contains the methods related to sending e-mail. Each class collects the methods (or if we still want to use the term “functions”) related to their problem-solving class.

Theobject that is instantiated (created) by the Class, is nothing more than a container of the methods that implements the Class (and of properties that are nothing more than the variables in play within the Class) that can be used to solve the main problem.

Of course this is one approach, but everyone could draw their own conclusions about the actors as they see fit and there would be no right and wrong version. For example, a developer could have integrated the methods for sending Mail within the Invoice Class since they relate to sending Mail containing billing data. That would have been reasoning that I disagree with but not incorrect.

Why using the object-oriented paradigm makes the code easier to maintain?

Simple! Because if I were to be asked tomorrow to integrate the average of the total invoices as well, all I would have to do is add a method to the Invoices Class that would take care of calculating the average value of that Customer’s invoices, without having to stand around looking in a single file for the part of the code that deals with the invoice.

The important thing to do when programming in objects is therefore to figure out what problems are involved, structure a diagram called the UML, and collect within each class all the microproblem-solving methods assigned to that Problem Class. Once the argument runs smoothly on paper you can start writing comments (a best practice that you can read about in this article) and lastly lay out the code. The task will become really trivial because the bulk of the work was done first with pen and paper.

Of course, this is not a course in OOP programming, the rules of object-oriented programming are many and must be understood in full: daughter class inheritance, abstract classes, interfaces, traits, etc., but once you get into the mindset of “What is a Class” and “Why move to object-oriented programming” it will be just a matter of studying these rules and applying them as you program and continue to program more and more. You will realize, once you understand it, the conceptual ease and how it really comes in handy for organizing code according to rules that can be easily interpreted even by another person who will have to redo your code.

As you have seen object-oriented programming is much simpler than people say, it is by no means an abstract and terrible concept that creates blocks for people who want to learn programming… It’s all about taking it the right way without standing there talking about Houses, Cars and Motorcycles (this is the most cited example), Palaces, Recipes, and you name it.

[starbox]

L'articolo Programming: from procedural to OOP proviene da RENOR & Partners S.r.l..