Un errore semantico si colloca generalmente nel contesto della programmazione, e si riferisce a una logica errata che porta a risultati non desiderati, nonostante il codice sia sintatticamente corretto e venga eseguito. Rilevare e correggere questi errori richiede una comprensione profonda della logica del programma e degli obiettivi che si intendono raggiungere, e spesso non ci sono criteri applicabili in generale: si usano infatti un mix di logica, esperienza e buonsenso.

In informatica, gli errori semantici (o logici) sono errori nel codice sorgente di un programma che causano un comportamento non desiderato, nonostante il programma possa essere sintatticamente corretto. Questo tipo di errore si colloca nel contesto della programmazione e dello sviluppo software, dove il codice deve non solo rispettare le regole sintattiche del linguaggio di programmazione, ma anche produrre i risultati attesi in base alla logica implementata.

Quando si verifica un errore di questo tipo (esempio)

In generale l’errore semantico (dal greco sss) si verifica quando usiamo male gli elementi che abbiamo a disposizione in un linguaggio di programmazione, ma potrebbero verificarsi anche in lingua italiana. Questi esempi illustrano come gli errori semantici possono compromettere la chiarezza e la comprensibilità del linguaggio, causando fraintendimenti o rendendo le frasi incoerenti.

• Uso improprio delle parole: Frase: “Il cane miagola nel giardino.”
  • Spiegazione: Il verbo “miagola” è semanticamente errato perché i cani abbaiano, mentre i gatti miagolano.
• Antropomorfismo errato: Frase: “Il computer è arrabbiato perché non gli piace il programma.”
  • Spiegazione: I computer non hanno emozioni. Questa frase è semanticamente errata perché attribuisce emozioni umane a un oggetto inanimato, per quanto possa essere usata per fornire esempi comprensibili o durante una spiegazione o un talk specialistico.
• Ambiguità semantica: Frase: “Il professore ha parlato con lo studente del problema.”
  • Spiegazione: Non è chiaro se “del problema” si riferisca al professore o allo studente, creando ambiguità.

Immaginiamo adesso di voler scrivere una funzione che calcola la somma dei primi n numeri naturali. Un errore semantico potrebbe facilmente verificarsi se sbagliamo la logica della somma. Non è difficile immaginare che la somma debba andare da 1 fino ad n, passando per 2, 3, 4 , … n-2, n-1, ma un conto è pensarlo altro conto è tradurlo in termini di codice software.

Un errore semantico si verifica pertanto quando un programma non si comporta come previsto, spesso sulla base di fraintendimenti di contesto, di modalità e di significato. Questi errori in effetti sono a volte difficili da rilevare automaticamente, perché il codice sembra tecnicamente corretto dal punto di vista della sintassi, e nonostante questo il programma produce risultati sbagliati perché la logica applicata non è quella giusta. Ad esempio, poniamo di voler calcolare la somma dei primi n numeri interi a partire da zero, quindi se n=5 vogliamo ottenere 1+2+3+4+5 = 15.

Il problema è facile da risolvere in linguaggio Python, ad esempio in questi termini:

def somma_primi_n_numeri(n):
 somma = 0
 for i in range(1, n + 1):
  somma += i
 return somma

# Chiamata della funzione
n = 5
print(f"La somma dei primi {n} numeri naturali è: {somma_primi_n_numeri(n)}")

un programmatore inesperto potrebbe, ad esempio, commettere l’errore semantico di non considerare che la funzione range spazza i valori dal primo fino al secondo parametro più uno, per cui potrebbe scrivere la terza riga del codice come segue:

 for i in range(1, n):

in tal caso il codice eseguirebbe lo stesso senza errori sintattici, ma il risultato per n=5 sarebbe 11 e non 15 (e sarebbe quindi sbagliato).

Altri tipi di errori semantici classici

Ecco una lista di errori semantici comuni che possono verificarsi in una singola riga di codice:

1. Utilizzo di variabili non inizializzate.
2. Divisione per zero.
3. Utilizzo di un operatore errato (ad esempio, * invece di +).
4. Accesso a un indice fuori dai limiti di un array.
5. Confronto errato tra variabili (ad esempio, = invece di ==).
6. Uso di una funzione con parametri sbagliati.
7. Errato casting di tipi di dati.
8. Modifica involontaria di una variabile globale all’interno di una funzione.
9. Concatenazione errata di stringhe e numeri senza conversione.
10. Logica condizionale sbagliata in un’istruzione if.

Questi errori possono far sì che un programma si comporti in modo inatteso o produca risultati errati nonostante il codice sia sintatticamente corretto.

Differenza tra errori sintattici e semantici

Gli errori semantici si differenziano dagli errori sintattici, che sono violazioni delle regole grammaticali del linguaggio di programmazione e vengono rilevati dal compilatore o dall’interprete durante la fase di analisi sintattica.

Stando alla pianificazione ufficiale diffusa nel sito PHP.net, la versione 8 del linguaggio per il web più utilizzato e popolare al mondo dovrebbe andare in release pubblica a dicembre 2020; in questa data, infatti, dovrebbe vedere la luce la prima versione stable. Di conseguenza, ci si aspetta che i vari servizi di hosting vadano ad adeguarsi alla nuova versione del linguaggio già  verso la metà  del prossimo anno.

PHP 8 è anche oggetto di un talk di Sebstian Bergmann, che entra nel merito con dettagli tecnici e performativi rispetto a questa nuova ed attesissima versione del linguaggio. Tra le novità  più attese, l’introduzione di nuove interfacce e funzioni per il DOM PHP, l’introduzione di nuove funzioni di pattern matching e debug, l’uso del compilatore JIT di default, attributi per le variabili e nuovi tipi di costruttori per le classi.

Compilatore Just In Time (JIT)

Le novità  di PHP 8 passano anzitutto per l’introduzione e consolidamento di un compilatore Just-In-Time, che era già  disponibile dalla versione 7.4 del linguaggio (e che ho già  sperimentato con successo nell’ambito dell’implementazione di OPCache). In genere un compilatore just-in-time (JIT) permette un tipo di compilazione del codice scritto in PHP più veloce e performante, in   quanto viene ridotto notevolmente il tempo necessario per l’esecuzione degli script e la generazione di un bytecode più veloce da eseguire rispetto al caso ordinario.

Con la versione PHP 8 tutto questo farà  un ulteriore passo avanti, per quando (stando alle specifiche ufficiali) non è detto che WordPress e CMS simili scritti in PHP ne riescano ad usufruire facilmente. I test di benchmark sul JIT, di fatto, sono effettuati e apprezzabili soltanto nel caso in cui il codice venga sfruttato per la generazione di frattali, o comunque per sfruttare determinate caratteristiche del linguaggio PHP che non sempre, lato web, vengono utilizzate.

Sulla sinistra, in questo esempio (fonte) è possibile vedere una generazione di frattali con PHP standard, più lenta e “a scatti”, mentre a destra si può vedere l’elaborazione più fluida ottenibile con l’integrazione di un compilatore JIT.

Una novità  che, a conti fatti, rischia un po’ di essere un uovo di colombo (quel benchmarch è visualmente efficace ma difficile da applicare nella pratica dei siti web, alla fine), senza contare che per gli informatici non è nemmeno una novità  colossale (la modalità  JIT esisteva già  su vari linguaggi e framework da anni, e non sarà  certo una salvezza per chi poi dovrà  effettuare debug e manutenzione del codice). Porta sicuramente vantaggi interessanti in potenziale, ma il rischio è che la corsa all’aggiornamento si riveli più problematica che altro.

Pattern matching ottimizzato

Chiunque debba effettuare la ricerca di un pattern in una stringa sa bene quanto l’operazione, formalmente semplice sulla carta, possa rivelarsi complessa all’atto pratico. Storicamente il pattern matching tra stringhe si può effettuare mediante regex (espressioni regolari) oppure mediante strpos, che pero’ ha una sintassi francamente un po’ ostica da comprendere e ricordare.

PHP 8 ha introdotto una nuova funzione:

str_contains ( $ago, $pagliaio ) 

che restituisce true o false se la stringa $ago è contenuta nel $pagliaio. Per cercare all’inizio e solo alla fine di una stringa, similmente, sono introdotte le funzioni:

str_starts_with ( $ago, $pagliaio )
 str_ends_with( $ago, $pagliaio ) 

che restituiscono sempre un valore boolean true o false.

Constructor Property Promotion

Questa feature permette al programmatore PHP di risparmiarsi righe di codice, inserendo direttamente le proprietà  da modificare (campi di variabili private) all’interno del costruttore della classe, per cui una classe del genere, vagamente ridondante nella sua definizione:

class LaMiaClasse
{
    public string $nome;

    public function __construct(
        string $nome = 'Pippo'
    ) {
        $this->nome = $nome;
    }
}

sarà  equivalente alla nuova sintassi compatta:

class LaMiaClasse
{
    public function __construct(
        public string $nome = 'Pippo',
    ) {}
}

Attributi v2

A partire dalla versione 8 di PHP, saranno disponibili gli attributi per le variabili, da inserire nel codice nella forma:

<<attributo>>

Debug: throw e rilevazione in real time del tipo di una variabile

Storicamente il tipo di una variabile PHP poteva essere rilevato a runtime mediante instanceof:

if ( ($x instanceof Foo) ) {
	// se $x è un oggetto di tipo Foo, fai robe...
}

con PHP 8 si può usare in combinazione con la nuova funzione get_debug_type:

if ( !($x  get_debug_type Foo) ) {


// se $x NON è un oggetto di tipo Foo

echo "oggetto x di tipo: ". get_debug_type($x); }

Sempre a livello di debug, con PHP 8 è possibile usare la funzione throw in modo più autonomo, come se fosse una funzione stand alone, e non solo in caso di specifiche Exception.

Uso dei trait con firma digitale

Si propone un uso più uniforme dei trait PHP, sfruttando le indicazioni di un nuovo RFC che esprime la necessità  di firmare digitalmente le chiamate ad un metodo contenuto in un trait, lanciando eventualmente un’eccezione specifica in caso di violazioni.

Uso delle interface con firma digitale

Si fa un discorso simile a quello visto per i trait, solo che qui varrà  per le interfacce (interface) delle classi.

Indici negativi consecutivi

Viene inserito by default il fatto che se inizializzo un array con indice negativi, i successivi indici utilizzati – ad esempio in caso di uso della funzione push() – possano essere sfruttati non più a partire da 0, bensì dai numeri successivi. AD esempio se inserisco un elemento in posizione -7, gli altri inserimenti saranno in corrispondenza di -6, -5 e -4.

array(4) {
	[-7]=>
	'PHP'
	[-6]=>
	'versio 8'
	[-5]=>
	'cambierà '
	[-4]=>
	'molte cose'
}

Union Types

PHP 8 supporterà  gli Union Types, ovvero le variabili o i record che possono assumere uno o più tipi (ad esempio float o integer), consentendo così una maggiore flessibilità  in fase di programmazione.

Ulteriori novità 

Sono previsti infine un supporto migliorato per le weak maps, nuova sintassi ::class ammessa nel linguaggio, errori di tipo ottimizzati, possibilità  di concludere l’elenco di parametri di una funzione con una virgola. (fonte: wiki.php.net)

Oggiamo proviamo a progettare un videogioco semplice in Java: “Indovina il numero”. Funziona da terminale. Il computer sceglie un numero casuale, tu provi a indovinarlo.

Obiettivo del gioco

• Il computer genera un numero segreto tra 1 e 100
• Tu provi a indovinare
• Dopo ogni tentativo, il gioco ti dice se il numero è troppo alto, troppo basso, o giusto

Codice completo — IndovinaNumero.java

(Trovi una copia del codice anche qui su gdb compiler)

import java.util.Scanner;
import java.util.Random;

public class IndovinaNumero {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Random rand = new Random();

        int numeroSegreto = rand.nextInt(100) + 1; // numero da 1 a 100
        int tentativi = 0;
        boolean indovinato = false;

        System.out.println("Benvenuto in 'Indovina il numero'!");
        System.out.println("Ho scelto un numero tra 1 e 100. Riuscirai a trovarlo?");
        System.out.println("Se vuoi arrenderti, scrivi 'mi arrendo'.");

        while (!indovinato) {
            System.out.print("Inserisci il tuo numero o 'mi arrendo': ");
            String inputUtente = input.nextLine().trim();

            if (inputUtente.equalsIgnoreCase("mi arrendo")) {
                System.out.println("Hai scelto di arrenderti. Il numero segreto era: " + numeroSegreto);
                break;
            }

            try {
                int tentativo = Integer.parseInt(inputUtente);
                tentativi++;

                if (tentativo < numeroSegreto) { System.out.println("Troppo basso!"); } else if (tentativo > numeroSegreto) {
                    System.out.println("Troppo alto!");
                } else {
                    System.out.println("✅ Complimenti! Hai indovinato in " + tentativi + " tentativi.");
                    indovinato = true;
                }
            } catch (NumberFormatException e) {
                System.out.println("Input non valido! Inserisci un numero oppure 'mi arrendo'.");
            }
        }

        input.close();
    }
}

Il programma genera un numero segreto casuale da 1 a 100 e chiede all’utente di indovinare inserendo un numero o scrivendo “mi arrendo” per rinunciare.

Ad ogni input, letto come stringa, verifica se l’utente si arrende e in tal caso mostra il numero segreto e termina, altrimenti prova a convertire l’input in un numero intero, incrementa il contatore dei tentativi e confronta il tentativo con il numero segreto, dando indicazioni se è troppo basso o troppo alto, o congratulandosi se è esatto.

Se l’input non è né un numero valido né il comando di resa, il programma segnala un errore e richiede un nuovo tentativo, continuando il ciclo fino a indovinare o arrendersi.

▶️ Come eseguirlo

1. Salva il file come IndovinaNumero.java
2. Compila:

javac IndovinaNumero.java

3. Avvia:

java IndovinaNumero

Cosa puoi aggiungere dopo (opzionale)

• Difficoltà (facile = 1–50, difficile = 1–500)
• Limite di tentativi
• Giocare di nuovo alla fine
• Cronometro (con System.currentTimeMillis())

Problema e soluzione generale del pattern matching

Dato un testo generico T composto da n caratteri ed un pattern P di m caratteri (una lettera, una parola o una stringa di lunghezza variabile), con m minore o uguale a n, vogliamo determinare tutti i match del pattern all’interno di T. Se ad esempio il testo T è dato da:

“the cat is on the table”

e il pattern P= “the”, il match dovrà restituire il punto del testo in cui è presente la corrispondenza, ovvero:

{1, 15} -> “the cat is on the table”

La strategia più immediata per fare pattern matching è naturalmente quella di posizionare P all’inizio del testo, e per ogni singolo carattere da 1 a n spostare di uno la stringa, fino ad arrivare alla posizione limite n-m+1 (ipotizziamo di lavorare con stringhe in base 1 per non complicare la notazione), e tenendo traccia in una lista inizialmente delle corrispondenze trovate.

Questo pseudocodice rappresenta un approccio “ingenuo” o basico al problema del pattern matching, che esamina tutte le possibili posizioni nel testo T confrontando il pattern P.

In pseudo codice:

Funzione patternMatching(testo T, pattern P)
n = lunghezza di T
m = lunghezza di P
corrispondenze = lista vuota

per ogni i da 1 a n - m + 1
trovatoMatch = vero

per ogni j da 1 a m
se T[i + j - 1] non corrisponde a P[j]
trovatoMatch = falso
interrompi il ciclo

se trovatoMatch è vero
aggiungi (i, i + m - 1) a corrispondenze

restituisci corrispondenze
Fine Funzione

Approcci più efficenti al pattern matching

Tuttavia, esistono approcci più efficienti come l’algoritmo di Knuth-Morris-Pratt (KMP) o l’algoritmo di Rabin-Karp che sono in grado di gestire questa ricerca in modo più ottimizzato, specialmente con testi di grandi dimensioni. L’algoritmo di Rabin-Karp e l’algoritmo di Knuth-Morris-Pratt (KMP) sono entrambi utilizzati per la ricerca di pattern, ma si differenziano principalmente nel loro approccio e nella logica di esecuzione. Entrambi hanno complessità O(n+m).

algoritmo di Knuth-Morris-Pratt

Funzione calcolaLPS(pattern P, lunghezza m, lista lps)
lunghezzaPrefisso = 0
lps[1] = 0
i = 2

while i <= m
if P[i] è uguale a P[lunghezzaPrefisso + 1]
lunghezzaPrefisso = lunghezzaPrefisso + 1
lps[i] = lunghezzaPrefisso
i = i + 1
else
if lunghezzaPrefisso non è uguale a 0
lunghezzaPrefisso = lps[lunghezzaPrefisso]
else
lps[i] = 0
i = i + 1

Funzione KMP(testo T, pattern P)
n = lunghezza di T
m = lunghezza di P
lps = lista di lunghezza m+1
corrispondenze = lista vuota

calcolaLPS(P, m, lps)

i = 1
j = 1

while i <= n
if T[i] è uguale a P[j]
i = i + 1
j = j + 1

if j è uguale a m
aggiungi (i - j, i - 1) a corrispondenze
j = lps[j]
else
if j non è uguale a 1
j = lps[j]
else
i = i + 1

restituisci corrispondenze
Fine Funzione

algoritmo di Rabin-Karp

String testo = "Il gatto è sulla sedia";
String pattern = "gatto";
boolean match = testo.contains(pattern);
if (match) {
System.out.println("Pattern trovato!");
} else {
System.out.println("Pattern non trovato.");
}

#include <iostream>
#include <string>
using namespace std;

int main() {
string testo = "Il gatto è sulla sedia";
string pattern = "gatto";
if (testo.find(pattern) != string::npos) {
cout << "Pattern trovato!" << endl;
} else {
cout << "Pattern non trovato." << endl;
}
return 0;
}

$testo = "Il gatto è sulla sedia";
$pattern = "gatto";
if (strpos($testo, $pattern) !== false) {
echo "Pattern trovato!";
} else {
echo "Pattern non trovato.";
}

$testo = "Il gatto è sulla sedia";
$pattern = "/gatto/";
if (preg_match($pattern, $testo)) {
echo "Pattern trovato!";
} else {
echo "Pattern non trovato.";
}

testo = "Il gatto è sulla sedia"
pattern = "gatto"
if pattern in testo:
print("Pattern trovato!")
else:
print("Pattern non trovato.")

FizzBuzz è un popolare gioco matematico spesso usato come esercizio per insegnare ai bambini i concetti di divisione e multipli. Questo gioco può essere utilizzato sia come strumento didattico per insegnare i concetti di divisione ai bambini, sia come esercizio di programmazione per valutare le abilità di programmazione di base.

L’obiettivo è generare una sequenza di numeri da 1 a N, sostituendo determinati numeri con parole specifiche in base a determinate regole. Per ogni numero nella sequenza, si applicano le seguenti regole:

• Se il numero è divisibile sia per 3 che per 5, anziché stampare il numero, si stampa “FizzBuzz“.
• Se il numero è solo divisibile per 3, si stampa “Fizz”.
• Se il numero è solo divisibile per 5, si stampa “Buzz”.
• Se il numero non è divisibile né per 3 né per 5, si stampa semplicemente il numero stesso.

L’obiettivo è creare una sequenza di numeri in cui i multipli di 3 vengono sostituiti da “Fizz”, i multipli di 5 vengono sostituiti da “Buzz”, e i multipli di entrambi 3 e 5 vengono sostituiti da “FizzBuzz”. Il problema FizzBuzz è un esercizio di programmazione molto popolare, spesso utilizzato nei colloqui di lavoro per valutare la comprensione delle strutture di controllo e della logica condizionale.

Nonostante la sua apparente semplicità, ci sono diversi errori comuni che i programmatori possono commettere nella sua implementazione:​

1. 
   

   Ordine errato delle condizioni: Verificare prima la divisibilità per 3 o per 5 anziché per entrambi. Questo può portare a non stampare mai “FizzBuzz” per i numeri divisibili sia per 3 che per 5, poiché le condizioni precedenti catturano già questi numeri. È importante controllare prima la condizione più specifica (divisibilità per 3 e 5) e poi quelle più generali. ​mautoblog.com

   
   
2. 
   

   Mancata gestione dei numeri non divisibili: Dimenticare di stampare il numero stesso quando non è divisibile né per 3 né per 5. Ogni numero che non soddisfa le condizioni per “Fizz”, “Buzz” o “FizzBuzz” dovrebbe essere stampato come numero stesso. ​Medium+13mautoblog.com+13codenewbie.org+13

   
   
3. 
   

   Uso improprio dell’operatore confronto/assegnamento: Non utilizzare correttamente l’operatore modulo (%) per determinare la divisibilità. Ad esempio, usare i % 3 = 0 invece di i % 3 == 0 può causare errori di sintassi o logici nel codice.​

   
   
4. 
   

   Inizializzazione o range errato del ciclo: Iniziare il ciclo da 0 invece che da 1, o terminare prima di raggiungere il numero desiderato. Ad esempio, un ciclo che va da 0 a 99 invece che da 1 a 100 non rispetta le specifiche del problema. ​

   
   
5. 
   

   Errori di stampa o formattazione: Stampare “Fizzbuzz” invece di “FizzBuzz” o includere spazi o caratteri non necessari può portare a risultati non conformi alle aspettative. ​blog.regehr.org

   
   
6. 
   

   Mancata comprensione delle specifiche: Interpretare erroneamente le regole del problema, come scambiare l’associazione tra “Fizz” e “Buzz” con i numeri 3 e 5, rispettivamente. ​Reddit

   
   

Evitando questi errori comuni, è possibile implementare una soluzione FizzBuzz corretta ed efficiente.

Dispensa in PDF: Re-Code

Come imparare velocemente a programmare in C++, con una semplice guida progressiva passo-passo.

fizzBuzz-1.pdf (free download)

Fizz Buzz in C++

#include <iostream>
using namespace std;

void fizzbuzz(int n) {
for (int i = 1; i <= n; ++i) {
if (i % 3 == 0 && i % 5 == 0) {
cout << "FizzBuzz" << endl;
} else if (i % 3 == 0) {
cout << "Fizz" << endl;
} else if (i % 5 == 0) {
cout << "Buzz" << endl;
} else {
cout << i << endl;
}
}
}

int main() {
int n = 20; // Puoi cambiare questo numero per visualizzare la sequenza fino a un limite diverso
fizzbuzz(n);
return 0;
}

Una delle migliori codifiche del problema prevede che vengano utilizzate solo tre righe di codice, sfruttando le condizioni implicite innestate, che in C++ diventano come segue.

# include < iostream >
using namespace std ;

 int main () {
 for ( int i = 1; i <= 100; i ++)
 cout << ( i % 3 == 0 ? " Fizz " : " " ) << ( i % 5
== 0 ? " Buzz " : " " ) << ( i % 3 && i % 5 ?
to_string ( i ) : " " ) << endl ;
 return 0;
 }

Fizz Buzz in JS

Altre versioni corrette, più standard, sono queste (fonte).

// JavaScript program for Fizz Buzz Problem
// by checking every integer individually

function fizzBuzz(n) {
let res = [];

for (let i = 1; i <= n; ++i) {

// Check if i is divisible by both 3 and 5
if (i % 3 === 0 && i % 5 === 0) {

// Add "FizzBuzz" to the result array
res.push("FizzBuzz");
}

// Check if i is divisible by 3
else if (i % 3 === 0) {

// Add "Fizz" to the result array
res.push("Fizz");
}

// Check if i is divisible by 5
else if (i % 5 === 0) {

// Add "Buzz" to the result array
res.push("Buzz");
}
else {

// Add the current number as a string to the
// result array
res.push(i.toString());
}
}
return res;
}

// Driver code
let n = 20;
let res = fizzBuzz(n);
console.log(res.join(' '));

Fizz Buzz in Python

Procedendo per gradi, un programmatore principiante potrebbe essere tentato dallo scrivere qualcosa del genere, considerando che i casi in gioco sono soltanto tre per cui servono tre condizioni per tutti i numeri che vanno da 1 ad N:

def fizzbuzz(n):
    # Iniziamo un ciclo che va da 1 fino a n (incluso)
    for i in range(1, n+1):
        # Se i è divisibile per 3, stampiamo "Fizz"
        if i % 3 == 0:
            print("Fizz")
        # Altrimenti, se i è divisibile per 5, stampiamo "Buzz"
        elif i % 5 == 0:
            print("Buzz")
        # Altrimenti, se non è divisibile né per 3 né per 5, stampiamo "FizzBuzz"
        else:
            print("FizzBuzz")

# Assegniamo un valore di esempio a n e chiamiamo la funzione fizzbuzz con questo valore
n = 10
fizzbuzz(n)

A leggerla così potrebbe sembrare corretto, ma basta lanciare il programma per rendersi conto che non tira fuori quello che servirebbe. La sequenza risultante infatti è solo parzialmente corretta:

FizzBuzz
FizzBuzz
Fizz
FizzBuzz
Buzz
Fizz
FizzBuzz
FizzBuzz
Fizz
Buzz

Non abbiamo considerato un caso importante, in questo caso, che consiste in quello in cui viene stampato il numero direttamente.

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

Per fare questo, ci rendiamo conto che i casi da considerare sono in realtà 4:

• Se un numero è divisibile solo per 3, viene sostituito con “Fizz”.
• Se un numero è divisibile solo per 5, viene sostituito con “Buzz”.
• Se un numero è divisibile sia per 3 che per 5, viene sostituito con “FizzBuzz”.
• Se un numero non è divisibile né per 3 né per 5, rimane invariato e viene semplicemente stampato.

Chiarito questo, scriviamo:

# Definiamo una funzione chiamata fizzbuzz che prende un parametro n
def fizzbuzz(n):
    # Iniziamo un ciclo che va da 1 fino a n (incluso)
    for i in range(1, n+1):
        # Se i è divisibile per 3, stampiamo "Fizz"
        if i % 3 == 0:
            print("Fizz")
        # Altrimenti, se i è divisibile per 5, stampiamo "Buzz"
        elif i % 5 == 0:
            print("Buzz")
        # Altrimenti, se non è divisibile né per 3 né per 5, stampiamo "FizzBuzz"
        else:
            print("FizzBuzz")

# Assegniamo un valore di esempio a n e chiamiamo la funzione fizzbuzz con questo valore
n = 10
fizzbuzz(n)

Chiariamo: non posso fare previsioni certe sul futuro. Nessuno può farne. Si rischia di diventare ridicoli, di essere sbertucciati in futuro dal vituperatissimo “popolo del web”. Tuttavia, possiamo fare alcune riflessioni sul rapporto tra programmatori e intelligenza artificiale (IA), provando a non esacerbarlo e a non immaginare per inerzia scenari modello Terminator anche per il rapporto tra aziende e programmatori informatici.

È probabile che l’IA continuerà a evolversi e a influenzare il lavoro dei programmatori nel tempo, ma ciò non significa che i programmatori diventeranno obsoleti. Piuttosto, potrebbero essere richieste nuove competenze e adattamenti nel campo della programmazione per sfruttare appieno il potenziale dell’IA.

Perchè le IA (non) sostituiranno i programmatori

È vero che l’IA sta avanzando rapidamente in molti campi, inclusa la programmazione stessa. Esistono già strumenti che automatizzano alcune attività di programmazione, come la generazione automatica di codice o la correzione di errori comuni. Questi strumenti possono migliorare l’efficienza e la produttività dei programmatori, e in larga parte già lo fanno. I programmatori hanno un compito complesso, di per sè: progettare soluzioni, farle funzionare, mantenerle nel tempo, renderle comprensibili ai futuri colleghi (si spera).

È chiaro che i programmatori rimangono essenziali per lo sviluppo e il mantenimento dei sistemi basati sull’IA, quindi in parte la risposta è già insita nella domanda, e pensare il contrario è come pensare che i meccanici siano sostituiti dalle automobili che riparano. L’IA richiede un’intensa attività di programmazione per essere ideata, progettata, addestrata e integrata in diverse applicazioni: i programmatori sono tra i principali responsabili della scelta degli algoritmi, della raccolta e preparazione dei dati, nonché della validazione e del miglioramento continuo dei modelli di intelligenza artificiale.

Il processo è comunque supervisionato da uno o più umani, e la maggioranza delle IA sono e rimangono supervisionate. Inoltre, i programmatori svolgono un ruolo fondamentale nell’interpretazione e nell’applicazione dei risultati prodotti dall’IA. Nonostante l’avanzamento dell’IA, è necessaria la competenza umana per comprendere il contesto, valutare l’affidabilità dei risultati e prendere decisioni informate basate sui dati. Mentre l’IA può automatizzare alcune attività di programmazione, i programmatori avranno ancora un ruolo cruciale nello sviluppo, nell’implementazione e nell’applicazione dell’IA. La collaborazione tra l’intelligenza artificiale e i programmatori umani potrebbe portare a risultati più potenti ed efficaci di quanto sia possibile con uno o l’altro da solo.

Le IA possono programmare (entro certi limiti)

È vero che con lo sviluppo accelerato delle intelligenze artificiali, potrebbe verificarsi un impatto significativo sul lavoro dei programmatori. Alcune attività di programmazione più semplici e ripetitive potrebbero essere automatizzate in modo più efficace dalle IA, questo sembra fuori discussione. Il codice pero’ va organizzato, mantenuto, gestito nel tempo, eventualmente riutilizzato.

Tuttavia, ci sono ulteriori ragioni per cui i programmatori continueranno a svolgere un ruolo importante nonostante l’avanzamento delle IA:

1. Non tutte le attività di programmazione sono facili da automatizzare. La programmazione richiede una comprensione approfondita dei requisiti del software, dell’architettura del sistema e delle logiche complesse.
2. La risoluzione dei problemi e il pensiero creativo sono spesso necessari per affrontare sfide complesse che vanno oltre la semplice automazione.
3. La programmazione non si limita solo a scrivere codice. I programmatori sono responsabili della progettazione dei sistemi, dell’architettura dei software e dell’implementazione di soluzioni innovative, oltre alla capacità di gestire e correggere i bug. Questi aspetti richiedono creatività, conoscenza dei domini specifici e competenze tecniche avanzate che vanno oltre la semplice scrittura di codice.
4. Anche se una parte dell’attività di sviluppo potrebbe essere automatizzata, il mantenimento e il debugging dei sistemi richiedono ancora una competenza umana. Gli errori possono verificarsi in situazioni impreviste e richiedono analisi, correzione e testing da parte dei programmatori per garantire il corretto funzionamento del software.
5. Le IA possono fornire risultati e suggerimenti, ma la comprensione e l’interpretazione di tali risultati richiedono ancora la competenza umana. I programmatori devono essere in grado di valutare la validità degli output dell’IA, considerare il contesto e prendere decisioni informate basate sui dati.

In definitiva, mentre le IA possono automatizzare alcune attività di programmazione, i programmatori continueranno a svolgere un ruolo cruciale nell’affrontare sfide complesse, nella progettazione di sistemi innovativi e nella gestione dei processi di sviluppo e manutenzione del software. La collaborazione tra programmatori e IA può portare a risultati migliori e più efficienti, piuttosto che sostituire completamente i programmatori stessi.

Per usare una IA per programmare devi saper formulare la domanda

C’è anche in ballo la difficoltà forse più sottovalutata di tutte: per usare una IA per programmare devi saper formulare la domanda. molti programmatori non è detto che sappiano farlo (senza offesa, s’intende).

Punto essenziale, a mio avviso: l’interazione con un sistema basato sull’IA richiede la capacità di formulare domande e specificare correttamente i requisiti. Anche se l’IA può fornire suggerimenti e assistenza nella scrittura del codice, è necessario comunicare in modo chiaro ciò che si desidera ottenere affinché l’IA possa rispondere in modo appropriato.

La capacità di formulare domande efficaci è una competenza chiave per i programmatori che lavorano con l’IA. Richiede una buona comprensione dei concetti di programmazione, della logica e degli algoritmi, nonché una conoscenza del dominio specifico in cui si sta lavorando. E non tutti sono attrezzati in tal senso.

Inoltre è importante sottolineare che la capacità di formulare domande efficaci può essere sviluppata e migliorata nel tempo. I programmatori possono apprendere nuove tecniche di interrogazione e migliorare le proprie competenze comunicative per interagire in modo più efficace con i sistemi basati sull’IA. Tutti (?) i futuri progressi nella progettazione delle interfacce utente potranno semplificare l’interazione con le IA, consentendo ai programmatori di utilizzare strumenti e linguaggi più intuitivi per comunicare con i sistemi di intelligenza artificiale. Ma la capacità di formulare domande in modo efficace è un aspetto importante per utilizzare le IA per programmare, e sarà questo a “fare muro” indirettamente perchè le IA non sostituiranno i programmatori.

La questione della privacy

L’uso di IA proprietarie e chiuse come ChatGPT pone il problema dei dati che i programmatori farebbero trapelare. le aziende potrebbero non essere d’accordo e bloccare le IA preventivamente, o vietarle per policy.

Hai sollevato un’altra questione significativa riguardante l’uso di IA proprietarie e il problema potenziale della gestione dei dati da parte delle aziende. È vero che molte aziende possono essere caute nell’adottare IA proprietarie o chiuse a causa delle preoccupazioni sulla sicurezza dei dati sensibili o sulla violazione della privacy. Le aziende spesso definiscono politiche e linee guida riguardo all’uso dei dati e potrebbero limitare l’accesso alle IA o imporre restrizioni sull’utilizzo di determinate tecnologie. Questo potrebbe comportare la necessità di passare attraverso processi di approvazione o di ottenere il consenso dell’azienda per l’uso di IA.

Mentre strumenti come GitHub favoriscono la collaborazione e la condivisione del codice, ci possono essere casi in cui le aziende desiderano mantenere segrete le proprie soluzioni o proteggere la loro proprietà intellettuale. Tuttavia è importante notare che esistono anche soluzioni basate su IA open source e comunitarie, che promuovono la condivisione dei dati e del codice sorgente. Queste soluzioni possono aiutare a superare le restrizioni imposte dalle IA proprietarie e consentire ai programmatori di lavorare in modo collaborativo e aperto, personalizzandole e tenendole al sicuro nei rispettivi server.

Le IA che programmano possono filtrare progetti informatici assurdi o malposti

Se un imprenditore vuole progettare l’ennesima startup e non ha le idee chiare, la IA può schermare richieste di programmazione con requisiti assurdi o disfunzionali

È possibile che, in alcuni casi, la IA possa schermare richieste di programmazione con requisiti insoliti o poco pratici se non vengono fornite istruzioni chiare e specifiche. L’IA può essere addestrata su dati esistenti e modelli predefiniti, ma se le richieste del cliente restano ambigue, assurdamente ambiziose o poco chiare, l’IA potrebbe comunque produrre risultati incoerenti o non adeguati. Con il vantaggio di averlo fatto senza far sbattere la testa al povero ennesimo programmatore sottopagato.

E vi lamentate? 🙂

Ecco perchè – ulteriore perchè – i programmatori continueranno a servire a lungo, peraltro. Quando un cliente ha idee vaghe o poco chiare per una startup, può essere utile coinvolgere esperti di dominio o consulenti tecnici per affinare e tradurre tali idee in requisiti di programmazione più concreti. Questo aiuterà a fornire indicazioni chiare all’IA o ai programmatori umani sulle aspettative e sugli obiettivi del progetto. Inoltre, i programmatori umani possono svolgere un ruolo importante nel comprendere le richieste del cliente, fare domande di approfondimento e fornire una consulenza tecnica sulla fattibilità e sulle migliori pratiche. La collaborazione tra programmatori e clienti è essenziale per tradurre le idee in requisiti realistici e realizzabili.

L’utilizzo di tecniche di progettazione partecipativa, come workshop o sessioni di brainstorming, può aiutare a stabilire un dialogo aperto e iterativo con il cliente per affinare le idee e sviluppare requisiti di programmazione più solidi. In questo modo, si può evitare che la IA produca risultati basati su requisiti ambigui o poco pratici. (immagine di copertina: DALL-E)