| Home / Indice sezione | www.icosaedro.it | |
P-Code alla riscossaJava, .NET e Mono hanno segnato un revival dello pseudo-codice, e sembrano indicare la strada verso i nuovi linguaggi di programmazione e sistemi di sviluppo del futuro. Ecco una panoramica con particolare riferimento a Mono.
Con l'introduzione di Java nel 1996, e oggi con i nuovi framework .NET e Mono, la tecnologia dello pseudocodice sta riemergendo prepotentemente. Ricordo nei primi anni `80 il sistema operativo UCSD Pascal, interamente implementato su di una macchina virtuale a 16 bit stack-based denominata ``p-machine'' su di un progetto del politecnico ETH di Zurigo: a quel tempo questa era una soluzione obbligata per far stare un sistema di sviluppo relativamente complesso dentro a macchine che disponevano solo di un processore a 8 bit e di 64 KB di RAM. Il revival del p-code di questi anni sembra invece una risposta ad altre esigenze: maggiore indipendenza dall'hardware, compattezza del codice, facilità di implementazione su architetture diverse del sistema di sviluppo e dell'ambiente di esecuzione, ...
Non cambia invece la strategia globale del sistema:
Le soluzioni Java, .NET e Mono differiscono un po' nella terminologia, ma la strategia del sistema è la stessa. La figura 1 illustra schematicamente come funzionano le cose nei tre sistemi e permette di familiarizzare con le terminologie di cui sicuramente si parlerà molto nei prossimi anni.
Nel seguito ci concentreremo in particolare con il sistema Mono perché gira su sistema operativo GNU/Linux. Per completare il quadro, facciamo precedere una breve introduzione sui sistemi Java e .NET.
Lanciato da Sun Microsystems nel 1996 come architettura aperta,
Java si è evoluto negli anni grazie al contributo di numerosi altri
soggetti, per cui oggi è disponibile una grande varietà di
librerie, di implementazioni diverse e di piattaforme hardware supportate.
Dal sito ufficiale java.sun.com
si possono scaricare il compilatore (javac), le librerie
di sviluppo, e l'interprete del bytecode (java).
La p-machine progettata da Sun implementa nativamente la programmazione
ad oggetti, dispone di un garbage collector automatico, ed è
dedicata alla esecuzione di codice prodotto a partire da sorgente Java.
Il compilatore javac traduce il sorgente Java nell'eseguibile
p-code denominato bytecode. L'eseguibile viene poi interpretato
dalla p-machine detta Java Virtual Machine (JVM), implementata
dal programma java.
Nell'ottobre 2000 vengono depositate le specifiche dell'architettura ECMA TC39 TG2 e ECMA TC39 TG3, più popolarmente note per la loro implementazione in .NET fatta da Microsoft. Pertecipano alla redazione di queste specifiche diverse aziende ed istituzioni: Fujitsu Software Corporation, Hewlett-Packard, Intel Corporation, IBM Corporation, Microsoft Corporation, Monash University, Netscape, Phone Com, Plum Hall e Sun Microsystems.
Queste specifiche tecniche descrivono una p-machine ad oggetti
basata su stack e dotata di garbage collector automatico, descrivono le
librerie di funzioni di base e un nuovo linguaggio di programmazione C#
(che si legge ``c-sharp''). La p-machine è stata progettata per
supportare, almeno in parte, anche altri linguaggi di programmazione.
Il compilatore csc traduce il sorgente C# nell'eseguibile
p-code denominato Intermediate Language (IL). L'eseguibile viene poi
interpretato dalla p-machine detta Common Language Runtime (CLR).
Nel giugno 2001 Ximian lancia la sfida per la creazione di una implementazione delle specifiche ECMA TC39 come progetto open source, e avvia la realizzazione di una p-machine e di un compilatore C#. Il progetto prevede di realizzare un sistema completo che va dalla p-machine, al compilatore, alle librerie, e che sia compatibile e alternativa alla implementazione .NET di Microsoft.
Per scelta del suo principale artefice Miguel de Icaza, fondatore di Ximian e tra i principali realizzatori del programma Midnight Commander e del desktop manager e window manager GNOME, il compilatore C# di Mono è stato realizzato nel linguaggio C# stesso. Per superare il problema dell'uovo e della gallina, il compilatore è stato dapprima realizzato su piattaforma .NET mentre nel frattempo veniva completato l'interprete Mono su piattaforma GNU/Linux. Una volta terminato l'interprete, il codice eseguibile del compilatore è stato portato su GNU/Linux, e da quel momento lo sviluppo del sistema Mono è potuto proseguire interamente su questo sistema operativo. Il 27 marzo 2002 sul sito del progetto Mono viene data la notizia, con una certa enfasi e soddisfazione, che il compilatore C# di Mono ora si compila su sè stesso interamente su GNU/Linux: a questo punto il progetto Mono ha raggiunto la sua piena autonomia, e lo sviluppo di questo sistema è destinato a proseguire ancora più velocemente.
Dal sito www.go-mono.org
bisogna scaricare i sorgenti seguenti (le versioni indicate sono aggiornate
al 7 giugno 2002, per cui nel frattempo potrebbero essere uscite versioni
più aggiornate):
pkgconfig-0.12.0.tar.gz - Programma per il controllo delle versioni delle librerie (0.6 MB).
glib-1.3.12.tar.gz - Libreria di base di GNOME (1.8 MB).
mcs-0.12.tar.gz - Il compilatore C# di Mono e alcune librerie CTS (2.2 MB).
mono-0.12.tar.gz - L'interprete IL (1.7 MB).
Procedere come al solito allo scompattamento, configurazione del makefile e compilazione:
# tar xfz - pkgconfig-0.12.0.tar.gz # cd pkgconfig-0.12.0 # ./configure # make # make install
e similmente per gli altri pacchetti. Il pacchetto mcs non
necessita di compilazione perché contiene già il codice
IL eseguibile.
Ecco il tradizionale programma ``Hello, world!'' scritto in C#:
using System;
class HelloWorld
{
public static int Main()
{
Console.WriteLine("Hello, world!");
return 0;
}
}
Salvare questo sorgente nel file hello-world.cs e compilare
con il comando:
$ mcs hello-world.cs
che produce l'eseguibile hello-world.exe scritto in codice IL.
Questo programma binario può essere eseguito attivando l'interprete
Mono:
$ mono hello-world.exe
Lo stesso programma hello-world.exe può essere eseguito
anche su piattaforma Windows .NET con un doppio click oppure digitando il
nome del programma su di una finestra di console.
La JVM utilizza istruzioni costituite da un opcode a un byte più eventuali parametri. Sono previste 205 opcode di cui tre riservati. I restanti opcode non sono definiti e potrebbero essere usati per future estensioni.
Le operazioni sullo stack avvengono di norma su parole a 32 bit, sufficienti per contenere la maggior parte dei tipi semplici (numeri in bassa precisione, caratteri Unicode, indici, riferimenti a oggetti). Per la manipolazione di dati sullo stack di ampiezza superiore, come i tipi numerici in doppia precisione, sono disponibili istruzioni apposite.
Tra gli opcode sono presenti:
try/catch).
finally del try/catch di Java).
I metodi sono vincolati ad avere un numero fisso di argomenti determinato
in fase di compilazione. Funzionalità simili alla funzione
printf() del linguaggio C devono perciò essere simulate
mediante l'uso di array.
L'accesso al file system, ai protocolli di rete, alle funzioni matematiche
avanzate (trigonometria, logaritmi, ecc.) e alla grafica sono implementate
come librerie di classi esterne realizzate in linguaggio C e interfacciate
al programma Java con la tecnica dei metodi native (JNI).
Uno degli obiettivi principali della JVM era la facilità di implementazione su di una varietà di piattaforme, con particolare riguardo agli apparecchi portatili dotati di processore come i PDA, i telefoni ma anche le soluzioni embedded. Un'altro obiettivo era la compattezza del codice per velocizzare il trasferimento dei programmi nelle applicazioni di rete client/server, come le applet del WEB.
Oltre agli aspetti di basso livello della JVM che abbiamo analizzato
prima, Sun distribuisce anche una varietà di librerie di
utilità. Tra queste, le AWT permettono la creazione di interfacce
utente grafiche (GUI) indipendenti dalla piattaforma secondo una metafora
a finestre e a icone simile alle GUI dei personal computer di oggigiorno,
anche se non altrettanto sofisticata. La successiva introduzione della
libreria Swing ha molto migliorato l'efficacia della GUI, dotandola
di strumenti e un aspetto più moderni.
Il grande pregio
della portabilità del bytecode è però inficiato
da due aspetti negativi: 1) l'interfaccia grafica risultante è
``aliena'' rispetto a qualsiasi GUI nativa del sistema operativo sul
quale gira l'applicazione; 2) si nota una certa lentezza e pesantezza
nelle operazioni di disegno.
Il CLR è costituito principalmente dall'interprete dell'IL ed è l'omologo della JVM. Sono previste 214 istruzioni costituite da un opcode ad uno o due byte e dagli eventuali parametri. Di conseguenza c'è ampio margine per potere aggiungere in futuro eventuali nuove istruzioni. Alcuni opcode non utilizzati sono riservati per le estensioni future, altri opcode sono riservati agli sviluppatori a scopo eperimentale.
Il primo aspetto interessante che balza all'occhio è
l'esiguità degli operatori matematici. Ad esempio, esiste un solo
opcode add che esegue la somma, indipendentemente dalla
lunghezza e dalla precisione degli operandi (interi lunghi e corti, con
e senza segno, in precisione reale, ecc.). Il comando add
agisce sui due operandi presenti in cima allo stack, li somma, e li
sostituisce col risultato. Il tipo degli operandi non viene codificato
nella istruzione, ma viene codificato direttamente dentro agli operandi
stessi.
Tra gli opcode sono presenti:
alloca() del C),
try/catch),
Sono supportati metodi con numero variabile di argomenti, così
che si possono tradurre in IL anche le tipiche funzionalità
del C come il printf().
A differenza della soluzione Java proposta da Sun, le specifiche ECMA di questa p-machine nulla dicono relativamente alla GUI, la cui eventuare realizzazione viene lasciata all'implementatore. Di conseguenza la questione della portabilità delle applicazioni dotate di GUI, in questo caso non è stata considerata.
L'unica implementazione completa oggi disponibile di questa p-machine è quella fattane da Microsoft nel suo progetto .NET. In questo caso la GUI è stata implementata nella libreria di classi detta Forms, grazie alla quale l'applicazione può esibile all'utente del sistema operativo MS Windows una aspetto e un comportamento perfettamente integrati col resto del sistema. In effetti, nei piani di Microsoft, questa p-machine e il linguaggio C# dovrebbero costituire lo strumento di sviluppo privilegiato nell'ambito dei suoi futuri sistemi operativi. Tutte la applicazioni desktop e le future soluzioni di comunicazione in Internet sviluppate da Microsoft dovrebbero quindi basarsi su questa nuova p-machine.
Sul fronte Mono ad oggi sono disponibili le librerie di classi di base in fase di messa a punto. Riguardo alla GUI, invece, nei progetti di Ximian c'è l'integrazione di Mono con le librerie GTK (le stesse che sono a fondamento di GNOME), come del resto c'era da aspettarsi. E' probabile che nei prossimi mesi vedremo fiorire intorno a Mono una messe di altre librerie alternative per il supporto della GUI e di altre funzionalità.
www.go-mono.org
- Il sito ufficiale del progetto Mono di Ximian.
www.microsoft.com/net
- Il sito ufficiale del progetto .NET di Microsoft Corp.
java.sun.com - Il sito
ufficiale del progetto Java di Sun Microsystems.
www.dotnetexperts.com
- Molte info e link sulle specifiche ECMA di .NET e Mono.
| Umberto Salsi | Commenti | Contatto | Mappa | Home / Indice sezione |
Still no comments to this page. Use the Comments link above to add your contribute.