{"id":78,"date":"2001-12-11T00:00:00","date_gmt":"2001-12-10T23:00:00","guid":{"rendered":""},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T22:00:00","slug":"78","status":"publish","type":"post","link":"https:\/\/www.vialattea.net\/content\/78\/","title":{"rendered":"Vorrei sapere a quale generazione di linguaggi un linguaggio di programmazione ad oggetti appartiene e in base a che criterio si pu\u00f2 fare questa catalogazione.\r\nIn particolare Java, C++, Visual Basic, JavaScript in quale generazione di linguaggi sono inseriti."},"content":{"rendered":"

La
\ndomanda \u00e8 interessante, e merita una attenta analisi storica dell’evoluzione
\ndei linguaggi di programmazione.
\nAgli inizi i calcolatori erano molto costosi, giganteschi e tremendamente limitati.
\nNon esistevano monitor, ne vere tastiere, la quantit\u00e0 di memoria per i
\nprogrammi e i loro dati era limitata a pochissimi kb. Ma anche quei dinosauri
\ndovevano essere programmati per fare qualcosa di utile, per cui gli scienziati
\ndell’epoca erano costretti a scrivere degli algoritmi in pseudo linguaggi, su
\ncarta che poi manualmente traducevano in istruzioni sempre pi\u00f9 semplici,
\nfino a raggiungere il livello delle istruzioni comprese direttamente dal microprocessore.
\nIn altre parole si programmava in quello che viene definito linguaggio macchina,
\ne che si pu\u00f2 senz’altro definire la prima generazione di linguaggi, molto
\nvariabili soprattutto perch\u00e9 dipendenti dalla macchina sottostante, nella
\ncompleta assenza di qualsiasi sistema operativo, in cui le istruzioni venivano
\nscritte direttamente in codici binari.
\nSuccessivamente si cerc\u00f2 di semplificare la programmazione, creando un
\nlinguaggio che introducesse, un maggiore livello di astrazione, permettendo l’uso
\ndi simboli al posto dei codici binari. Cos\u00ec nacquero i primi linguaggi
\nassembler, ancora molto rozzi, ma sicuramente pi\u00f9 semplici da usare per
\nla definizione di algoritmi, i codici delle istruzioni diventarono delle abbreviazioni
\ntestuali pi\u00f9 facili da leggere e ricordare, e le variabili acquistarono
\ndei nomi pi\u00f9 significativi, rispetto ai loro semplici indirizzi in memoria.
\nCon l’evoluzione dei sistemi, aumentarono le potenze di calcolo e le dimensioni
\ndella memoria. Inoltre iniziarono a comparire i primi dispositivi di registrazione
\ndi massa dei dati (dischi e nastri magnetici, ecc.). Di pari passo le mire dei
\nricercatori, crebbero e la necessit\u00e0 di scrivere algoritmi pi\u00f9 complessi
\ne potenti, nonch\u00e9 il bisogno di riutilizzare il codice gi\u00e0 scritto
\no condividere con altri il proprio codice, si rese pi\u00f9 importate.
\nA questo scopo vennero pensati dei linguaggi ancora pi\u00f9 astratti che ignorassero
\ndel tutto le istruzioni comprese dal processore, assumendo che alcune operazioni
\ndi base fossero disponibili ovunque o che se non altro si potessero implementare
\ncon quelle esistenti. In questo processo di astrazione tutte le variabili non
\nfurono pi\u00f9 visibili come semplici indirizzi di memoria, ma solo con i loro
\nnomi simbolici, e furono introdotti i primi concetti di codice strutturato per
\nil controllo del flusso di esecuzione delle istruzioni. I pi\u00f9 linguaggi
\nconosciuti di questo tipo sono il BASIC e il FORTRAN, in cui vediamo per la prima
\nvolta la possibilit\u00e0 di definire dei blocchi di codice che possiamo eseguire
\nripetutamente in base a condizioni definibili in modo decisamente evoluto, tramite
\nespressioni di controllo molto simili a funzioni matematiche. Queste espressioni
\npossono essere usate per decidere se eseguire un blocco di codice o no. Ma soprattutto
\nmettono in pratica uno dei primi teoremi della computer science, quello di B\u00f6hm-Jacopini<\/a>.
\nParallelamente a questi linguaggi definiti imperativi, perch\u00e9 contengono
\nsolo comandi ben precisi da eseguire in un certo ordine, nasce un’altra classe
\ndi linguaggi detti logici, in cui non esistono procedure rigide, ma solo un elenco
\ndi regole di cui non si pu\u00f2 stabilire a priori l’ordine di applicazione.
\nUno di questi linguaggi \u00e8 il Prolog, e rappresenta una vera rivoluzione
\ndel modo di pensare l’elaborazione automatica dei dati. In un programma Prolog,
\nsi definiscono tutte le regole applicabili nelle diverse situazioni che si possono
\nincontrare in un problema. Ognuna delle quali per essere applicata deve soddisfare
\nun elenco di condizioni organizzate con operatori logici (or, and, not, xor),
\ne alla cui applicazione pu\u00f2 corrispondere un cambiamento del problema di
\npartenza, che quindi si trasforma fino a raggiungere uno stato che possiamo definire
\nsoluzione.
\nNonostante queste sue caratteristiche sia il Prolog che i linguaggi della sua
\nclasse non ebbero un grande successo, per il motivo fondamentale che la maggior
\nparte dei problemi reali, come il controllo di processi industriali o l’archiviazione
\ndi dati \u00e8 gestibile in modo pi\u00f9 semplice e sicuro con linguaggi
\nimperativi.
\nI linguaggi logici fondamentalmente furono pensati per esplorare le capacit\u00e0
\ndi pensiero artificiale, e infatti furono e sono tuttora strumenti di nicchia
\nin intelligenza artificiale.
\nTornando ai linguaggi imperativi, BASIC, Fortran e simili, permisero senza dubbio
\nun passo avanti considerevole, ma soffrivano ancora di una primitiva strutturazione
\ne spingevano all’uso di un’istruzione che rendeva poco chiaro il codice e che
\nfece coniare il termine di programmazione spaghetti per via delle imprevedibili
\ndiramazioni del flusso di esecuzione. Quest’istruzione \u00e8 il GOTO, tradotto
\nletteralmente in “vai a”, ossia un salto incondizionato ad una certa
\nistruzione. I programmi che pi\u00f9 soffrivano di questa “malattia”
\nerano quelli scritti in BASIC, ma anche gli altri non ne erano immuni.
\nPer limitarne l’uso furono introdotti linguaggi sempre pi\u00f9 strutturati,
\ncome il Pascal, molto usato nella didattica, in cui rispetto ai primi BASIC, c’\u00e8
\nl’introduzione delle funzioni e procedure che permettono agevolmente di evitare
\nl’uso del GOTO, presente anche in Pascal, ma con una piccola modifica che ne permette
\nun uso pi\u00f9 disciplinato, ossia la necessit\u00e0 di definire un punto
\ndi arrivo del salto, le label(ricordo che in basic si specificava solo il numero
\ndi riga e se per qualche motivo si aggiungeva o si cancellava del codice i salti
\na numero di riga diventavano imprevedibili, portando il flusso di esecuzione in
\npunti del tutto sbagliati).
\nNonostante tutti questi sforzi per strutturare e astrarre i linguaggi di programmazione,
\nrimaneva sempre la necessit\u00e0 di poter controllare l’hardware sottostante
\nsenza limiti per sfruttarlo al meglio, ma di certo non era opportuno tornare all’assembler
\ne rinunciare ai benefici della programmazione strutturata. Per risolvere questi
\nproblemi fu inventato un linguaggio a met\u00e0 strada, ancora frequentemente
\nusato in molti tipi di applicazioni, sto parlando del C.
\nIl C nelle sue prime versioni forniva tutto quello che ci si aspettava per una
\nprogrammazione strutturata, e quindi cicli, espressioni di controllo, esecuzione
\ncondizionata di blocchi di codice, funzioni, strutture dati (presenti anche in
\npascal) ossia la possibilit\u00e0 di dare un nome ad un gruppo di variabili
\ne gestirle come oggetti compatti. Ma nonostante questo manteneva un profondo legame
\ncon l’assembler, comprendendo funzioni a bassissimo livello come lo shift dei
\nbit di una variabile, o la possibilit\u00e0 di indicare al compilatore che una
\nvariabile sarebbe stato opportuno non fosse allocata in memoria, ma fosse direttamente
\nun registro del processore. Purtroppo soffriva di una quasi totale assenza di
\ncontrollo dei tipi delle variabili, in altre parole si poteva tranquillamente
\nassegnare ad un intero il valore di una stringa, senza che venisse generato neanche
\nun messaggio di avvertimento per l’assegnazione ad una variabile di un tipo il
\nvalore di un’altra di tipo del tutto differente.
\nDopo questa generazione di linguaggi strutturati, i progetti da sviluppare nella
\nvita reale divennero sempre pi\u00f9 complessi e di grandi dimensioni, di pari
\npasso all’evoluzione delle macchine. Cos\u00ec cominci\u00f2 a farsi strada
\nun’altra rivoluzione, che porta il nome di programmazione ad oggetti.
\nL’idea di base \u00e8 che tutti i programmi non fanno altro che definire gruppi
\ndi funzioni che manipolano pacchetti di dati spesso strutturati a pi\u00f9 livelli,
\nossia strutture che contengono altre strutture e cos\u00ec via. Cos\u00ec
\nsi cominci\u00f2 a pensare che non aveva senso separare le strutture dati dalle
\nfunzioni che le manipolano, \u00e8 cos\u00ec nacque il concetto di oggetto
\nnel software.
\nUn oggetto definiva i suoi dati e tutte le funzioni che erano state progettate
\nper la loro gestione. Il tutto in un blocco unico, al punto tale che le funzioni
\nera come se non esistessero senza la creazione dell’oggetto a cui appartenevano.
\nInoltre sia le variabili che le funzioni potevano essere pubbliche o private,
\ncio\u00e8 visibili e utilizzabili dall’esterno o no, introducendo il concetto
\ndi information hiding. La rivoluzione non finisce qui, infatti ci si rese conto
\nanche, che molto spesso si utilizzavano oggetti simili in diversi progetti, ma
\nanche in uno stesso progetto. Per cui si pens\u00f2 alla possibilit\u00e0
\ndi definire oggetti che derivavano da altri, a cui aggiungevano capacit\u00e0
\n(funzioni), dati o semplicemente ridefinendone alcune funzioni. Con queste caratteristiche
\nfurono introdotti altri due concetti fondamentali della programmazione ad oggetti:
\nl’ereditariet\u00e0 e il polimorfismo.
\nForse il primo linguaggio che introdusse la vera programmazione ad oggetti fu
\nlo SmallTalk, successivamente fu esteso il linguaggio C, dando origine al C++
\nche in realt\u00e0 non sposa completamente la filosofia ad oggetti, permettendo
\nla definizione di elementi non appartenenti a nessun oggetto, cosa che lo rende
\nun poco pulito da questo punto di vista.
\nSuccessivamente nacquero linguaggi come Java, che in questo processo di astrazione
\naggiunge un ulteriore elemento.
\nDal punto di vista della sintassi \u00e8 praticamente identico al C++, semanticamente
\nha alcune differenze da tenere ben presenti per un suo corretto uso. Per prima
\ncosa in Java si tagliano completamente i ponti con l’hardware, croce e delizia
\ndel C++, e si astrae la macchina definendo un processore virtuale o per meglio
\ndire una macchina virtuale. Per fare una cosa del genere si introdusse un software
\n(necessario per far girare le applicazioni scritte in Java), che si comportava
\ncome una semplice processore hardware.
\nIn poche parole un programma viene compilato in linguaggio macchina, ma non per
\nla macchina dove si sta lavorando, ma per la macchina virtuale, questo linguaggio
\nmacchina \u00e8 molto simile a quello vero, per cui la sua esecuzione \u00e8
\nmolto veloce, essendoci una corrispondenza di quasi 1:1 (ovviamente il rapporto
\nvaria da piattaforma a piattaforma, o per meglio dire dalla complessit\u00e0
\ndel processore reale). Anche in questo modo, il fatto che ci sia un interprete
\ndelle istruzioni purtroppo ne limita le performance, ma in compenso permette una
\nsicurezza totale (se la macchina virtuale \u00e8 stata implementata correttamente),
\ne una completa indipendenza dalla macchina che comunque deve avere delle caratteristiche
\nminime, scelte in modo da abbracciare la quasi totalit\u00e0 delle macchine
\nmoderne.
\nJava a parte la sintassi molto simile al C++, porta con se delle notevoli innovazioni
\nper rendere pi\u00f9 difficile commettere errori e aumentare conseguentemente
\nla produttivit\u00e0. Per prima cosa non \u00e8 pi\u00f9 possibile vedere
\nindirizzi di memoria, tutte le variabili fanno riferimento a oggetti, ma non \u00e8
\npossibile leggerne l’indirizzo, ne spostarlo di un numero di byte a piacere. L’unica
\noperazione ammessa con le variabili(riferimenti a locazioni di memoria) \u00e8
\nla copia da una a l’altra o la cancellazione del riferimento impostandolo a null.
\nQuesto impedisce ai programmi di accedere a qualsiasi locazione di memoria, eliminando
\nla possibilit\u00e0 di provocare grossi danni al sistema. Inoltre la gestione
\ndegli errori \u00e8 completamente affidata alle eccezioni, e infine sono previsti
\nmeccanismi di sincronizzazione per i thread direttamente nel linguaggio.
\nPer finire la deallocazione della memoria \u00e8 gestita automaticamente, con
\nun processo chiamato Garbage Collector che solleva il programmatore dalla gestione
\ndella distruzione degli oggetti.
\nLa critica maggiore che si pu\u00f2 fare a Java, \u00e8 che ha spinto l’astrazione
\na livelli eccessivi a scapito della efficienza del codice, ma d’altro canto grazie
\na questo, e ai limiti nell’accesso alla macchina, permette di evitare molti errori
\ne aumenta notevolmente la produttivit\u00e0 dei programmatori, e nello stesso
\ntempo permette la creazione di applicazioni molto robuste.
\nParallelamente a questi linguaggi si posizionano gli script, come il Visual Basic
\nScript, Java Script, ecc. che in realt\u00e0 non definirei dei veri e propri
\nlinguaggi. Infatti non permettono la definizione di vere applicazioni, ma semplicemente
\ndi definire dei comportamenti particolari in software che li comprendono, come
\ni browser internet e quindi sono molto dipendenti dalla versione di questi ultimi.
\nComunque la loro utilit\u00e0 \u00e8 indubbia, infatti spesso non si ha bisogno
\ndi una vera applicazione, ma semplicemente di effettuare delle piccole procedure
\nin programmi particolari, e uno script \u00e8 di sicuro una buona soluzione,
\nse non l’unica.
\nDi linguaggi script, come \u00e8 facile immaginare, ne esistono infiniti, \u00e8
\nspesso le applicazioni professionali ne supportano uno, vedi lo scripting dei
\nprogrammi di grafica come 3D Studio, 3D Studio MAX, AutoCAD, Maya, ecc. Ognuno
\ndi questi programmi permette la definizione di procedure per gestire animazioni
\no creare superfici e curve irrealizzabili a mano con la precisione necessaria.
\nInfine esistono i meta linguaggi, usati in tools per la creazione di interpreti
\no compilatori, come Flex\/Bison o ANTLR, con cui si definiscono regole grammaticali,
\ncon procedure da eseguire quando vengono applicate, che non si possono definire
\nscript in quanto, con questi meta linguaggi vengono generati i sorgenti di vere
\ne proprie applicazioni che comprendono altri linguaggi (interpreti). Ma la cosa
\nche li rende particolarmente interessanti \u00e8 che in realt\u00e0 generano
\ni sorgenti di queste applicazioni (per esempio ANTLR permette la generazione sia
\ndi codice Java che C\/C++), cosa che permette la loro integrazione in progetti
\ndi pi\u00f9 ampio respiro (vedi le applicazioni grafiche accennate prima).
\nSpero che questa breve storia dei linguaggi permetta una visione pi\u00f9 chiara
\ndel panorama attuale, e che non sia stata troppo noiosa, ma soprattutto spero
\nche piaccia ai lettori, almeno quanto \u00e8 piaciuto a me scriverla.<\/font><\/p>\n","protected":false},"excerpt":{"rendered":"

[…]<\/p>\n","protected":false},"author":176,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[62],"tags":[],"class_list":["post-78","post","type-post","status-publish","format-standard","hentry","category-software"],"_links":{"self":[{"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/posts\/78","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/users\/176"}],"replies":[{"embeddable":true,"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/comments?post=78"}],"version-history":[{"count":0,"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/posts\/78\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/media?parent=78"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/categories?post=78"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.vialattea.net\/content\/wp-json\/wp\/v2\/tags?post=78"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}