La filosofia e il codice hanno qualcosa in comune: entrambi nascono dalla necessità di dare forma al pensiero. La prima cercava di rispondere alla domanda “Che cos’è il mondo?”, la seconda si chiede “Come posso rappresentarlo e trasformarlo logicamente?”. Se è vero che programmare è pensare in modo strutturato, allora è naturale scoprire echi della filosofia greca nei paradigmi di programmazione e nelle architetture software.
Platone, Aristotele, Eraclito e Pitagora non scrivevano codice, ma erano sviluppatori di concetti, architetti del pensiero. E oggi, in un mondo fatto di funzioni, eventi, oggetti e pattern, le loro intuizioni risuonano più che mai.
Platone e la programmazione orientata agli oggetti
Platone ci parla di un mondo delle Idee: forme perfette, eterne, che esistono in un Iperuranio immateriale. Il mondo sensibile, per lui, è solo un’ombra, un riflesso imperfetto.
Questa visione ricorda sorprendentemente da vicino il paradigma OOP (Object-Oriented Programming): la classe è l’Idea, l’astrazione pura e immutabile; l’oggetto è la sua concretizzazione nel mondo esecutivo.
Ma l’analogia va oltre:
- Quando progettiamo un sistema, partiamo da modelli concettuali (domain model) che rispecchiano le idee platoniche.
- I design pattern sono forme ideali che riutilizziamo per risolvere problemi comuni.
- Il principio Open/Closed di SOLID riflette la tensione tra stabilità dell’Idea e varietà delle sue manifestazioni.
La lezione di Platone? Tieni ben chiara l’Idea alla base della tua architettura, perché ogni implementazione concreta sarà una sua proiezione imperfetta.
Aristotele e la programmazione funzionale
Aristotele rompe con l’astrazione platonica e guarda al mondo così com’è. Introduce il concetto di sostanza e la distinzione tra potenza (ciò che può accadere) e atto (ciò che accade effettivamente).
Nel mondo del software, questa visione si rispecchia nella programmazione funzionale, dove il focus non è sugli oggetti statici, ma sulle trasformazioni dei dati:
- Le funzioni pure sono strumenti per descrivere come un’entità si realizza.
- Le composizioni funzionali descrivono un flusso logico, un’azione teleologica (orientata a uno scopo), proprio come i processi aristotelici.
Inoltre, Aristotele ci parlava delle cause (materiale, formale, efficiente, finale). Questo ha un’eco nella progettazione software:
- Il perché scriviamo una funzione (causa finale),
- Cosa trasforma (causa materiale),
- Come la definiamo (causa formale),
- Chi o cosa la esegue (causa efficiente, ad esempio un trigger o un input dell’utente).
Il pensiero aristotelico ci insegna a progettare comportamenti coerenti e orientati al fine, anziché semplici oggetti con stato.
Eraclito e le architetture a eventi
Eraclito è il filosofo del cambiamento: “Panta rei”, tutto scorre. Per lui la realtà non è mai statica, ma un fluire continuo. “Non ci si può bagnare due volte nello stesso fiume” è la sintesi perfetta del tempo che modifica tutto.
Questa intuizione trova riscontro diretto nelle architetture event-driven, dove:
- Lo stato è derivato da una sequenza di eventi, non da una fotografia momentanea.
- Ogni entità è definita dalla sua storia, non dal suo valore attuale.
Tecnologie come Apache Kafka, Event Sourcing, Command Query Responsibility Segregation (CQRS) e pratiche come Event Storming incarnano questa visione:
- Gli eventi sono immortali (immutabili),
- Il sistema è reattivo, non prescrittivo,
- L’evoluzione non è un’eccezione, ma la regola.
Eraclito oggi lavorerebbe in un team DevOps su architetture reactive, prediligendo microservizi asincroni e streaming real-time.
Pitagora e l’estetica del codice
Pitagora è spesso ricordato per il suo teorema, ma fu anche mistico, scienziato, visionario. Per lui, i numeri erano il principio ordinatore del cosmo. L’universo, sosteneva, è fondato su armonia, proporzione, simmetria.
Nel codice questa idea vive nella ricerca della bellezza funzionale:
- Un codice pulito, leggibile e coerente non è solo più elegante, è anche più manutenibile.
- Pattern come MVC, Repository, Decorator sono espressioni di ordine.
- Pratiche come il refactoring continuo, il design modulare o i test automatici ben scritti rendono il software armonico.
Anche le architetture hexagonal o onion riflettono questa tensione tra bellezza e funzione.
Per Pitagora, tutto ciò che funziona bene è anche bello: un principio che vale anche per l’UX, il naming, la struttura dei file.
Conclusione: i filosofi greci erano architetti del pensiero. Noi lo siamo del codice
Guardare alla filosofia greca non è un gioco accademico, ma un modo per riscoprire la profondità del nostro mestiere. Scrivere codice significa pensare in forma esecutiva. Ogni scelta di design, ogni architettura, ogni naming riflette una visione del mondo.
- Platone ci invita a progettare prima di implementare.
- Aristotele ci ricorda che la trasformazione è l’essenza della realtà.
- Eraclito ci insegna a pensare al tempo come dimensione viva del software.
- Pitagora ci mostra che eleganza e correttezza possono (e devono) coesistere.
Forse, dopotutto, il mestiere del programmatore è figlio di un pensiero millenario: quello che ha iniziato a strutturare il caos del mondo attraverso il logos.
E oggi, noi continuiamo questa tradizione.
Con un IDE, una tastiera e qualche migliaio di righe di codice.
PS: pensando a Socrate, mi viene da pensare agli LLM, in grado di generare testo senza realmente comprenderne il significato.. .una elogio del “So di non sapere” e della maieutica socratica 😀
Lascia un commento