Il nostro Blog

7 trucchi di programmazione suggeriti dall’AI (ma l'arte del coding è un’altra cosa)

 

La programmazione è un’attività creativa complessa che a noi di ESSE I piace definire un’arte. E in ogni arte ci sono trucchi e tecniche che non tutti conoscono e utilizzano per rendere il proprio lavoro più efficiente, elegante, performante o semplicemente migliore.

Il coding non è da meno, e in questo contesto parliamo di metodi che, usati con scaltrezza, rivelano esperienza nella programmazione.

Certo, essere esperti programmatori non risiede solo nella conoscenza, ma anche nel costruire e mantenere un pensiero “trasversale” che porti a risolvere determinati problemi in modo nuovo e originale. Soprattutto nell’avere una visione generale di ciò che si sta facendo, del come lo si sta facendo e, in particolare, del perché lo si sta facendo.

Tuttavia crediamo che conoscere certi trucchi di coding possa favorire la maturazione e l’applicazione di tale esperienza. E, perché no, velocizzare il lavoro, senza per questo mancare in efficacia nella risoluzione dei singoli problemi.

È con questa premessa che nell’articolo di oggi, per la nostra rubrica mensile dedicata al coding “comprESSE I”, esploreremo sette trucchi di programmazione non sempre conosciuti che potrebbero fare la differenza nella scrittura del codice.

Per illustrarli considereremo alcuni dei linguaggi più popolari come JavaScript, Python e C; tieni però presente che molti di questi trucchi potrebbero essere tradotti anche in altri linguaggi. Ma di questo parleremo nell’ultimo punto.

 

 

1) Usa la destructuring

La destructuring è una caratteristica di alcuni linguaggi di programmazione che consente di scomporre o destrutturare in parti più piccole strutture di dati complessi come oggetti o array. È comune soprattutto in linguaggi come JavaScript e Python.

Qui un esempio di descructuring di una variabile in JavaScript. L’oggetto in questione è “persona”, così facendo ne estraiamo le proprietà nome, cognome ed età in variabili separate:

const persona = { nome: 'Mario', cognome: 'Rossi', età: 30 };
const { nome, cognome, età } = persona;

console.log(nome); // Output: Mario
console.log(cognome); // Output: Rossi
console.log(età); // Output: 30

In questo altro esempio, invece, destrutturiamo l’array “numeri” per estrarre i primi due elementi in variabili separate (primo e secondo). Gli elementi che rimangono vengono così raccolti nell’array “restanti”.

const numeri = [1, 2, 3, 4, 5];

const [primo, secondo, ...restanti] = numeri;

console.log(primo); // Output: 1
console.log(secondo); // Output: 2
console.log(restanti); // Output: [3, 4, 5]

Perché usare la destructuring? Perché rende più semplice l’accesso e l’assegnazione di valori all’interno dei dati complessi.

 

 

2) Sfrutta il lazy loading delle immagini

Non tutti i programmatori di pagine web sono sempre coscienti dell’importanza di rendere il caricamento delle pagine il più veloce possibile per migliorare l’esperienza utente e, di conseguenza, mandare un “flag positivo” a Google, che ne terrà conto nelle sue SERP.

Il lazy loading delle immagini è una tecnica molto utile a questo scopo, è infatti utilizzata per ritardare il caricamento di immagini non essenziali nella pagina web fino a quando l’utente si avvicina alla loro visualizzazione. Ciò può migliorare in modo significativo le prestazioni della pagina, riducendo il carico iniziale e accelerando il tempo di caricamento.

Non tutti sanno che HTML5 integra il lazy loading in modo molto nativo e semplice attraverso l’attributo “loading” del tag “<img>”. Qui è l’opzione “lazy” a indicare il lazy loading, ritardando così il caricamento delle immagini.

<img loading="lazy" src="image.jpg" alt="Lazy-loaded Image">

Per avere un maggior controllo è possibile utilizzare del codice JavaScript, le librerie Lazy Loading oppure l’altrettanto semplice e, analogamente a html, non sempre conosciuta versione css:

img {

loading: lazy;
}

 

 

3) Ottimizza le query SQL con JOIN

Non tutti sanno che unire due o più tabelle di un database usando SQL può migliorare le prestazioni delle query, fattore molto importante che è in grado, se reiterato e sollecitato da molte chiamate client-server, di ridurre considerevolmente il carico e di conseguenza le performance complessive di un progetto web.

Qui il codice di esempio in linguaggio SQL (da adattare alla propria situazione):

SELECT users.name, orders.product

FROM users
JOIN orders ON users.id = orders.user_id;

L’utilizzo di JOIN (disponibile anche nelle varianti INNER JOIN, LEFT JOIN, RIGHT JOIN e FULL JOIN) è fondamentale quando si lavora con database relazionali che contengono dati distribuiti tra più tabelle, perché permette di costruire relazioni e di recuperare informazioni correlate in modo efficiente. 

 

 

4) Utilizza lo XOR per lo swapping di variabili

Molti programmatori per fare lo swap, ovvero per invertire il valore di due variabili tra loro, tendono a usare una variabile temporanea. Un metodo semplice ma non proprio efficiente. Per fare lo swap esiste però “XOR bitwise” che qui spieghiamo con l’ausilio di un semplice codice in linguaggio C:

a = a ^ b;
b = a ^ b;
a = a ^ b;

Ma come funziona esattamente?

Lo XOR è un’operazione logica “bit a bit” che esegue un confronto esclusivo tra i bit corrispondenti di due operandi, restituendo il valore 1 per ogni coppia di bit diversi e il valore 0 per ogni coppia di bit uguali. 

• a = a ^ b; esegue lo XOR tra i valori di “a” e “b” assegnando il risultato alla variabile “a”. Dopo questa riga “a” contiene il risultato dello XOR tra il valore originale di “a” e il valore originale di “b”.
• b = a ^ b; esegue lo XOR tra il nuovo valore di “a” (ottenuto dalla riga precedente) e il valore originale di “b” assegnandone il risultato a “b”. Dopo questa riga, “b” contiene il risultato dello XOR tra il nuovo valore di “a” e il valore originale di “b”, che in pratica è il valore originale di “a”.
• a = a ^ b; infine esegue lo XOR tra il nuovo valore di “a” (ottenuto dalla prima riga) e il nuovo valore di “b” (ottenuto dalla seconda riga) assegnandone il risultato ad “a”. Dopo questa riga, “a” contiene il risultato dello XOR tra il nuovo valore di “a” e il nuovo valore di “b”, che in pratica è il valore originale di “b”.

 

 

5) Ottimizza il matching con le espressioni regolari

Programmando è spesso necessario effettuare il “matching”, una tecnica che consiste nell’individuare una porzione di testo in un’altra porzione di testo solitamente più lunga (la “stringa”) in modo che soddisfi il “pattern” (la regola specificata nell’espressione regolare).

Un trucchetto non conosciuto da tutti, e qui esposto in JavaScript, è utilizzare il “non-catturante” (ovvero “?:” seguito dal pattern) quando si hanno gruppi nelle espressioni regolari e non è necessario catturare il matching. Ecco un esempio con i due diversi approcci.

// Senza non-catturante
/(\d+)-(\d+)/

// Con non-catturante
/(?:\d+)-(\d+)/

Nel primo approccio, l’uso dei gruppi di cattura significa che il risultato del matching includerà sia la parte di cifre prima del trattino che quella dopo il trattino. Ad esempio, applicando questa espressione regolare alla stringa “123-456” otterrai due gruppi di cattura: “123” (gruppo 1) e “456” (gruppo 2).

Nel secondo approccio, invece, la parte di cifre prima del trattino non viene inclusa nei gruppi di cattura. L’uso di “?:” rende il gruppo non-catturante, il che significa che NON sarà incluso nel risultato del matching. Quindi, se per esempio applichi questa espressione regolare alla stringa “123-456”, otterrai solo un gruppo di cattura e cioè “456” (gruppo 1).

L’uso di un gruppo non-catturante consente di specificare un blocco di pattern senza includerlo nei gruppi di cattura del risultato del matching, rendendo più flessibile e chiaro il processo di estrazione delle informazioni dalla stringa.

 

 

6) Utilizza il “Ternary Operator” in assegnazioni

Prendiamo ad esempio la seguente riga di codice Python:

result = "Even" if num % 2 == 0 else "Odd"

Abbiamo voluto aggiungere questa espressione condizionale (o “ternary conditional expression”) alla nostra lista perché consente di scrivere in modo conciso e diretto (grazie all’integrazione dell’assegnazione) un’istruzione condizionale in una singola riga. Una tecnica che riteniamo utile quando si desidera mantenere il codice conciso e leggibile.

Tuttavia attenzione: sarebbe meglio utilizzare questa forma in modo responsabile e solo quando il codice risulta più chiaro e comprensibile, specialmente quando la logica condizionale è semplice. In alcune situazioni, soprattutto quando la logica condizionale è complessa, l’uso di un’istruzione if-else disposta su più righe potrebbe essere preferibile per migliorare la leggibilità del codice. Di leggibilità del codice e della sua importanza – e di come potrebbe scontrarsi con l’applicazione di trucchetti come questo – ne abbiamo parlato in questo articolo meno recente.

 

 

7) Traduci il codice con l’AI generativa

Bisogna ammettere che l’AI generativa, con strumenti come OpenAI ChatGPT o l’ancora più specifico GitHub Copilot, rappresenta ormai un grande aiuto per i programmatori. Spesso è sufficiente indicare un semplice prompt per ottenere script già funzionanti, ben documentati e che eseguono in modo efficace il compito richiesto. Per la stesura di questo stesso articolo l’AI si è rivelata molto utile.

Tuttavia non si pensi che sia sufficiente: un software, a differenza di un singolo script, è qualcosa di estremamente complesso che richiede un controllo e una supervisione generale competente, e un’esperienza che una macchina non può avere. Però l’AI è utile laddove è necessario compiere singole operazioni meccaniche e specifiche oppure, ed è qui che vogliamo parlarne come un “trucco” a cui forse non avevi mai pensato, quando occorre effettuare attività di traduzione di codice da un linguaggio a un altro.

Per documentare questo trucco abbiamo fatto eseguire a ChatGPT la traduzione di uno script da VBScript a PHP. E il bello è che il codice iniziale non abbiamo dovuto neanche scriverlo noi visto che è stato generato anch’esso dall’AI.

Siamo partiti dal seguente prompt: “Scrivi un codice in VBScript/ASP che si connette a un database, che legge un dato specifico in base alla query string e lo visualizza”.

Questa è la risposta ottenuta:

<%@ Language=VBScript %>

<% Option Explicit %>
<% Response.Buffer = True %>

<%
' Connessione al database
Dim connStr
connStr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & Server.MapPath("YourDatabase.mdb")
Dim conn
Set conn = Server.CreateObject("ADODB.Connection")
conn.Open connStr

' Recupero il parametro dalla query string
Dim userID
userID = Request.QueryString("ID")

' Eseguo la query per ottenere il dato specifico
Dim sql
sql = "SELECT * FROM YourTable WHERE ID = " & userID
Dim rs
Set rs = Server.CreateObject("ADODB.Recordset")
rs.Open sql, conn

' Verifico se ci sono risultati
If Not rs.EOF Then
' Visualizzo i dati
Response.Write("<p>ID: " & rs("ID") & "</p>")
Response.Write("<p>Nome: " & rs("Nome") & "</p>")
Response.Write("<p>Cognome: " & rs("Cognome") & "</p>")
Else
' Messaggio se non ci sono risultati
Response.Write("<p>Nessun risultato trovato.</p>")
End If

' Chiudo la connessione e il recordset
rs.Close
Set rs = Nothing
conn.Close
Set conn = Nothing
%>

Poi abbiamo digitato: “Riscrivi questo codice in linguaggio PHP”. Qui il risultato:

<?php
// Connessione al database
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "YourDatabase";

$conn = new mysqli($servername, $username, $password, $dbname);

// Verifica la connessione al database
if ($conn->connect_error) {
die("Connessione al database fallita: " . $conn->connect_error);
}

// Recupero il parametro dalla query string
$userID = $_GET["ID"];

// Eseguo la query per ottenere il dato specifico
$sql = "SELECT * FROM YourTable WHERE ID = " . $userID;
$result = $conn->query($sql);

// Verifico se ci sono risultati
if ($result->num_rows > 0) {
// Visualizzo i dati
while ($row = $result->fetch_assoc()) {
echo "<p>ID: " . $row["ID"] . "</p>";
echo "<p>Nome: " . $row["Nome"] . "</p>";
echo "<p>Cognome: " . $row["Cognome"] . "</p>";
}
} else {
// Messaggio se non ci sono risultati
echo "<p>Nessun risultato trovato.</p>";
}

// Chiudo la connessione
$conn->close();
?>

Come vedi, sia il codice creato da zero che la sua traduzione sono script (ovviamente da riadattare alla propria “situazione”, ad esempio il database a cui ci si connette deve esistere ed essere configurato in modo adeguato) corretti e funzionanti, prova che l’AI può essere utile anche in questo campo.

E rivela anche che interrogandola opportunamente è possibile che gli altri trucchetti suggeriti (sebbene non sempre) possano essere tradotti in altri linguaggi.

Anche se abbiamo finito con la carrellata dei nostri sette trucchetti di coding, per favore non smettere di leggere questo articolo perché ciò che vogliamo sottolineare in chiusura è molto importante.

 

 

Concludendo

Molti lettori conosceranno già la “potenza” dell’AI generativa e la sua applicazione nel mondo del coding. È una rivoluzione in atto già da tempo che non si può ignorare, e infatti non lo facciamo. Anche perché non la temiamo, non abbiamo paura che l’AI ci rubi il lavoro, non crediamo in fesserie simili.

Come dicevamo all’inizio, l’arte del coding non risiede nei trucchi ma in una visione progettuale che solo l’uomo può soddisfare. Certamente crediamo che l’AI generativa sia una comodità che velocizza e facilita il lavoro e che conoscere certi trucchi di programmazione, inclusi quelli che riguardano l’uso – purché consapevole – dell’AI, possa favorire la maturazione del programmatore. Aiutarlo nell’apprendimento, anche.

Insomma, scrivere codice con l’AI o farlo tradurre è un trucchetto secondo noi utile proprio come, crediamo, conoscere e applicare tutti i nostri sette trucchi presentati in questo articolo.

Ma, e lo ripetiamo fino alla nausea, facciamolo sempre prestando la massima attenzione.

Perché realizzare un progetto software vero e proprio – applicando la creatività autentica che contraddistingue “l’arte della programmazione” – è un altro paio di maniche.