Errori cross-piattaforma

In parole semplici

Linguaggi diversi danno nomi diversi allo stesso problema. Il classico “ho usato qualcosa che non esisteva” si chiama TypeError in JavaScript, NullPointerException in Java, nil in Swift, KeyError o TypeError in Python, Segmentation fault in C, panic in Go o Rust. Riconoscere lo schema sotto la facciata ti permette di portare l’esperienza di un linguaggio all’altro.

Parole nuove

• null/nil/None: rappresentazione di “valore assente” in vari linguaggi.
• null pointer: puntatore non inizializzato o impostato a “nessun indirizzo”.
• panic: errore non recuperabile in Go o Rust.
• segmentation fault (segfault): accesso a memoria non valida in C/C++.

Cosa impari

• Mappare lo stesso bug logico nei messaggi di cinque linguaggi.
• Sapere che dietro a nomi diversi spesso vive lo stesso schema.
• Trasferire intuizioni di debug da un linguaggio noto a uno nuovo.

Lo stesso bug in cinque linguaggi

Bug: chiamare un metodo su un valore “vuoto”.

JavaScript

const u = undefined;
u.nome;
// TypeError: Cannot read properties of undefined (reading 'nome')

Python

u = None
u.nome
# AttributeError: 'NoneType' object has no attribute 'nome'

d = {"a": 1}
d["b"]
# KeyError: 'b'

Java / Kotlin

String s = null;
s.length();
// java.lang.NullPointerException

Swift

let u: User? = nil
u!.nome
// Fatal error: Unexpectedly found nil while unwrapping an Optional value

C / C++

int *p = NULL;
*p = 5;
// Segmentation fault (core dumped)

Go

var u *User
fmt.Println(u.Nome)
// runtime error: invalid memory address or nil pointer dereference

Rust

let v: Option<&str> = None;
v.unwrap();
// thread 'main' panicked at 'called `Option::unwrap()` on a `None` value'

Tutti, in lingue diverse, dicono la stessa cosa: “ho usato qualcosa che non c’era”.

Schemi ricorrenti

* Java distingue tra null e “chiave non presente” se usi Map.get che ritorna null.

Perché conta

Se hai imparato a debuggare un TypeError in JavaScript, sai già:

• guardare lo stack;
• chiedere “da dove arriva questo valore?”;
• risalire la catena.

Quando incontri un NullPointerException o un panic Go la prima volta, non ricominci da zero: applichi lo stesso schema.

Esempio: lo stesso bug logico portato altrove

Lo stesso codice JS:

function media(numeri) {
  return numeri.reduce((a, n) => a + n, 0) / numeri.length;
}
media();

Errore JavaScript:

TypeError: Cannot read properties of undefined (reading 'reduce')

In Python equivalente:

def media(numeri):
    return sum(numeri) / len(numeri)

media()

Errore Python:

TypeError: media() missing 1 required positional argument: 'numeri'

In Java equivalente:

static double media(int[] numeri) {
    int somma = 0;
    for (int n : numeri) somma += n;
    return (double) somma / numeri.length;
}
// invocata con null:
media(null);
// java.lang.NullPointerException

Tre messaggi diversi. Stesso schema: “il parametro che richiede esistere non c’era”.

Lab cross-piattaforma

Scegli un piccolo bug logico (es. divisione per zero, accesso a indice inesistente, valore opzionale non gestito).

1. Riproducilo in tre linguaggi che conosci anche solo di vista (JS, Python, e uno a scelta).
2. Cattura il messaggio di errore esatto.
3. Compila una riga della tua tabella personale schema → linguaggio → messaggio.

Quando l’analogia non regge

Alcuni schemi non hanno corrispondente perfetto:

• C segfault spesso non dice nemmeno dove. Senza debugger (gdb, lldb) è cieco.
• Rust Option/Result sposta l’errore a compile-time: il bug “uso un valore assente” diventa impossibile se non lo gestisci esplicitamente.
• JavaScript silenzioso: arr[100] su un array da 3 elementi ritorna undefined senza errore. Lo scopri solo dopo.

Quando l’analogia non regge, è ancora più importante leggere il runtime model del linguaggio nuovo.

Esercizi

Base · facile

Questi tre messaggi vengono da linguaggi diversi ma descrivono lo stesso schema. Quale?

1) TypeError: Cannot read properties of undefined (reading 'nome')   (JavaScript)
2) java.lang.NullPointerException                                    (Java)
3) Fatal error: Unexpectedly found nil while unwrapping an Optional  (Swift)

Intermedio · medio

Per ognuno di questi errori indica il linguaggio probabile e a quale schema appartiene (valore assente, valore fuori range/chiave mancante, memoria non valida).

1) KeyError: 'b'
2) Segmentation fault (core dumped)
3) panic: runtime error: index out of range [3] with length 3

Sfida · difficile

Prendi un bug logico che conosci in un linguaggio (es. accesso a un campo di un oggetto che potrebbe essere assente) e scrivi come si manifesterebbe in tre linguaggi diversi, con il messaggio tipico di ciascuno. Spiega perché riconoscere lo schema, e non il nome, rende trasferibile l’esperienza di debug.

// JavaScript
utente.nome;  // TypeError: Cannot read properties of undefined (reading 'nome')

# Python
utente.nome   # AttributeError: 'NoneType' object has no attribute 'nome'

// Swift
utente!.nome  // Fatal error: Unexpectedly found nil while unwrapping an Optional value

Errori frequenti del principiante

• Pensare che il linguaggio nuovo sia “strano”. Il messaggio cambia, il problema no.
• Aspettarsi un errore quando il linguaggio è silenzioso. JS non protesta su array out-of-bounds.
• Confidare nel debugger del linguaggio originale. gdb non aiuta su una JVM, jdb non aiuta su Python.
• Trattare ogni linguaggio come unico. Gli schemi sono pochi, le facce molte.