Paradigma di programmazione

In informatica, un paradigma di programmazione è un insieme di strumenti concettuali per la modellazione di algoritmi, determinanti quindi il modo in cui il programmatore progetta, implementa e interpreta i programmi corrispondenti.

Diversi paradigmi si differenziano per i concetti e le astrazioni usate per rappresentare gli elementi di un programma (come ad esempio le funzioni, gli oggetti, le variabili, vincoli, ecc.) e per i procedimenti usati per l'esecuzione delle procedure di elaborazione dei dati (assegnazione, calcolo, iterazione, data flow, ecc.).

Descrizione

Ogni linguaggio di programmazione è generalmente ispirato — e riconducibile — ad un particolare paradigma di programmazione; un programma object-oriented, ad esempio, è costituito da oggetti che interagiscono fra loro, mentre nella programmazione funzionale il programma è una composizione di funzioni; per quanto riguarda i linguaggi, ad esempio, Pascal e C sono basati sul paradigma della programmazione strutturata, Lisp su quello della programmazione funzionale, Prolog su quello della programmazione logica e così via.

Alcuni linguaggi di programmazione invece sono influenzati da molteplici paradigmi; due esempi macroscopici sono Ada, che fu esplicitamente progettato come summa di concetti provenienti dalla programmazione strutturata, dalla programmazione modulare, dalla programmazione generica, dalla programmazione concorrente e dalla programmazione per tipi di dati astratti, e C++, che unisce parti di programmazione procedurale, funzionale e ad oggetti.

La storia dei paradigmi di programmazione si presta a essere rappresentata con un albero genealogico; in molti casi, infatti, un nuovo paradigma nasce come evoluzione di un altro, aggiungendo nuovi concetti e mantenendo quelli fondamentali del precedente (ponendoli eventualmente in una prospettiva nuova o modificandone l'importanza relativa). A volte questo "salto evolutivo" consiste nel rendere obbligatorio e/o supportare esplicitamente un modo di procedere che nei paradigmi precedenti si era affermato solamente come regola di buona programmazione. Per esempio, la programmazione strutturata ha introdotto strutture di controllo standard (sequenze, selezioni e cicli) e ha di fatto reso non raccomandabile l'uso dell'istruzione di salto incondizionato goto, della quale si era dimostrata la non indispensabilità con il teorema di Böhm-Jacopini. Quando questo avvenne, i rischi legati all'uso indiscriminato del goto erano già noti a molti programmatori ed erano diffuse regole di stile che suggerivano di restringere l'uso del goto a casi che si potessero far sostanzialmente corrispondere alle strutture di controllo della programmazione strutturata.

Sulla base della considerazione precedente, si può anche osservare che non è strettamente necessario, per programmare secondo un certo paradigma, avere a disposizione un linguaggio di programmazione direttamente ispirato a quello stesso paradigma; ad esempio, è possibile, anche se non facilissimo, programmare a oggetti in linguaggio C. I meccanismi di astrazione dei linguaggi di programmazione, differenti per i vari paradigmi, possono contribuire a rendere possibile stili di programmazione basati su concetti non direttamente forniti dal linguaggio utilizzato.

Tipi di paradigmi

Per quanto riguarda almeno i linguaggi di programmazione usati nella pratica industriale dello sviluppo del software, si può identificare un "filone principale" di paradigmi di programmazione:

programmazione modulare

(metà anni settanta) Modula, CLU (linguaggio)

programmazione orientata agli aspetti

Una estensione dell'OOP (anni 2000) AspectJ

programmazione orientata agli utenti

Inside Microsoft Windows NT Internet Development (1998 Microsoft Press), piattaforma .NET

programmazione orientata agli oggetti

(anni ottanta) Smalltalk, Eiffel, C++, Java, Python, Ruby, piattaforma .NET

programmazione strutturata secondo patterns

Java blueprints, Sun Java blueprints

programmazione per pattern matching

(Espressioni regolari)

programmazione procedurale

(anni sessanta) Fortran, COBOL, F#

programmazione strutturata

(primi anni settanta) Pascal, C

programmazione per tipi di dati astratti

(tardi anni settanta) OBJ

Altri paradigmi sono nati per applicazioni specifiche:

programmazione concorrente

Inizialmente per il calcolo su architetture parallele (anni settanta) Erlang, Communicating Sequential Processes (CSP), Occam, Go

programmazione logica

Per applicazioni euristiche, intelligenza artificiale, ecc.; (anni settanta) Prolog

programmazione funzionale

Per applicazioni matematiche e scientifiche ecc.; (anni settanta) Lisp, Haskell

programmazione orientata agli eventi

Per applicazioni real-time e interfacce grafiche

programmazione a vincoli

Critiche

Alcuni ricercatori criticano l'uso dei paradigmi per la classificazione dei linguaggi di programmazione, si vedano, ad esempio, Harper, ^[1] e Krishnamurthi. ^[2] Essi sostengono che molti linguaggi di programmazione non possono essere classificati rigorosamente in un paradigma, ma piuttosto includono caratteristiche di diversi paradigmi. Si veda il confronto di linguaggi di programmazione multi-paradigma.

Storia

Nel corso del tempo si sono sviluppati diversi approcci alla programmazione. La classificazione di ciascun approccio è stata descritta al momento del suo primo sviluppo, ma spesso solo in un secondo momento, retrospettivamente. Un primo approccio consapevolmente identificato come tale è la programmazione strutturata, diffusasi dalla metà degli anni '60. Il concetto di paradigma di programmazione in quanto tale risale almeno al 1978, nel discorso di accettazione del premio Turing di Robert W. Floyd, intitolato The Paradigms of Programming, che cita la nozione di paradigma utilizzata da Thomas Kuhn nel suo The Structure of Scientific Revolutions (1962). ^[3] I primi linguaggi di programmazione non avevano paradigmi di programmazione chiaramente definiti e talvolta i programmi facevano ampio uso di istruzioni goto. Il loro uso eccessivo portava alla creazione di codice a spaghetti, difficile da capire e sottoporre a manutenzione. Ciò ha portato allo sviluppo di paradigmi di programmazione strutturata che non consentivano l'uso di istruzioni goto, consentendo solo l'uso di costrutti di programmazione più strutturati. ^[4]