Il documento descrive i linguaggi di programmazione, distinguendoli tra alto e basso livello e spiegando i vari processi di compilazione e interpretazione. Viene approfondita l'architettura delle piattaforme Java e .NET, enfatizzando rispettivamente la portabilità del codice e l'indipendenza dal linguaggio. Inoltre, si menzionano i compilatori JIT che ottimizzano l'esecuzione, e infine si confrontano le due piattaforme in termini di architettura.

1. LINGUAGGI DI PROGRAMMAZIONE
Un linguaggio di programmazione è un linguaggio formale, dotato di un lessico, di una sintassi e di
una semantica ben definiti, utilizzabile per il controllo del comportamento di una macchina formale o di una
implementazione di essa (tipicamente, un computer) ovvero per la programmazione di questa attraverso la
scrittura di un programma sotto forma di codice.
Si distinguono linguaggi di basso livello (orientati al linguaggio macchina, assembler) e di alto livello
(orientati all’uomo).
Quindi si possono ottenere dei programmi in modo:
• DIRETTO il programma viene scritto in binario
• ASSEMBLATO (assembly + assemblatore + linker)
ASSEMBLATORE: è un programma che riceve un intero programma sorgente (file in ascii) in input e
restituisce in output il programma oggetto (in binario).
LINKER (o collegatore) :
- risolve i riferimenti esterni (es: le Librerie)
- predispone i segmenti permettendo all’utente di ottenere un programma rilocabile
- crea il file eseguibile .exe

2. • COMPILATO (linguaggio di alto livello – compilato – assemblatore – collegato)
Un esempio di linguaggio compilato è il Pascal, il programma viene scritto utilizzando quel
linguaggio e successivamente compilato cioè tradotto in un file.asm (compatibile con il processore
utilizzato ) che poi per diventare eseguibile seguirà gli stessi passaggi descritti nella modalità
assemblata.
Compilazione e assemblaggio attualmente avvengono spesso in un passaggio unico per evitare
tappe inutili.
• INTERPRETATO
il programma è interpretato linea per linea,
quindi non esistono il file.asm e il file.obj e
i cicli non possono essere implementati visto la
particolare modalità di traduzione.
Un esempio di linguaggio interpretato è il BASIC
dove l’unico controllo esistente è il “go to”.
Esso è stato utilizzato per molti anni nonostante lo
svantaggio dei cicli perché l’interprete richiedeva
16K di ram e con i pc IBM dotati di 64K di ram era la
soluzione più comoda (contro circa 600K utilizzati
dai compilatori Pascal).
Il maggior vantaggio della interpretazione è senz’altro l’essere svincolati da una piattaforma
(combinazione di architettura hardware e sistema operativo) particolare, al prezzo di una minore
efficienza rispetto alla compilazione che è sicuramente più veloce, ma risulta scomoda per l’assenza
di un’intercompatibilità.
• PIATTAFORMA e LINGUAGGIO JAVA
Il programma sorgente scritto in java viene compilato in un linguaggio intermedio ibrido chiamato
byte code e poi interpretato dalla Java Virtual Machine, ossia un’interprete di basso livello che emula
una CPU.
In questo modo il programma diventa eseguibile da qualsiasi computer avente la propria JVM
installata.
• PIATTAFORMA .NET
Analogamente alla piattaforma java il programma sorgente viene compilato in un linguaggio
intermedio chiamato Portable Executable FIle e interpretato dalla Common Language Runtime che
concettualmente è molto simile a una virtual machine.
Questo componente deve essere eseguito prima di poter lanciare i programmi .Net, una volta in
memoria si preoccupa di richiamare i moduli di cui si ha bisogno e li compila con il JIT.

3. PIATTAFORMA JAVA E .NET
Una soluzione intermedia fra compilazione e interpretazione è quella adottata dai linguaggi Java e Python,
con il byte code e in Visual Basic e.NET di Microsoft con il P-code.
In tutti e due questi casi il codice sorgente dei programmi non viene compilato in linguaggio macchina, ma in
un codice intermedio "ibrido" destinato a venire interpretato al momento dell'esecuzione del programma: il
motivo di questo doppio passaggio è di avere la portabilità dei linguaggi interpretati ma anche, grazie alla
pre-compilazione, un interprete più semplice e quindi più veloce.
Tuttavia il codice intermedio è più facile sia da interpretare che da compilare: per questo motivo sia per Java
che per i linguaggi .NET sono stati sviluppati i compilatori JIT (Just In Time), che al momento del lancio di un
programma Java, VB o .NET compilano “al volo” (cioè durante l’esecuzione del programma stesso) il codice
intermedio e mandano in esecuzione un normale codice macchina nativo, eliminando completamente la
necessità dell'interprete e rendendo i programmi scritti in questi linguaggi veloci quasi quanto i normali
programmi compilati.
IN BREVE..
Il Programma sorgente viene compilato in un linguaggio intermedio ibrido (es: byte code) una volta per tutte
Il linguaggio intermedio viene interpretato da una Virtual Machine (VM) ossia un interprete di basso livello
che emula una CPU
La portabilità su una CPU diversa è garantita dall’esistenza della VM per quella specifica CPU

4. Architettura Java
“Write Once, Run Anywhere” è il motto che la Sun utilizza per identificare Java.
Già da questa si intuisce l’obiettivo di questo linguaggio: rendere il codice scritto indipendente dalla
piattaforma. In Java è possibile scrivere un programma in ambiente Linux ed eseguirlo in ambiente
Windows, senza apportare alcuna modifica al codice sorgente.
Per ottenere questa indipendenza viene utilizzata la seguente architettura:
Quindi l’utente scrive il proprio codice in Java e il file prodotto viene compilato, in questa maniera viene
creato un codice intermedio indipendente dalla macchina denominato byte code.
La “virtual machine”, il componente fondamentale della struttura che è differente per ogni sistema
operativo, si occupa di rendere effettivamente portabile il codice. Quando un programma viene eseguito,
prima viene caricata la “virtual machine” la quale chiama ed esegue il byte code di cui si ha bisogno ed
utilizzando una compilazione Just In Time (JIT) si preoccupa di tradurre in linguaggio macchina le istruzioni
del programma.
Per eseguire il medesimo programma su di un sistema operativo diverso basta assicurarsi che sulla
macchina di destinazione sia presente una “virtual machine” appropriata, copiare sulla macchina il byte
code del programma ed eseguirlo. In questa semplice maniere viene mantenuta la portabilità del codice.

5. Architettura .Net
Il prodotto Microsoft parte da un presupposto diverso, invece di puntare sulla portabilità del codice (anche
se non è esclusa questa possibilità) punta sulla possibilità di lasciare la libertà al programmatore di usare il
linguaggio di programmazione da lui preferito. Questa scelta secondo Microsoft permette di creare
programmi molto velocemente perché per utilizzare questa piattaforma non è necessario imparare alcun
nuovo linguaggio. Altri, invece, vedono questa libertà come una nota negativa che a lungo porta a scrivere
codice più confuso, più difficile da leggere e da mantenere.
Il sistema è il seguente:
Si scrive il proprio codice nel linguaggio preferito, il file così generato deve essere compilato con un
compilatore per il linguaggio prescelto che sia compatibile con le specifiche .Net. Questa compilazione
genera un codice intermedio molto simile al byte code di Java che in questo caso viene chiamato “portable
executable file”, la creazione di questo codice intermedio permette quindi di nascondere il tipo di
linguaggio utilizzato. Nel caso della programmazione ad oggetti si può anche passare come argomento di un
metodo oggetti scritti in altri linguaggi. Questa interoperabilità tra linguaggi è possibile proprio perché tutti
i compilatori generano codice coerente tra loro. Quando viene richiamato dal nostro programma un
metodo esterno non si ha la necessità di sapere in che linguaggio è stato scritto poiché sappiamo che
sicuramente è stato compilato seguendo delle regole comuni, di conseguenza tutto il codice .Net è
utilizzabile da tutti i linguaggi .Net.
Una volta compilato il proprio programma, per poterlo eseguire, bisogna utilizzare il “common language
runtime” che concettualmente è molto simile alla “virtual machine”.
Questo componente deve essere eseguito prima di poter lanciare i programmi .Net, una volta in memoria si
preoccupa di richiamare i moduli di cui si ha bisogno e li compila con il JIT.

6. Confronto
Dal punto di vista architetturale i due framework sono molto simili, Java ha enfatizzato l’indipendenza dalla
macchina mentre .Net ha enfatizzato l’indipendenza dal linguaggio.
Con piccole aggiunte queste due caratteristiche sono ottenibili da entrambi i concorrenti; infatti, nel caso
di Java esistono dei progetti funzionanti che permettono l’indipendenza dal linguaggio e dal punto di vista
di .Net è possibile ottenere l’indipendenza dalla piattaforma.

7. Riferimenti:
• Spiegazioni in classe
• http://it.wikipedia.org/wiki/Piattaforma_Java
• http://it.wikipedia.org/wiki/Microsoft_.NET
• https://docs.google.com/viewer?
a=v&q=cache:mO_2CMAmlNEJ:microservo.altervista.org/Collaborazioni/Confronto
%2520java
%2520net.doc+principio+di+funzionamento+.net+java&hl=it&gl=it&pid=bl&srcid=ADGEESh
tRgLhhRk0SllNRKLCPpPbvaqAHehK9SsvEXeNGE7x0tOmGhNDkwvrzTIuqhcuwbrmu3KJXt2P
Qqv1qLzBb7STLyF0lhFrbprkm7ryde7nC1Z-
r5BcRbDdEvoLrEfcOXmIGroU&sig=AHIEtbSJPxSodPkx0Sc1wmJ8Mwv9EOugcw
Martina De Stefani III E