Perché l’IA può aiutare gli studenti a capire davvero Java e Python

La domanda che frequentemente viene posta dagli alunni, solitamente alla fine dell’anno scolastico, è: «… ma l’anno prossimo quale linguaggio di programmazione utilizzeremo?». Negli occhi dello studente che pone questa domanda, si coglie a volte il desiderio di sperimentare nuove soluzioni, oppure, in altri casi, la volontà di riscatto: dopo le difficoltà incontrate nella programmazione nel linguaggio X, l’attesa di una nuova opportunità con il passaggio al linguaggio Y.

Il nodo centrale da far comprendere agli studenti è che l’obiettivo non consiste nell’imparare continuamente nuovi linguaggi di programmazione, ma nel consolidare le capacità di analisi, astrazione e problem solving, sviluppando la consapevolezza del percorso che conduce dall’ideazione della soluzione alla produzione dell’artefatto digitale.

Il pensiero computazionale non coincide con la conoscenza di un linguaggio di programmazione: riguarda invece la capacità di analizzare problemi; scomporre in parti più semplici; individuare schemi ricorrenti; progettare algoritmi, e verificare soluzioni.

Per questo motivo, passare da un linguaggio come Java a Python non significa ricominciare da zero, ma trasferire competenze già costruite in un nuovo contesto sintattico e metodologico.

Il contesto

Il Dipartimento dell’IISS Augusto Righi di Taranto in quarta classe ha definito, tra l’altro, lo studio della programmazione a oggetti in Java.

Tuttavia, nella pratica didattica emerge spesso un ostacolo ricorrente: gli studenti mostrano diffuse difficoltà nel compiere il salto concettuale dalla programmazione procedurale a quella orientata a classi e oggetti. Questo scoglio cognitivo è dovuto alla necessità di gestire contemporaneamente sia l’astrazione logica del problema sia la complessa “burocrazia” sintattica di Java, come i modificatori di accesso; la firma dei metodi e la gestione dei tipi, che rischia di oscurare il cuore del paradigma OOP (Object-Oriented Programming).

Per superare questa barriera e rendere visibile l’invisibile, si è adottato come ambiente di sviluppo BlueJ^[1] (Figura 1).

Questo IDE è specificamente progettato per l’insegnamento e si integra perfettamente con il percorso di modellazione che si vuole tracciare. BlueJ, infatti, elimina l’astrazione del codice puro mostrando graficamente le classi come scatole collegate da frecce di dipendenza, riproducendo di fatto una versione interattiva del diagramma UML^[2] sul computer dello studente.

Figura 1: BlueJ – IDE per lo sviluppo in Java.

Questo approccio visuale e pragmatico trasforma il rigore di Java da un limite sintattico a un’esperienza geometrica e tangibile, gettando le basi logiche necessarie affinché, in un secondo momento, il passaggio a linguaggi più fluidi come Python e a metodologie moderne come il vibe coding avvenga in modo naturale, forte di una consapevolezza architetturale già interiorizzata.

Sviluppo in Java con BlueJ

Un aspetto cruciale per il superamento delle difficoltà didattiche è che BlueJ^[3] non si limita a una visualizzazione statica del modello (Figura 2), ma introduce gli studenti a un’esperienza di programmazione fortemente interattiva e manipolativa.

Figura 2: Diagramma UML: dipendenza tra le classi.

L’ambiente permette infatti di istanziare gli oggetti manualmente (Figura 3) con un semplice click sulla classe desiderata. Una volta posizionati sul banco di lavoro virtuale (object workbench), questi oggetti diventano tangibili: gli studenti possono ispezionarli in tempo reale per osservare l’evoluzione dei loro attributi interni e, soprattutto, possono applicare su di essi i relativi metodi implementati, verificandone immediatamente l’effetto sullo stato del sistema.

Figura 3: Creazione ed ispezione di Oggetti.

Il rigore di Java

Java possiede caratteristiche che, dal punto di vista didattico, favoriscono l’educazione al rigore logico e alla formalizzazione dei problemi. Non è soltanto un linguaggio di programmazione: in molti contesti scolastici e universitari diventa uno strumento per insegnare metodo, organizzazione del pensiero e progettazione astratta.

Uno degli aspetti più significativi riguarda la necessità di definire esplicitamente la struttura del programma prima di poterlo eseguire. In Java, infatti, lo studente non può limitarsi a “scrivere istruzioni”: deve progettare classi, definire attributi, scegliere tipi di dati, stabilire responsabilità e relazioni tra oggetti. Questo processo costringe a riflettere sul problema in termini strutturati.

Ad esempio, in un semplice sistema di gestione delle Ordinazioni al Bar, occorre chiedersi:

• quali entità esistono;
• quali proprietà possiedono;
• quali comportamenti devono avere;
• come interagiscono tra loro.

Prima ancora di programmare, è necessario costruire un modello concettuale della realtà. Questa fase di modellazione rappresenta uno degli elementi più formativi del pensiero computazionale: non si lavora direttamente sulla soluzione tecnica, ma sulla rappresentazione astratta del problema.

Questa caratteristica obbliga a ragionare sulla natura delle informazioni:

• un valore è numerico o testuale?
• una variabile contiene un singolo elemento o una collezione?
• gli oggetti appartengono tutti alla stessa categoria?

La tipizzazione non è solo una regola sintattica: diventa un esercizio di classificazione logica.

Lo studente sviluppa progressivamente:

• capacità di categorizzazione;
• precisione semantica;
• attenzione alla coerenza dei dati.

Inoltre, il controllo statico dei tipi permette di intercettare errori già in fase di compilazione. Questo introduce una forma di disciplina mentale: prima di eseguire il programma, occorre verificarne la correttezza strutturale.

• La OOP modello mentale: il caso “Gestione ordini al bar”

Nel progetto “Gestione Ordini al Bar” (Figura 4), sviluppato in Java e rappresentato graficamente in BlueJ, la programmazione orientata agli oggetti non è soltanto una tecnica di sviluppo software, ma diventa un vero modello mentale per analizzare e rappresentare la realtà.

Figura 4: Il Progetto in esame: Gestione ordini al bar.

Lo studente non parte dal codice, ma dall’osservazione del problema reale:

• esistono tavoli;
• esiste un menu;
• ci sono prodotti;
• i clienti effettuano ordini;
• ogni ordine contiene più prodotti.

Questa analisi porta naturalmente alla costruzione di entità astratte.

Così nel sistema reale del bar:

• un caffè ha nome e prezzo;
• un tavolo contiene ordini;
• una riga ordine collega un prodotto ad una quantità.

Lo studente traduce questi concetti in classi: Prodotto, Tavolo, RigaOrdine, Menu. Questo passaggio è cognitivamente importante perché si impara a distinguere tra oggetti concreti e modelli astratti; così la classe Prodotto non rappresenta “quel singolo caffè”, ma il concetto generale di prodotto vendibile; la classe Tavolo rappresenta una struttura organizzativa del sistema; la classe RigaOrdine rappresenta una relazione tra un prodotto e una quantità.

Gli studenti iniziano quindi a ragionare in termini di modellazione della realtà.

Nel progetto emerge anche un altro principio fondamentale: ogni classe deve avere responsabilità precise. Ad esempio: un Menù gestisce l’elenco dei prodotti; un Tavolo gestisce gli ordini del tavolo; GestisciMenu carica o organizza il menu; GestisciTavoli coordina l’insieme dei tavoli. Questo aiuta gli studenti a comprendere il concetto di modularità: un problema complesso viene suddiviso in componenti autonome e collaborative. Didatticamente è molto potente perché mostra che un sistema software non è un blocco unico di codice, ma una rete organizzata di responsabilità.

Nel diagramma BlueJ gli studenti visualizzano anche le relazioni:

• un Menu contiene molti Prodotto;
• un Tavolo contiene molte RigaOrdine;
• una RigaOrdine utilizza un Prodotto.

La visualizzazione grafica rende concreta l’idea di composizione tra oggetti. Gli studenti iniziano a comprendere come gli oggetti collaborano tra loro: RigaOrdine non crea il prodotto, ma riceve un oggetto Prodotto e una quantità, e utilizza il tutto per calcolare il sub-totale; “tante” RigaOrdine costituiscono l’Ordine di un Tavolo.

BlueJ, nella comprensione mentale, ha un enorme valore educativo proprio perché rende visibile questa struttura.

Gli studenti vedono le classi; osservano le relazioni; creano oggetti interattivamente; chiamano metodi direttamente. Il diagramma UML non è più qualcosa di astratto: diventa una rappresentazione concreta del sistema, che aiuta moltissimo nella costruzione del modello mentale orientato agli oggetti.

Questo introduce concetti avanzati come: dipendenza, collaborazione e riuso degli oggetti.

Trasformazione del codice e Vibe Coding assistito dall’IA

Riprendendo la riflessione iniziale, nella quale emerge come gli studenti tendano spesso ad associare l’apprendimento informatico al semplice cambio di linguaggio di programmazione, il passaggio dal progetto “Gestione Ordini al Bar” in Java a Python rappresenta invece un’occasione concreta per mostrare la continuità del pensiero computazionale al di là della sintassi adottata.

Nella trasformazione del progetto “Gestione Ordini al Bar” da Java a Python, l’utilizzo dell’Intelligenza Artificiale (IA) assume un ruolo particolarmente interessante dal punto di vista didattico, perché permette agli studenti di concentrarsi sulle strutture concettuali del software piuttosto che sui dettagli sintattici. Oggi si fa spesso uso di pratiche associate al cosiddetto “Vibe Coding”^[4], con cui si intende che lo studente dialoga con l’IA in linguaggio naturale, descrivendo obiettivi, funzionalità e trasformazioni desiderate, e ricevendo in tempo reale suggerimenti, traduzioni di codice, refactoring e spiegazioni comparative tra linguaggi. In questo contesto, l’IA non sostituisce il ragionamento algoritmico, ma agisce come supporto cognitivo e strumento di mediazione: gli studenti possono osservare come una stessa architettura orientata agli oggetti, con classi, relazioni, responsabilità e collezioni, venga mantenuta passando ad esempio da Java a Python, pur cambiando sintassi, tipizzazione e livello di verbosità.

Dopo le fasi iniziali di analisi del problema; progettazione UML e successiva implementazione in Java, si è deciso di introdurre anche il supporto dell’IA come strumento di confronto e riflessione sul processo di sviluppo software. A partire dal diagramma delle classi realizzato dagli studenti in BlueJ, l’IA è stata utilizzata per generare autonomamente una propria versione del codice Java del progetto “Gestione Ordini al Bar”.

L’attività si è rivelata particolarmente significativa dal punto di vista didattico perché ha permesso di confrontare il codice progettato e scritto dagli studenti con il codice prodotto automaticamente dall’IA.

Il confronto ha evidenziato numerose analogie nella struttura generale. A solo titolo esplicativo, si evidenzia la presenza delle stesse classi principali; il mantenimento delle relazioni tra oggetti; l’utilizzo coerente dell’approccio orientato agli oggetti, e la suddivisione delle responsabilità tra classi.

Allo stesso tempo sono emerse differenze interessanti legate soprattutto alle scelte implementative e alle librerie utilizzate. In particolare, una delle osservazioni più rilevanti ha riguardato la gestione dei vettori dinamici: nella versione sviluppata dagli studenti veniva utilizzato Vector, mentre l’IA ha proposto l’utilizzo di ArrayList.

Questo confronto ha consentito di approfondire aspetti importanti della programmazione Java: evoluzione delle collezioni nel framework Java; differenze tra strutture legacy e strutture moderne; sincronizzazione e prestazioni; motivazioni storiche e progettuali delle librerie. Ad esempio, Vector appartiene alle prime versioni di Java ed è sincronizzato automaticamente; ArrayList rappresenta oggi la soluzione più utilizzata grazie a maggiore efficienza e flessibilità in contesti non concorrenti.

L’esperienza ha quindi trasformato l’IA in uno strumento di analisi critica e non in un semplice generatore automatico di codice. Gli studenti hanno potuto comprendere che uno stesso problema può essere risolto con scelte implementative differenti e il codice prodotto dall’IA deve essere letto, interpretato e valutato; la qualità del software dipende anche dalle decisioni architetturali e dall’evoluzione storica dei linguaggi e delle librerie.

In questo senso, il Vibe Coding^[5] assistito dall’IA non ha sostituito il processo di apprendimento, ma ha originato una riflessione più profonda sulle scelte progettuali e la natura stessa della programmazione come attività di modellazione, confronto e revisione continua.

Il Vibe Coding favorisce così una modalità di apprendimento più esplorativa e iterativa, nella quale il coding diventa una conversazione continua tra progettazione mentale, sperimentazione e revisione assistita, rafforzando la comprensione dei paradigmi computazionali indipendentemente dal linguaggio utilizzato.

Dal rigore di Java alla flessibilità di Python

Occorre dire che gli studenti non hanno mai affrontato formalmente Python^[6], se non in alcuni casi per semplice curiosità personale. Così la fase successiva del percorso, “dal rigore di Java alla flessibilità di Python”, ha rappresentato un momento particolarmente significativo nello sviluppo della consapevolezza computazionale.

Partendo dal medesimo caso di studio “Gestione Ordini al Bar”, già progettato in UML e implementato in Java, si è utilizzato nuovamente il supporto dell’Intelligenza Artificiale per ottenere una versione equivalente del software in Python. Anche in questo caso, l’obiettivo non era semplicemente “tradurre codice”, ma osservare come le stesse strutture logiche e progettuali potessero essere espresse attraverso paradigmi sintattici differenti.

Gli studenti hanno così potuto verificare concretamente che classi, oggetti, relazioni, responsabilità, algoritmi, gestione delle collezioni rimanevano sostanzialmente invariati; mentre cambiavano la sintassi, il livello di formalizzazione, la tipizzazione e la verbosità del linguaggio (Figura 5).

Figura 5: Equivalente delle classi Prodotto e Riga Ordine in Python.

Il confronto tra le due implementazioni ha portato alla costruzione di una tabella di osservazione critica, particolarmente utile dal punto di vista didattico (Figura 6).

Figura 6: Confronto tra Java e Python.

L’esperienza si è rivelata molto efficace, perché gli studenti hanno iniziato a comprendere che il vero nucleo della programmazione non coincide con il linguaggio utilizzato, ma con la capacità di modellare problemi, organizzare dati, progettare relazioni, costruire algoritmi coerenti.

In questo processo, l’IA ha svolto una funzione di “mediatore cognitivo”: ha reso possibile il confronto immediato tra linguaggi differenti, riducendo il carico iniziale legato alla sintassi, e permettendo agli studenti di concentrarsi sugli aspetti strutturali e concettuali del software.

Il passaggio da Java a Python non è stato quindi percepito come una rottura o un nuovo inizio, ma come una naturale evoluzione del medesimo pensiero computazionale espresso attraverso strumenti differenti.

La verbosità nei linguaggi di programmazione: Java e Python a confronto

Uno degli aspetti che gli studenti percepiscono immediatamente nel passaggio da Java a Python è la differenza di verbosità del codice. Per verbosità si intende la quantità di istruzioni, simboli e dichiarazioni necessarie per esprimere una determinata soluzione algoritmica. In termini semplici: un linguaggio verboso richiede più codice per fare la stessa cosa, mentre un linguaggio meno verboso permette di ottenere lo stesso risultato con meno istruzioni. A titolo di esempio (Figura 7), nel caso di studio in esame si mostra la differenza tra la definizione della classe Prodotto, in Java e Python.

Figura 7: La classe Prodotto in Java e Python.

Risulta evidente che in Java lo studente deve esplicitare la visibilità (public private); il tipo degli attributi; il tipo di ritorno dei metodi; la struttura del costruttore; i metodi getter. Il risultato è che questo aumenta notevolmente la quantità di codice.

In Python la stessa classe risulta snella ed essenziale: nessuna dichiarazione di tipo; nessun modificatore di accesso; nessun getter obbligatorio, e struttura molto più compatta.

Gli studenti vedono che la stessa idea progettuale richiede molto meno codice.

8. Effetti cognitivi della verbosità

La maggiore verbosità di Java rappresenta uno degli elementi più caratteristici del linguaggio, e produce dal punto di vista didattico effetti sia positivi sia critici. Tale verbosità non è casuale, ma nasce da precise scelte progettuali orientate alla chiarezza del codice; al controllo rigoroso dei tipi; alla sicurezza del software e alla gestione di progetti complessi sviluppati da grandi team. In Java molte informazioni devono essere esplicitate chiaramente: il tipo delle variabili; la visibilità di attributi e metodi; i parametri delle funzioni, e i valori restituiti. Questo rende il codice più lungo, ma anche meglio strutturato e controllabile.

Tra gli aspetti positivi, la verbosità obbliga gli studenti a rallentare il processo di scrittura, e a riflettere con maggiore attenzione sulla struttura del problema, prima ancora della codifica vera e propria. Lo studente deve pianificare le classi; distinguere dati e comportamenti; definire relazioni tra oggetti e organizzare logicamente il sistema. In questo senso Java favorisce precisione metodologica, formalizzazione e sviluppo di capacità progettuali. La maggiore quantità di codice diventa quindi una palestra cognitiva che stimola l ‘attenzione ai dettagli, la pianificazione preventiva, il rigore logico, l’organizzazione del software e la consapevolezza della struttura del programma.

Proprio per queste caratteristiche, Java viene spesso considerato un linguaggio fortemente formativo nello sviluppo del pensiero computazionale e della progettazione orientata agli oggetti.

Accanto agli aspetti positivi emergono però anche elementi critici, soprattutto nelle prime fasi di apprendimento. Gli studenti principianti tendono spesso a concentrarsi eccessivamente sugli aspetti sintattici piuttosto che sulla logica algoritmica. Errori legati a parentesi mancanti, punti e virgola, incompatibilità di tipo o firme dei metodi possono generare frustrazione e sovraccarico cognitivo. In molti casi il cosiddetto “rumore sintattico” rischia di nascondere il nucleo logico dell’algoritmo, portando gli studenti a percepire la programmazione come un insieme di regole formali da rispettare, piuttosto che come attività di modellazione e problem solving.

È proprio in questo contesto che il successivo passaggio a Python assume un valore pedagogico particolarmente interessante: riducendo drasticamente la verbosità e il peso della sintassi, Python consente agli studenti di concentrarsi sulla logica computazionale e sulle strutture concettuali già costruite durante l’esperienza con Java.

Python e la riduzione del carico cognitivo

Python riduce drasticamente questa complessità. L’assenza di molte dichiarazioni permette agli studenti di focalizzarsi sulla logica, sugli algoritmi e sulla struttura del problema.

Nel caso del progetto “Ordini al Bar”, gli studenti hanno osservato che la struttura OOP restava invariata, ma il codice Python risultava molto più corto e leggibile.

In Java la gestione delle collezioni è più formale e tipizzata: una lista di oggetti Prodotto deve essere dichiarata esplicitamente con il tipo (ArrayList<Prodotto>) e inizializzata con il costruttore della classe (new ArrayList<>()).

Questo garantisce maggiore controllo già in fase di compilazione, ma rende il codice più verboso. In Python invece le liste sono native e dinamiche: basta assegnare prodotti = [] senza dichiarare tipi o strutture aggiuntive.

Il risultato è una sintassi più compatta e veloce da scrivere, ma con meno vincoli statici sul contenuto della collezione (Figura 8).

Figura 8: Confronto della sintassi tra Liste di Java e Python.

L’utilizzo dell’IA nel processo di traduzione da Java a Python ha reso particolarmente evidente proprio il tema della verbosità.

Gli studenti hanno potuto osservare in tempo reale come l’IA eliminasse automaticamente parti ridondanti; come strutture molto articolate in Java diventassero essenziali in Python; come il modello logico rimanesse però sostanzialmente identico.

Questo ha favorito una riflessione matura: la programmazione non consiste nello “scrivere tanto codice”, ma nel progettare correttamente strutture e relazioni tra dati, oggetti e algoritmi.

Il Duck Typing in Python

Uno degli aspetti più interessanti emersi durante il passaggio da Java a Python riguarda il cosiddetto Duck Typing^[7], concetto strettamente collegato alla tipizzazione dinamica di Python. L’espressione deriva dalla frase: “If it walks like a duck and quacks like a duck, then it’s a duck”, cioè: se un oggetto si comporta come un’anatra, allora può essere trattato come un’anatra. In Python, infatti, ciò che conta non è tanto il tipo formale dichiarato di un oggetto, quanto i metodi e i comportamenti che esso possiede realmente durante l’esecuzione. Come si evince dalla Figura 9, la funzione non richiede che obj appartenga ad una specifica classe: è sufficiente che possieda l’attributo nome. Questo approccio rende Python estremamente dinamico e favorisce una programmazione più flessibile e meno vincolata da gerarchie formali.

Figura 9: Confronto del metodo di stampa in Java e Python.

Dal punto di vista didattico, il Duck Typing rappresenta un cambiamento importante nel modo di concepire gli oggetti: in Java si ragiona principalmente in termini di tipi dichiarati, mentre in Python si ragiona maggiormente in termini di comportamento degli oggetti. Nel progetto “Gestione Ordini al Bar”, ad esempio, qualunque oggetto dotato di attributi e metodi compatibili potrebbe essere utilizzato nelle varie componenti del sistema, anche senza appartenere formalmente alla stessa gerarchia di classi. Gli studenti scoprono così che la collaborazione tra oggetti può basarsi non soltanto sull’ereditarietà, ma anche sulla compatibilità comportamentale. Questa caratteristica rende Python molto potente nei contesti dove rapidità di sviluppo e flessibilità assumono un ruolo centrale: prototipali, esplorativi, scientifici, orientati alla data science e all’Intelligenza Artificiale. Allo stesso tempo, il Duck Typing aiuta gli studenti a comprendere un aspetto profondo del pensiero computazionale: nei sistemi software spesso conta più “cosa un oggetto sa fare” che “come è stato formalmente dichiarato”.

Conclusioni

Nel confronto tra docenti emergono spesso visioni differenti riguardo ai linguaggi più adatti per introdurre gli studenti alla programmazione. Da una parte vi sono coloro che vedono in Python uno strumento particolarmente efficace grazie alla sua semplicità sintattica, alla riduzione della verbosità e alla possibilità di concentrarsi rapidamente sulla logica degli algoritmi e la sperimentazione. Dall’altra parte, molti docenti continuano a riconoscere in Java un forte valore formativo, soprattutto per quanto riguarda il rigore progettuale, la formalizzazione, la modellazione orientata agli oggetti e lo sviluppo di un pensiero computazionale strutturato.

Più che contrapporre rigidamente i due approcci, l’esperienza del progetto “Gestione degli Ordini al Bar” ha mostrato come il vero elemento centrale non sia il linguaggio utilizzato, ma il percorso cognitivo che lo studente costruisce attraverso la progettazione, la modellazione e la traduzione delle idee in artefatti digitali funzionanti. In questo senso, Java e Python possono essere considerati strumenti complementari all’interno di una stessa traiettoria educativa.

Java è espressione di rigore metodologico e progettuale, mentre Python resta un ambiente di sperimentazione, rapidità espressiva e applicazione interdisciplinare.

L’azione realmente importante non consiste quindi nello scegliere il linguaggio migliore, ma nel guidare gli studenti a comprendere che i paradigmi computazionali, le strutture logiche e le capacità di problem solving restano stabili anche quando cambiano sintassi, strumenti e tecnologie. È proprio questa consapevolezza che trasforma il coding da semplice esercizio tecnico a processo di costruzione del pensiero.

In tale prospettiva, anche il supporto dell’Intelligenza Artificiale e le pratiche di Vibe Coding possono diventare opportunità educative significative: non per sostituire la progettazione umana, ma per favorire confronto, riflessione critica, revisione delle soluzioni e trasferimento delle competenze tra linguaggi differenti. Il vero obiettivo didattico rimane quindi formare studenti capaci di adattarsi, interpretare e progettare sistemi software in modo consapevole, indipendentemente dal linguaggio di programmazione utilizzato.

^[1] https://www.bluej.org/

^[2] C. Larman “Applicare UML e i pattern. Analisi e progettazione orientata agli oggetti“ (PEARSON).

^[3] D. Barnes – M. Kolling “Programmare in Java con Bluej. Introduzione alla programmazione a oggetti” (PEARSON).

^[4] G. Kim, S. Yegge “Vibe Coding. Metodologie e pratiche per lo sviluppo software con

GenAI, Chatbot e Agent” (APOGEO).

^[5] https://it.wikipedia.org/wiki/Vibe_coding

^[6] M. Fiore, A. Zanga “Informatica per progetti. Programmare in Python” (ZANICHELLI).

^[7] https://it.wikipedia.org/wiki/Duck_typing